MFPointNet: A Point Cloud-Based Neural Network Using Selective Downsampling Layer for Machining Feature Recognition

Abstract

Machining feature recognition is a research hotspot in recent years. A point cloud is a geometry data representation format of three-dimensional (3D) models. The use of point cloud-based convolutional neural networks (CNNs) for machining feature recognition has received increasing research attention. However, these point cloud-based networks usually have large complexity size and training time. In this paper, a selective downsampling-based point neural network for machining feature recognition is proposed. Firstly, a machining feature dataset called MFDataset is constructed and contains 33 feature types. Secondly, a selective downsampling algorithm of the input points is presented, which drops out unimportant points while keeping the important ones. In single-machining feature recognition, MFPointNet is proposed by utilizing the selective downsampling of the input points. In multi-machining feature recognition, the segmentation part of the MFPointNet is adopted with the selective downsampling algorithm to segment and recognize multiple features. Compared with other point cloud-based networks, experimental results show that MFPointNet reduces the computational complexity without losing the recognition accuracy basically. MFPointNet is more robust to model complexity when more machining feature points are input to the network. Moreover, several intersecting feature models validate the segmentation performance of MFPointNet.

1. Introduction

In the realm of smart manufacturing, each product or part originates from a computer-aided design (CAD). The technologies of CAD and computer-aided manufacturing (CAM) help increase the design productivity and the process of manufacturing products. As a bridge between CAD and CAM, computer-aided process planning (CAPP) realizes the integration of CAD and CAM. However, the independent operation of the CAD and CAPP system has resulted in the inability to interconnect design information with manufacturing information [1]. Therefore, in order to realize the information transmission between CAD and CAPP, it is indispensable to recognize the machining feature from the 3D CAD model. Machining feature recognition can directly apply the processing feature information to the design of process planning, followed by obtaining the feature information from the 3D design information. It is worth noting that how to effectively recognize machining features from CAD models remains relatively immature, which is still the focus of research in academia and industry.

Machining feature recognition techniques have been developed for over thirty years. Many researchers have proposed many recognition methods. In general, these methods can be divided into two categories: traditional recognition methods [2] and deep learning-based methods [3]. The traditional recognition algorithms can be summarized as the graph-based method [4], volume decomposition-based method [5], feature hint-based method [6], rule-based method [7], semantic-based method [8], and the hybrid method [9]. In general, these methods usually only can recognize machining features in the B-rep model [10]. In addition, they suffer from poor robustness, computational complexity, and poor ability to recognize intersecting features. In recent years, researchers try to apply deep learning algorithms to machining feature recognition. Before inputting the machining feature into the CNN, we need to convert the feature into a format suitable for the network, as described by the representation vector (RV) [11]. These feature encoding methods are mainly categorized as the voxel, multi-view representation, and point cloud. In particular, the point cloud is easily accessible and widely used in 3D shape recognition. Some existing point cloud-based networks have been proposed, such as PointNet [12], PointNet++ [13], PointCNN [14], and DGCNN [15]. These point cloud methods use publicly available datasets such as ModelNet and ShapeNet to classify or segment the specific 3D shape entities. They cannot recognize and segment groups of associated geometric entities with specific shapes and properties, such as through-holes, keyways, and threads. Moreover, the input to point cloud-based network above are all the points in the 3D model, either PointNet++ for FPS downsampling [16] or DGCNN for KNN clustering [17], resulting in a large use of computational memory and an increasing CNN training time.

Motivated by the adaptive hierarchical downsampling [18] for point cloud classification, where a permutation-invariant layer called the critical points layer (CPL) reduces the input point while keeping the important points, a selective downsampling algorithm of the point cloud input is presented in this paper. In the case of single-machining feature recognition, we construct MFDataset, a publicly available machining feature dataset. It contains approximately 2000 features per category for classification. An improved CNN structure MFPointNet, utilizing the selective downsampling of the input points, is proposed to recognize the different features. In terms of multi-machining feature recognition, the segmentation part of the MFPointNet is adopted and combined with the MLP [19] to recognize those multi-machining features.

The studies of this paper make the contributions as follows: (i) MFDataset is established, which is dedicated to specific machining features. (ii) The proposed selective downsampling algorithm reduces the computational complexity without loss in the recognition accuracy basically. (iii) MFPointNet is compared with other point cloud-based networks. Experimental results demonstrate that MFPointNet strikes a balance between recognition accuracy and computational complexity.

The remainder of this paper is organized as follows. A literature review on feature recognition methods is presented in Section 2. In Section 3, the process of establishing the machining feature dataset MFDataset is described. The proposed MFPointNet is presented in Section 4, containing the classification network and segmentation network. The network training parameters and comparative experimental results are discussed in Section 5. Finally, the conclusion is shown in Section 6.

