MBD-Based Machining Feature Recognition and Process Route Optimization

Abstract

Machining feature recognition is considered the key connecting technique to the integration of Computer-Aided Design (CAD) and Computer-Aided Process Planning (CAPP), and decision-making of the part processing scheme and the optimization of process route can effectively improve the processing efficiency and reduce the cost of product machining cost. At present, for the recognition of machining features in CAD models, there is a lack of a systematic method to consider process information (such as tolerance and roughness) and an effective process route optimization method to plan part processing procedures. Here we represent a novel model processing feature recognition method, and, on the basis of feature processing plan decision, realize the optimization of the process route. On the basis of a building model Attributed Adjacency Graph (AAG) based on model geometry, topology, and process information, we propose an AAG decomposition and reconstruction method based on Decomposed Base Surface (DBS) and Joint Base Surface (JBS) as well as the recognition of model machining features through Attributed Adjacency Matrix-based (AAM) feature matching. The feature machining scheme decision method based on fuzzy comprehensive evaluation is adopted, and the decision is realized by calculating the comprehensive evaluation index. Finally, the Machining Element Directed Graph (MEDGraph) is established based on the constraint relationship between Machining Elements (MEs). The improved topological sorting algorithm lists the topological sequences of all MEs. The evaluation function is constructed with the processing cost or efficiency as the optimization objective to obtain the optimal process route. Our research provides a new method for model machining feature recognition and process route optimization. Applications of the proposed approach are provided to validate the method by case study.

1. Introduction

Automatic Feature Recognition (AFR) refers to the extraction of feature information with specific engineering significance from part models. A CAD model of a part is composed of low-level graphic elements such as surface, line, and point, while CAPP information is generated based on high-level features with engineering semantics. Feature recognition is an intelligent interface between CAD and CAPP. AFR can identify the corresponding features according to specific process requirements, which is the basis of process planning and the most important step in transforming design information into manufacturing process information. With the help of AFR, the structure feature can be identified according to specific process information, which is considered the most crucial technique to turn design information into a manufacturing process [1].

In recent years, feature recognition has developed rapidly, but the traditional feature recognition methods based on model topology and surface geometry recognition do not take model process information into account. If the roughness and tolerance grade of the assembly surface of two models with identical topology and geometric dimensions are quite different, their processing technology may be completely different. Therefore, machining feature recognition based on machining information has become a problem that must be considered.

Model-Based Definition (MBD) is a model-based product data definition method that adds tolerance, annotation, and other process information on the basis of model topology and geometric data. Based on the geometric and process information in the MBD model, the processing feature recognition based on MBD lays a foundation for the subsequent feature processing scheme decision and process route optimization.

The paper plans to solve the problems of machining feature recognition, machining scheme decision, and process route optimization in the MBD model. On the basis of extracting the model geometry and process information, the model Attributed Adjacency Graph (AAG) is established and decomposed to obtain a feature subgraph, and then the feature subgraph is matched with predefined machining features to realize machining feature recognition. The decision-making method of the model feature processing scheme based on fuzzy comprehensive evaluation is adopted. By analyzing the influencing factors of the feature processing scheme, the subordinate relationship between each influencing factor and the processing scheme is established. A multi-factor comprehensive evaluation model is established according to the single-factor evaluation results, and the optimization of feature processing schemes is realized by calculating the comprehensive evaluation index vector. Finally, based on the constraint relationship between the processing elements, a Machining Elements Directional Graph (MEDGraph) is established. The improved topological sorting algorithm lists all the topological sequences of the processing elements, takes the processing cost or efficiency as the optimization objective, constructs an evaluation function, and obtains the optimal process route.

The remainder of the paper is organized as follows. Section 2 reviews the literature relating to feature recognition. In Section 3, the method of information extraction from MBD is introduced. Model AAG-based machining feature recognition method is constructed in Section 4. In Section 5, the feature processing scheme is decided. In Section 6, the model process route is optimized. The proposed methods are validated through a case study in Section 7, followed by a conclusion in Section 8.

2. Literature Review

In order to achieve feature recognition and process route optimization based on the CAD model, scholars carried out research in the fields of machining feature recognition and process route optimization.

2.1. Machining Feature Recognition

The purpose of machining feature recognition is to realize the conversion from design features to machining features. The concept of feature recognition was first proposed by Kyprianou [2], and its main research object is the geometric topology classification of models. Since then, various types of feature recognition methods have emerged, including graph-based methods, volume decomposition-based methods, neural network-based methods, trace-based methods, rule-based methods, and hybrid methods combining various methods [3].

The graph-based method is considered to be the most successful method. This method describes the feature recognition problem as a graph matching problem. The B-rep model is converted into a graph representation. Joshi and Chang first proposed the feature recognition method of AAG [4]. By acquiring the geometric topological relationship between surfaces and edges of the model, AAG is constructed, and then the machining features are identified by subgraph matching. However, in its research, only the concave–convex attributes of surfaces and edges are considered, and the model information is not fully expressed. Li [5] adds other attributes of vertices on the basis of AAG to form an Extended Attributed Adjacency Graph (EAAG). Marefat and Kashyap proposed the concept of virtual connection and tried to recover the boundary information lost due to the intersection of features [6]. This method realized the recognition of intersection features. However, the virtual connection construction is difficult, and the method is not universal.

Armstrong first proposed feature recognition based on unit decomposition [7]. Sakurai et al. conducted more in-depth research and made great progress [8,9,10]. This method can effectively identify intersection features and provide multiple interpretations [11]. However, this method is low efficient, so it needs to be further filtered. Campana and Mele proposed a rule-based feature recognition method [12], which needs to formulate predefined rules for each type of feature to be recognized. However, the definition of feature rules is not unique, and the calculation of feature recognition methods is large. Requicha et al. proposed a feature recognition method based on traces [13], which mainly studies the traces generated when different features intersect inside the part. Sunil and Pande proposed a feature recognition method based on neural networks [14], which can effectively recognize intersection features. However, due to the problem of data source, the accuracy of its recognition results cannot be guaranteed.

Hybrid feature recognition methods combine the advantages of two or more traditional feature recognition methods. Li et al. used the hybrid feature recognition method to improve the recognition reliability of rib features [15]. Gao and Shah proposed an intersection feature recognition method based on the mixture of graph and rule [16]. Fougeres and Ostrosi adopted a hybrid representation combining framework, syntax, and diagrams for the representation of features [17].

Liu et al. proposed a hybrid feature recognition method based on graph decomposition and feature factor clustering [18]. Zhang et al. input the geometric topology information of the model into the improved BP neural network for feature recognition by reading the step neutral file [19]. Duan et al. proposed a feature recognition method based on feature layering for cabin parts [20]. Luo et al. proposed a hybrid feature recognition method based on the combination of graph and rule-based reasoning [21].

The above feature recognition technologies have the defect of insufficient correlation between the identified features and model process information, which is not conducive to the processing of later process information.

2.2. Feature Processing Scheme Decision

Feature processing scheme decision-making is an important step in process design, which requires comprehensive consideration of many factors, such as material, type of processing features, and processing accuracy. The application of novel decision-making methods, such as the production rule decision-making method, method based on decision table or decision tree, fuzzy reasoning decision-making method, and neural network decision-making method, greatly improves the decision-making efficiency of the processing scheme compared with the traditional method based on process manual.

Berenji et al. proposed a decision-making method based on production rules to determine the processing scheme through the selection structure of judgment [22]. Huang established a mathematical model of fuzzy comprehensive evaluation for the decision-making of feature processing schemes and realized the decision-making process by synthesizing the fuzzy relations [23]. Ma et al. analyzed the fuzzy mapping relationship between feature attributes and the processing scheme and established a processing scheme decision model based on fuzzy reasoning [24]. Hu et al. established a feature processing scheme decision-making model based on Tsukamoto fuzzy reasoning and realized the optimization of feature processing schemes according to the membership degree of each processing scheme [25]. Zhong [26] and Zhao [27] used the neural network method to make feature processing scheme decisions. Guan et al. combined a genetic algorithm and Analytic Hierarchy Process (AHP) to realize the decision of the processing scheme [28]. Hu et al. used particle swarm optimization to optimize processing schemes with the goal of product benefits and product quality [29].

2.3. Process Route Optimization

The formulation of process route is the key to product production, which determines the machining process and cost of parts [30]. The traditional process route formulation method is inefficient and difficult to achieve optimization. With the development of computer technology such as artificial intelligence and data mining, the application of various intelligent algorithms makes it possible to formulate product process plans with high efficiency, low energy consumption, and low cost [31].

Chen et al. studied the CAPP system based on the feature parameter model and realized the process route decision by extracting the geometric feature parameters on the model and matching them with the template base [32]. Peng et al. extracted the feature factors of gear blanks using the fault tree analysis method and obtained the manufacturing process route with the best ecological efficiency [33]. Krishna et al. proposed a novel heuristic ant colony algorithm to search for the global optimal process route, constructed the optimal objective function model, and verified its progressiveness [34]. Salehi et al. proposed a two-level planning process route optimization method [35]. Zhou et al. built a multi-objective model to optimize the low-carbon-based process route optimization method, which determines the minimum carbon emissions and processing time as the objective of optimizing the process route [36].

Cheng et al. integrated the ant colony algorithm and bacterial foraging algorithm and designed two search phases of manufacturing resources and processing element sequence [37]. An et al. proposed an optimization algorithm combining intuitionistic fuzzy sets and the second generation of intensity Pareto to construct a multi-objective function with the lowest replacement cost of processing resources to realize the optimization of the process route [38]. Based on the genetic algorithm, Guo et al. introduced feasible process sequences to improve the genetic algorithm, and the convergence speed and global optimization ability of the genetic algorithm were improved [39,40,41]. Liu et al. combined polychromatic set theory and genetic algorithm and took the shortest auxiliary time as the optimization goal, realizing the work step sequencing in the machining center [42].

3. MBD-Based Model Information Extraction

MBD model data express product design and manufacturing information, including 3D model data, datum, coordinate system, annotation information, and other data, which can provide information support for subsequent process planning of products. Currently, MBD has become a general model definition method. Every mainstream 3D product design software has established a data conversion interface to STEP files and also developed corresponding customized development functions, such as Creo Toolkit of Creo, UG Open provided by UG, and CATIA CAA of CATIA.

The identification of model machining features mainly involves solid model information and annotation information in the MBD model [43]. The solid model reflects the product geometry and is composed of the basic geometric elements through topological connection, including model geometry information and auxiliary geometry information. Auxiliary geometric information is associated with geometric elements such as points, lines, and faces. Annotation information includes dimension, tolerance, roughness, and other elements related to machining requirements. The dimension information expresses the topological relationship between geometric elements, and the relative position between geometric elements can be determined by the dimension. Tolerance and roughness together express the machining accuracy requirements of parts.

Currently, there are two main expression schemas of 3D models, which are CSG and B-Rep. B-Rep representation mainly expresses geometric and topological information. The former is composed of position, coordinate, curve equation, etc., and the latter is formed by point, edge, contour, surface, and logical relationship among them. Most current modeling software supports B-Rep representation.

3.1. MBD Model Data Structure

Geometric elements are topologically connected to form a solid model. From the perspective of data structure, it is mainly composed of surfaces and edges. Annotation information expresses process information of the model and is the basis for formulating machining route. Most 3D modeling software use surfaces, contours, and edges to describe solid models. Surfaces and edges are the main carriers of model information, and contours, as auxiliary geometric elements, play a transitional role between surfaces and edges. The annotation information of the MBD model mainly includes dimension, tolerance, and surface roughness, which are attached to the model geometry.

The model elements involved in feature recognition mainly include surface, edge, dimension, tolerance, and roughness. Structure arrays are defined to represent model elements, as shown in Table 1. Among them, the arrays surface [], edge [], contour [], surfinish [], gtol [], and dimension [], respectively store the information on surfaces, edges, contours, tolerances, and dimensions of the model.

The contour is divided into inner contour and outer contour. The inner contour is a closed loop formed by the end-to-end connected edges inside the model surface. There can be multiple inner contours on a surface. The outer contour is a closed loop formed by the end-to-end connected edges on the outermost side of the model surface. There is only one outer contour on a surface. Each edge has two or more adjacent faces, and the inner contour properties of some edges on different faces are different. It is specified that if an edge appears as an inner contour edge on an adjacent face, the edge is an inner contour edge.

3.2. Extraction of MBD Model Information

The geometry and topology information and annotation information contained in the MBD model are the data basis for subsequent machining feature recognition and process route optimization. There are mainly two methods to extract model data. The first method is to extract information from neutral format files [44], and the other method is through customized development tools provided by commercial CAD modeling software [45]. In this paper, the latter method is used to develop an automatic model data extraction system and construct the data foundation of a machining feature recognition system based on MBD. This paper will take Creo software as an example to extract model information through Creo Toolkit.

The geometry and topology information of the model includes geometric information and topology information. Among them, geometric information describes the geometric data of vertices, edges, and faces; topology information describes the connection between vertices, edges, and faces. According to the above description of model information, when extracting geometric information, the extracted surface data includes ID and type of the surface and the contour information on it. The extracted edge data is the ID and type of the edge. The extracted topological information is mainly the connection relationship between model surfaces and edges, including the concavity–convexity of surfaces and edges and their adjacent surfaces.

When extracting model information, first use the Creo Toolkit interface function to access the model. Then traverse the model surfaces, and record their ID, type, concavity–convexity of the surface, and the adjacent surface ID in sequence. Traverse the contours on the surface, judge the type of the contours and record its constituent edges. Finally, traverse the edges of the model, and record its ID, type, concavity–convexity, and the ID of the adjacent surface in turn.

Take the Creo model as an example, and build its geometry and topology information extraction flow chart, as shown in Figure 1. The main functions related to model geometry and topology information extraction in Creo Toolkit are shown in Table 2.

The pseudo-code of the geometric and topology information extraction algorithm is shown in Appendix A Algorithm A1.