2. Literature Review

In recent years, researchers have proposed different kinds of machining feature recognition algorithms, which can be summarized as traditional recognition methods [2] and deep learning-based methods [3]. This section conducts a wide range of feature recognition methods.

2.1. Traditional Feature Recognition Methods

The traditional rule-based recognition method mainly consists of graph-based method [4], volume decomposition method [5], hint-based method [6], and the hybrid recognition method [9].

The graph-based recognition method was first presented by Joshi et al. [20] in 1988. It introduced the concept of attributed adjacency graph (AAG), which is an auxiliary shape descriptor. Gao et al. [21] proposed the extended attributed adjacency graph (EAAG), consisting of node face attributes and arched edge attributes. Yeo et al. [22] proposed a method to evaluate manufacturability after the machining features recognition from 3D CAD models. They used two test cases to demonstrate feature recognition results. Xu et al. [23] developed the generalized attributed adjacency graph (GAAG) to recognize the high-level composite machining features in detail. The graph-based methods are effective in recognizing single features. However, these methods are difficult to deal with intersecting machining features due to their concavity to represent the relationship between surfaces. Furthermore, the graph-based method tends to have inaccurate recognition.

The hint-based method was developed by abundant information as an indispensable module of a machining feature’s boundary. This kind of method generates hints based on the rules. They include topological, geometrical [24,25,26] and taxonomies [27,28]. Then these features are inferred by these hint rules [29]. Li et al. [30] presented a novel hint-based shape feature recognition approach for 3D B-rep models. Gong et al. [31] put forward a hole feature recognition method based on the hint. They completed the automatic recognition of hole features and can endow machining and manufacturing semantics for manufacturability checks. However, the hint-based method has its application limitations. It is difficult to recognize the feature hint in the case of interacting machining features.

The volume decomposition method decomposes the removal volume of stock into intermediate volumes. The machining features are presented by combining these volumes based on the predefined rules. It can be divided into convex-hull decomposition [32,33] and cell-based decomposition [34,35]. Woo et al. [36] proposed a set of machining features in a part to recognize by decomposing the delta volume. Gupta et al. [37] used volume subtraction and syntactic pattern recognition to identify machining features on a prismatic part from B-Rep data extracted from a 3D model. However, the volume decomposition method is less accurate and more computationally intensive in recognizing features.

Based on the above recognition method, many experts proposed varied hybrid machining feature recognition methods. Verma et al. [38] proposed a hybrid machining feature recognition method consisting of graphs and hints to recognize the milling features. Rameshbabu et al. [39] proposed a hybrid recognition method combining the volume decomposition method and the graph-based method to recognize machining features from a 3D model. Jong et al. [40] used the hybrid recognition method based on the graph-based method, the rule-based method, and the hint-based method to identify 3D shape features. Guo et al. [41] developed a hybrid 3D machining feature recognition method to recognize machining features, based on the graph-based method and the rule-based method. Mazin wswasi et al. [42] presented a methodology for recognizing the features of rotational parts. They extracted the geometrical and topological information of the feature, building a dataset containing 54 predefined features. Sunil et al. [43] developed a new hybrid (graph + rule-based) approach for recognizing the interacting features from B-Rep CAD models of prismatic machined parts. Although the hybrid feature recognition methods eliminate some flaws of the above method, they still suffer from low multi-machining feature recognition accuracy and high computational cost.

2.2. Deep Learning-Based Feature Recognition Methods

With the development of deep learning, researchers have tried to apply deep learning algorithms to machining feature recognition in recent years.

The voxelization-based method is to voxelize the triangular mesh model into a 3D voxel mesh, which is then input into the CNN. Zhang et al. [44] proposed FeatureNet to learn machining features from CAD models of mechanical parts. Sambit Ghadai et al. [45] presented the 3D-GradCAM framework to learn local features from a voxelized representation of a CAD model and classify its manufacturability. Ning et al. [46] studied a convolutional neural network combined with a graph-based method to recognize the machining features. The comparison results demonstrated the high recognition accuracy of convex features. Dheeraj Peddireddy et al. [47] presented a two-step machining process identification system based on a 3D CNN and transfer learning. The system showed more than 98% accuracy in identifying the manufacturability of a part. Lee et al. [48] proposed a method to reconstruct 3D CAD models containing machining features into voxels through an encoder–decoder network. The recognition accuracy of the voxel neural network is closely related to resolution size. As the voxel resolution increases, the computational cost increases linearly. This makes large-scale network training difficult.