The extracted model annotation information mainly includes dimension, tolerance, and roughness. Dimension information includes dimension symbols, types, values, deviations, and IDs of associated geometric elements. Tolerance information includes tolerance symbols, types, values, IDS of associated geometric elements, and datums; The surface roughness includes roughness value and associated surface ID. The above information is obtained by traversing the surface dimensions, tolerances, and roughness.

4. Machining Feature Recognition Based on AAM

Based on the preceding MBD model information extraction, a machining feature recognition algorithm based on Attributed Adjacency Matrix (AAM) is proposed. The model AAG is constructed by extracting the model information and then decomposed into feature subgraphs and converted into AAM, which is matched with the predefined features to realize the recognition of machining features.

In the process of machining feature recognition based on AAM, a model AAG is constructed according to the geometric and topology information of the model, and it is decomposed based on Decomposition Base Surface (DBS) and Joint Base Surface (JBS). Then match the decomposed AAG subgraph with predefined features to identify machining features. The process is shown in Figure 2.

The related concepts involved in the research process are as follows.

DBS [46] refers to the surface containing one or more inner contours in a 3D model. As shown in Figure 3, the top surface f of the hexahedron contains an inner contour composed of four model edges, and the surface f is a DBS.

Feature Base Surface (FBS) refers to a concave plane in a 3D model, and there is no entity of the model along the normal direction of the surface. As shown in Figure 4, the bottom plane of the keyway is an FBS, which belongs to the concave plane, and there is no entity of the model along its normal direction.

JBS refers to two unconnected model surfaces, which need to be processed as the same surface when machining. When two surfaces have the same equation expression, and at least one of them is concave, the two surfaces are JBSs, such as f₃ and f₄, in Figure 5.

The Maximum Concave Connection Subgraph (MCCS) [18] of a node is the maximum connected graph that can be obtained by taking this node as the starting node and extending outward along the node line of the concave attribute in an AAG.

4.1. Construction of Model AAG

In the process of machining feature recognition based on AAG, the B-Rep information of the model is expressed by AAG, which can accurately describe the topological structure of the model surfaces and edges. Conventional AAG uses nodes to represent surfaces, and lines represent the intersecting edges of two surfaces. When the intersecting edge is convex, it is represented by the number 1, and when it is concave, it is represented by the number 0. This representation that does not include other attributes has certain limitations. Sometimes, AAG cannot accurately express the model.

When constructing the model AAG, the attributes of model surfaces and edges are extracted and used to enhance the expression ability of AAG. The node of AAG represents the model surface, and its attributes include type, concavity–convexity, DBS attribute, FBS attribute, and JBS attribute; its definition is shown in Table 3. The line between AAG nodes represents model edges, and its attributes include type, concavity–convexity, and inner contour edges; its definition is shown in Table 4.

4.1.1. Concavity–Convexity Judgment of Model Edge

The concavity–convexity of model edges is an important attribute of AAG, which determines the properties of model features. Zhou defined edge concavity–convexity as two adjacent surfaces on the mode; when the angle outside the solid is less than 180°, the intersection line is a concave edge. When the angle outside the solid is greater than 180°, the intersection line is convex [47]. According to the above definition, the edge l in Figure 6a is concave, and l’ in Figure 6b is convex.

The preceding method defines the concavity–convexity of the intersection line when the plane intersects with the plane, but does not involve the concavity–convexity judgment of the intersection edge between the surface and planar plane or between two surfaces. According to the extraction of model information in this paper, we propose the definition of model edge concavity–convexity is as follows: when the adjacent surface of the edge is a plane, and the included angle of the non-solid side of the model is in the interval (π, 2π), this edge is convex. When the included angle is in the interval (0, π), this side is concave. When the adjacent surfaces are not all planar planes, and the included angle between the tangent plane of the surface at one point and another plane (or the tangent plane of the surface) on the non-solid side is in the interval (0, π), this edge is concave. When the included angle is in the interval (π, 2π), this side is convex, and when the included angle is equal to 180°, this side is smooth, as shown in Figure 7.

The concavity–convexity of an edge is determined by the included angle of two planes where the edge is located. Luo [21] proposed a method to solve the included angle by using the arccosine of the plane normal vector, as shown in Formula (1).

(1)$\theta =arccos\frac{{\mathit{n}}_1·{\mathit{n}}_2}{\left|{\mathit{n}}_1\right|\left|{\mathit{n}}_2\right|}$

where, $\theta$ is the angle between two planes, ${\mathit{n}}_1$ and ${\mathit{n}}_2$ is the normal vector of the plane.

The included angle that can be calculated in Formula (1) ranges from 0 to π, which can only be applied to the calculation of concave edges. A method to define the included angle between two surfaces is proposed, which can be used to solve the included angle of any angle between two planes or surfaces. The algorithm is as follows:

(1) When the adjacent surfaces of the edges are all planar planes, select one as the base plane, define the edge direction vector as the vector product of the base plane normal vector and the non-base plane normal vector, define the reference direction vector as the vector product of the edge direction vector and the non-base plane normal vector, and the angle between the reference direction vector and the base plane normal vector is $\theta$. When $\cos \left(\theta \right)>0$, the edge is concave. When $\cos \left(\theta \right)<0$, the edge is convex.

(2) When the adjacent surfaces of the edge are not all planar planes, first, take a point P on the edge. If the adjacent surfaces are planes, then select this plane as the base plane, and the tangent plane of the surface at point P is the non-base plane. If the adjacent surfaces are all curved surfaces, the tangent plane of any curved surface at point P is taken as the base surface, and the tangent plane of the other curved surface is taken as the non-base surface. It is defined that the tangent vector at point P is the vector product of the normal vector of the base plane and the normal vector of the non-base plane, the reference direction vector is the vector product of the tangent vector at point P and the normal vector of the non-base plane, and the angle between the reference direction vector and the normal vector of the base plane is $\theta$. When $\cos \left(\theta \right)>0$, the edge is concave. When $\cos \left(\theta \right)<0$, the edge is convex. When $\cos \left(\theta \right)=0$, the edge is smooth.

Take Figure 8 as an example to judge the concavity–convexity of the edges. In (a), $f_1$ and $f_2$ are planar planes, and their normal vectors are ${\mathit{n}}_1$ and ${\mathit{n}}_2$. Take $f_1$ as the base plane, the direction vector of the straight side e is ${\mathit{n}}_e={\mathit{n}}_1\times {\mathit{n}}_2$, and the reference direction vector is $\mathit{n}={\mathit{n}}_e\times {\mathit{n}}_2$. The included angle of $\mathit{n}$ and ${\mathit{n}}_1$ is $\theta$. Because of $cos\theta >0$, the edge is concave. In (b), $f_1$ is a surface, $f_2$ is planar, $f_2$ is taken as the base plane, and then take a point P on the intersection of two surfaces. ${\mathit{n}}_1$ is the normal vector of the tangent plane of $f_1$ at point P, ${\mathit{n}}_2$ is the normal vector of $f_2$, the tangent vector of the intersection at point P is ${\mathit{n}}_e={\mathit{n}}_2\times {\mathit{n}}_1$, and the reference direction vector is $\mathit{n}={\mathit{n}}_e\times {\mathit{n}}_1$. The angle between $\mathit{n}$ and ${\mathit{n}}_2$ is $\theta$. Because of $\cos \left(\theta \right)<0$, the edge e is convex.

4.1.2. Concavity–Convexity Judgment of Model Surface

Guo’s definition of surface concavity–convexity is as follows [48]. If all the edges of the outer contour are convex, the face is convex, and if not, it is concave. But in Figure 9, the outer contour edges of $f_1$ and $f_2$ contain concave edges, and according to the above definition, both surfaces are concave. However, it is generally considered that $f_1$ is convex. So, the above definition is not accurate enough to express the topological information of the model and is only applicable to the model without convex features.

A new method to define the surface convexity–concavity is proposed. The rules are as follows: (1) For a planar plane, when all its outer contour edges are convex, the surface is convex, and when the outer contour edges of the surface are not all convex, the surface is concave. (2) For a quadric surface, its concavity–convexity is judged according to whether the normal vector at any position on the surface is on the same side as the curvature circle at that point. When it is on the same side, the surface is concave; otherwise, it is convex. This is shown in Figure 10.

4.1.3. Construction of AAG

Based on the preceding model information extraction method and attribute research, the model AAG is constructed by taking the model surface as the node, taking the intersection line as the edge, and adding the attributes of surface and line. Its process is shown in Figure 11, and the main steps are as follows.

(1) Extract B-Rep model information. Taking Creo models as examples, the Creo Toolkit is used to traverse the model surfaces and lines to extract their attribute.

(2) Model AAG framework is established, which is based on the geometric information and topological relationship between surface and line. AAG nodes are created based on model surfaces, and AAG edges are created based on the topological relationship between surfaces and edges.

(3) Add model surface attribute information. Traverse AAG nodes and add their attribute information.

(4) Add model edge attribute information. Traverse AAG edges and add their attribute information.

Based on the preceding research on model information extraction and AAG construction, the serialization of model AAG is realized by building structure arrays and assigning values to the structure members. The main steps are as follows:

(1) Access the structure arrays surface [], edge [], and contour [], which were assigned in the previous information extraction.

(2) Construct node structure array node [] and line structure array line [], and establish the corresponding relationship between surface [] and node [] and between edge [] and line [].

(3) Traverse and extract the data in surface [], and define the relevant attributes of node []. The data in edge [] is extracted to define the relevant attributes of the node connection line [].

After the above operations, the model AAG is serialized in the form of a structure array, and its pseudo-code is shown in Appendix A Algorithm A2.

4.2. AAG Decomposition and Reconstruction Based on DBS and JBS

The essence of machining feature recognition based on AAG is to search for isomorphic subgraphs matching predefined features in model AAG [49]. Graph matching is a typical NP-complete problem. So far, there is no suitable method to solve it. The usual countermeasure is to decompose the AAG and then match the subgraphs obtained after decomposition with predefined features. In most of the previous studies, AAGs are decomposed according to the concavity–convexity of the model edges, which has high accuracy for concave feature recognition. However, for convex features, it is not ideal.

An AAG decomposition and reconstruction algorithm based on DBS and JBS is proposed. According to the node attributes, AAG is decomposed to realize the recognition of various features, and the features with the same JBS are reconstructed into subgraphs to merge the segmented features. The basic principle is as follows. AAG is searched for nodes with DBS attributes, and according to the concavity–convexity attributes of the inner contour edges, the subgraphs with concave and convex features are extracted respectively. It is further judged whether the convex feature subgraphs still contain concave feature subgraphs, and the nodes corresponding to the non-machining surfaces in the remaining AAG are deleted. The MCCS with the FBS attribute is extracted. Finally, the nodes with JBS attributes are searched and merged to realize the subgraph reconstruction within the model. The main steps are as follows.

(1) AAG decomposes based on DBS. Traverse AAG to find DBS in the model and delete the inner contour on it. If the edge of the inner contour is a convex edge, the decomposed subgraph is merged into the concave feature subgraph set MAAG. Otherwise, the subgraph is merged into the convex feature subgraph set TAAG.

(2) If a concave edge exists in the convex feature subgraph TAAG-i, the MCCS CAAG-i is extracted with the adjacent face of the edge as the starting node, and CAAG-i and the remaining graphs are merged into the feature subgraph set MAAG. Otherwise, TAAG-i is set as an independent feature and is merged into the feature subgraph set MAAG.

(3) Delete the surface of the non-machining feature. AAG is updated to AAG-1, and the node with the convex surface attribute in AGG-1 and the edges connected with this node are deleted.

(4) AAG decomposes based on FBS. AAG-1 is updated to AAG-2, the nodes with FBS attribute are taken as start nodes, and the MCCS is extracted, which is put into the feature subgraph set MAAG.

(5) Subgraph reconstructs based on JBS. Search for nodes with the same JBS attribute in the feature subgraph set MAAG and merge them to obtain the reconstructed feature subgraph.

The pseudo-code of the preceding algorithm is shown in Appendix A Algorithm A3.

Taking the model shown in Figure 12 as an example, the process of AAG decomposition and reconstruction based on DBS and JBS will be described. According to the method in Section 4.2, its AAG is constructed as shown in Figure 13. There are 16 nodes and 35 lines in the graph, which represent the number of model surfaces and edges, respectively. The numbers on the line represent the edge concavity–convexity, “1” represents the convex edge, and “−1” represents the concave edge. The red lines represent the inner contour edge attribute, the red nodes represent FBS attribute, the orange nodes represent DBS attribute, and the green nodes represent JBS attribute.

The AAG decomposition process of the above model is shown in Figure 14. First, search for the nodes with DBS attribute, which are $f_{15}$ and $f_6$. Search for lines that are connected to $f_{15}$ and $f_6$ and have inner contour attributes, which are the two red lines in the AAG, and delete them. Since $f_6$ has convex edge attribute, the subgraph (I) is composed of a single node $f_6$, which is a concave characteristic subgraph. Then, update AAG to get AAG-1, as shown in (a). Delete the node with the convex attribute in AAG-1 and the line connected with the node, and update to get AAG-2, as shown in (b). Search AAG-2 for nodes with FBS attribute, which are $f_9$, $f_{12}$, and $f_{15}$. Finally, the MCCSs of nodes $f_9$, $f_{12}$, and $f_{15}$ are extracted, respectively, to obtain the feature subgraph (II) composed of nodes $f_8$, $f_9$, and $f_{10}$; the feature subgraph (III) composed of nodes $f_{11}$, $f_{12}$, and $f_{13}$; and the feature subgraph (IV) composed of nodes $f_{14}$ and $f_{15}$. After decomposition, a total of four feature subgraphs are obtained, as shown in (c), which are the through-hole feature where $f_{16}$ is located, the blind-hole feature where $f_{15}$ is located, the groove feature where $f_9$ is located, and the groove feature where $f_2$ is located.