There are also studies where machining feature recognition technology is combined with 3D CAD systems. Lee et al. [49] presented a deep learning method to recognize machining features from a 3D CAD model and detect feature areas using gradient-weighted class activation mapping. Their model can achieve a feature classification accuracy of 98.81%. Yeo et al. [50] proposed a method making integration of a 3D CAD system with a neural network using feature descriptors as input for recognizing machining features. The feature types for all test cases were recognized. Zhang et al. [51] designed an intelligent machining feature recognition method for STEP-NC-compliant manufacturing based on the artificial bee colony algorithm and back propagation neural network. It was concluded by some case studies that the method is feasible. Shi et al. [52] presented a feature recognition method using heat kernel signature for manufacturability analysis.

The multi-view representation method uses the feature multi-view images as input for recognition. Shi et al. [53] presented MsvNet, in which multiple sectional views of a model are inputted into the CNN for recognition. However, it is difficult to segment intersecting features accurately according to the shape information in an unsupervised way, since the topology information of the features might be destroyed. Motivated by an object detection algorithm named single shot multibox detector (SSD), Shi et al. [54] proposed SsdNet, where feature segmentation and recognition are carried out via supervised learning. However, these methods produce less favorable results in recognizing highly interacting features, especially when collecting training data becomes difficult. To tackle the above issue, Shi et al. [55] designed a method named RDetNet which is capable of recognizing highly interacting features with small training samples. Experiments showed the interacting feature recognition performance of RDetNet.

A point cloud is a series of data points in 3D space that contains only 3D coordinates XYZ or contains other attributes such as normal vectors. Andrew et al. [56] presented a method for the creation and labeling of point clouds from 3D CAD models for machine learning technology. Qi et al. [12] designed PointNet, which is accepted the point cloud as input directly and the model classification or part segmentation as output results. To improve the network performance, Qi et al. [13] improved a network called PointNet++ to combine the features from multiple scales. Li et al. [14] introduced a CNN architecture called PointCNN to learn the x-transformation from input clouds directly. Wang et al. [15] proposed a dynamic graph CNN for learning on point clouds, which uses the Edge-Conv to make local geometric architecture. Yao et al. [16] constructed a feature recognition approach based on the hierarchical neural network. It is demonstrated to recognize the features accurately with low computational cost. Zhang et al. [57] designed the associatively segmenting and identifying network (ASIN) based on point cloud to recognize the machining features. The ASIN can realize the machining feature segmentation, feature identification, and bottom face identification simultaneously. Jonathan et al. [58] described a machining feature recognition based on the point cloud. They used PointNet as the baseline architecture. This approach can be used to recognize 12 features, with a recognition rate of 95%.

3. Machining Feature Dataset Creation

This section first summarizes some of the relevant issues in the existing literature, which motivate the proposed method. Then, the creation process of the point cloud machining feature dataset is illustrated in detail.

3.1. Overview

As discussed in Section 2.1, the traditional feature recognition methods (Yeo et al. [22] and Sunil et al. [43]) suffer from inaccurate recognition and intensive computational cost. Moreover, they have difficulty recognizing intersecting features.

As illustrated in Section 2.2, voxel recognition methods (FeatureNet [44]) and multi-view recognition methods (MsvNet [53]) are subject to many objective experimental conditions. Point cloud data are easily accessible. Most existing point cloud-based recognition methods (PointCNN [14]) classify or segment the 3D object, rather than the machining feature. Additionally, there is a lack of dedicated feature datasets. Not only that, but the existing point cloud-based method (PointNet [12] or PointNet++ [13]) inputs are all point data, causing the network to be more computationally and parametrically intensive. Therefore, the main research of this paper is how to construct a machining feature dataset and reduce the network complexity size while ensuring the recognition accuracy. To solve these problems, an improved method is proposed in this paper.

3.2. Definition and Types of Machining Feature

Machining feature is a set of geometric shapes with certain properties and semantics in parts [59]. After reference to the machining feature specified in the ISO STEP AP224 [60] standard, we construct MFDataset by SolidWorks, containing about 66000 machining feature data.

A cubic raw stock of 10 cm × 10 cm × 10 cm side length is applied to create the non-rotary feature models, as shown in Figure 1. Moreover, Figure 2 shows some rotary machining feature models, which are established by a raw cylindrical blank of 5 cm in diameter × 15 cm in height. These machining feature models are generated with random parameters in a predefined certain range. All the feature types of MFDataset are presented in Figure A1 in Appendix A. All the parameter ranges of MFDataset are presented at https://github.com/leiruoshan/MFPointNet_feature_dataset (accessed on 2 June 2022).

3.3. Point Cloud Feature Dataset

A point cloud is a representation of 3D objects in real space. Each point is determined by the three coordinate dimensions (X, Y, Z). Moreover, the point can also be expressed by (X, Y, Z, ${\sigma }_x$, ${\sigma }_y$, ${\sigma }_z$), where ${\sigma }_x$ denotes the spatial normal vector along the x-axis. For machining feature datasets in the STL format model, we need to transform it into the point cloud format which is suitable for inputting point cloud-based networks. Figure 3 illustrates the dataset conversion process. The process can be divided into three steps: (i) The machining feature surface sets non-relevant to the feature should be stripped from the original STL format model. (ii) We use the Poisson distribution sampling [61] on machining feature surface sets to get the point cloud feature models. (iii) The point cloud models are augmented through random rotation. After data pre-processing, the point cloud machining feature dataset is established.

3.3.1. Extraction of Machining Feature Surface Point Sets

In order to reduce the impact of the cubic on the recognition accuracy, a machining feature dataset containing the surface point sets is used in this paper. The triangular faces that are not part of the features need to be removed from the original STL model. The machining feature surface point set extraction procedure is shown in Algorithm 1. All the feature surface point extraction results are shown in Figure A2 in Appendix B.

Algorithm 1 The process of machining feature surface set extraction.

Input: Original STL feature model with the cubic raw stock Output: STL feature model after feature surface point sets extraction     for ProcessSurface (document) do           if select (document) == NULL then                 return false;           else                 file += open (document);                 S += pass “solid *.**”;                 if S != “endsolid” then                       file += normal vectors + coordinates;                       if addsurfaces (normal, vertex) then                            newSets += face (normal, vertex);                       end if                 end if          end if end for for addsurfaces (normal, vertex) do     i = 0 || i = 1 || i = 2;     j = 0 || j = 1 || j = 2;     if vertex[i][j] == 0 || vertex[i][j] == 10 then           return true;     end if end for

3.3.2. Poisson-Disk Sampling

The technique of uniform sampling of the triangular grid is the key point to obtaining the feature dataset. Corsini et al. [62] presented a constrained Poisson-disk sampling algorithm to generate customized point sets. This method creates a new layer populated with a point sampling of the current meshes. Based on the Poisson-disk sampling, we use a 3D mesh processing software named Meshlab [63] to achieve the sampling from the original STL format models. For each feature type, we collect the coordinates without normal vectors by default, sampling 256 points, 512 points, and 1024 points, respectively. For the comparison experiments, we additionally collect point clouds with normal vectors for 1024 points. Some point cloud models are shown in Figure 4. The 512-point sampling model and the 256-point sampling model are shown in Figure A3 of Appendix C and Figure A4 of Appendix D, respectively.

3.3.3. Feature Data Pre-Processing

Machining features can appear in any position of a model with diversified attitudes and sizes. Even identical machining features can lead to different point cloud data due to differences in location. These create a great deal of uncertainty in feature recognition. Therefore, we need to normalize the point cloud data by offsetting the point cloud to the origin and scaling the data to [−1, 1], which can be illustrated as follows (Equations (1)–(3)):

$${x_i}^{+}=2\times \frac{x_i-mean\left(x\right)}{max\left(x\right)-min\left(x\right)}$$

(1)

$${y_i}^{+}=2\times \frac{y_i-mean\left(y\right)}{max\left(y\right)-min\left(y\right)}$$

(2)

$${z_i}^{+}=2\times \frac{z_i-mean\left(z\right)}{max\left(z\right)-min\left(z\right)}$$

(3)

3.4. Multi-Machining Feature Dataset

To recognize the multi-machining feature precisely, some point cloud feature models are established. They are based on MFDataset, by a Boolean summation operation [64] of multiple single-machining features. All the multi-machining feature models are built on the cubic raw stock of 15 cm × 15 cm × 15 cm side length. The detailed information of the models is shown in

Table 1. The detailed description of the multi-machining feature dataset.

Model Definition	Number of Feature Types	Feature Categories	Intersecting Degrades
Model 1	3	02 + 10 + 24	slight
Model 2	3	01 + 03 + 30	slight
Model 3	4	01 + 03 + 15 + 23	slight
Model 4	4	01 + 01 + 15 + 16	slight
Model 5	5	01 + 03 + 05 + 09 + 15	moderate
Model 6	5	01 + 03 + 07 + 15 + 24	moderate
Model 7	6	01 + 03 + 05 + 15 + 23 + 32	high
Model 8	7	01 + 02 + 03 + 04 + 07 + 08 + 30	high
Model 9	8	02 + 04 + 15 + 23 + 24 + 25 + 30 + 31	high