Surface f₉ and f₁₂ are JBSs, and they will generally be processed as a feature when machining. However, it is now divided due to the intersection of features, so two feature subgraphs are generated through the decomposition of AAG. According to the AAG reconstruction method based on JBS described above, it is found that three groups of nodes, $f_8$ and $f_{11}$, $f_9$ and $f_{12}$, and $f_{10}$ and $f_{13}$, have the same JBS attribute. Through subgraph reconstruction, the two features corresponding to nodes $f_8$, $f_9$, $f_{10}$ and $f_{11}$, $f_{12}$, $f_{13}$ are merged into one through slot feature, as shown in Figure 15.

4.3. Machining Feature Matching Based on AAM

Generally, feature matching is accomplished by the isomorphism of graphs. Its principle is as follows: after the decomposition of AAG, the feature subgraph is isomorphically matched with the predefined features. If the two have the same topology, it indicates that the feature matching is successful, and the feature object is recognized as the corresponding processing feature; if the matching fails, the feature type is undefined or does not exist. In order to overcome the shortcomings of the existing feature matching methods, a machining feature matching method based on AAM is proposed.

4.3.1. Machining Feature Matching Method Based on AAM

Aiming at the problem of feature matching, a feature matching algorithm based on AAM is proposed. The decomposed feature subgraph is constructed as AAM and matched with the predefined feature to realize the recognition of machining features. The advantage of this method is that it only needs to match the features of the constituent elements of AAM and avoids the similarity transformation of AAM.

The AAM constructed by AAG is a square matrix whose order is equal to the number of nodes in the feature subgraph. Diagonal elements represent the attributes of nodes in the feature subgraph, and non-diagonal elements represent the attributes of edges in the feature subgraph. The AAM of a feature subgraph is shown in Formula (2).

(2)$M\left[n][n\right]=\left[\begin{array}{cccc}{m}_{11}& m_{12}& \cdots & m_{1n}\\ m_{21}& m_{22}& \cdots & m_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ m_{n1}& m_{n2}& \cdots & m_{nn}\end{array}\right]$

where, $n$ represents the number of nodes of the feature subgraph, $m_{ij}$ ($i\ne j$) indicates the attribute of edge, $m_{ii}$ indicates the attribute of the node.

The node attribute is composed of concavity–convexity, type, and FBS attribute of the surface. It is expressed as a positive integer containing three digits. It is recorded as $m_{ii}=abc$, and the values of each attribute are shown in Formulas (3)–(5).

(3)$a=\{\begin{array}{l}1 \mathrm{Convexity} \mathrm{surface}\hfill \\ 0 \mathrm{Concavity} \mathrm{surface}\hfill \end{array}$

(4)$b=\{\begin{array}{l}1 \mathrm{Planar} \mathrm{plane}\hfill \\ 2 \mathrm{Cylinder}\hfill \\ 3 \mathrm{conical} \mathrm{surface}\hfill \\ 4 \mathrm{other} \mathrm{surface}\hfill \end{array}$

(5)$c=\{\begin{array}{l}1 \mathrm{FBS}\hfill \\ 2 \mathrm{Non} \mathrm{FBS}\hfill \end{array}$

The edge attribute consists of concavity–convexity and the type of the edge, which is represented by a positive integer containing two digits and is recorded as $m_{ij}=de$. The values of each attribute are shown in Formulas (6) and (7).

(6)$d=\{\begin{array}{l}1 \mathrm{Concavity} \mathrm{edge}\hfill \\ 2 \mathrm{Convexity} \mathrm{edge}\hfill \\ 3 \mathrm{smooth} \mathrm{edge}\hfill \end{array}$

(7)$e=\{\begin{array}{l}1 \mathrm{Staight} \mathrm{edge}\hfill \\ 2 \mathrm{Arc} \mathrm{edge}\hfill \\ 3 \mathrm{other} \mathrm{edge}\hfill \end{array}$

The node and edge attributes are stored in the structure array node [][] and line [][], respectively. Node attribute can be assessed through node [ ][ ].node_at, node[ ][ ].node_ type and node[ ][ ].node_ f_face. Edge attribute can be obtained through line[ ][ ].line_ at and line[ ][ ].line_type.

If the geometric information and topological structure of the nodes and edges in the predefined feature and feature subgraph are the same, it means that they match, which should meet the requirement of the same order of the matrix, same diagonal elements, and the similarity of each row element set. The similarity of each row element set means that each row element of the AAM of the feature subgraph has a one-to-one mapping relationship with each row element of the predefined AAM.

The main process of the AAM-based feature matching algorithm is as follows.

(1) Judge whether the order of the feature subgraph AAM and the predefined AAM are the same.

(2) Judge whether diagonal elements are equal.

(3) Judge whether the sets formed by each row element are similar. If any of the conditions are not met, the matching is unsuccessful.

(4) If the matching is not successful, the sub-feature is exported, and whether they are machining features will be judged by human–computer interaction. If so, they will be added to the predefined feature library.

Table 5 shows typical machining features and their predefined AAMs, in which the green area is the machining feature. The algorithm in this paper can effectively identify through hole, blind-hole, closed key slot, open key slot, through groove, cylinder extrusion, blind groove, step, and other machining features.

4.3.2. AAM Establishment Algorithm

For a characteristic subgraph t, the structure arrays of the nodes and edges are node[t][n] and line[t][n]. Traverse the members of the node array node[ ][ ].node_at, node[ ][ ].node_ type and node[ ][ ].node_ f_face and get the node properties. Traverse the edge array members line[ ][ ].line_ at and line[ ][ ].line_type and get the edge properties. The establishment process of AAM is shown in Figure 16.

The main steps are as follows, and the pseudo-code of the algorithm is shown in Appendix Algorithm A4.

(1) Access the data of line2[t][] and node2[t][], and define matrix $M\left[n][n\right]$, and assign the initial value of each element to 0.

(2) Determine the value of $m_{ii}$. If node2[t][$i$].node_f_face = true, then $a=1$. If node2[t][$i$].node_f_face = false, then a = 2. Determine the value of b as follows: $b=\mathrm{node}2\left[t\right][i].\mathrm{node}\_ \mathrm{type}$. Determine the value of c as follows: $c=\mathrm{node}2\left[t\right][i].\mathrm{node}\_\mathrm{at}$.

(3) Assign the data of $m_{ij}$ as follows: $d=\mathrm{line}2\left[t\right]\left[j\right].\mathrm{line}\_\mathrm{type}$ and $e=\mathrm{line}2\left[t\right]\left[j\right].\mathrm{line}\_ \mathrm{at}$.

4.3.3. AAM Matching Algorithm

A matching method of feature subgraph AAM and predefined feature AAM is proposed. The feature subgraph AAM to be matched is represented by matrix $\mathrm{A}\left[n][n\right]$, and the predefined feature AAM is represented by matrix $\mathrm{B}\left[m][m\right]$. The main process of matching between them is as follows.

(1) If $n=m$, go on; otherwise, the matching is unsuccessful.

(2) Define set $S_1$ and $S_2$, and assign the values of diagonal elements of $\mathrm{A}\left[n][n\right]$ to $S_1$, and the value of $\mathrm{B}\left[m][m\right]$ diagonal element to $S_2$. If $S_1$ = $S_2$, go on; otherwise, the matching is not successful.

(3) Define set $S_{Ai}$ and $S_{Bj}$ and assign the valve of No.i row of a [n] [n] to set $S_{Ai}$, the valve of No.j row of a [n] [n] to set $S_{Bj}$. If each set $S_{Ai}$ can find the set $S_{Bj}$ that is equal to it and does not repeat, the matching is successful and the machining feature is recognized; otherwise, the matching is unsuccessful.

The flow chart of feature subgraph matching is shown in Figure 17, and the pseudo-code of the algorithm is shown in Appendix A Algorithm A5.

5. Decision Making of Feature Processing Scheme Based on Fuzzy Comprehensive Evaluation

The determination of the feature processing scheme is a complex decision-making process and also the premise of process route optimization. Based on the recognition of MBD model machining features, a feature processing scheme decision method based on fuzzy comprehensive evaluation is proposed. By analyzing the influencing factors of processing scheme selection, the mapping relationship between the influencing factors and processing schemes is established. A multi-factor comprehensive evaluation model is established according to the single-factor evaluation results. By calculating the comprehensive evaluation index vector, the optimization of feature processing schemes is realized. The processing scheme decision-making process based on fuzzy comprehensive evaluation is shown in Figure 18. The main steps are as follows:

(1) Establish the factor set that affects the decision-making of the processing scheme. The set is shown as follows

(8)$U=\left\{u_1,u_2,\cdots ,u_i\right\}$

where, $u_i$ is the No.i factor affecting the evaluation object.

(2) Determine the weight of each influencing factor. In the evaluation of processing methods, the importance of each influencing factor is different. The weight of the influencing factor $u_i$ is expressed as $w_i$. Therefore, the weight set of influencing factors is established as shown in the following formula

(9)$W=\left\{w_1,w_2,\cdots ,w_i\right\}$

(3) Establish an alternative set of processing schemes. The alternative set of processing schemes is the set of all possible results of the evaluation object.

(4) Single-factor fuzzy evaluation. The fuzzy comprehensive evaluation matrix R is obtained according to the fuzzy relationship matrix between each influencing factor and the alternative set of the processing scheme.

(5) Calculate the fuzzy comprehensive evaluation index vector $B=W·R$. Select the largest evaluation index $b_i$ as the final result.

According to the process characteristics of parts, the features are divided into face features and hole features. We take face features as an example and carry out fuzzy comprehensive evaluation of feature processing schemes on the basis of studying its single factor fuzzy evaluation.

5.1. Establishment of Alternative Sets for Fuzzy Evaluation of Surface Features

The main influencing factors of the surface feature process scheme include workpiece material, feature type, processing accuracy, roughness, and other process requirements. The fuzzy evaluation influencing factor set is shown in the following formula

(10)$U_1=\left\{M,F,IT,R_a\right\}$

where, $M$ stands for workpiece material, $F$ stands for feature type, $IT$ stands for machining accuracy and $R_a$ stands for surface roughness. The workpiece material $M$ is specifically expressed as:

(11)$M=\left\{m_1,m_2,m_3\right\}$

where, $m_1~m_3$ represent steel, cast iron, and non-ferrous metals, respectively.

Feature type $F$ is represented by the set shown in the following formula

(12)$F=\left\{f_1,f_2,f_3,f_4,f_5,f_6,f_6\right\}$

where, $f_1~f_6$ denote plane, step, blind step, through groove, blind groove, cavity, and boss, respectively.

The alternative set of fuzzy evaluation of feature processing schemes is the set of all possible feature processing schemes. The type, processing size, material, and accuracy requirements of features are the main factors to be considered in formulating processing schemes. The typical processing scheme set of surface processing features is shown in Table 6.

A fuzzy evaluation candidate set of face features is established according to the above processing scheme, as shown below

(13)$X=\left\{x_1,x_2,x_3,x_4,x_5,x_6\right\}$

where, $x_1~x_6$ represent typical processing schemes of surface features, which are rough planing, rough planing fine planing, rough planing fine planing wide blade fine planing, rough milling, rough milling fine milling, rough milling fine milling fine grinding.

5.2. Determination of Weight of Each Influencing Factor

In order to ensure the objectivity of the weights of the influencing factors of fuzzy evaluation, the method of combining the Analytic Hierarchy Process (AHP) and expert consultation [50] is used to establish the weight set of the influencing factors of area characteristics, as shown below

(14)$W=\left\{w_1,w_2,w_3,w_4\right\}$

where, $w_1~w_4$ represent the weight of processing material, feature type, processing accuracy, surface roughness, and ${\displaystyle \sum }_{i=1}^4{w}_i=1$.

Because each factor has a different influence on the feature processing scheme, according to the scale of AHP shown in Table 7, a comparison matrix A of surface features is established, as shown in Formula (15).

(15)${\left[a_{ij}\right]}_{4\times 4}=\left[\begin{array}{cccc}1& 2& 3& 3\\ \frac{1}{2}& 1& 3& 3\\ \frac{1}{3}& \frac{1}{3}& 1& 1\\ \frac{1}{3}& \frac{1}{3}& 1& 1\end{array}\right]$

where, $a_{ij}=C_i/C_j$, $a_{ij}>0, a_{ij}=1/a_{ij}$.

In order to ensure the rationality of the comparison matrix, the consistency test is carried out. The consistency verification ratio $CR$ of the comparison matrix is shown as follows

(16)$CR=CI/RI$

where, $CI$ is the consistency index of comparison matrix, which is defined as follows

(17)$CI=\left(\lambda -n\right)/\left(n-1\right)$

where, $n$ is the order of the comparison matrix, and $RI$ is the random consistency index. The values of RI are shown in Table 8.

If $CR<0.1$, it is considered that the consistency of the comparison matrix is satisfactory, and its normalized eigenvector can be used as the weight vector. Through calculation, the maximum eigenvalue of the comparison matrix A of surface features is 5.0606, and the consistency verification ratio of its comparison matrix $CR$ is 0.0224, which is less than 0.1. Therefore, the consistency is satisfactory. Normalize the feature vector of a to obtain the weight set of influencing factors $W=\left\{0.444,0.312,0.122,0.122\right\}$.

5.3. Single Factor Fuzzy Mapping of Machining Schemes for Surface Features

For surface feature processing schemes, according to the set of influencing factors for fuzzy evaluation, a fuzzy mapping relationship model with each influencing factor is established, as shown in Figure 19.

In the preceding figure, $U_{M\times X}$, $U_{F\times X}$, $U_{IT\times X}$, and $U_{Ra\times X}$ are the fuzzy relations between workpiece material, feature type, machining accuracy, surface roughness, and surface feature machining scheme.

5.3.1. Fuzzy Mapping between Workpiece Material and Machining Schemes

According to the application scope of the machining scheme of each surface feature, the corresponding relationship between the workpiece material and the machining scheme is shown in Table 9.

When the workpiece material $m_i$ can be processed by the processing scheme $x_j$, the membership degree of $\left(m_i,x_j\right)$ is set to 1; otherwise, it is set to 0. According to the preceding correspondence, the fuzzy mapping expression between the material type and the surface feature processing scheme is obtained, as shown below

(18)$f_{M\times X}\left(m_i,x_j\right)=\{\begin{array}{c}{f}_{M\times X}\left(m_1,x_j\right)=\left\{\frac{1}{x_1},\frac{1}{x_2},\frac{1}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{1}{x_6}\right\}\\ f_{M\times X}\left(m_2,x_j\right)=\left\{\frac{1}{x_1},\frac{1}{x_2},\frac{1}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{1}{x_6}\right\}\\ f_{M\times X}\left(m_3,x_j\right)=\left\{\frac{1}{x_1},\frac{1}{x_2},\frac{1}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{0}{x_6}\right\}\end{array}$

From the above formula, the fuzzy relationship between the workpiece material set $M$ and the surface feature machining scheme set $X$ can be obtained, which is represented by fuzzy matrix $R_{M\times X}$, as shown in Equation (19).

(19)${\left[r_{ij}\right]}_{3\times 6}=\left[\begin{array}{cccccc}1& 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1& 0\end{array}\right]$

where, $r_{ij}={\mu }_{M\times X}\left(m_i,x_j\right)$ indicates the possibility of selecting a processing scheme $x_j$ when the workpiece material is $m_i$.

5.3.2. Fuzzy Mapping between Feature Types and Machining Schemes

The corresponding relationship between the feature types and the processing schemes of the features of each surface is shown in Table 10.

When the processing feature of type $f_i$ can be processed with processing scheme $x_j$, the membership degree of $\left(f_i,x_j\right)$ is set to 1; otherwise, it is set to 0. According to the corresponding relationship, the fuzzy mapping expression between the feature type and the surface feature processing scheme is obtained, as shown below.

(20) $\{\begin{array}{c}{f}_{F\times X}\left(f_1,x_j\right)=\left\{\frac{1}{x_1},\frac{1}{x_2},\frac{1}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{1}{x_6}\right\}\\ f_{F\times X}\left(f_2,x_j\right)=\left\{\frac{1}{x_1},\frac{1}{x_2},\frac{1}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{1}{x_6}\right\}\\ f_{F\times X}\left(f_3,x_j\right)=\left\{\frac{0}{x_1},\frac{0}{x_2},\frac{0}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{0}{x_6}\right\}\\ f_{F\times X}\left(f_4,x_j\right)=\left\{\frac{1}{x_1},\frac{1}{x_2},\frac{1}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{1}{x_6}\right\}\\ f_{F\times X}\left(f_5,x_j\right)=\left\{\frac{0}{x_1},\frac{0}{x_2},\frac{0}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{0}{x_6}\right\}\\ f_{F\times X}\left(f_6,x_j\right)=\left\{\frac{0}{x_1},\frac{0}{x_2},\frac{0}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{0}{x_6}\right\}\\ f_{F\times X}\left(f_7,x_j\right)=\left\{\frac{0}{x_1},\frac{0}{x_2},\frac{0}{x_3},\frac{1}{x_4},\frac{1}{x_5},\frac{0}{x_6}\right\}\end{array}$

According to Formula (20), the fuzzy relationship between the feature type set $F$ and the surface feature processing scheme set $X$ can be obtained, which is expressed by the fuzzy matrix $R_{F\times X}$, as shown below

(21)${\left[r_{ij}\right]}_{7\times 6}=\left[\begin{array}{cccccc}1& 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 1& 1& 0\\ 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 1& 1& 0\\ 0& 0& 0& 1& 1& 0\\ 0& 0& 0& 1& 1& 0\end{array}\right]$

where, $r_{ij}={\mu }_{F\times X}\left(f_i,x_j\right)$, which indicates the possibility of selecting machining scheme $x_j$ when the machining feature type is $f_i$.

5.3.3. Fuzzy Mapping between Machining Accuracy and Machining Schemes

The machining accuracy range of feature machining scheme $x_j$ is $ITn~ITm$, $n<m$. The following assumptions are made in this paper:

(1) When $IT$ is less than $ITn-2$, the scheme $x_j$ cannot meet the processing requirements, so the possibility of scheme selection is 0.

(2) When $IT$ is greater than $ITm$, although this scheme can meet the processing requirements, its economy is poor, so the possibility of selecting this scheme is 0.

(3) When $IT$ is in the range of $ITn-2~ITn$, the possibility of selecting this scheme is 0.8~1.

(4) When $IT$ is in the range of $ITn~ITm$, the possibility of selecting this scheme is 1.

The membership function of the fuzzy mapping between the machining accuracy and the scheme is defined using the piecewise function method, as shown in Formula (22).

(22)$\mu \left(IT,x_j\right)=\{\begin{array}{cc}0& IT<ITn-2\\ 1-\frac{\left(ITn-IT\right)}{5\left(ITm-ITn\right)}& ITn-2\le IT<ITn\\ 1& ITn\le IT\le ITm\\ 0& IT>ITm\end{array}$

According to $\mu \left(IT,x_j\right)$, the fuzzy relationship between the machining accuracy $IT$ and the surface feature machining scheme set $X$ is obtained, which is expressed by the fuzzy matrix $R_{IT\times X}$, as shown below

(23)$R_{IT\times X}={\left[r_{1j}\right]}_{1\times 6}$

where, $r_{1j}$ represents the possibility of selecting the machining scheme $x_j$ when the machining feature accuracy requirement is $IT$.

5.3.4. Fuzzy Mapping between Surface Roughness and Machining Scheme

When the surface roughness is greater than the upper limit of the roughness obtained by the machining scheme, the machining scheme cannot meet the requirement, and the selectivity of the machining scheme is 0. When the surface roughness is between the upper and lower limits of the scheme roughness, the processing scheme can meet the requirements, and the optional range of the scheme is 0.8~1. When the surface roughness is less than the lower limit of the scheme roughness, the machining scheme can meet the requirements, but the economy is reduced, so its selectivity is zero. The membership function of the surface roughness is shown below

(24)$\left(R_a,x_j\right)=\{\begin{array}{cc}0& R_a<a\\ 1-\frac{\left(logb-log{R}_a\right)}{5\left(logb-loga\right)}& a\le R_a\le b\\ 0& R_a>b\end{array}$

where, $R_a$ is the surface roughness required by the machining feature, $a$ is the minimum roughness that can be achieved by the machining scheme, and $b$ is the maximum. Since the surface roughness standard series is approximately an equal ratio series, and its common ratio is $\sqrt{10}$, the logarithm of the surface roughness value is taken [25].

According to the membership function of the surface roughness $\mu \left(R_a,x_j\right)$, the fuzzy relationship between the surface roughness and the processing scheme set $X$ can be obtained, which is expressed by the fuzzy matrix $R_{Ra\times X}$, as shown below

(25)$R_{Ra\times X}={\left[r_{1j}\right]}_{1\times 6}$

where, $r_{1j}$ represents the possibility of selecting the machining scheme $x_j$ when the machining surface roughness requirement is $Ra$.

5.4. Fuzzy Comprehensive Evaluation of Feature Processing Scheme

The fuzzy comprehensive evaluation of feature machining scheme is a decision-making process of the machining scheme, which comprehensively considers various influencing factors. According to the fuzzy relation matrix of each single-factor, the final fuzzy comprehensive evaluation matrix can be obtained, as shown in Equation (26).

(26)$R={\left[R_M,R_F,R_{IT},R_{Ra}\right]}^T$

where, $R_M$ is workpiece material fuzzy matrix, $R_F$ is feature type fuzzy matrix, $R_{IT}$ is machining accuracy fuzzy matrix, and $R_{Ra}$ is surface roughness fuzzy matrix.

The calculation of fuzzy comprehensive evaluation index vector is shown in Formula (27).

(27)$B=W·R$

where, $W$ is weight vector of influencing factors and $R$ is fuzzy comprehensive evaluation matrix.

According to the calculation results, the candidate set element corresponding to the maximum evaluation index $b_i$ is selected as the processing scheme. The pseudo-code of the feature processing scheme decision algorithm based on fuzzy comprehensive evaluation is shown in Appendix A Algorithm A6.

6. Process Route Optimization Based on MEDGraph

The process route optimization of the feature machining scheme is a problem of optimizing the Machining Element (ME) sequence. On the basis of analyzing the constraint relationship among the MEs, a model machining process route optimization method based on MEDGraph is proposed. First, MEDGraph is established based on the constraint relationship among the MEs, and then the topology sequence of all the MEs is listed by the improved topology sorting algorithm. Finally, the evaluation function is constructed with the machining cost or efficiency as the optimization objective to obtain the optimal process route.

6.1. Description of Process Route Optimization Problem

The optimization of the process route is to sort the processes in the machining scheme according to the process rules and optimization objectives and obtain the optimal or near-optimal processing route. A part to be machined can be regarded as a set of multiple machining features. It is assumed that a part has n machining features, which is represented as follows

(28)$Part=\left\{f_1,f_2,\cdots ,f_n\right\}$

where, $f_i$ is the No.i machining feature in the part.

Each machining feature is usually formed through a plurality of processes, which correspond to the machining scheme of the machining feature. Dou et al. [40] defines the information entities related to feature processing as ME, which is represented as a six tuple, as shown below

(29)$me=\left(ID,f_i,S,M,T,TAD\right)$

where, ID is the ME number; $f_i$ is the characteristics processed by ME; S is the processing name, such as rough turning and fine turning; M is the machine tool used for processing; T is the required tools; and TAD is the tool approach direction.

The machining process of a part can be expressed as a set of MEs, as shown below

(30)$ME=\left\{m{e}_1,m{e}_2,\cdots ,m{e}_n\right\}$

where, $m{e}_i$ is the No.i ME in the processing element set.

On the basis of the preceding definition, the optimization of the process route is transformed into the optimization of the processing elements sorting in $ME$. That is, the evaluation function is established with the processing cost or production efficiency as the optimization objective, and the processing element ranking result with the best target value is obtained under the condition that the relevant process rules are met.

Structure array me[] is constructed, which is used to store relevant information of processing elements. Its members include me_id, stage, TAD, feature_id, operation_name, t_id, and m_id, which are used to store ME ID, processing stage, TAD, machined feature, processing name, tool ID, and machine ID, respectively. Among them, the processing stages to which the processing element belongs are represented by 1, 2, 3, and 4, which are rough processing, semi-finishing, finish processing, and finishing processing, respectively.

6.2. The Construction of MEDGraph

In order to ensure the processing quality, the formulation of the process route needs to comply with the relevant rigid process rules and give priority to meeting the additional rules. Rigid process rules are mainly as follows: benchmark first, rough machining before finish machining, surface machining before hole, and process the main surface first and then the other surface. Additional rules are recommended rules during processing, mainly including: (1) Adjacency rule. The process execution sequence of certain machining features is preferably adjacent. (2) Clustering rules. Features on the same surface, features of the same type, or features that need to be processed with the same tool are best arranged for processing together.

Based on the constraint relationship between the processing elements, the process flow represented by the directed graph is called Machining Element Directed Graph (MEDGraph) [51], which is defined as

(31)$G=\left(V,E\right)$

where, $V$ is the node of the digraph, representing the MEs set, and its definition is shown as Formula (32); $E$ is the set of directed edges, which indicates the priority relationship between MEs. Its definition is shown as Formula (33).

(32)$V=ME=\left\{m{e}_0,m{e}_1,m{e}_2,\cdots ,m{e}_n\right\}$

(33)$E=\left\{e\left(m{e}_i,m{e}_j\right)|0\le i,j\le n,i\ne j\right\}$

The processing element directed graph is established according to the constraint relationship between processing elements. The establishment process is as follows: traverse all processing elements, randomly select two of them, create corresponding nodes, judge the constraint relationship between the two processing elements, and create a directed edge between nodes according to their priority order until all processing elements have created corresponding nodes. The process element digraph is represented by an adjacency matrix, and its definition is shown in Equation (34).

(34)$\mathrm{E}\left[n\right]\left[n\right]=\left[\begin{array}{ccc}\begin{array}{cc}{e}_{11}& e_{12}\\ e_{21}& e_{22}\end{array}& \cdots & \begin{array}{c}{e}_{1n}\\ e_{1n}\end{array}\\ ⋮& \ddots & ⋮\\ \begin{array}{cc}{e}_{n1}& e_{n2}\end{array}& \cdots & e_{nn}\end{array}\right]$

where, $n$ is the number of nodes in MEDGraph, $e_{ii}$ is machining element $m{e}_i$, $e_{ij}$ is the constraint relationship between $m{e}_i$ and $m{e}_j$. The value rules of $e_{ij}$ are as follows: when $m{e}_i$ takes precedence over $m{e}_j$, $e_{ij}=1$, $e_{ji}=-1$; if there is no priority constraint relationship between $m{e}_i$ and $m{e}_j$, $e_{ij}=e_{ji}=0$.

The construction process of the MEDGraph matrix is shown in Figure 20, and its main steps are as follows:

(1) Assign an initial value of 0 to the element $e_{ij}$ of $\mathrm{E}\left[n\right]\left[n\right]$, $1\le i\le n, 1\le j\le n$.

(2) Let $i=1$, $j=i+1$, and judge whether there is a benchmark relationship between $\mathrm{me}\left[i-1\right].\mathrm{feature}$ and $\mathrm{me}\left[j-1\right].\mathrm{feature}$ If $\mathrm{me}\left[j-1\right].\mathrm{feature}$ is based on $\mathrm{me}\left[i-1\right].\mathrm{feature}$, let $e_{ij}=1$, $e_{ji}=-1$; otherwise, go to (3).

(3) If $\mathrm{me}\left[i-1\right].\mathrm{stage}<\mathrm{me}\left[j-1\right].\mathrm{stage}$, let $e_{ij}=1, e_{ji}=-1$; otherwise, go to (4).

(4) Judge whether there is a dependency between $\mathrm{me}\left[i-1\right].\mathrm{feature}$ and $\mathrm{me}\left[j-1\right].\mathrm{feature}$. If $\mathrm{me}\left[j-1\right].\mathrm{feature}$ depends on $\mathrm{me}\left[i-1\right].\mathrm{feature}$, let $e_{ij}=1$, $e_{ji}=-1$; otherwise, go to step 5.

(5) Let j + +, and return to (2) until j = n + 1 and go to (6).

(6) let i + +, j = i + 1, return to (2) until i = n + 1, and end the program.

6.3. Acquisition of ME Topological Sequence Based on Improved Topology Sorting Algorithm

The MEDGraph constructed by the preceding method is a Directed Acyclic Graph (DAG). Using a topological sorting algorithm, all vertices in the DAG can be arranged into a linear sequence so that any pair of nodes $u$ and $v$ in the graph, if $⟨u,v⟩\in \mathrm{E}\left(\mathrm{DAG}\right)$, $u$ appears before $v$ in the linear sequence. Such a linear sequence is called a topological sequence. The basic principles of the topology sorting algorithm are as follows: (1) select a node with a degree of 0 from the digraph and output it. (2) Delete this node and all directed edges from it from the directed graph. (3) Repeat the above steps until there are no more nodes with a degree of 0 in the digraph. The algorithm is shown in Figure 21.

The results of the topological sorting of digraphs are not unique, and the conventional topological sorting algorithm can only obtain one result at random. By combining the topological sorting algorithm with the backtracking method, an improved topological sorting algorithm is proposed to obtain all the MEs topological sequences. The basic principle is as follows: after outputting a topological sequence, trace back to the previous node, and output nodes different from the previous topological sequence at this level. If there are no different nodes, continue to trace back to the previous level and finally realize the output of all topological sequences; its flow chart is shown in Figure 22, and the process is as follows:

(1) Read the MEDGraph.

(2) Find all the nodes in the current digraph with an indegree of 0, which constitute the node set $S\left(j\right)$, and set the set index $i=0$. Go to (3) if the set is not empty; otherwise, go to 4.

(3) If $i<\mathrm{length}\left(S\left(j\right)\right)$, take $S\left(j\right)\left[i\right]$ as the value of the current topological sequence element $\mathrm{result}\left[j\right]$, and add 1 to i. Delete all the directional edges starting from $\mathrm{result}\left[j\right]$, and mark the deleted directional edges so that they can be recovered during backtracking. Return to (2) and continue to obtain the value of the current topology sequence element $\mathrm{result}\left[j+1\right]$.

If $i>\mathrm{length}\left(S\left(j\right)\right)$, trace back to the last topological sequence element $\mathrm{result}\left[j-1\right]$, and change its value to the next value in the corresponding set $S\left(j-1\right)$. Before using this value, recover all directed edges starting from $S\left(j-1\right)\left[n\right]$ and turn to (2). If n is equal to the number of elements in the set $S\left(j-1\right)$, the backtracking continues. Subtract 1 from j, and recover the deleted edge to obtain a new value. When j is equal to −1, it ends.

(4) If the number of elements in the current topology sequence is equal to the number of nodes, output it, go to (3), and continue to find other possible topology sequences.

Through the improved topological sorting algorithm, the topological sequence of all MEs is obtained.

6.4. Acquisition of Optimal Machining Element Topological Sequence

All the ME topological sequences are obtained by using the improved topological sorting algorithm mentioned above, and each of them can be converted into a feasible process route. An optimal route will be selected according to cost, efficiency, and other factors. Therefore, it is necessary to build an evaluation function and select the optimal ME topological sequence according to the value of the function. Considering that frequent replacement of manufacturing resources in the machining process will increase process error and reduce quality and efficiency, the evaluation function of the processing element sequence is constructed with the minimum number of replacements of manufacturing resources as the optimization objective, as follows

(35)$F={\gamma }_1{F}_1+{\gamma }_2{F}_2+{\gamma }_3{F}_3$

where, $F_1$, $F_2$, and $F_3$ are machine tool transformation function, fixture transformation function, and tool transformation function, respectively, and ${\gamma }_1$, ${\gamma }_2$, and ${\gamma }_3$ are the weight coefficients of the above functions.

Different ME may use different machine tools, but frequent replacement of the machine tools during the machining process will increase the auxiliary time. At the same time, because the workpiece needs to be relocated when replacing the machine tool, the machining accuracy will be affected. The MEs using the same machine tool shall be arranged in adjacent positions as far as possible. The machine transformation function is defined as follows:

(36)$F_1={{\displaystyle \sum }}_1^{n-1}{\partial }_1\left(\mathrm{me}\left[i\right].\mathrm{m}\_\mathrm{id},\mathrm{me}\left[i+1\right].\mathrm{m}\_\mathrm{id}\right)$

Similarly, different processing elements may use different fixtures and tools, and changing fixtures and tools will also increase auxiliary time and reduce accuracy. The processes using the same fixtures and tools shall be arranged in adjacent positions as far as possible. The fixture and tool transformation functions are shown in Formulas (37) and (38).

(37)$F_2={{\displaystyle \sum }}_1^{n-1}{\partial }_2\left({\partial }_1\left(\mathrm{me}\left[i\right].\mathrm{m}\_\mathrm{id},\mathrm{me}\left[i+1\right].\mathrm{m}\_\mathrm{id}\right),{\partial }_1\left(\mathrm{me}\left[i\right].\mathrm{TAD},\mathrm{me}\left[i+1\right].\mathrm{TAD}\right)\right)$

(38)$F_3={{\displaystyle \sum }}_1^{n-1}{\partial }_2\left({\partial }_1\left(\mathrm{me}\left[i\right].\mathrm{m}\_\mathrm{id},\mathrm{me}\left[i+1\right].\mathrm{m}\_\mathrm{id}\right),{\partial }_1\left(\mathrm{me}\left[i\right].\mathrm{t}\_\mathrm{id},\mathrm{me}\left[i+1\right].\mathrm{t}\_\mathrm{id}\right)\right)$

where, $\partial \left(x,y\right)$ is defined as follows:

(39)${\partial }_1\left(x,y\right)=\{\begin{array}{c}1 x\ne y\\ 0 x=y\end{array}$

(40)${\partial }_2\left(x,y\right)=\{\begin{array}{cc}1& \mathrm{other}\\ 0& x=y=0\end{array}$

The pseudo-code for obtaining the optimal machining element sequence is shown in Appendix A Algorithm A7.

7. Case Study

To validate the proposed machining feature recognition and process route optimization algorithm, a case study is performed in collaboration with a machinery enterprise. When developing product process flow, the enterprise first uses the machining feature recognition method proposed by us to traverse the machining features in the model, then makes the feature machining method decision, and finally optimizes the process route. We have established a prototype system, and its architecture is shown in Figure 23, which includes a human–computer interaction layer, functional layer, and database layer. The functions of each part are as follows:

In order to verify the system functions, take the MBD model shown in Figure 24 as an example to verify the method proposed in this paper. First, extract the model information, as shown in Figure 25 and Figure 26. The former figure shows the geometry and topology information of the model, and the latter shows the annotation information. A total of 71 faces and 219 edges of the model are extracted.

The extracted information is serialized in the Access database. With the tables of “surface_ data”, “edge_ data”, “dimension_ Data”, and “gtol roughness”, the database stores the model information of surface, edge, dimension, tolerance, and roughness information, respectively, as shown in Figure 27.

AAG decomposition method based on DBS and JBS is adopted to identify machining features, and the results are shown in Figure 28. A total of 28 machining features were identified, and the results were automatically imported into the Excel database to complete serialization, as shown in Figure 29.

Set the material attribute of the model as cast iron, and use the feature processing scheme decision based on fuzzy comprehensive evaluation to make the feature processing scheme decision. The result is shown in Figure 30. Serialize the decision results.

According to the machining feature recognition and processing scheme decision results, the ME sequence is generated and stored in the database, as shown in Figure 31. The manufacturing resource information involved is shown in Table 11.

Fifty-three topological sequences of ME are obtained by optimizing the ME sorting, among which the evaluation function value of the optimal sequence: F = 1 × 0.530 + 9 × 0.297 + 21 × 0.163 = 6.626; this sequence is the optimal process route for this part machining, as shown in Figure 32.

8. Conclusions

In summary, aiming at the problem of machining feature recognition and process route optimization in the MBD model, we propose a feature matching algorithm based on model AAM after studying the model AAG decomposition based on DBS and JBS, which first constructs the decomposed feature subgraph as AAM, and then realizes machining feature recognition by matching with predefined feature AAM. A feature processing scheme decision-making method based on fuzzy comprehensive evaluation is proposed. By analyzing the influencing factors of processing scheme selection, the mapping relationship between the influencing factors and the processing scheme is established. Based on the single-factor evaluation results, a multi-factor comprehensive evaluation model is established. By calculating the comprehensive evaluation index, the optimization of the feature processing scheme is realized. Based on the optimized scheme, a model processing route optimization method based on MEDGraph is proposed. Based on the constraint relationship between MEs, the MEDGraph is established. The improved topological sorting algorithm is applied to list the topological sequence of all MEs. Finally, the evaluation function is constructed to obtain the optimal process route. Our research realized the recognition of machining features in parts and the determination of the optimal process route without complex similarity transformation of AAM. The application of our research can provide a premise for enterprise intelligent manufacturing on the basis of automatic recognition of model machining features.

Our future work will focus on the recognition of machining features, including free-form surfaces and complex intersection features, as well as the optimization of process routes considering other factors, such as machining parameters and process tolerance allocation.

Author Contributions

S.D. made contributions to the conceptualization and original draft writing. Z.G. contributed to the validation and resource. B.W. contributed to the original draft writing and software prototype validation. H.W. contributed to the investigation and editing. F.M. contributed to the draft review and editing. All authors have read and agreed to the published version of the manuscript.

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Data Availability Statement

Not applicable.

Conflicts of Interest

The authors declare no conflict of interest.

Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Figures and Tables

Figure 1. Flow chart of model geometric topology information extraction.

Figure 2. Flow chart of machining feature recognition.

Figure 3. DBS.

Figure 4. FBS.

Figure 5. Joint base surface.

Figure 6. The definition of edge concavity–convexity. (a) l is concave; (b) l’ is convex.

Figure 7. Examples of concavity and convexity of edges in the model.

Figure 8. Concavity–convexity judgment of model edge. (a) shows the intersection line of two planar planes; (b) shows the intersection line of planar plane and curved surface.

Figure 9. Concavity–convexity judgment of model surface.

Figure 10. Judgment of curvature of surface.

Figure 11. AAG construction flow.

Figure 12. MBD model. Where, f1–f16 represent the 16 surfaces of the model.

Figure 13. Model AAG.

Figure 14. AAG decomposition based on DBS. (a) shows the updated AAG-1; (b) shows the updated AAG-2; (c) shows the four decomposed subgraphs.

Figure 15. Subgraph reconstruction based on JBS.

Figure 16. The AAM construction process.

Figure 17. AAM matching process.

Figure 18. Decision of feature processing method based on fuzzy comprehensive evaluation.

Figure 19. Fuzzy mapping model between machining scheme and influencing factors.

Figure 20. Construction of MEDGraph matrix.

Figure 21. Topology sorting algorithm.

Figure 22. Improved topology sorting algorithm.

Figure 23. Prototype system architecture.

Figure 24. Example model.

Figure 25. Extraction of model geometry and topology information.

Figure 26. Extraction of model annotation information.

Figure 27. Storage of model information. (a) Surface information; (b) Edge information; (c) Dimension information; (d) Tolerance and roughness information.

Figure 28. Recognition of machining features.

Figure 29. Serialization of recognition result.

Figure 30. Decision results of machining scheme.

Figure 31. MEs sequence.

Figure 32. Optimal ME sequence.

Table 1

Structure arrays for the storage of MBD model.

Structure Array	Surface [ ]	Edge [ ]	Contour [ ]	Surfinish [ ]	Gtol [ ]	Dimension [ ]
Structure member	ID	ID	Type	Symbol	Symbol	Symbol
	Type	Type	Edge ID	Value	Type	Type
	Concavity–convexity	Concavity–convexity	/	Related surface ID	Value	Value
	Adjacent surface ID	Adjacent surface ID	/	/	Related surface ID	Upper deviation
	Edge ID	Inner contour attribute	/	/	Datum ID	Lower deviation
	Contour information	/	/	/	/	Related surface ID
	Roughness	/	/	/	/	/
	Tolerance	/	/	/	/	/

Table 2

Functions of geometric and topology information extraction.

No.	Name	Function
1	ProMdlCurrentGet	Get the handle of current model
2	ProSolidSurfaceVisit	Traverse the model surfaces
3	ProSurfaceContourVisit	Traverse the contour on the surface
4	ProContourEdgeVisit	Traverse the edge on the contour
5	ProContourTraversalGet	Get the type of contour
6	ProSurfaceIdGet	Get the surface ID
7	ProSurfaceTypeGet	Get the type of the surface
8	ProSurfaceDataGet	Get the surface data
9	ProEdgeIdGet	Get the edge ID
10	ProEdgeTypeGet	Get the edge type

Table 3

Attribute of AAG nodes.

Attribute Name	Type of Variable	Attribute Definition
Type	int	$\{\begin{array}{cc}1& \mathrm{Planar} \mathrm{Plane}\\ 2& \mathrm{Cylinder}\\ 3& \mathrm{Conical} \mathrm{surface}\\ 4& \mathrm{other} \mathrm{surface}\end{array}$
Concavity–convexity	int	$\{\begin{array}{cc}-1& \mathrm{Concave} \mathrm{surface}\\ 1& \mathrm{Convex} \mathrm{surface}\end{array}$
DBS attribute	bool	$\{\begin{array}{cc}\mathrm{true}& \mathrm{DBS}\\ \mathrm{false}& \mathrm{Not} \mathrm{DBS}\end{array}$
FBS attribute	bool	$\{\begin{array}{cc}\mathrm{true}& \mathrm{FBS}\\ \mathrm{false}& \mathrm{Not} \mathrm{FBS}\end{array}$
JBS attribute	int	/

Table 4

Attribute definition of node connection in AAG.

Attribute Name	Type of Variable	Attribute Definition
Type	int	$\{\begin{array}{cc}1& \mathrm{Straight} \mathrm{edge}\\ 2& \mathrm{Arc} \mathrm{edge}\\ 3& \mathrm{Other} \mathrm{edge}\end{array}$
Concavity–convexity	int	$\{\begin{array}{cc}-1& \mathrm{Concave} \mathrm{edge}\\ 0& \mathrm{Smooth} \mathrm{edge}\\ 1& \mathrm{Convex} \mathrm{edge}\end{array}$
Inner contour	bool	$\{\begin{array}{cc}\mathrm{true}& \mathrm{Inner} \mathrm{contour} \mathrm{edge}\\ \mathrm{false}& \mathrm{No} \mathrm{inner} \mathrm{contour} \mathrm{edge}\end{array}$

Table 5

Typical machining features.

No.	Feature Name	Graphical Representation	AAM
1	Through-hole	[Image omitted. Please see PDF.]	$\left[220\right]$
2	Blind-hole	[Image omitted. Please see PDF.]	$\left[\begin{array}{cc}220& 21\\ 21& 110\end{array}\right]$
3	Closed key slot	[Image omitted. Please see PDF.]	$\left[\begin{array}{ccccc}220& 13& 0& 13& 21\\ 13& 210& 13& 0& 11\\ 0& 13& 220& 13& 21\\ 13& 0& 13& 210& 11\\ 21& 11& 21& 11& 110\end{array}\right]$
4	Open key slot	[Image omitted. Please see PDF.]	$\left[\begin{array}{cccc}110& 11& 21& 11\\ 11& 210& 13& 0\\ 21& 13& 220& 21\\ 11& 0& 21& 210\end{array}\right]$
5	Through groove	[Image omitted. Please see PDF.]	$\left[\begin{array}{ccc}210& 11& 0\\ 11& 110& 11\\ 0& 11& 210\end{array}\right]$
6	Cylinder extrusion	[Image omitted. Please see PDF.]	$\left[\begin{array}{cc}111& 22\\ 22& 221\end{array}\right]$
7	Blind groove	[Image omitted. Please see PDF.]	$\left[\begin{array}{cccc}210& 11& 0& 11\\ 11& 110& 11& 11\\ 0& 11& 210& 11\\ 11& 11& 11& 110\end{array}\right]$
8	Step	[Image omitted. Please see PDF.]	$\left[\begin{array}{cc}210& 11\\ 11& 210\end{array}\right]$
9	Rectangular blind cavity	[Image omitted. Please see PDF.]	$\left[\begin{array}{ccccc}210& 11& 0& 11& 11\\ 11& 210& 11& 0& 11\\ 0& 11& 210& 11& 11\\ 11& 0& 11& 210& 11\\ 11& 11& 11& 11& 110\end{array}\right]$
10	Rectangular through cavity	[Image omitted. Please see PDF.]	$\left[\begin{array}{cccc}210& 11& 0& 11\\ 11& 210& 11& 0\\ 0& 11& 210& 11\\ 11& 0& 11& 210\end{array}\right]$

Table 6

Typical processing scheme of surface features.

No.	Processing Scheme	Machining Accuracy	Surface Roughness $\mathit{R}\mathit{a}/\mathsf{\mu }\mathbf{m}$	Scope of Application
1	Rough planing	IT11~13	12.5~50	Plane processing of ferrous and nonferrous metals
2	Rough planing—fine planing	IT8~10	3.2~6.3
3	Rough planing—fine planing—wide blade fine planing	IT6~7	0.8~1.6
4	Rough milling	IT11~13	6.3~25	Plane, through groove, step, and other features of ferrous and non-ferrous metals
5	Rough milling—finish milling	IT8~10	1.6~6.3
6	Rough milling—finish milling—fine grinding	IT6~7	0.8~1.6	Plane of ferrous metal

Table 7

Scale table.

Scale Value	Meaning
1	$C_i$ is as important as $C_j$
3	$C_i$ is slightly more important than $C_j$
5	$C_i$ is more important than $C_j$
7	$C_i$ is significantly more important than $C_j$
9	$C_i$ is extremely more important than $C_j$
2, 4, 6, 8	Preceding adjacent median
Reciprocal of scale value	Contrary to the above comparison between $C_i$ and $C_j$

Table 8

Random consistency index.

$n$	1	2	3	4	5	6	7	8	9
$RI$	0	0	0.58	0.90	1.12	1.24	1.32	1.41	1.51

Table 9

Correspondence between workpiece material and surface feature processing scheme.

No.	${\mathit{x}}_1$	${\mathit{x}}_2$	${\mathit{x}}_3$	${\mathit{x}}_4$	${\mathit{x}}_5$	${\mathit{x}}_6$
$m_1$	√	√	√	√	√	√
$m_2$	√	√	√	√	√	√
$m_3$	√	√	√	√	√

Table 10

Correspondence between feature type and surface feature processing scheme.

No.	${\mathit{x}}_1$	${\mathit{x}}_2$	${\mathit{x}}_3$	${\mathit{x}}_4$	${\mathit{x}}_5$	${\mathit{x}}_6$
$f_1$	√	√	√	√	√	√
$f_2$	√	√	√	√	√	√
$f_3$				√	√
$f_4$	√	√	√	√	√	√
$f_5$				√	√
$f_6$				√	√
$f_7$				√	√

Table 11

Manufacturing resource information.

No.	Type	Name	Resource	No.	Type	Name	Resource
1	machine	M1	drilling machine	1	tool	Z1, Z2, Z3	Twist drill
2		M2	Vertical milling machine	2		J1, J2	Reamer
3		M3	CNC milling machine	3		KZ1	Counterbore drill
4		M4	Horizontalmilling machine	4		X1, X2, X3, X4, X5, X6	Milling cutter

Appendix A

Algorithm A1. Geometric & topology information extraction algorithm

1. Input: MBD model2. Output: Store geometric & topology information in computer memory3./*Definition of structure array*/4. struct Surface_data5. {6.       ElemType  surf_id7.       ElemType  surf_type 8.       ElemType  surf_at9.       vector< ElemType >  adj_surf_id 10.       vector< ElemType >  edge_id11.       vector< ElemType >  cont_data12.       ElemType  surffinish_value13.       vector< ElemType >  gtol_data14. }15. struct Contour_data16. {17.       vector< ElemType >  edge_id18.       ElemType  contour_type19. }20. struct Edge_data21. {22.       ElemType  edge_id23.       ElemType  edge_type24.       ElemType  edge_at25.       vector<ElemType >  adja_suf26.       ElemType  edge_in27. }28./*Define structure array*/29. Surface_data  surf[num1], Contour_data  contour[num2], Edge_data  edge[num3]30. k← 0, h← 031. Call ProMdlCurrentGet( ) to get the handle of the current model32. Call ProSolidSurfaceVisit( ) to traverse surface and obtain and output surface[]33. Call ProArraySizeGet( ) to get the length of surf[ ], which is m34. for (i = 0; i < m; i ++) do35.     Call ProSurfaceIdGet( ) to get the ID of No.i+1 surface and write it to surf[i].surf_id36.     Call ProSurfaceTypeGet( ) to get the type of No.1+1 surface and write to surf[i]. surf_type37.     Call ProSurfaceAtGe ( ) to get the concavity-convexity of No.1+1 surface38.     Write to surface[i].surf_at39.     Call ProSurfaceContourVisit( ) to traverse the contour and write them to Contour[ ]40.     Call ProArraySizeGet( ) to get the length of Contour[], which is n41.     for (j = 0; j < n; j ++) do42.         Call ProContourTraversalGet( ) to get the type of contour and write to contour[k].contour_type 43.         Call ProContourEdgeVisit( ) to traverse the edges of contour and write to Edge[]44.         Call ProArraySizeGet( ) to get the length of edge[], which is e45.             for (t = 0; t < e; t ++) do46.                 Call ProEdgeIdGet( ) to get the ID of edge47.                 Write it to edge[h].edge_id, contour [k].edge_id48.                 if (edge[h].edge_id $\notin$ surface[i].edge_id ) then49.                     Write to surface[i].edge_id50.                 end if51.                 Call ProEdgeTypeGet( ) to get type of edge and write to edge[h].edge_type52.                 Call ProEdgeAtGet( ) to get concavity-convexity and write to edge[h].edge_at53.                 Call ProEdgeNeighborsGet( ) to get the adjacent surface ID54.                 Write to edge[h].adja_suf55.                 if (edge[h].adja_suf $\notin$ surface[i].edge_id ) then 56.                     Write to surface[i]. adj_surf_id57.                 end if58.         h++59.         end for60.         Write contour[k] to surface[i].cont_data61.       k++62.       end for63. end for

Algorithm A2. AAG construction

1. Input: MBD model information structure array surface[ ], edge[ ] and contour[ ]2. Output: line[num1], node[num2]3./*Define structure array node[num2] and line[num1], num1 and num2 is the number of model edge and surface*/4. struct Node5. {6.       ElemType  surface_id 7.       vector< ElemType >  adj_line8.       ElemType  node_type9.       ElemType  node_at 10.       ElemType  d_face 11.       ElemType  f_face 12.       ElemType  c_face 13. } node[num2]14. struct Line15. {16.       ElemType  edge_id17.       ElemType  node118.       ElemType  node2 19.       ElemType  line_type 20.       ElemType  line_at 21.       ElemType  in_contour22. } line[num1]23./*Assign the id of line and surface */24. for (i = 0; i < num1; i ++) do25.       line[i]. edge_id ← edge[i].edge_id 26. end for27. for (i = 0; i < num2; i ++) do28.       node[j]. surface_id ← surface[j].surface_id 29. end for30./* Determine the connection relationship between nodes and edges*/31. for (i = 0; i < num2; i ++) do32.       for (j = 0; j < num1; j ++) do 33.           for (k = 0; k < surface[i].edge_id.size(); k ++) do 34.                 if (line[j]. edge_id == surface[i].edge_id[k]) then 35.                     Add line[j] to node[i]. adj_line36.                     if (line[j].node1==NULL) then37.                         line[j].node1 ← node[i]38.                     else39.                         line[j].node2 ← node[i]40.                     end if41.                 end if 42.           end for43.       end for 44. end for45./*Add node attribute*/46. for (i = 0; i < num2; i ++) do47.     /*Assign the type*/48.       if (surface[i].type == planar) then node[i].node_type ← 1 end if49.       if (surface[i].type == cylinder) then node[i].node_type ← 2 end if50.       if (surface[i].type == conical) then node[i].node_type ← 3 end if51.       if (surface[i].type == other) then node[i].node_type ← 4 end if52.     /*Assign the concavity-convexity of surface*/53.       if (surface[i].concavity-convexity ==concave) then 54.         node[i].node_at ← −155.       else 56.           node[i].node_at ← 157.       end if58.     /*Assign the DBS attribute*/59.       if (surface[i].contour_information == inner) then60.           node[i].d_face ← true61.       else 62.           node[i].d_face ← false63.       end if64.     /*Assign the FBS attribute*/65.         Calculation the extrusion of $f_i$, which is $V_b$66.       if (surface[i].type == planar && surface[i].concavity-convexity == convex                &&$V_b{{\displaystyle \cap }}^{ }part=\varnothing$ then 67.           node[i].f_face ← true68.       else 69.           node[i].f_face ← false70.       end if71. end for72./*Traverse the JBS*/73. for (i = 0; i < num2; i ++) do74.       for (j = 0; j < num2; j ++) do75.           if (surface[i] and surface[j] == JBS) then 76.                 node[i].c_face ← node[j]. c_face ← k77.                 k++78.           end if79.       end for80. end for81./*Add edge attribute*/82. for (i = 0; i < num1; i ++) do83.     /*Assign the type*/84.       if (edge[i].type == straight) then line[i].line_type ← 1 end if85.       if (edge[i].type == arc) then line[i].line_type ← 2 end if86.       if (edge[i].type == other) then line[i].line_type ← 3 end if87.       if (edge[i].type == straight) then line[i].line_type ← 1 end if88.     /*Assign the concavity-convexity*/89.       if (edge[i].concavity-convexity == concavity) then line[i].line_at ← −1 end if90.       if (edge[i].concavity-convexity == convexity) then line[i].line_at ← 1 end if 91.       if (edge[i].concavity-convexity == smooth) then line[i].line_at ← 0 end if92.     /*Assign the inner contour attribute*/93.       if (edge[i].inner_contour == true) then94.           line[i]. in_contour ← true95.       else 96.           line[i]. in_contour ← false97.       end if98. end for

Algorithm A3. AAG decomposition and reconstruction based on DBS and JBS

1. Input: line[num1] and node[num2]2. Output: line1[n][ ] and node1[n][ ], which represent the edge and node after reconstruction3./*Decomposition based on DBS*/4. Nsign[i] ← 05. for (i = 0; i < num2; i ++) do6.       if (node[i].d_face == ture) then7.           for (j = 0; j < num1; j ++) do8.               if (line[j].node1 == node[i] || line[j].node2 = node[i]) then 9.                   if (line[j].in_contour == true && line[j].line_at == −1) then10.                           Nsign[i] ← −1 11.                           line[j] ← NULL 12.                   end if13.                   if (line[j].in_contour == false && line[j].line_at == 1) then14.                       Nsign [i] ← 115.                       line[j] ← NULL 16.                   end if17.               end if18.         end for19.       end if20. end for21. for (i = 0; i < num2; i ++ ) do22.       if (node[i] ==−1) then23.           Extract the information of node[ ] and line[ ] adjacent to node[i]24.           if (line[ ].line_at = −1) then 25.               line[ ] ← NULL26.                 Assign the value of node[ ] to corresponding node1[ ][ ]27.               Obtain the value of line1[ ][ ] according to node1[ ][ ]28.           else29.                 Store the corresponding node1[ ][ ] and line1[ ][ ]30.           end if31.       end if32.       if (node[i] ==1) then33.           Extract the information of node[ ] and line[ ] adjacent to node[i], and store them to node1[ ][ ] and line1[ ][ ]34.       end if35.       Delete line[ ] and node[ ]36. end for37./*Delete non-machining surface*/38. for (i = 0; i < node[ ].size; i ++) do39.       if (node[i].node_at == 1) then 40.           node[i] ← NULL41.             Delete line[ ] adjacent to node[i].adj_line42.           Update line[ ] and node[ ]43.       end if44. end for45./*Extract the MCCS on FBS*/46. for (j = 0; j < node[ ].size; j ++) do47.       if (node[j].f_face == true) then 48.           for (k = 0; k < node[j].adj_line.size; k ++) do 49.                 if (node[j].adj_line[k].line_at == −1) then50.                       Extract the node adjacent to node[j].adj_line[k]51.                     if (extracted node has concave edge) then52.                       Continue to extract nodes adjacent to the concave edges53.                     end if54.                 end if55.           end for56.       end if57.       Store node[ ] to node1[ ][ ] and then get the corresponding line1[ ][ ]58. end for59./*Search the node with the same JBS attribute*/60. c_sign[n][ ] ← 0 61. for (i = 0; i < n; i ++) do62.       for (j = 0; j < node1[i][ ].size; j ++) do63.           if (node1[i][j].c_face $\ne \varnothing$ then64.                 c_sign[i][j] ←node1[i][j].c_face65.           end if66.       end for67. end for68. for (k = 0; k < n; k ++) do69.       for (s = 0; s < n; s ++) do70.           if (c_sign[k][ ] and c_sign[s][ ] have the same element) then71.                 Merge line1[s][ ] to line1[k][ ]72.                 Merge node1[s][ ] to node1[k][ ]73.           end if74.       end for75. end for

Algorithm A4. AAM establishment algorithm

1. Input: line2[m][ ] and node2[m][ ]2. Output: The AAM of machining feature to be identified3. sg ← 0, M[n][n] ← 0 4. for (t = 0; t < m; t ++) do5.       for (i = 0; i < node[t][ ].size; i ++) do6.           a ← 2, b ← c ← 07.           c ← node2[t][i].node_at8.           b ← node2[t][i].node_type9.           if (node2[t][i].node_ f_face == true) then10.                 a ← 111.           end if12.           M[sg][sg] ← a*100+b*10+c 13.         sg++14.       end for15. end for16. for (w = 0; w < m; w ++) do 17.       for (j = 0; j < line2[w][ ].size; j ++) do18.           d ← 0, e ← 019.           d ← line2[w][j].line_type20.           e ← line2[w][j].line_at21.           Search node2[ ][ ] for line2[w][j].node122.           Search node2[ ][ ] for line2[w][j].node223.           Determine the position of line2[w][j] in AAM according to node2[ ][ ]24.           M[k][h] ← M[h][k] ← d*10+e25.       end for26. end for

Algorithm A5. Matching between feature subgraph AAM and predefined feature AAM

1. Input: feature subgraph AAM to be identified represented by matrix A[n][n], and predefined feature AAM represented by matrix B[m][m]2. Output: matching result3./* Define the function SetJudgment(matrix1, matrix2) to determine whether matrix1 and matrix2 is identical */4. SetJudgment(matrix1, matrix2)5. {6.       k ← 07.       for (i = 0; i < matrix1.size; i ++) do8.           for (j = 0; j < matrix2.size; j ++)j ← 0 to matrix2.size do9.                 if (matrix1[i] == matrix2[j]) then10.                     k++11.                     matrix2 ← matrix2.erase(matrix2.begin( )+j)12.                     break13.               end if14.         end for15.       end for16.       if (k == n) then17.           result ← true18.       else20.           result ← false21.       end if22.       return result23. }24. for (i = 0; i < f; i ++) do//f is the number of feature subgraphs25.       if (n$\ne$m) then26.           Get next AAM27.       else28.           vector<int> $S_1$, vector<int> $S_2$29.           for (i = 0; i < n; i ++) do30.                 $S_1$ ← A[i][i]31.                 $S_2$ ← B[i][i]32.           end for33.           result1 = SetJudgment($S_1, S_2$)34.           if (!result1) then35.                 Get next AAM36.           else37.                 vector<int> $S_{Ai}$, vector<int> $S_{Bi}$ 38.                 for (i = 0; i < n; i ++) do39.                     $S_{Ai}\leftarrow$A[i][ ]40.                     $S_{Bi}\leftarrow$B[i][ ]41.                 end for42.                 index ← 043.                 for (w = 0; w < n; w ++) do44.                     for (u = 0; u < n; u ++) do45.                         result2=SetJudgment($S_{Aw}$, $S_{Bu}$)46.                       if (!result2) then47                             Get next AAM48.                     else49.                         $S_{Bu} \leftarrow 0$50.                         index ++51.                         break52.                     end if53.                 end for54.           end for55.           if (index$\ne$ n) then 56.                 Get next AAM57.           else58.                   success59.           end if60.       end if61. end for

Algorithm A6. Decision algorithm of feature machining scheme

1. Input: machining feature information2. Output: Optimal processing scheme3. Call ProMaterialDataGet( ) to get the material properties, which is Mat4. for (i = 0; i < n; i ++) do//n is the number of processing features5.       if (feature[i] ≠ hole feature) then//Processing scheme decision6.         /* Calculate fuzzy matrix of each influencing factor for surface features*/7.           for (j = 0; j < 6; j ++) do8.                 if (x[j] is suitable for Mat) then RM[j] ← 1 end if9.                 if (x[j] is suitable for feature[i].feature_type) then RF[j] ← 1 end if10.                   GetSchemeIT(x[j])//Obtain the precision range ITn~ITm of scheme x[j]11.                   $\mathbf{if} \left(\mathrm{feature}\right[i].\mathrm{IT}<$ $\mathrm{ITn}-2 \left|\right| \mathrm{feature}\left[i\right].\mathrm{IT}>$ ITm) then RIt[j] ←$0 \mathbf{end} \mathbf{if}$$12. \mathbf{if} (\mathrm{ITn}\le \mathrm{feature}[i].\mathrm{IT}\le$ ITm) then RIt[j] ←$1 \mathbf{end} \mathbf{if}$$13. \mathbf{if} (\mathrm{ITn}-2\le \mathrm{feature}[i].\mathrm{IT}<$ ITn) then RIt[j] ← 1-((ITn-feature[i].IT)/(5*(ITm-ITn))) end if14.                   GetSchemeRa(x[j])//Obtain the roughness range a~b of scheme x[j]$15. \mathbf{if} \mathrm{feature}\left[i\right].\mathrm{Ra}<$ $\mathrm{a} \left|\right| \mathrm{feature}\left[i\right].\mathrm{Ra}>$ b then RRa[j] ←$0 \mathbf{end} \mathbf{if}$$16. \mathbf{if} \mathrm{a}\le \mathrm{feature}\left[i\right].\mathrm{Ra}\le$ b then RRa[j] ← 1-(log(b)-log(feature[i].Ra))/5(log(b)-log(a)) end if17.           end for18.         /*Calculating fuzzy comprehensive evaluation matrix R1[ ][ ]*/19.             for (k1 = 0; k1 < 6; k1 ++) do 20.                 R1[0][k1] ← RM[k1]21.             end for22.             for (k2 = 0; k2 < 6; k2 ++) do 23.                 R1[1][k2] ← RF[k2]24.             end for25.             for (k3 = 0; k3 < 6; k3 ++) do 26.               R1[2][k3] ← RIt[k3]27.             end for28.             for (k4 = 0; k4 < 6; k4 ++) do 29.                 R1[3][k4] ← RRa[k4]30.             end for31.         /*Calculating fuzzy comprehensive evaluation index vector B[ ]*/32.           for (num = 0; num < 6; num ++) do 33.             for (i = 0; i < 6; i ++) do34.                 for (j = 0; j < 4; j ++) do35.                     B[num] ←B[num]+W[j]*R1[i][j]36.                 end for37.             end for38.           end for39.           Take x[ ] corresponding to element with largest value in B[ ] as the scheme [i] 40.       end if41.       if (feature[i] == hole feature) then42.           for (w = 0; w < 13; w ++) do43.               if (y[w] is suitable for Mat) then RM[w] ← 1 end if44.               GetFeatureD( )//Get the diameter D of hole feature45.               if (y[w] is suitable for D) then RD[w] ←$1 \mathbf{end} \mathbf{if}$$46. \mathrm{GetSchemeIT}\left(\mathrm{y}\right[w\left]\right)//\mathrm{Get} \mathrm{the} \mathrm{precision} \mathrm{range} \mathrm{ITn}~\mathrm{ITm} \mathrm{of} \mathrm{scheme} \mathrm{y}\left[w\right]$$47. \mathbf{if} \left(\mathrm{feature}\right[i].\mathrm{IT}<\mathrm{ITn}-2 || \mathrm{feature}[i].\mathrm{IT}>$ ITm) then RIt[j] ←$0 \mathbf{end} \mathbf{if}$$48. \mathbf{if} (\mathrm{ITn}\le$ $\mathrm{feature}\left[i\right].\mathrm{IT}\le$ ITm) then RIt[j] ←$1 \mathbf{end} \mathbf{if}$$49. \mathbf{if} (\mathrm{ITn}-2\le$ $\mathrm{feature}\left[i\right].\mathrm{IT}<$ ITn) then RIt[j] ←$1-\left(\right(\mathrm{ITn}-\mathrm{feature}\left[\mathrm{i}\right].\mathrm{IT})/(5*(\mathrm{ITm}-\mathrm{ITn})\left)\right) \mathbf{end} \mathbf{if}$$50. \mathrm{GetSchemeRa}\left(\mathrm{y}\right[w\left]\right)//\mathrm{Get} \mathrm{the} \mathrm{roughness} \mathrm{range} \mathrm{a}~\mathrm{b} \mathrm{of} \mathrm{scheme} \mathrm{y}\left[w\right]$$51. \mathbf{end} \mathbf{if}$$52. \mathbf{if} \left(\mathrm{feature}\right[i].\mathrm{Ra}<$ $\mathrm{a} \left|\right| \mathrm{feature}\left[i\right].\mathrm{Ra}>$ b) then RRa[w] ←$0 \mathbf{end} \mathbf{if}$$53. \mathbf{if} \left(\mathrm{feature}\right[i].\mathrm{Ra}<$ $\mathrm{a} \left|\right| \mathrm{feature}\left[i\right].\mathrm{Ra}>$ b) then54.                     RRa[w] ← 1-(log(b)-log(feature[i].Ra))/5(log(b)-log(a))55.                 end if56.           end for57.         /* Calculate fuzzy comprehensive evaluation matrix R2[ ][ ] of hole feature*/58.           for (s1 = 0; s1 < 13; s1 ++) do 59.             R2[0][s1] ← RM[s1]60.           end for61.           for (s2 = 0; s2 < 13; s2 ++) do 62.                 R2[1][s2] ← RD[s2]63.           end for64.           for (s3 = 0; s3 < 13; s3 ++) do 65.               R2[2][s3] ← RIt[s3]66.           end for67.           for (s4 = 0; s4 < 4; s4 ++) do 68.               R2[3][s4] ← RRa[s4]69.           end for70.         /*Calculate fuzzy comprehensive evaluation index vector B[ ]*/71.           for (num = 0; num < 13; num ++) do 72.                 for (i = 0; I < 13; i ++) do73.                     for (j = 0; j < 4; j ++) do74.                         B[num] ←B[num]+W[j]*R2[i][j]75.                     end for76.                 end for77.           end for78.       Take y[ ] corresponding to the element with largest value in B[ ] as the scheme [i]79.       end if80. end for

Algorithm A7. acquisition of optimal machining element sequence

1. Input: all the MEs sequence TS[i][ ]2. Output: optimal sequence OTS[ ]3. max ← 0, op ← 0, F[ ] ← 04. for (i = 0; i < n; i ++) do//n is the number of sequences5.       diff_m ← 0, diff_t ← 0, diff_D ← 06.       for (j = 0; j < m−1; j ++) do//m is the number of machining element7.           num ← TS[i][j] 8.           if (me[num].m_id $\ne$ me[num+1].m_id) then diff_m++ end if9.           if (me[num].m_id $\ne$ me[num+1].m_id || me[num].t_id $\ne$ me[num+1].t_id) then10.                 diff_t++ 11.                 end if12.           if (me[num].m_id $\ne$ me[num+1].m_id || me[num].TAD$\ne$ me[num+1].TAD) then13.                 diff_D++ 14.           end if15.       end for16.       F[i] ← 0.53* diff_m+0.163* diff_t+0.297* diff_D17. end for18. for (s = 0; s < n; s ++) do 19.       if (F[s]$>$ max) then 20.           max ← F[s]21.           op ← s 22.       end if23. end for24. for (k = 0; k < n; k ++) do 25.       OTS[k] ← TS[op][k] 26. end for

References

1. Al-wswasi, M.; Ivanov, A.; Makatsoris, H. A survey on smart automated computer-aided process planning (ACAPP) techniques. Int. J. Adv. Manuf. Technol.; 2018; 97, pp. 809-832. [DOI: https://dx.doi.org/10.1007/s00170-018-1966-1]

2. Kyprianou, L.K. Shape Classification in Computer-Aided Design. Ph.D. Thesis; Cambridge University: Cambridge, UK, 1980.

3. Han, J.H.; Pratt, M.; Regli, W.C. Manufacturing feature recognition from solid models: A status report. IEEE Trans. Robot. Autom.; 2000; 16, pp. 782-796. [DOI: https://dx.doi.org/10.1109/70.897789]

4. Joshi, S.; Chang, T.C. Graph-based heuristics for recognition of machined features from a 3D solid model. Comput. Aided. Des.; 1988; 20, pp. 58-66. [DOI: https://dx.doi.org/10.1016/0010-4485(88)90050-4]

5. Li, Y.G.; Ding, Y.F.; Mou, W.P.; Guo, H. Feature recognition technology for aircraft structural parts based on a holistic attribute adjacency graph. Proc. Inst. Mech. Eng. B J. Eng. Manuf.; 2010; 224, pp. 271-278. [DOI: https://dx.doi.org/10.1243/09544054JEM1634]

6. Marefat, M.; Kashyap, R.L. Geometric reasoning for recognition of three-dimensional object features. IEEE Trans. Pattern. Anal. Mach. Intell.; 1990; 12, pp. 949-965. [DOI: https://dx.doi.org/10.1109/34.58868]

7. Armstrong, G.T. A Study of Automatic Generation of Non-Invasive NC Machine Paths from Geometric Models. Ph.D. Thesis; University of Leeds: Leeds, UK, 1982.

8. Verma, A.K.; Rajotia, S. A review of machining feature recognition methodologies. Int. J. Comput. Integr. Manuf.; 2010; 23, pp. 353-368. [DOI: https://dx.doi.org/10.1080/09511921003642121]

9. Jüttler, B.; Kapl, M.; Nguyen, D.M.; Pan, Q.; Pauley, M. Isogeometric segmentation: The case of contractible solids without non-convex edges. Comput. Aided. Des.; 2014; 57, pp. 74-90. [DOI: https://dx.doi.org/10.1016/j.cad.2014.07.005]

10. Kim, B.C.; Mun, D. Feature-based simplification of boundary representation models using sequential iterative volume decomposition. Comput. Graph.; 2014; 38, pp. 97-107. [DOI: https://dx.doi.org/10.1016/j.cag.2013.10.031]

11. Tao, S.Q.; Huang, Z.D.; Ma, L.J.; Guo, S.S.; Wang, S.T.; Xie, Y.B. Partial retrieval of CAD models based on local surface region decomposition. Comput. Aided. Des.; 2013; 45, pp. 1239-1252. [DOI: https://dx.doi.org/10.1016/j.cad.2013.05.008]

12. Campana, G.; Mele, M. An application to Stereolithography of a feature recognition algorithm for manufacturability evaluation. J. Intell. Manuf.; 2020; 31, pp. 199-214. [DOI: https://dx.doi.org/10.1007/s10845-018-1441-8]

13. Vandenbrande, J.H.; Requicha, A.A.G. Spatial reasoning for the automatic recognition of machinable features in solid models. IEEE Trans. Pattern. Anal. Mach. Intell.; 1993; 15, pp. 1269-1285. [DOI: https://dx.doi.org/10.1109/34.250845]

14. Sunil, V.B.; Agarwal, R.; Pande, S.S. An approach to recognize interacting features from B-Rep CAD models of prismatic machined parts using a hybrid (graph and rule based) technique. Comput. Ind.; 2010; 61, pp. 686-701. [DOI: https://dx.doi.org/10.1016/j.compind.2010.03.011]

15. Li, Y.; Wang, W.; Liu, X.; Ma, Y. Definition and recognition of rib features in aircraft structural part. Int. J. Comput. Integr. Manuf.; 2014; 27, pp. 1-19. [DOI: https://dx.doi.org/10.1080/0951192X.2013.799784]

16. Gao, S.; Shah, J.J. Automatic recognition of interacting machining features based on minimal condition subgraph. Comput. Aided. Des.; 1998; 30, pp. 727-739. [DOI: https://dx.doi.org/10.1016/S0010-4485(98)00033-5]

17. Alain-Jérôme, F.; Egon, O. Intelligent agents for feature modelling in computer aided design. J. Comput. Des. Eng.; 2018; 5, pp. 19-40.

18. Liu, X.M.; Jia, Y.Q.; Chen, Z.R. Recognition of machining feature for engine cylinder blocks. Comput. Integr. Manuf. Syst.; 2016; 22, pp. 1197-1204. [DOI: https://dx.doi.org/10.13196/j.cims.2016.05.004]

19. Zhang, Y.; Dong, X.Y.; Li, D.S.; Zeng, Q.F.; Yang, S.H.; Gong, Y.D. Method for STEP–NC manufacturing feature recognition based on STEP and improved neural network. Acta Aeronaut. Astronaut. Sin.; 2019; 40, pp. 256-267. [DOI: https://dx.doi.org/10.7527/S1000-6893.2018.22687]

20. Duan, X.Y.; Yu, S.; Peng, F.Y.; Zheng, Y.; Xiang, F. Feature Matrix Based Complex Feature Hierarchical Recognition for Blank Model of Large Cabin Component. J. Mech. Eng.; 2021; 57, pp. 166-176. [DOI: https://dx.doi.org/10.3901/JME.2021.05.166]

21. Luo, Z.Y.; Sheng, B.Y.; Chen, Y.K. Machining feature recognition of injection mold based on graph matching. Mod. Manuf. Eng.; 2020; 11, pp. 61-67. [DOI: https://dx.doi.org/10.16731/j.cnki.1671-3133.2020.11.009]

22. Berenji, H.R.; Khoshnevis, B. Use of artificial intelligence in automated process planning. Comput. Mech. Eng.; 1986; 5, pp. 47-55.

23. Huang, W.J. Fundamental Research on the Optimization of Process Planning for the Complicated Components. Ph.D. Thesis; School of Mechanical Science & Engineering, Huazhong University of Science and Technology: Wuhan, China, 2012; [DOI: https://dx.doi.org/10.7666/d.D229096]

24. Ma, S.M.; Liu, C.J.; Sun, Y.; Li, A.P. Research on decision-making of part feature machining program based on fuzzy reasoning. J. Mach. Des.; 2014; 31, pp. 15-19. [DOI: https://dx.doi.org/10.13841/j.cnki.jxsj.2014.03.004]

25. Hu, Q.W.; Liu, D.L.; Du, P. Feature Processing Scheme Decision Based on Tsukamoto Fuzzy Reasoning. Aerosp. Manuf. Technol.; 2018; 4, pp. 5-9. [DOI: https://dx.doi.org/10.3969/j.issn.1674-5108.2018.04.003]

26. Zhong, J.W.; Deng, Z.H.; Shi, Y.D.; Liu, W. Process Planning of Groove Feature Milling and Optimal Selecting for Tool Based on BP Neural Network. Mach. Build. Autom.; 2019; 48, pp. 51-55. [DOI: https://dx.doi.org/10.19344/j.cnki.issn1671-5276.2019.03.014]

27. Zhao, Y.D.; Tan, C.; Xu, J.C. Decision-making of processing links based on the fuzzy back-propagation network. Manufacturing Automation. Mach. Build. Autom.; 2012; 34, pp. 31-33. [DOI: https://dx.doi.org/10.3969/j.issn.1009-0134.2012.6]

28. Guan, X.S.; Wang, Y.Q.; Tao, L.Y. Machining scheme selection of digital manufacturing based on genetic algorithm and AHP. J. Intell. Manuf.; 2009; 20, pp. 661-669. [DOI: https://dx.doi.org/10.1007/s10845-008-0155-8]

29. Hu, Y.J.; Wang, Y.; Wang, Z.L.; Wang, Y.Q.; Zhang, B.C. Machining scheme selection based on a new discrete particle swarm optimization and analytic hierarchy process. Artif. Intell. Eng. Des. Anal. Manuf.; 2014; 28, pp. 71-78. [DOI: https://dx.doi.org/10.1017/S0890060413000504]

30. Deng, Z.H.; Lv, L.S.; Huang, W.L.; Shi, Y.D. A high efficiency and low carbon oriented machining process route optimization model and its application. Int. J. Precis. Eng. Manuf. Technol.; 2019; 6, pp. 23-41. [DOI: https://dx.doi.org/10.1007/s40684-019-00029-0]

31. Jiang, Z.G.; Jiang, Y.; Wang, Y.; Zhang, H.; Cao, H.J.; Tian, G.D. A hybrid approach of rough set and case-based reasoning to remanufacturing process planning. J. Intell. Manuf.; 2019; 30, pp. 19-32. [DOI: https://dx.doi.org/10.1007/s10845-016-1231-0]

32. Chen, Y.F.; Huang, Z.D.; Chen, L.P.; Wang, Q.F. Parametric process planning based on feature parameters of parts. Int. J. Adv. Manuf. Technol.; 2006; 28, pp. 727-736. [DOI: https://dx.doi.org/10.1007/s00170-004-2428-5]

33. Peng, H.; Wang, H.; Chen, D.J. Optimization of remanufacturing process routes oriented toward eco-efficiency. Front. Mech. Eng.; 2019; 14, pp. 422-433. [DOI: https://dx.doi.org/10.1007/s11465-019-0552-z]

34. Rao Krishna, A.G.; Rao, K.M. Optimisation of operations sequence in CAPP using an ant colony algorithm. Int. J. Adv. Manuf. Technol.; 2006; 29, pp. 159-164. [DOI: https://dx.doi.org/10.1007/s00170-004-2491-y]

35. Li, L.; Fuh, J.Y.H.; Zhang, Y.F.; Nee, A.Y.C. Application of genetic algorithm to computer-aided process planning in preliminary and detailed planning. Robot. Comput. Integr. Manuf.; 2005; 21, pp. 568-578. [DOI: https://dx.doi.org/10.1016/j.rcim.2004.12.003]

36. Zhou, G.H.; Tian, C.L.; Zhang, J.J.; Chang, F.T.; Lu, Q. Multi-objective process route optimization considering carbon emissions. Int. J. Adv. Manuf. Technol.; 2018; 96, pp. 1195-1213. [DOI: https://dx.doi.org/10.1007/s00170-018-1646-1]

37. Chen, B.; Jing, B.X. Process route optimization based on bacteria foraging and ant colony algorithm. Chin. J. Eng. Des.; 2020; 27, pp. 600–607, 624. [DOI: https://dx.doi.org/10.3785/j.issn.1006-754X.2020.00.073]

38. An, X.H.; Chen, T. Optimization of process route based on intuitionistic fuzzy number and multi - objective optimization algorithm. Comput. Integr. Manuf. Syst.; 2019; 25, pp. 1180-1191. [DOI: https://dx.doi.org/10.13196/j.cims.2019.05.016]

39. Guo, X.Y.; Wang, L.; Zhang, Y.J. Machining Process Planning Based on Immune Genetic Algorithm under Rule Constraints. China Mech. Eng.; 2020; 31, pp. 482-488. [DOI: https://dx.doi.org/10.3969/j.issn.1004-132X.2020.04.016]

40. Dou, J.P.; Li, J.; Su, C. Optimization of operation sequencing based on feasible operation sequence oriented genetic algorithm. Comput. Integr. Manuf. Syst.; 2019; 25, pp. 1981-1990. [DOI: https://dx.doi.org/10.13196/j.cims.2019.08.012]

41. Ouyang, H.B.; Shen, B. STEP-NC oriented process planning optimization based on hybrid genetic algorithm. Comput. Integr. Manuf. Syst.; 2012; 18, pp. 66-75. [DOI: https://dx.doi.org/10.13196/j.cims.2012.01.68.ouyhb.009]

42. Liu, X.M.; Meng, F.F.; Li, A.P.; Gu, Z.Y. Research on Machining Step Sequencing of Machining Center Based on Polychromatic Sets Theory and Genetic Algorithm. China Mech. Eng.; 2013; 24, pp. 2437-2442. [DOI: https://dx.doi.org/10.3969/j.issn.1004-132X.2013.18.005]

43. Zhou, X. Research on MBD Based 3D CAD Model Feature Recognition and Similarity Evaluation. Master’s Thesis; Department of Mechanical and Engineering Electronic, Shandong University of Science and Technology: Qingdao, China, 2021.

44. Venu, B.; Komma, V.R.; Srivastava, D. STEP-based feature recognition system for B-spline surface features. Int. J. Autom. Comput.; 2018; 15, pp. 500-512. [DOI: https://dx.doi.org/10.1007/s11633-018-1116-0]

45. Ding, S.H.; Feng, Q.; Sun, Z.Y.; Ma, F. MBD Based 3D CAD Model Automatic Feature Recognition and Similarity Evaluation. IEEE Access; 2021; 9, pp. 150403-150425. [DOI: https://dx.doi.org/10.1109/ACCESS.2021.3126333]

46. Cheng, B.; Ding, J.L. Interacting Feature recognition based on Hint and Feature Main Base Face. Mach. Tool. Hydraul.; 2019; 47, pp. 72-77. [DOI: https://dx.doi.org/10.3969/j.issn.1001-3881.2019.01.017]

47. Zhou, Y.P.; Zhang, J.; Qin, W. Feature recognition methodology for large thin-wall part of spacecraft. Comput. Integr. Manuf. Syst.; 2016; 22, pp. 2505-2512. [DOI: https://dx.doi.org/10.13196/j.cims.2016.11.002]

48. Guo, F.L.; Sun, G.Z.; Zhou, J.T.; Shao, L. Machining Feature Recognition Based on Graph Twice Decomposition. Mach. Des. Manuf.; 2013; 5, pp. 56-59. [DOI: https://dx.doi.org/10.19356/j.cnki.1001-3997.2013.05.017]

49. Wang, B. Research on Machining Feature Recognition and Process Path Optimization Based on MBD Model. Master’s Thesis; Department of Mechanical and Engineering Electronic, Shandong University of Science and Technology: Qingdao, China, 2022.

50. Wei, Z.Y. Application Research of Fuzzy Comprehensive Evaluation in the Optimization of Feasibility Study Scheme. Master’s Thesis; Department of Civil Engineering, Lanzhou Jiaotong University: Lanzhou, China, 2020.

51. Zhou, Y.F. Study of the Key Technologies of Hybrid CAPP System Based on the Knowledge-Driven. Master’s Thesis; Department of Electronic Engineering, North University of China: Taiyuan, China, 2012.