. An intersecting number of features (3–8) is randomly applied to construct the feature models. When the number of features is 3 or 4, we define the models as slightly intersecting features; when the number is 5, we call them moderately intersecting features; otherwise, they are viewed as highly intersecting features.

4. MFPointNet for Machining Feature Recognition

In this section, we present the MFPointNet architecture based on the original PointNet. MFPointNet can be divided into single-machining feature classification tasks and intersecting feature segmentation tasks, as shown in Section 4.1 and Section 4.2, respectively.

4.1. Single-Machining Feature Recognition

Unlike PointNet, which inputs all points data into the network, MFPointNet only selectively inputs some more important points data into the network. Moreover, the selective downsampling layer (SDL) avoids judging the importance only based on the global maximum pooling for each feature vector in adaptive hierarchical downsampling [18] module. The description of the SDL module and MFPointNet are explained as follows.

4.1.1. The Selective Downsampling Layer (SDL)

The SDL module measures the importance of each machining feature point by the degree to which it contributes to the global average pooling feature (avg-reduced feature vector). The detail of the SDL module is shown in Figure 5. Firstly, the original network input has N feature points, each feature with dimension D, i.e., the input machining feature f is an N × D two-dimensional matrix. The average of each column of f is taken to obtain a 1 × D feature vector $f_a$. Secondly, the first value of the machining feature points that are greater than the average value in each column are stored in the feature vector $f_m$, and the index corresponding to each of the machining features in $f_m$ are marked down and saved in the array idx. idx represents the specific feature points that contribute to the input machining feature vector f. Thirdly, the corresponding values in $f_m$ of the duplicate indexes in idx are added up and represented by a new feature vector $f_c$. Meanwhile, the indexes are stored in a new vector uidx after merging duplicate indexes. Fourthly, the feature points of $f_c$ are sorted in ascending order, and the corresponding indexes are sorted in order successively. suidx is used to represent the new indexes. Considering that different numbers of points during network training will result in different numbers of indexes in the suidx array, nearest neighbor resizing [65] is used to transform suidx into a new index array ruidx to ensure that the same number of machining feature points is fed into MFPointNet. Finally, the input N × D features are turned into M × D features, where M ≤ N, according to the index ruidx of the machining feature points with large contributions. By reducing the number of features from N to M, we achieve the selective downsampling of the input machining feature points.

4.1.2. The Architecture of the MFPointNet

The overall architecture of the MFPointNet is shown in Figure 6. The number of input points is set to N, and the input point cloud is $p\in R^{N\times 3}$ (no normal vector) or $p\in R^{N\times 6}$ (using normal vector). The overall structure is divided into two branches: single-machining feature classification and multi-machining feature segmentation.

In the backbone, after inputting the feature points into a T-Net module, the attribute of input points remains unchanged. MLP (3, 128) or MLP (6, 128) is convolved through a two-layer perceptron network [66] to obtain an N × 128 output feature point cloud. Only half of the original input points are inputted after the SDL module, obtaining an output feature of (N/2) × 128. This is then followed by a T-Net module to guarantee the rotational invariance of the input point. Then after an SDL module, the output point becomes (N/4) × 128. The (N/4) × 1024 output feature points are obtained by using four convolution layers, each with 128, 256, 512, and 1024 convolution kernels of size 1 × 1, respectively. After this step, the output features are transformed from (N/4) × 1024 by global max pooling to obtain 1 × 1024.

In the single-machining feature classification network, the feature vector 1 × 1024 represents the global feature information. Then followed by four convolutional layers, each with 512, 256, 128, and 33 convolution kernels of size 1 × 1, respectively. Now, we finally can obtain the machining feature classification and recognition results.

4.2. The Procedure of Multi-Machining Feature Recognition

The overall procedure for the multi-feature recognition task is shown in Figure 7. Firstly, the multi-feature models are established by Boolean operation according to the MFDataset. These models are in STL format. Secondly, a transformation process will be used to convert into the point cloud models. Thirdly, we input the feature point cloud models into MFPointNet directly. As to the intersecting features, MFPointNet concatenates global features with previously learned local features of each feature point, which is shown in Figure 8, and then passes MLP to obtain the classification labels for each machining feature point.

As illustrated in Figure 6 and Figure 8, the multi-machining feature segmentation network is an extension of single-machining feature classification network. After finding the global feature points, we feed it back to per-point features by concatenating the global feature with each of the local features. Then we extract the new point features based on the combined features-both the local feature information and global feature information are taken into account. Therefore, the N × 128 output features obtained by feature extraction and the 1 × 1024 output features are fused to obtain N × 1152 output features. After the SDL module, the (3N/4) × 1152 output feature points are received. For each of the (3N/4) feature points, the segmentation network will output the corresponding m scores. m represents the semantic feature subcategories. Because the multi-machining feature model is based on MFDataset, m here is equal to a fixed value of 33. This is followed by four convolutional layers, each with 512, 256, 128, and 33 convolution kernels of size 1 × 1, respectively, and we can get the final (3N/4) × 33 output machining feature point labels.

5. Experimental Results and Discussion

Based on MFPointNet proposed in Section 4 and the machining feature dataset MFDataset presented in Section 3, the effect of different numbers of input points on recognition accuracy is shown in this section. Moreover, we compare MFPointNet to PointNet [12], PointNet++ [13], PointCNN [14], and DGCNN [15] in terms of the recognition accuracy and complexity model size under the different input points. In multi-machining feature recognition, the multi-machining feature segmented into single-machining features is analyzed.

All the experiments in this paper are conducted on the “High Performance Computing Public Service Platform of Huazhong University of Science and Technology” platform, using Pytorch [67] as the deep learning framework. Moreover, the platform is available in the following configurations: a Linux Operating System with NVIDIA Tesla V100S GPU, 32 GB memory, and Intel Xeon Gold 6230R CPU with 256 GB memory.

The network training parameters are set as follows: the default setting for the number of input points is 1024 (alternatives are 256 and 512). The maximum number of training iteration epochs is set to 200. The batch size is set to 64. The initial learning rate is 0.001. The optimizer is Adam. The decay rate is 0.0001. The number of categories is set to 33. The loss function is set to cross entropy (CE). The point cloud dataset is not used with normal vectors, i.e., use normals == false. The dataset is divided into the training set (70% of the whole dataset) and the testing set (30% of the whole dataset).

5.1. Single-Machining Feature Recognition

In this section, experimental results of MFPointNet and comparative experiments with other point cloud-based neural networks are shown separately.

5.1.1. The MFPointNet Experimental Results

To demonstrate the performance of MFPointNet, we use the training epoch number, average epoch time, total training time, training model size, network parameters, and overall classification accuracy as the evaluation indicators on MFDataset. We have used 256 points, 512 points, and 1024 points successively as the original input point numbers in the network. To verify the effect of input normal vectors on the experiment results, we added a set of experiments using the 1024 points with normal vectors as the input. The relevant experimental results are shown in

Table 2. The experimental results of MFPointNet.

Input Point Numbers	Using Normal Vectors	Training Epoch Number	Average Epoch Time	Total Training Time	Training Model Size	Network Parameters	Overall Classification Accuracy
256	No	185	470.9 s	24.20 h	0.1067 G	5.2118M	96.88%
512	No	188	474.8 s	24.79 h	0.1435 G		98.09%
1024	No	190	490.4 s	25.88 h	0.2172 G		98.93%
	Yes	189	488.8 s	25.66 h	0.2188 G		99.60%

. As can be seen from Table 2, the average training epoch time and network parameters definitely do not increase linearly with the number of input points but remain essentially unchanged. Compared to 256 and 512 input points, the classification accuracy of 1024 input points is slightly higher, reaching 98.93%. The model size with normal vectors is only a bit more than without them, but the classification accuracy reaches 99.60% clearly. The classification recognition accuracy with normal vectors is the highest among the four experiment groups.

5.1.2. Comparative Experiments of Effect on Input Point Number with Other Point Cloud-Based Networks

Table 3. The effect of input point numbers on recognition accuracy and parameters.

Methods	Input Point Numbers	Network Parameters	Overall Accuracy	Mean Class Accuracy
PointNet [12]	256	3.469674M	96.41%	96.12%
PointNet++ [13]		1.745569M	96.82%	96.58%
PointCNN [14]		0.275449M	94.42%	94.04%
DGCNN [15]		1.810849M	95.02%	94.88%
MFPointNet		5.211882M	96.88%	96.20%
PointNet [12]	512	3.469674M	97.33%	96.95%
PointNet++ [13]		1.745569M	98.35%	97.99%
PointCNN [14]		0.275449M	96.37%	95.96%
DGCNN [15]		1.810849M	97.75%	97.01%
MFPointNet		5.211882M	98.09%	97.23%
PointNet [12]	1024	3.469674M	98.05%	97.09%
PointNet++ [13]		1.745569M	98.34%	97.20%
PointCNN [14]		0.275449M	98.89%	97.75%
DGCNN [15]		1.810849M	98.59%	97.56%
MFPointNet		5.211882M	98.93%	97.99%

shows the effect of different input point numbers on the network training parameters and recognition accuracy. As can be seen from Table 3, the parameters for different networks do not change at all as the input point number varies. This is due to the fact that these neural networks have shared weights and the different input sizes will not affect the network parameters. The parameters of MFPointNet are the largest due to the successive use of MLP. The parameters of the PointCNN network are the smallest, owing to the X-Conv architecture. Moreover, the recognition accuracy increases with the number of input points, regardless of the network. The recognition accuracy of the MFPointNet network is highest when the number of input points is 256 and 1024, respectively, while the recognition accuracy of the MFPointNet is slightly lower than that of PointNet++ when the number of input points is 512.

Table 4. The effect of input point numbers on training time and model complexity size.

Methods	Input Point Numbers	Training Epoch Number	Average Epoch Time	Total Training Time	Model Complexity Size
PointNet [12]	256	184	200.9 s	10.27 h	0.11393 G
PointNet++ [13]		178	430.8 s	21.30 h	1.02956 G
PointCNN [14]		174	746.4 s	36.08 h	0.04760 G
DGCNN [15]		190	190.8 s	10.07 h	0.62470G
MFPointNet		185	470.9 s	24.20 h	0.10676 G
PointNet [12]	512	165	199.8 s	9.16 h	0.22484 G
PointNet++ [13]		196	441.3 s	24.03 h	2.09457 G
PointCNN [14]		179	2127.7 s	105 h	0.06665 G
DGCNN [15]		175	194.0 s	9.43 h	1.24821 G
MFPointNet		188	474.8 s	24.79 h	0.14359 G
PointNet [12]	1024	200	200.2 s	11.12 h	0.44704 G
PointNet++ [13]		199	447.2 s	24.72 h	4.01569 G
PointCNN [14]		188	7340.8 s	383.35 h	0.10476 G
DGCNN [15]		185	199.8 s	10.27 h	2.49523 G
MFPointNet		194	490.4 s	26.43 h	0.21725 G

shows the effect of different input feature point numbers on the network training time and model complexity size. Despite the increasing number of input feature points, the training time per epoch for all the methods remains largely unchanged, with the exception of PointCNN. The average epoch training time of MFPointNet is twice that of PointNet and close to that of PointNet++. The longer training time per epoch for MFPointNet may be caused by the fact that MFPointNet takes some time to go through the SDL module and MLP. On the other hand, the training time for PointCNN basically increases linearly with the number of input points. It is mainly because in every training epoch a transformation matrix X needs to be learned. This poses some difficulties for network training.

The model size of each network grows essentially linearly as the number of input feature points increases, in which that of the PointCNN is the smallest. It is mainly because the convolution operation uses separable convolution to reduce the parameters and computational consumption. Although the model size of MFPointNet is slightly higher than that of PointCNN, it is the smallest compared to PointNet, PointNet++, and DGCNN. It may be because of the use of the SDL module, which only selects the more important points for network training. In addition, as can be seen in Table 4, when the number of input feature points increases from 256 to 1024, the model size of PointNet, PointNet++, and DGCNN increases by a factor of four. Meanwhile, MFPointNet only increases by a factor of two, from 0.10676 G to 0.21725 G. This illustrates that MFPointNet is more robust to model complexity when more machining feature points are input to the neural network. In general, MFPointNet can reduce the network model complexity size while ensuring the feature recognition accuracy.

5.1.3. Comparative Experiments of Effect on Input Normal Vectors with Other Point Cloud-Based Networks

To verify the effect of the input normal vector on the network parameters and recognition accuracy, some comparative experiments are done as shown in

Table 5. The effect of normal vectors on recognition accuracy and network parameters.

Methods	Input Point Numbers	Using Normal Vectors	Network Parameters	Overall Accuracy	Mean Class Accuracy
PointNet [12]	1024	No	3.469674M	98.05%	97.09%
PointNet++ [13]			1.745569M	98.34%	97.20%
PointCNN [14]			0.275449M	98.89%	97.75%
DGCNN [15]			1.810849M	98.59%	97.56%
MFPointNet			5.211882M	98.93%	97.99%
PointNet [12]	1024	Yes	3.470058M	99.94%	98.56%
PointNet++ [13]			1.746049M	99.96%	98.79%
PointCNN [14]			0.280056M	99.03%	98.09%
DGCNN [15]			1.820042M	99.54%	98.23%
MFPointNet			5.211882M	99.80%	98.55%

, while keeping the input point number constant at 1024. When we use an input point with normal vectors compared to that without normal vectors, the network parameters increase slightly. This is due to the change of parameters in the head part of the network, which is caused by the input normal vectors.

As can be seen from Table 5, regardless of the network, the recognition accuracy with input normal vectors is higher than that without input normal vectors. This is because the normal vectors in the x, y, and z directions contain more feature information, which helps to improve the classification accuracy. MFPointNet achieves the highest recognition accuracy of 98.93% when no normal vectors are input, but PointNet++ achieves the highest accuracy when normal vectors are used.

The influence of normal vectors on training time and model complexity size is shown in

Table 6. The effect of normal vectors on training time and model complexity size.

Methods	Input Point Numbers	Using Normal Vectors	Training Epoch Number	Average Epoch Time	Total Training Time	Model Complexity Size
PointNet [12]	1024	No	200	200.2 s	11.12 h	0.44704 G
PointNet++ [13]			199	447.2 s	24.72 h	4.01569 G
PointCNN [14]			188	7340.8 s	383.35 h	0.10476 G
DGCNN [15]			185	199.8 s	10.27 h	2.49523 G
MFPointNet			194	490.4 s	26.43 h	0.21725 G
PointNet [12]	1024	Yes	147	200.5 s	8.19 h	0.44664 G
PointNet++ [13]			189	448.2 s	23.53 h	4.02960 G
PointCNN [14]			191	7336.6 s	389.25 h	0.11257 G
DGCNN [15]			190	200.1 s	10.56 h	2.50613 G
MFPointNet			189	488.8 s	25.66 h	0.21885 G

. Having no vector input has essentially no effect on the training every epoch time. MFPointNet takes only slightly more epoch time than PointNet++, while DGCNN takes the least training epoch time. As is illustrated in Table 6, the model size of the input normal vector is slightly more than that of the no normal vector input. The model size of MFPointNet is the least computationally intensive in comparison, being only slightly more than that of PointCNN. This is due to the downsampling of the SDL module.

5.2. Multi-Machining Feature Recognition

To demonstrate the segmentation performance of the MFPointNet, nine test models with varied intersecting features are used to recognize the multi-machining features. The related results are shown in Figure 9 and Figure 10. As can be seen in Figure 9 and Figure 10, MFPointNet identifies all the segment features correctly for slightly intersecting models. For the two moderately intersecting models, 13 of the 14 machining features can be recognized correctly. It is worth noting that the cylindrical countersunk hole feature has been misrecognized as a round stepped hole. This may be due to the fact that these two features are simply similar and the connecting surfaces are not expressed accurately. For the three highly intersecting models in Figure 10, 23 of the 25 features are recognized correctly.

The misclassification of closed pockets as general step features in Model 7 is probably caused by the confusing intersection between the closed pocket and the straight groove in depth. Furthermore, the rounding feature in Model 9 is incorrectly classified as the round, which is a failure of recognition for MFPointNet. In general, 52 out of 55 machining features are segmented and recognized, with a recognition accuracy of 94.54%. In future work, we intend to establish multi-machining feature datasets, rather than the few models here, to train the neural network to get better recognition accuracy.

6. Conclusions

Machining feature recognition plays an important role in the 3D machining process. In this paper, we propose a neural network MFPointNet, utilizing the selective downsampling layer of the input point to achieve the machining feature recognition. The presented selective downsampling algorithm works by dropping out unimportant points while keeping the important ones. It is proven to reduce the computational model size without accuracy loss. We establish the MFDataset feature dataset. Then the extraction of machining feature surface point sets is adopted to get the corresponding feature data separately, followed by Poisson-disk sampling. In single-feature recognition, we use MFPointNet to train the 256, 512, and 1024 input points. Moreover, the impact of normal vector input is also studied in our method. Experimental results show that compared with other point cloud-based networks, MFPointNet can get a higher single-feature classification accuracy based on the original input point 1024. Due to the selective downsampling layer, the computational model size of MFPointNet is smaller than other point cloud-based networks in general. MFPointNet is more robust to model complexity when more machining feature points are input to the neural network. Compared with the 256 and 512 input points, the classification accuracy of 1024 input points is a bit higher, reaching 98.93%. The model size with normal vectors is only a little more than that without them, but the classification accuracy reaches 99.60%. In multi-machining feature recognition, nine intersecting feature models are made to test MFPointNet’s segmentation performance. Experimental results demonstrate that 52 of the overall 55 machining features are segmented and recognized, with a segmentation accuracy of 94.54%. As this paper is still mainly focused on single-feature recognition, the multi-machining feature dataset creation and a better multi-feature segmentation network will be carried out in future work.