A method, device, electronic device and medium for sorting and batch naming of teeth

Abstract

The present application provides a method, device, electronic device and medium for sorting teeth, as well as a method, device, electronic device and medium for batch naming of teeth. The tooth sorting method is applied to multiple independent teeth obtained by segmenting a three-dimensional dental arch model, or to multiple independent teeth obtained by segmenting three-dimensional voxel data. The tooth sorting method includes: obtaining a list of all teeth to be sorted and a list of sorted teeth, wherein the list of all teeth to be sorted records all teeth to be sorted, and the sorted tooth list records sorted teeth, and the sorted teeth are a subset of all teeth to be sorted; based on the configured sorting loop body, determining the remaining list of teeth to be sorted, determining the target tooth object from the remaining list of teeth to be sorted, determining the sorting position of the target tooth object in the sorted tooth list, and recording the target tooth object in the sorted tooth list based on the sorting position to form sorted teeth. The tooth sorting method provides a simple solution that can be automatically executed, and can quickly sort multiple independent teeth. The tooth batch naming method is an application of the tooth sorting method, and can quickly batch name multiple independent teeth.

Description

Technical Field

[0001] The present disclosure relates to the field of oral digitization, and in particular to a method, device, electronic device and medium for sorting teeth, and a method, device, electronic device and medium for batch naming teeth. Background Art

[0002] In the field of oral digitalization, naming independent three-dimensional tooth models is a prerequisite for subsequent work.

[0003] The data format of the 3D tooth model includes but is not limited to one of the following: 3D mesh, 3D point cloud, wherein the 3D mesh refers to a set of 3D point sets and connections within the 3D point sets, and the 3D point cloud refers to a set of unordered 3D point sets.

[0004] Methods for obtaining a three-dimensional tooth model include but are not limited to one of the following: (1) first use an intraoral scanner (IOS) to scan the upper or lower teeth of a person's mouth to obtain a three-dimensional dental arch model, and then use an artificial intelligence algorithm to segment the three-dimensional dental arch model to obtain an independent three-dimensional tooth model; (2) first use a cone beam computer tomography (CBCT) or a computed tomography (CT) device to scan a person to obtain three-dimensional voxel data (voxels), and then use an artificial intelligence algorithm to segment the three-dimensional voxel data (voxels) to obtain an independent three-dimensional tooth model. (CUI ZM,FANG Y,MEI LZ,et al.A fully automatic AI system for tooth and alveolar bone segmentation from cone-beam CT images[J].Nature Communications,2022,13(1))(HAO J,LIU J,LIJ,etal.AI-enabled Automatic Multimodal Fusion of Cone-Beam CT and IntraoralScans for Intelligent 3D Tooth-Bone Reconstruction and Clinical Applications[J].ArXiv,2022,abs / 2203.05784)

[0005] At present, there are some artificial intelligence algorithms that can realize automatic tooth naming (US 2018 / 0360567A1, Automatic detection of tooth type and eruption status) (LIAN CF, WANG L, WU TH, et al. Deep Multi-Scale Mesh Feature Learning for Automated Labeling of RawDental Surfaces From 3D Intraoral Scanners [J]. Ieee Transactions on Medical Imaging, 2020, 39 (7): 2440-50). However, artificial intelligence algorithms cannot obtain satisfactory results in some cases, and human intervention is required.

[0006] In addition, since the current relevant artificial intelligence algorithms are not open source, there is a situation where no artificial intelligence algorithm is available. In this case, it takes a lot of time to manually name teeth.

[0007] Regarding tooth naming, when human intervention is required or no artificial intelligence algorithm is available, there is no technical solution available for reference on how to quickly batch name multiple independent three-dimensional tooth models through a simple algorithm. Summary of the invention

[0008] In order to solve the above technical problems, the present disclosure provides a tooth sorting method, device, electronic device and medium, as well as a tooth batch naming method, device, electronic device and medium. The tooth sorting method provides a simple solution that can be automatically executed, which can quickly sort multiple independent three-dimensional tooth models. The tooth batch naming method is an application of the tooth sorting method, which can quickly batch name multiple independent three-dimensional tooth models.

[0009] The present disclosure provides a method for sorting teeth, the method comprising:

[0010] Obtain a list of all teeth to be sorted (list_A) and a list of sorted teeth (list_B); the list of all teeth to be sorted (list_A) records all teeth to be sorted; the list of sorted teeth (list_B) records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted;

[0011] Based on the configured sorting loop body, a target tooth object (closest_obj) is determined, a sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined, and based on the sorting position, the target tooth object (closest_obj) is recorded in the sorted tooth list (list_B) to form a sorted tooth;

[0012] The determining of the target tooth object (closest_obj) comprises: determining a remaining tooth list to be sorted, wherein the remaining tooth list to be sorted includes teeth in the list of all teeth to be sorted (list_A) but not in the sorted tooth list (list_B); determining the closest tooth at the head (closest_A1), the distance at the head (min_distance_A1), the closest tooth at the tail (closest_A2) and the distance at the tail (min_distance_A2) according to the sorted tooth list (list_B) and the remaining tooth list to be sorted; and determining the target tooth object (closest_obj) from the closest tooth at the head (closest_A1) and the closest tooth at the tail (closest_A2) according to the distance at the head (min_distance_A1) and the distance at the tail (min_distance_A2);

[0013] The method of determining the closest tooth (closest_A1), the distance (min_distance_A1), the closest tooth (closest_A2) and the distance (min_distance_A2) at the end according to the sorted tooth list (list_B) and the remaining teeth to be sorted includes: determining the first sorted tooth (list_B[0]) and the last sorted tooth (list_B[-1]) in the sorted tooth list (list_B); finding the tooth closest to the first sorted tooth (list_B[0]) from the remaining teeth list to be sorted and recording it as The closest tooth to the head (closest_A1), determine the distance between the closest tooth to the head (closest_A1) and the first sorted tooth (list_B[0]) and record it as the head distance (min_distance_A1); find the tooth closest to the last sorted tooth (list_B[-1]) from the remaining teeth to be sorted list and record it as the tail closest tooth (closest_A2), determine the distance between the closest tooth to the tail (closest_A2) and the last sorted tooth (list_B[-1]) and record it as the tail distance (min_distance_A2).

[0014] The present disclosure also provides a method for batch naming of teeth, the method comprising:

[0015] Get a list of all teeth to be sorted (list_A), a list of sorted teeth (list_B) and a list of tooth names (list_C); the list of all teeth to be sorted (list_A) records all teeth to be sorted, and the teeth to be sorted are also teeth to be named; the sorted list of teeth (list_B) records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted; the tooth name list (list_C) records the preset names of the teeth to be named, and the preset names recorded in the tooth name list (list_C) are arranged continuously, and the length of the tooth name list (list_C) is equal to the length of the list of all teeth to be sorted (list_A); before executing the above-mentioned tooth sorting method, the sorted tooth list (list_B) has one and only one element, which is the sorting starting tooth (act_obj), and the sorting starting tooth (act_obj) is any tooth among all the teeth to be sorted;

[0016] Perform the above-mentioned tooth sorting method;

[0017] Determine whether it is necessary to perform a reverse operation on the elements in the sorted tooth list (list_B) according to the index of the sorting start tooth (act_obj) in the sorted tooth list (list_B) and the length of the sorted tooth list (list_B);

[0018] The preset names recorded in the tooth name list (list_C) are assigned to the teeth in the sorted tooth list (list_B) according to the index order of the elements in the list.

[0019] The present disclosure also provides a tooth sorting device, the device comprising:

[0020] The first module is used to obtain a list of all teeth to be sorted (list_A) and a list of sorted teeth (list_B); the list of all teeth to be sorted (list_A) records all teeth to be sorted; the list of sorted teeth (list_B) records sorted teeth, and the sorted teeth are a subset of all teeth to be sorted;

[0021] The second module is used to determine a target tooth object (closest_obj) based on the configured sorting loop body, determine the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B), and record the target tooth object (closest_obj) into the sorted tooth list (list_B) based on the sorting position to form a sorted tooth;

[0022] The determining of the target tooth object (closest_obj) includes: determining a remaining tooth list to be sorted, wherein the remaining tooth list to be sorted includes teeth in the list of all teeth to be sorted (list_A) but not in the sorted tooth list (list_B); determining the closest tooth at the head (closest_A1), the head distance (min_distance_A1), the closest tooth at the tail (closest_A2) and the tail distance (min_distance_A2) according to the sorted tooth list (list_B) and the remaining tooth list to be sorted; and determining the target tooth object (closest_obj) from the closest tooth at the head (closest_A1) and the closest tooth at the tail (closest_A2) according to the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0023] The present disclosure also provides a device for batch naming of teeth, the device comprising:

[0024] The third module is used to obtain a list of all teeth to be sorted (list_A), a list of sorted teeth (list_B) and a list of tooth names (list_C); the list of all teeth to be sorted (list_A) records all teeth to be sorted, and the teeth to be sorted are also teeth to be named; the sorted list of teeth (list_B) records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted; the tooth name list (list_C) records the preset names of the teeth to be named, and the preset names recorded in the tooth name list (list_C) are arranged continuously, and the length of the tooth name list (list_C) is equal to the length of the list of all teeth to be sorted (list_A); before calling the above-mentioned tooth sorting device, the sorted tooth list (list_B) has one and only one element, which is the sorting starting tooth (act_obj), and the sorting starting tooth (act_obj) is any tooth among all the teeth to be sorted;

[0025] The fourth module is used to call the above-mentioned tooth sorting device;

[0026] A fifth module, for determining whether it is necessary to execute the reverse operation of the elements in the sorted tooth list (list_B) according to the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) and the length of the sorted tooth list (list_B);

[0027] The sixth module is used to assign the preset names recorded in the tooth name list (list_C) to the teeth in the sorted tooth list (list_B) according to the index order of the elements in the list.

[0028] An embodiment of the present disclosure also provides an electronic device, which includes: a processor; a memory for storing executable instructions of the processor; the processor is used to read the executable instructions from the memory and execute the instructions to implement the tooth sorting method and / or tooth batch naming method provided in the embodiment of the present disclosure.

[0029] The embodiment of the present disclosure also provides a computer-readable medium, which stores a computer program, and the computer program is used to execute the tooth sorting method and / or tooth batch naming method provided by the embodiment of the present disclosure.

[0030] The tooth sorting method provided by the embodiment of the present disclosure has the following advantages: (1) it can automatically sort multiple independent three-dimensional tooth models, which is efficient and time-saving; (2) it is applicable to various dentition conditions: the dentition has misplaced teeth far away from the dental arch, the dentition has misplaced teeth close to the dental arch, and the dentition has missing teeth (or gaps); (3) it is applicable to various tooth numbers: it is applicable to a dentition with N teeth (N is a natural number); (4) there is no need to pre-adjust the orientation of the dentition; (5) this method can be used for dimensionality reduction and is used for automatic sorting of multiple independent two-dimensional tooth images, including photographs and X-rays.

[0031] The tooth batch naming method provided by the embodiment of the present disclosure has the following advantages: (1) It can quickly batch name multiple independent three-dimensional tooth models, which is efficient and time-saving; (2) The input is simple and efficient: the program only needs to obtain all the teeth to be sorted (list_A), the sorted teeth list (list_B) and the tooth name list (list_C), and only the sorting start teeth (act_obj) in the tooth name list (list_C) and the sorted teeth list (list_B) need to be input; (3) Since the preset names are used, the consistency of the tooth naming results can be ensured, which is convenient for executing subsequent work; (4) It is applicable to various dentition conditions: the situation where there are misplaced teeth far away from the dental arch in the dentition, the situation where there are misplaced teeth close to the dental arch in the dentition, and the situation where there are missing teeth (or gaps) in the dentition; (5) It is applicable to various tooth quantity situations: it is applicable to the dentition with N teeth (N is a natural number); (6) There is no need to pre-adjust the orientation of the dentition; (7) This method can be used for dimensionality reduction and is used for the rapid batch naming of multiple independent two-dimensional tooth images, including photos and X-rays. BRIEF DESCRIPTION OF THE DRAWINGS

[0032] The above and other features, advantages and aspects of the embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. Throughout the accompanying drawings, the same or similar reference numerals represent the same or similar elements. It should be understood that the drawings are schematic and the originals and elements are not necessarily drawn to scale.

[0033] Figure 1 A schematic diagram of a process of a tooth sorting method provided in an embodiment of the present disclosure;

[0034] Figure 2 A schematic diagram of a flow chart of a sorting loop provided in an embodiment of the present disclosure;

[0035] Figure 3 A schematic diagram of another flow chart of a sorting loop provided in an embodiment of the present disclosure;

[0036] Figure 4 A schematic diagram of a flow chart of another sorting loop provided in an embodiment of the present disclosure;

[0037] Figure 5 A schematic diagram of a process for batch naming of teeth provided in an embodiment of the present disclosure;

[0038] Figure 6 A schematic diagram of steps 502, 504, 506 and 516 of the method for batch naming of teeth provided for exemplary embodiment 1 and exemplary embodiment 2 of the present disclosure;

[0039] Figure 7A schematic diagram of steps 502, 504, 506 and 516 of the method for batch naming of teeth provided in exemplary embodiment 3 of the present disclosure;

[0040] Figure 8 A schematic diagram of steps 502, 504, 506 and 516 of the method for batch naming of teeth provided for exemplary embodiment 4 and exemplary embodiment 5 of the present disclosure;

[0041] Fig. 9 A schematic diagram of steps 502, 504, 506 and 516 of the method for batch naming of teeth provided for exemplary embodiment 6 of the present disclosure;

[0042] Fig.10 Schematic diagram of steps 502, 504, 506 and 516 of the tooth batch naming method provided for exemplary embodiment 7, exemplary embodiment 8 and exemplary embodiment 9 of the present disclosure;

[0043] Fig.11 Schematic diagram of steps 502, 504, 506 and 516 of the method for batch naming of teeth provided for exemplary embodiment 10, exemplary embodiment 11 and exemplary embodiment 12 of the present disclosure;

[0044] Fig.12 A flowchart of a method for adding an anatomical part name to a tooth landmark name provided by an embodiment of the present disclosure;

[0045] Fig.13 A schematic diagram of steps 1202 and 1212 of a method based on adding an anatomical part name to a tooth landmark name provided by an exemplary embodiment of the present disclosure;

[0046] Fig.14 A flowchart of a method for adding a preset tooth name to a tooth marking point name provided by an embodiment of the present disclosure;

[0047] Fig.15 A schematic diagram of steps 1402 and 1420 of a method based on adding a tooth preset name to a tooth landmark name provided by an exemplary embodiment of the present disclosure; DETAILED DESCRIPTION

[0048] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as being limited to the embodiments described herein, which are instead provided for a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not intended to limit the scope of protection of the present disclosure.

[0049] It should be understood that the various steps described in the method embodiments of the present disclosure may be performed in different orders and / or in parallel. In addition, the method embodiments may include additional steps and / or omit the steps shown. The scope of the present disclosure is not limited in this respect.

[0050] The term "including" and its variations used herein are open inclusions, i.e., "including but not limited to". The term "based on" means "based at least in part on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". The relevant definitions of other terms will be given in the following description.

[0051] It should be noted that the concepts such as "first" and "second" mentioned in the present disclosure are only used to distinguish different devices, modules or units, and are not used to limit the order or interdependence of the functions performed by these devices, modules or units.

[0052] It should be noted that the modifications of "one" and "plurality" mentioned in the present disclosure are illustrative rather than restrictive, and those skilled in the art should understand that unless otherwise clearly indicated in the context, it should be understood as "one or more".

[0053] The names of the messages or information exchanged between multiple devices in the embodiments of the present disclosure are only used for illustrative purposes and are not used to limit the scope of these messages or information.

[0054]

Tooth sorting method

[0055] Figure 1 The present invention provides a flow chart of a tooth sorting method provided in an embodiment of the present invention. The method can be executed by a device, wherein the device can be implemented by software and / or hardware and can generally be integrated into an electronic device. Figure 1 As shown, the method includes:

[0056] Step 102, obtaining a list of all teeth to be sorted (list_A); the list of all teeth to be sorted (list_A) records all teeth to be sorted;

[0057] Step 104, obtaining a sorted teeth list (list_B); the sorted teeth list (list_B) records sorted teeth, and the sorted teeth are a subset of all teeth to be sorted;

[0058] Step 106, judging whether the number of sorted teeth is less than the number of all teeth to be sorted, this step is the entry condition of the sorting loop; the number of sorted teeth is recorded as len(list_B), and the number of all teeth to be sorted is recorded as len(list_A);

[0059] Step 108, sorting loop body; the sorting loop body is used to: determine the target tooth object (closest_obj), determine the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B), and record the target tooth object (closest_obj) into the sorted tooth list (list_B) based on the sorting position to form sorted teeth;

[0060] Step 110: Output the sorted tooth list (list_B).

[0061] The teeth in steps 102 and 104 are segmented independent three-dimensional tooth models. The data format of the teeth includes but is not limited to one of the following: a three-dimensional mesh, a three-dimensional point cloud, or any suitable combination of the above and other data formats. Among them, a three-dimensional mesh refers to a set formed by a three-dimensional point set and the connections within the three-dimensional point set, and a three-dimensional point cloud refers to a set of unordered three-dimensional point sets. The attributes of the teeth include: location. The location includes but is not limited to one of the following: the coordinates of the geometric center of the tooth, the coordinates of the center of mass of the tooth, the coordinates of the anatomical feature points on the surface of the tooth, or any suitable combination of the above and other coordinates. The distance between any two teeth can be determined based on the attribute of location. The distance includes but is not limited to the Euclidean distance.

[0062] There are many ways to configure the sorting loop body. Figure 2 A schematic diagram of a flow chart of a sorting loop provided in an embodiment of the present disclosure, Figure 3 A schematic diagram of another sorting loop flow provided in an embodiment of the present disclosure, Figure 4 The above three methods are only examples of the configuration methods of the sorting loop body, and the present disclosure does not make any specific restrictions on the configuration methods of the sorting loop body.

[0063] Figures 2 to 4 The three sorting loop bodies are similar in that they determine the target tooth object (closest_obj), which includes:

[0064] Determine a remaining list of teeth to be sorted, wherein the remaining list of teeth to be sorted includes teeth in the list of all teeth to be sorted (list_A) but not in the sorted list of teeth (list_B); the remaining list of teeth to be sorted can be recorded as [obj for obj in list_A if obj not in list_B];

[0065] According to the sorted teeth list (list_B) and the remaining teeth list to be sorted, determine the closest tooth at the head (closest_A1), the distance at the head (min_distance_A1), the closest tooth at the tail (closest_A2) and the distance at the tail (min_distance_A2);

[0066] According to the head distance (min_distance_A1) and the tail distance (min_distance_A2), a target tooth object (closest_obj) is determined from the closest tooth at the head (closest_A1) and the closest tooth at the tail (closest_A2).

[0067] Specifically, the method of determining the closest tooth at the head (closest_A1), the distance at the head (min_distance_A1), the closest tooth at the tail (closest_A2) and the distance at the tail (min_distance_A2) according to the sorted tooth list (list_B) and the remaining tooth list to be sorted includes:

[0068] Determine the first sorted tooth (list_B[0]) and the last sorted tooth (list_B[-1]) in the sorted tooth list (list_B);

[0069] Step 202 (or step 302 or step 402), find the tooth closest to the first sorted tooth (list_B[0]) from the remaining teeth to be sorted, record it as the closest tooth (closest_A1), determine the distance between the closest tooth (closest_A1) and the first sorted tooth (list_B[0]) and record it as the min distance (min_distance_A1);

[0070] Step 204 (or step 304 or step 404), find out the tooth closest to the last sorted tooth (list_B[-1]) from the remaining teeth to be sorted, record it as the closest tooth to the tail (closest_A2), determine the distance between the closest tooth to the tail (closest_A2) and the last sorted tooth (list_B[-1]), record it as the tail distance (min_distance_A2).

[0071] Specifically, the determining of the target tooth object (closest_obj) from the closest tooth at the head (closest_A1) and the closest tooth at the tail (closest_A2) according to the head distance (min_distance_A1) and the tail distance (min_distance_A2) includes:

[0072] Step 206 (or step 306 or step 406), determine whether the head distance (min_distance_A1) is smaller than the tail distance (min_distance_A2);

[0073] According to the result of the determination, a target tooth object (closest_obj) is determined.

[0074] Specifically, determining the target tooth object (closest_obj) according to the result of the judgment includes:

[0075] Step 208 (or step 308 or step 408), in response to the head distance (min_distance_A1) being smaller than the tail distance (min_distance_A2), determining the head closest tooth (closest_A1) as the target tooth object (closest_obj);

[0076] In step 210 (or step 310 or step 410), in response to the head distance (min_distance_A1) being less than the tail distance (min_distance_A2) not being established, the tail closest tooth (closest_A2) is determined as the target tooth object (closest_obj).

[0077] Figures 2 to 4 The difference between the three sorting loop bodies lies in the method of determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B).

[0078] like Figure 2As shown, in some embodiments, determining the sort position of the target tooth object (closest_obj) in the sorted tooth list (list_B) includes:

[0079] According to the head distance (min_distance_A1) and the tail distance (min_distance_A2), a check tooth object (check_obj) is determined from the first sorted tooth (list_B[0]) and the last sorted tooth (list_B[-1]);

[0080] Step 214 and step 216, filter out the tooth and the two teeth closest to the target tooth object (closest_obj) from the list of all teeth to be sorted (list_A), and add the one and two teeth closest to the first closest tooth list (closest_1) and the second closest tooth list (closest_2) created respectively;

[0081] The sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined according to the check tooth object (check_obj), the first closest tooth list (closest_1), the second closest tooth list (closest_2), the sorted tooth list (list_B), the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0082] Specifically, the step of determining the check tooth object (check_obj) from the first sorted tooth (list_B[0]) and the last sorted tooth (list_B[-1]) according to the head distance (min_distance_A1) and the tail distance (min_distance_A2) comprises:

[0083] Step 206: determine whether the head distance (min_distance_A1) is smaller than the tail distance (min_distance_A2);

[0084] According to the result of the determination, a check tooth object (check_obj) is determined.

[0085] Further, the step of determining a check tooth object (check_obj) according to the result of the judgment comprises:

[0086] Step 208: In response to the head distance (min_distance_A1) being less than the tail distance (min_distance_A2), the first sorted tooth (list_B[0]) is determined as the check tooth object (check_obj);

[0087] Step 210: In response to the fact that the head distance (min_distance_A1) is less than the tail distance (min_distance_A2), the last sorted tooth (list_B[-1]) is determined as the check tooth object (check_obj).

[0088] Specifically, determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) according to the check tooth object (check_obj), the first closest tooth list (closest_1), the second closest tooth list (closest_2), the sorted tooth list (list_B), the head distance (min_distance_A1) and the tail distance (min_distance_A2) includes:

[0089] Step 218, determine whether the sorted tooth list (list_B) includes the second closest tooth list (closest_2), and whether the element in the first closest tooth list (closest_1) is not the check tooth object (check_obj); the sorted tooth list (list_B) includes the second closest tooth list (closest_2) which can be recorded as all (obj in list_B for obj in closest_2);

[0090] According to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined.

[0091] Further, the determining, according to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0092] Step 220: In response to the sorted tooth list (list_B) including the second closest tooth list (closest_2), and the element in the first closest tooth list (closest_1) is not the check tooth object (check_obj), it is determined whether the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is less than the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B); the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[0]); the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[1]);

[0093] Step 226, in response to the sorted tooth list (list_B) including the second closest tooth list (closest_2), and the element in the first closest tooth list (closest_1) is not the check tooth object (check_obj) is not established, then determine whether the head distance (min_distance_A1) is less than the tail distance (min_distance_A2);

[0094] According to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined.

[0095] Further, the determining, according to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0096] Step 222, in response to the fact that the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is less than the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the position after the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B); the position after the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[0])+1;

[0097] Step 224, in response to the fact that the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is less than the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is not established, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the position after the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B); the position after the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[1])+1;

[0098] Step 228, in response to the head distance (min_distance_A1) being less than the tail distance (min_distance_A2), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the beginning of the sorted tooth list (list_B);

[0099] Step 230: In response to the fact that the head distance (min_distance_A1) is less than the tail distance (min_distance_A2), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the end of the sorted tooth list (list_B).

[0100] It should be understood that the determination of whether len(list_A)>=3 in step 212 (i.e., the determination of whether the length of all the to-be-sorted tooth lists is greater than or equal to 3) is to ensure that the first closest tooth list (closest_1) and the second closest tooth list (closest_2) can be correctly obtained in steps 214 and 216. It should be understood that the determination of whether len(list_A)>=3 in step 218 is to short-circuit all subsequent and expressions when len(list_A)>=3 is not true, i.e., short-circuit all(obj in list_B for obj inclosest_2)and check_obj!=closest_1[0] when len(list_A)>=3 is not true, so as to prevent the program from calling the first closest tooth list (closest_1) and the second closest tooth list (closest_2) in step 218 and jumping from step 218 to step 226. Therefore, the determination of whether len(list_A)>=3 in step 212 and step 218 is an additional step when the number of teeth to be sorted is less than 3, and does not constitute a part of the core concept and business logic of the present disclosure. If the number of teeth to be sorted is greater than or equal to 3, there is no need to additionally determine whether len(list_A)>=3 in step 212 and step 218.

[0101] like Figure 3 As shown, in some other embodiments, determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) includes:

[0102] Step 314 and step 316, filter out the tooth and the two teeth closest to the target tooth object (closest_obj) from the list of all teeth to be sorted (list_A), and add the one and two teeth closest to the first closest tooth list (closest_1) and the second closest tooth list (closest_2) created respectively;

[0103] The sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined according to the first closest tooth list (closest_1), the second closest tooth list (closest_2), the sorted tooth list (list_B), the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0104] Specifically, determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) according to the first closest tooth list (closest_1), the second closest tooth list (closest_2), the sorted tooth list (list_B), the head distance (min_distance_A1) and the tail distance (min_distance_A2) includes:

[0105] Step 318: determine whether the sorted tooth list (list_B) includes the second closest tooth list (closest_2), and the element in the first closest tooth list (closest_1) is not the first sorted tooth (list_B[0]), and the element in the first closest tooth list (closest_1) is not the last sorted tooth (list_B[-1]); the sorted tooth list (list_B) includes the second closest tooth list (closest_2), which can be recorded as all(obj in list_B for obj in closest_2);

[0106] According to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined.

[0107] Further, the determining, according to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0108] Step 320: In response to the fact that the sorted tooth list (list_B) includes the second closest tooth list (closest_2), and the element in the first closest tooth list (closest_1) is not the first sorted tooth (list_B[0]), and the element in the first closest tooth list (closest_1) is not the last sorted tooth (list_B[-1]), it is determined whether the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is less than the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B); the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[0]); the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[1]);

[0109] Step 326: In response to the sorted tooth list (list_B) including the second closest tooth list (closest_2), and the element in the first closest tooth list (closest_1) is not the first sorted tooth (list_B[0]), and the element in the first closest tooth list (closest_1) is not the last sorted tooth (list_B[-1]) is not true, it is determined whether the head distance (min_distance_A1) is less than the tail distance (min_distance_A2);

[0110] According to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined.

[0111] Further, the determining, according to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0112] Step 322, in response to the fact that the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is less than the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the position after the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B); the position after the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[0])+1;

[0113] Step 324: In response to the fact that the index of the first element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) is less than the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the next position of the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B); the next position of the index of the second element in the second closest tooth list (closest_2) in the sorted tooth list (list_B) can be recorded as list_B.index(closest_2[1])+1;

[0114] Step 328: In response to the head distance (min_distance_A1) being less than the tail distance (min_distance_A2), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the beginning of the sorted tooth list (list_B);

[0115] Step 330: In response to the fact that the head distance (min_distance_A1) is less than the tail distance (min_distance_A2), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the end of the sorted tooth list (list_B).

[0116] It should be understood that the determination of whether len(list_A)>=3 in step 312 (i.e., the determination of whether the length of all the to-be-sorted tooth lists is greater than or equal to 3) is to ensure that the first closest tooth list (closest_1) and the second closest tooth list (closest_2) can be correctly obtained in steps 314 and 316. It should be understood that the determination of whether len(list_A)>=3 in step 318 is to short-circuit all subsequent and expressions when len(list_A)>=3 is not true, i.e., short-circuit all(obj in list_B for obj inclosest_2)and list_B[0]!=closest_1[0]and list_B[-1]!=closest_1[0] when len(list_A)>=3 is not true, so as to prevent the program from calling the first closest tooth list (closest_1) and the second closest tooth list (closest_2) in step 318 and jumping from step 318 to step 326. Therefore, the determination of whether len(list_A)>=3 in step 312 and step 318 is an additional step when the number of teeth to be sorted is less than 3, and does not constitute a part of the core concept and business logic of the present disclosure. If the number of teeth to be sorted is greater than or equal to 3, there is no need to additionally determine whether len(list_A)>=3 in step 312 and step 318.

[0117] like Figure 4 As shown, in some further embodiments, determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) includes:

[0118] The sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined according to the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0119] Specifically, determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) according to the head distance (min_distance_A1) and the tail distance (min_distance_A2) includes:

[0120] Step 406: determine whether the head distance (min_distance_A1) is smaller than the tail distance (min_distance_A2);

[0121] According to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined.

[0122] Further, the determining, according to the result of the judgment, the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0123] Step 412: In response to the head distance (min_distance_A1) being less than the tail distance (min_distance_A2), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the beginning of the sorted tooth list (list_B);

[0124] Step 414: In response to the fact that the head distance (min_distance_A1) is less than the tail distance (min_distance_A2), the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is the end of the sorted tooth list (list_B).

[0125] [Sample code for some steps of the tooth sorting method]

[0126] It should be understood that the present disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein.

[0127] It should be understood that the present disclosure may be written in one or more programming languages ​​or a combination thereof to form computer program codes for performing operations of the present disclosure, and the above-mentioned programming languages ​​include but are not limited to machine languages, assembly languages, and high-level languages.

[0128] Take Python as an example:

[0129] (1) The sample code of step 202 (or step 302 or step 402) is as follows:

[0130]

[0131] (2) The sample code of step 204 (or step 304 or step 404) is as follows:

[0132]

[0133]

[0134] (3) The sample code of step 214 and step 216 (or step 314 and step 316) is as follows:

[0135]

[0136] [Differences in implementation effects of the three sorting loops in the tooth sorting method]

[0137] As mentioned above, Figures 2 to 4 The difference between the three sorting loop bodies lies in the method of determining the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B), specifically:

[0138] like Figure 2 As shown, in some implementations (recorded as sorting loop body 1): when the determination condition in step 218 is met (step 218 is to determine whether closest_obj should be inserted in the middle of list_B), the index position of closest_2 in list_B is used as a reference to insert closest_obj in the middle of list_B (steps 222 and 224); when the condition in step 218 is not met, closest_obj is inserted at the beginning (step 228) or the end (step 230) of list_B;

[0139] like Figure 3 As shown, in some other implementations (recorded as sorting loop body 2): when the judgment condition in step 318 is met (step 318 is to judge whether closest_obj should be inserted in the middle of list_B), the index position of closest_2 in list_B is used as a reference to insert closest_obj in the middle of list_B (steps 322 and 324); when the condition in step 318 is not met, closest_obj is inserted at the beginning (step 328) or the end (step 330) of list_B;

[0140] like Figure 4 As shown, in some further implementations (recorded as sorting loop body three): closest_obj is always inserted at the beginning (step 412) or the end (step 414) of list_B.

[0141] That is, the last step of sort loop body 1 and sort loop body 2 is to insert closest_obj in the middle of list_B, or to insert closest_obj at the beginning or end of list_B; and the last step of sort loop body 3 is always to insert closest_obj at the beginning or end of list_B.

[0142] The difference between the first sorting loop and the second sorting loop is that the determination conditions (step 218 and step 318) for judging whether closest_obj should be inserted into the middle of list_B are different.

[0143] Since the three sorting loops determine the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) in different ways, the implementation effects of the three sorting loops are different for the misplaced teeth far away from the dental arch:

[0144] Compared with the sorting loop body 3, the sorting loop body 1 and the sorting loop body 2 add a crucial judgment (i.e., judging whether closest_obj should be inserted into the middle of list_B), so the sorting loop body 1 and the sorting loop body 2 can always handle the misaligned teeth far away from the dental arch well when automatically sorting the teeth (the tooth 'T9' in step 510 in exemplary embodiment 1, exemplary embodiment 2, exemplary embodiment 4 and exemplary embodiment 5);

[0145] However, the judgment (i.e., judging whether closest_obj should be inserted in the middle of list_B) is missing in the sorting loop body 3. Therefore, the sorting loop body 3 cannot always handle the misaligned teeth far away from the dental arch well when automatically sorting the teeth (tooth 'T9' in step 510 in exemplary embodiment 3 and exemplary embodiment 6), and other teeth (teeth 'T10', 'T11' and 'T12' in step 510 in exemplary embodiment 3 and exemplary embodiment 6) will be affected.

[0146] Therefore, when the tooth sorting method with sorting loop body three is applied in the tooth batch naming method, after the program is executed, manual intervention is required to modify the name of the dislocated tooth away from the dental arch (tooth 'T9' in exemplary embodiment 3 and exemplary embodiment 6) and the names of other affected teeth (teeth 'T10', 'T11' and 'T12' in exemplary embodiment 3 and exemplary embodiment 6).

[0147] As for misplaced teeth close to the dental arch (exemplary embodiment 7, exemplary embodiment 8 and exemplary embodiment 9) and missing teeth (or gaps) (exemplary embodiment 10, exemplary embodiment 11 and exemplary embodiment 12), the three sorting loops can handle them well and their implementation effects are basically the same.

[0148]

Batch naming method for teeth

[0149] The batch naming method of teeth is an application of the tooth sorting method.

[0150] Figure 5The present invention provides a flow chart of a method for batch naming of teeth, which can be executed by a device, wherein the device can be implemented by software and / or hardware, and can generally be integrated into an electronic device. Figure 5 As shown, the method includes:

[0151] Step 502, obtaining a list of all teeth to be sorted (list_A); the list of all teeth to be sorted (list_A) records all teeth to be sorted, and the teeth to be sorted are also teeth to be named;

[0152] Step 504, obtaining a sorted tooth list (list_B); the sorted tooth list (list_B) records sorted teeth, and the sorted teeth are a subset of all teeth to be sorted; before executing the tooth sorting method in the subsequent step 510, the sorted tooth list (list_B) has and only has one element, which is the sorting start tooth (act_obj), and the sorting start tooth (act_obj) is any tooth among all teeth to be sorted;

[0153] Step 506, obtaining a tooth name list (list_C); the tooth name list (list_C) records the preset names of the teeth to be named, the preset names recorded in the tooth name list (list_C) are arranged continuously, and the length of the tooth name list (list_C) is equal to the length of all teeth to be sorted (list_A); the preset names can be symbols specified in the clinical tooth position recording method, or other symbols; the data type of the symbol includes but is not limited to one of the following: string, integer, floating point number; the clinical tooth position recording method is one of the following: position recording method, Palmer recording system, universal numbering system, International Dental Federation system;

[0154] Step 508, judging whether the length of the list of all teeth to be sorted (list_A) is greater than 0, and the length of the list of tooth names (list_C) is equal to the length of the list of all teeth to be sorted (list_A); that is, judging whether the number of all teeth to be sorted is greater than 0, and the number of preset names is equal to the number of all teeth to be sorted; it should be understood that if the number of preset names is equal to the number of all teeth to be sorted (that is, the length of list_C is equal to that of list_A), then the length of list_C is also equal to the length of list_B outputted in the subsequent step 510, and then the subsequent step 516 can be executed correctly;

[0155] Step 510, executing the above-mentioned tooth sorting method;

[0156] Determine whether it is necessary to perform a reverse operation on the elements in the sorted tooth list (list_B) according to the index of the sorting start tooth (act_obj) in the sorted tooth list (list_B) and the length of the sorted tooth list (list_B);

[0157] Step 516: assign the preset names recorded in the tooth name list (list_C) to the teeth in the sorted tooth list (list_B) according to the index order of the elements in the list; that is, for i in range(len(list_B)):list_B[i].name=list_C[i].

[0158] The teeth in steps 502 and 504 are segmented independent three-dimensional tooth models. The data format of the teeth includes but is not limited to one of the following: a three-dimensional mesh, a three-dimensional point cloud, or any suitable combination of the above and other data formats. Among them, a three-dimensional mesh refers to a set formed by a three-dimensional point set and the connections within the three-dimensional point set, and a three-dimensional point cloud refers to a set of unordered three-dimensional point sets. The attributes of the teeth include: location, name. The location includes but is not limited to one of the following: the coordinates of the geometric center of the tooth, the coordinates of the center of mass of the tooth, the coordinates of the anatomical feature points on the surface of the tooth, or any suitable combination of the above and other coordinates. The distance between any two teeth can be determined based on the attribute of location. The distance includes but is not limited to the Euclidean distance.

[0159] In some embodiments, the determining whether it is necessary to reverse the elements in the sorted tooth list (list_B) according to the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) and the length of the sorted tooth list (list_B) comprises:

[0160] Step 512: determine whether the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) is less than half of the length of the sorted tooth list (list_B); the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) can be recorded as list_B.index(act_obj); half of the length of the sorted tooth list (list_B) can be recorded as len(list_B) / 2;

[0161] According to the result of the judgment, it is determined whether it is necessary to perform a reverse operation on the elements in the sorted tooth list (list_B).

[0162] Further, the determining whether it is necessary to reverse the elements in the sorted tooth list (list_B) according to the result of the judgment comprises:

[0163] In response to the index of the sorting start tooth (act_obj) in the sorted tooth list (list_B) being less than half the length of the sorted tooth list (list_B), reversing the elements in the sorted tooth list (list_B) is not performed;

[0164] Step 514, in response to the fact that the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) is less than half of the length of the sorted tooth list (list_B) is not true, executing the reverse operation of the elements in the sorted tooth list (list_B); the elements in the reversed sorted tooth list (list_B) can be recorded as list_B.reverse().

[0165] In some other embodiments, the determining whether it is necessary to reverse the elements in the sorted tooth list (list_B) according to the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) and the length of the sorted tooth list (list_B) comprises:

[0166] Step 512, determine whether the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) is greater than or equal to half of the length of the sorted tooth list (list_B); the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) can be recorded as list_B.index(act_obj); half of the length of the sorted tooth list (list_B) can be recorded as len(list_B) / 2;

[0167] According to the result of the judgment, it is determined whether it is necessary to perform a reverse operation on the elements in the sorted tooth list (list_B).

[0168] Further, the determining whether it is necessary to reverse the elements in the sorted tooth list (list_B) according to the result of the judgment comprises:

[0169] In response to the index of the sorting start tooth (act_obj) in the sorted tooth list (list_B) being greater than or equal to half of the length of the sorted tooth list (list_B), the elements in the sorted tooth list (list_B) are not reversed;

[0170] Step 514, if it does not hold that the index of the sorted starting tooth (act_obj) in the sorted tooth list (list_B) is greater than or equal to half of the length of the sorted tooth list (list_B), then execute the elements in the reverse sorted tooth list (list_B); the elements in the reverse sorted tooth list (list_B) can be denoted as list_B.reverse().

[0171] It should be understood that since the sorted starting tooth (act_obj) in step 504 is on the left or right side of the dental arch (which needs to be considered if the number of all teeth to be sorted is greater than or equal to 2), and the judgment condition in step 512 determines the order of the elements in the sorted tooth list (list_B), the order of the elements in the sorted tooth list (list_B) and the order of the preset names in the tooth name list (list_C) in step 506 determine the tooth batch naming result in step 516; it is necessary to determine whether the sorted starting tooth (act_obj) in step 504 should be on the left or right side of the dental arch according to the order of the preset names in the tooth name list (list_C) in step 506 and the judgment condition in step 512. Since in a specific embodiment, the order of the preset names in the tooth name list (list_C) in step 506 and the judgment condition in step 512 are known, at this time, whether the sorted starting tooth (act_obj) in step 504 should be on the left or right side of the dental arch is also known. For example:

[0172] (1) In Exemplary Embodiments 1-3 and Exemplary Embodiments 7-9: The tooth name list (list_C) in step 506 is ['16', '15', '14', '13', '12', '11', '21', '22', '23', '24', '25', '26'], where the order of the preset names is from right to left; the judgment condition in step 512 is list_B.index(act_obj) < len(list_B) / 2; at this time, the sorted starting tooth (act_obj) in step 504 should be on the right side of the dental arch;

[0173] Similarly, in Exemplary Embodiments 10-12: The tooth name list (list_C) in step 506 is ['16', '15', '13', '12', '11', '21', '22', '23', '25', '26'], where the order of the preset names is from right to left; the judgment condition in step 512 is list_B.index(act_obj) < len(list_B) / 2; at this time, the sorted starting tooth (act_obj) in step 504 should be on the right side of the dental arch;

[0174] (2) In exemplary embodiments 4 - 6: The tooth name list (list_C) in step 506 is ['16', '15', '14', '13', '12', '11', '21', '22', '23', '24', '25', '26'], where the order of the preset names is from right to left; the judgment condition in step 512 is list_B.index(act_obj) >= len(list_B) / 2; at this time, the sorting starting tooth (act_obj) in step 504 should be on the left side of the dental arch;

[0175] (3) If the tooth name list (list_C) in step 506 is ['26', '25', '24', '23', '22', '21', '11', '12', '13', '14', '15', '16'], where the order of the preset names is from left to right; the judgment condition in step 512 is list_B.index(act_obj) < len(list_B) / 2; at this time, the sorting starting tooth (act_obj) in step 504 should be on the left side of the dental arch;

[0176] (4) If the tooth name list (list_C) in step 506 is ['26', '25', '24', '23', '22', '21', '11', '12', '13', '14', '15', '16'], where the order of the preset names is from left to right; the judgment condition in step 512 is list_B.index(act_obj) >= len(list_B) / 2; at this time, the sorting starting tooth (act_obj) in step 504 should be on the right side of the dental arch.

[0177] Among them, the sorting starting tooth (act_obj) being on the left side of the dental arch means that the sorting starting tooth (act_obj) is one of the teeth in the left part; the sorting starting tooth (act_obj) being on the right side of the dental arch means that the sorting starting tooth (act_obj) is one of the teeth in the right part. The definitions of the left part and the right part are as follows: With reference to the left and right of the dental arch, all teeth to be sorted are divided into the left part and the right part; if the number of all teeth to be sorted is even and greater than or equal to 2, the number of teeth in the left part and the right part is the same; if the number of all teeth to be sorted is odd and greater than or equal to 3, the number of teeth in the left part and the right part is the same, and neither the left part nor the right part includes the one tooth in the middle position.

[0178]

Tooth Sorting Device

[0179] The present disclosure also provides a tooth sorting device, which can be implemented by software and / or hardware and can generally be integrated in an electronic device. The device includes:

[0180] The first module is used to obtain a list of all teeth to be sorted (list_A) and a list of sorted teeth (list_B); the list of all teeth to be sorted (list_A) records all teeth to be sorted; the list of sorted teeth (list_B) records sorted teeth, and the sorted teeth are a subset of all teeth to be sorted;

[0181] The second module is used to determine a target tooth object (closest_obj) based on the configured sorting loop body, determine the sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B), and record the target tooth object (closest_obj) into the sorted tooth list (list_B) based on the sorting position to form a sorted tooth;

[0182] The determining of the target tooth object (closest_obj) includes: determining a remaining tooth list to be sorted, wherein the remaining tooth list to be sorted includes teeth in the list of all teeth to be sorted (list_A) but not in the sorted tooth list (list_B); determining the closest tooth at the head (closest_A1), the head distance (min_distance_A1), the closest tooth at the tail (closest_A2) and the tail distance (min_distance_A2) according to the sorted tooth list (list_B) and the remaining tooth list to be sorted; and determining the target tooth object (closest_obj) from the closest tooth at the head (closest_A1) and the closest tooth at the tail (closest_A2) according to the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0183] Optionally, determining the sort position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0184] According to the head distance (min_distance_A1) and the tail distance (min_distance_A2), a check tooth object (check_obj) is determined from the first sorted tooth (list_B[0]) and the last sorted tooth (list_B[-1]);

[0185] Filter out the tooth and the two teeth closest to the target tooth object (closest_obj) from the list of all teeth to be sorted (list_A), and add the one and two teeth closest to the target tooth object (closest_obj) to the first closest tooth list (closest_1) and the second closest tooth list (closest_2) created respectively;

[0186] The sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined according to the check tooth object (check_obj), the first closest tooth list (closest_1), the second closest tooth list (closest_2), the sorted tooth list (list_B), the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0187] Optionally, determining the sort position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0188] Filter out the tooth and the two teeth closest to the target tooth object (closest_obj) from the list of all teeth to be sorted (list_A), and add the one and two teeth closest to the target tooth object (closest_obj) to the first closest tooth list (closest_1) and the second closest tooth list (closest_2) created respectively;

[0189] The sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined according to the first closest tooth list (closest_1), the second closest tooth list (closest_2), the sorted tooth list (list_B), the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0190] Optionally, determining the sort position of the target tooth object (closest_obj) in the sorted tooth list (list_B) comprises:

[0191] The sorting position of the target tooth object (closest_obj) in the sorted tooth list (list_B) is determined according to the head distance (min_distance_A1) and the tail distance (min_distance_A2).

[0192] The tooth sorting device provided in the embodiments of the present disclosure can execute the tooth sorting method provided in any embodiment of the present disclosure, and has the corresponding functional modules and beneficial effects of the execution method.

[0193] The embodiments of the present disclosure also provide a computer program product, including a computer program / instruction, which, when executed by a processor, implements the tooth sorting method provided by any embodiment of the present disclosure.

[0194]

Tooth batch naming device

[0195] The present disclosure also provides a device for batch naming of teeth, which can be implemented by software and / or hardware and can generally be integrated in an electronic device. The device includes:

[0196] The third module is used to obtain a list of all teeth to be sorted (list_A), a list of sorted teeth (list_B) and a list of tooth names (list_C); the list of all teeth to be sorted (list_A) records all teeth to be sorted, and the teeth to be sorted are also teeth to be named; the sorted list of teeth (list_B) records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted; the tooth name list (list_C) records the preset names of the teeth to be named, and the preset names recorded in the tooth name list (list_C) are arranged continuously, and the length of the tooth name list (list_C) is equal to the length of the list of all teeth to be sorted (list_A); before calling the above-mentioned tooth sorting device, the sorted tooth list (list_B) has one and only one element, which is the sorting starting tooth (act_obj), and the sorting starting tooth (act_obj) is any tooth among all the teeth to be sorted;

[0197] The fourth module is used to call the above-mentioned tooth sorting device;

[0198] A fifth module, for determining whether it is necessary to execute the reverse operation of the elements in the sorted tooth list (list_B) according to the index of the sorting starting tooth (act_obj) in the sorted tooth list (list_B) and the length of the sorted tooth list (list_B);

[0199] The sixth module is used to assign the preset names recorded in the tooth name list (list_C) to the teeth in the sorted tooth list (list_B) according to the index order of the elements in the list.

[0200] The tooth batch naming device provided in the embodiments of the present disclosure can execute the tooth batch naming method provided in any embodiment of the present disclosure, and has the corresponding functional modules and beneficial effects of the execution method.

[0201] The embodiments of the present disclosure also provide a computer program product, including a computer program / instruction, which, when executed by a processor, implements the method for batch naming of teeth provided by any embodiment of the present disclosure.

[0202]

Electronic equipment

[0203] An embodiment of the present disclosure also provides an electronic device, which includes: a processor; a memory for storing executable instructions of the processor; the processor is used to read the executable instructions from the memory and execute the instructions to implement a tooth sorting method and / or a tooth batch naming method as provided in any embodiment of the present disclosure.

[0204] The electronic devices in the embodiments of the present disclosure may include, but are not limited to, mobile terminals such as mobile phones, laptop computers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), VR (virtual reality) headsets, AR (augmented reality) headsets, MR (mixed reality) headsets, etc., and fixed terminals such as digital TVs, desktop computers, dental surgery robots, etc.

[0205] Electronic devices may include processing devices (e.g., central processing units, graphics processing units, etc.), which may perform various appropriate actions and processes according to programs stored in a read-only memory (ROM) or programs loaded from a storage device into a random access memory (RAM). In RAM, various programs and data required for the operation of the electronic device are also stored. The processing device, ROM, and RAM are connected to each other via a bus. An input / output (I / O) interface is also connected to the bus.

[0206] Typically, the following devices may be connected to the I / O interface: input devices including, for example, a touch screen, a touch pad, a keyboard, a mouse, a camera, a microphone, an accelerometer, a gyroscope, etc.; output devices including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; storage devices including, for example, a magnetic tape, a hard disk, etc.; and communication devices. The communication device may allow the electronic device to communicate with other devices wirelessly or by wire to exchange data. It should be understood that it is not required to implement or have all of the above devices, and more or fewer devices may be implemented or have instead.

[0207] In particular, the computer program product provided by the embodiment of the present disclosure includes a computer program carried on a non-transitory computer readable medium, the computer program including a program code for executing a tooth sorting method and / or a tooth batch naming method. In such an embodiment, the computer program can be downloaded and installed from a network through a communication device, or installed from a storage device, or installed from a ROM.

[0208]

Computer readable medium

[0209] An embodiment of the present disclosure further provides a computer-readable medium storing a computer program for executing a tooth sorting method and / or a tooth batch naming method as provided in any embodiment of the present disclosure.

[0210] It should be noted that the computer-readable medium mentioned above in the present disclosure may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. Examples of computer-readable media may include, but are not limited to, electrical, magnetic, electromagnetic, optical, infrared, or semiconductor systems, devices or devices, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer disks, hard disks, random access memories (RAM), read-only memories (ROM), erasable programmable read-only memories (EPROM or flash memory), optical fibers, portable compact disk read-only memories (CD-ROMs), optical storage devices, magnetic storage devices, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that may be used by or in conjunction with an instruction execution system, device or device. In the present disclosure, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, which carries a computer-readable program code. Such propagated data signals may take a variety of forms, including but not limited to electrical signals, magnetic signals, electromagnetic signals, optical signals, infrared signals, or any suitable combination of the above. The computer readable signal medium may also be any computer readable medium other than a computer readable storage medium, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

[0211] In some embodiments, the client and the server may communicate using any currently known or future developed network protocol such as HTTP (Hyper Text Transfer Protocol), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), an internet (e.g., the Internet), and a peer-to-peer network (e.g., an ad-hoc peer-to-peer network), as well as any currently known or future developed network.

[0212] The computer-readable medium may be included in the electronic device, or may exist independently without being incorporated into the electronic device.

[0213] [Example 1]

[0214] (1) Program used in this exemplary embodiment:

[0215] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 2 The sort loop body in ;

[0216] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0217] (2) Program data input:

[0218] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0219] Sort starting teeth ( Figure 5 , step 504): list_B = ['T3'];

[0220] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0221] The schematic diagram of steps 502, 504 and 506 is shown in Figure 6Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0222] (3) Program data processing:

[0223] When the user clicks the Run button, the program will automatically perform the following steps.

[0224] Step 510:

[0225] (Note: ① represents step 222; ② represents step 224; ③ represents step 228; ④ represents step 230)

[0226] Loop 1:

[0227] list_B[0] is 'T3'; list_B[-1] is 'T3';

[0228] closest_A1 is 'T2'; closest_A2 is 'T2';

[0229] closest_obj is 'T2'; check_obj is 'T3';

[0230] closest_2 is ['T3','T1']; closest_1 is ['T3'];

[0231] Execute step ④; list_B is ['T3', 'T2'];

[0232] Loop 2:

[0233] list_B[0] is 'T3'; list_B[-1] is 'T2';

[0234] closest_A1 is 'T4'; closest_A2 is 'T1';

[0235] closest_obj is 'T4'; check_obj is 'T3';

[0236] closest_2 is ['T5','T3']; closest_1 is ['T5'];

[0237] Execute step ③; list_B is ['T4', 'T3', 'T2'];

[0238] Loop 3:

[0239] list_B[0] is 'T4'; list_B[-1] is 'T2';

[0240] closest_A1 is 'T5'; closest_A2 is 'T1';

[0241] closest_obj is 'T5'; check_obj is 'T4';

[0242] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0243] Execute step ③; list_B is ['T5','T4','T3','T2'];

[0244] Loop 4:

[0245] list_B[0] is 'T5'; list_B[-1] is 'T2'

[0246] closest_A1 is 'T6'; closest_A2 is 'T1';

[0247] closest_obj is 'T6'; check_obj is 'T5';

[0248] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0249] Execute step ③; list_B is ['T6','T5','T4','T3','T2'];

[0250] Loop 5:

[0251] list_B[0] is 'T6'; list_B[-1] is 'T2';

[0252] closest_A1 is 'T7'; closest_A2 is 'T1';

[0253] closest_obj is 'T7'; check_obj is 'T6';

[0254] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0255] Execute step ③; list_B is ['T7','T6','T5','T4','T3','T2'];

[0256] Loop 6:

[0257] list_B[0] is 'T7'; list_B[-1] is 'T2';

[0258] closest_A1 is 'T8'; closest_A2 is 'T1';

[0259] closest_obj is 'T8'; check_obj is 'T7';

[0260] closest_2 is ['T10','T7']; closest_1 is ['T10'];

[0261] Execute step ③; list_B is ['T8','T7','T6','T5','T4','T3','T2'];

[0262] Loop 7:

[0263] list_B[0] is 'T8'; list_B[-1] is 'T2';

[0264] closest_A1 is 'T10'; closest_A2 is 'T1';

[0265] closest_obj is 'T10'; check_obj is 'T8';

[0266] closest_2 is ['T8','T11']; closest_1 is ['T8'];

[0267] Execute step ③; list_B is ['T10','T8','T7','T6','T5','T4','T3','T2'];

[0268] Loop 8:

[0269] list_B[0] is 'T10'; list_B[-1] is 'T2';

[0270] closest_A1 is 'T11'; closest_A2 is 'T1';

[0271] closest_obj is 'T11'; check_obj is 'T10';

[0272] closest_2 is ['T10','T12']; closest_1 is ['T10'];

[0273] Execute step ③; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2'];

[0274] Loop 9:

[0275] list_B[0] is 'T11'; list_B[-1] is 'T2';

[0276] closest_A1 is 'T12'; closest_A2 is 'T1';

[0277] closest_obj is 'T1'; check_obj is 'T2';

[0278] closest_2 is ['T2','T3']; closest_1 is ['T2'];

[0279] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0280] Loop 10:

[0281] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0282] closest_A1 is 'T12'; closest_A2 is 'T12';

[0283] closest_obj is 'T12'; check_obj is 'T11';

[0284] closest_2 is ['T11','T10']; closest_1 is ['T11'];

[0285] Execute step ③; list_B is ['T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0286] Loop 11:

[0287] list_B[0] is 'T12'; list_B[-1] is 'T1';

[0288] closest_A1 is 'T9'; closest_A2 is 'T9';

[0289] closest_obj is 'T9'; check_obj is 'T12';

[0290] closest_2 is ['T8','T10']; closest_1 is ['T8'];

[0291] Execute step ②; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0292] Steps 512 and 514:

[0293] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0294] The result of step 516 is shown in Figure 6 .

[0295] [Example 2]

[0296] (1) Program used in this exemplary embodiment:

[0297] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 3 The sort loop body in ;

[0298] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0299] (2) Program data input:

[0300] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0301] Sort starting teeth ( Figure 5 , step 504): list_B = ['T3'];

[0302] Preset Name ( Figure 5, step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0303] The schematic diagram of steps 502, 504 and 506 is shown in Figure 6 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0304] (3) Program data processing:

[0305] When the user clicks the Run button, the program will automatically perform the following steps.

[0306] Step 510:

[0307] (Note: ① represents step 322; ② represents step 324; ③ represents step 328; ④ represents step 330)

[0308] Loop 1:

[0309] list_B[0] is 'T3'; list_B[-1] is 'T3';

[0310] closest_A1 is 'T2'; closest_A2 is 'T2';

[0311] closest_obj is 'T2';

[0312] closest_2 is ['T3','T1']; closest_1 is ['T3'];

[0313] Execute step ④; list_B is ['T3', 'T2'];

[0314] Loop 2:

[0315] list_B[0] is 'T3'; list_B[-1] is 'T2';

[0316] closest_A1 is 'T4'; closest_A2 is 'T1';

[0317] closest_obj is 'T4';

[0318] closest_2 is ['T5','T3']; closest_1 is ['T5'];

[0319] Execute step ③; list_B is ['T4', 'T3', 'T2'];

[0320] Loop 3:

[0321] list_B[0] is 'T4'; list_B[-1] is 'T2';

[0322] closest_A1 is 'T5'; closest_A2 is 'T1';

[0323] closest_obj is 'T5';

[0324] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0325] Execute step ③; list_B is ['T5','T4','T3','T2'];

[0326] Loop 4:

[0327] list_B[0] is 'T5'; list_B[-1] is 'T2';

[0328] closest_A1 is 'T6'; closest_A2 is 'T1';

[0329] closest_obj is 'T6';

[0330] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0331] Execute step ③; list_B is ['T6','T5','T4','T3','T2'];

[0332] Loop 5:

[0333] list_B[0] is 'T6'; list_B[-1] is 'T2';

[0334] closest_A1 is 'T7'; closest_A2 is 'T1';

[0335] closest_obj is 'T7';

[0336] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0337] Execute step ③; list_B is ['T7','T6','T5','T4','T3','T2'];

[0338] Loop 6:

[0339] list_B[0] is 'T7'; list_B[-1] is 'T2';

[0340] closest_A1 is 'T8'; closest_A2 is 'T1';

[0341] closest_obj is 'T8';

[0342] closest_2 is ['T10','T7']; closest_1 is ['T10'];

[0343] Execute step ③; list_B is ['T8','T7','T6','T5','T4','T3','T2'];

[0344] Loop 7:

[0345] list_B[0] is 'T8'; list_B[-1] is 'T2';

[0346] closest_A1 is 'T10'; closest_A2 is 'T1';

[0347] closest_obj is 'T10';

[0348] closest_2 is ['T8','T11']; closest_1 is ['T8'];

[0349] Execute step ③; list_B is ['T10','T8','T7','T6','T5','T4','T3','T2'];

[0350] Loop 8:

[0351] list_B[0] is 'T10'; list_B[-1] is 'T2';

[0352] closest_A1 is 'T11'; closest_A2 is 'T1';

[0353] closest_obj is 'T11';

[0354] closest_2 is ['T10','T12']; closest_1 is ['T10'];

[0355] Execute step ③; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2'];

[0356] Loop 9:

[0357] list_B[0] is 'T11'; list_B[-1] is 'T2';

[0358] closest_A1 is 'T12'; closest_A2 is 'T1';

[0359] closest_obj is 'T1';

[0360] closest_2 is ['T2','T3']; closest_1 is ['T2'];

[0361] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0362] Loop 10:

[0363] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0364] closest_A1 is 'T12'; closest_A2 is 'T12';

[0365] closest_obj is 'T12';

[0366] closest_2 is ['T11','T10']; closest_1 is ['T11'];

[0367] Execute step ③; list_B is ['T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0368] Loop 11:

[0369] list_B[0] is 'T12'; list_B[-1] is 'T1';

[0370] closest_A1 is 'T9'; closest_A2 is 'T9';

[0371] closest_obj is 'T9';

[0372] closest_2 is ['T8','T10']; closest_1 is ['T8'];

[0373] Execute step ②; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0374] Steps 512 and 514:

[0375] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0376] The result of step 516 is shown in Figure 6 .

[0377] [Example 3]

[0378] (1) Program used in this exemplary embodiment:

[0379] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 4 The sort loop body in ;

[0380] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0381] (2) Program data input:

[0382] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0383] Sort starting teeth ( Figure 5 , step 504): list_B = ['T3'];

[0384] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0385] The schematic diagram of steps 502, 504 and 506 is shown in Figure 7Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0386] (3) Program data processing:

[0387] When the user clicks the Run button, the program will automatically perform the following steps.

[0388] Step 510:

[0389] (Note: ③ represents step 412; ④ represents step 414)

[0390] Loop 1:

[0391] list_B[0] is 'T3'; list_B[-1] is 'T3';

[0392] closest_A1 is 'T2'; closest_A2 is 'T2';

[0393] closest_obj is 'T2';

[0394] Execute step ④; list_B is ['T3', 'T2'];

[0395] Loop 2:

[0396] list_B[0] is 'T3'; list_B[-1] is 'T2';

[0397] closest_A1 is 'T4'; closest_A2 is 'T1';

[0398] closest_obj is 'T4';

[0399] Execute step ③; list_B is ['T4', 'T3', 'T2'];

[0400] Loop 3:

[0401] list_B[0] is 'T4'; list_B[-1] is 'T2';

[0402] closest_A1 is 'T5'; closest_A2 is 'T1';

[0403] closest_obj is 'T5';

[0404] Execute step ③; list_B is ['T5','T4','T3','T2'];

[0405] Loop 4:

[0406] list_B[0] is 'T5'; list_B[-1] is 'T2';

[0407] closest_A1 is 'T6'; closest_A2 is 'T1';

[0408] closest_obj is 'T6';

[0409] Execute step ③; list_B is ['T6','T5','T4','T3','T2'];

[0410] Loop 5:

[0411] list_B[0] is 'T6'; list_B[-1] is 'T2';

[0412] closest_A1 is 'T7'; closest_A2 is 'T1';

[0413] closest_obj is 'T7';

[0414] Execute step ③; list_B is ['T7','T6','T5','T4','T3','T2'];

[0415] Loop 6:

[0416] list_B[0] is 'T7'; list_B[-1] is 'T2';

[0417] closest_A1 is 'T8'; closest_A2 is 'T1';

[0418] closest_obj is 'T8';

[0419] Execute step ③; list_B is ['T8','T7','T6','T5','T4','T3','T2'];

[0420] Loop 7:

[0421] list_B[0] is 'T8'; list_B[-1] is 'T2';

[0422] closest_A1 is 'T10'; closest_A2 is 'T1';

[0423] closest_obj is 'T10';

[0424] Execute step ③; list_B is ['T10','T8','T7','T6','T5','T4','T3','T2'];

[0425] Loop 8:

[0426] list_B[0] is 'T10'; list_B[-1] is 'T2';

[0427] closest_A1 is 'T11'; closest_A2 is 'T1';

[0428] closest_obj is 'T11';

[0429] Execute step ③; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2'];

[0430] Loop 9:

[0431] list_B[0] is 'T11'; list_B[-1] is 'T2';

[0432] closest_A1 is 'T12'; closest_A2 is 'T1';

[0433] closest_obj is 'T1';

[0434] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0435] Loop 10:

[0436] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0437] closest_A1 is 'T12'; closest_A2 is 'T12';

[0438] closest_obj is 'T12';

[0439] Execute step ③; list_B is ['T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0440] Loop 11:

[0441] list_B[0] is 'T12'; list_B[-1] is 'T1';

[0442] closest_A1 is 'T9'; closest_A2 is 'T9';

[0443] closest_obj is 'T9';

[0444] Execute step ③; list_B is ['T9','T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'].

[0445] Steps 512 and 514:

[0446] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T10','T11','T12','T9'].

[0447] The result of step 516 is shown in Figure 7 .

[0448] After the program is executed, manual intervention is performed: the name of tooth 'T9' is changed to '23', the name of tooth 'T10' is changed to '24', the name of tooth 'T11' is changed to '25', and the name of tooth 'T12' is changed to '26'.

[0449] [Example 4]

[0450] (1) Program used in this exemplary embodiment:

[0451] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 2 The sort loop body in ;

[0452] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj)>=len(list_B) / 2.

[0453] (2) Program data input:

[0454] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0455] Sort starting teeth ( Figure 5 , step 504): list_B = ['T10'];

[0456] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0457] The schematic diagram of steps 502, 504 and 506 is shown in Figure 8 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0458] (3) Program data processing:

[0459] When the user clicks the Run button, the program will automatically perform the following steps.

[0460] Step 510:

[0461] (Note: ① represents step 222; ② represents step 224; ③ represents step 228; ④ represents step 230)

[0462] Loop 1:

[0463] list_B[0] is 'T10'; list_B[-1] is 'T10';

[0464] closest_A1 is 'T8'; closest_A2 is 'T8';

[0465] closest_obj is 'T8'; check_obj is 'T10';

[0466] closest_2 is ['T10','T7']; closest_1 is ['T10'];

[0467] Execute step ④; list_B is ['T10', 'T8'];

[0468] Loop 2:

[0469] list_B[0] is 'T10'; list_B[-1] is 'T8';

[0470] closest_A1 is 'T11'; closest_A2 is 'T7';

[0471] closest_obj is 'T11'; check_obj is 'T10';

[0472] closest_2 is ['T10','T12']; closest_1 is ['T10'];

[0473] Execute step ③; list_B is ['T11', 'T10', 'T8'];

[0474] Loop 3:

[0475] list_B[0] is 'T11'; list_B[-1] is 'T8';

[0476] closest_A1 is 'T12'; closest_A2 is 'T7';

[0477] closest_obj is 'T7'; check_obj is 'T8';

[0478] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0479] Execute step ④; list_B is ['T11','T10','T8','T7'];

[0480] Loop 4:

[0481] list_B[0] is 'T11'; list_B[-1] is 'T7';

[0482] closest_A1 is 'T12'; closest_A2 is 'T6';

[0483] closest_obj is 'T6'; check_obj is 'T7';

[0484] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0485] Execute step ④; list_B is ['T11','T10','T8','T7','T6'];

[0486] Loop 5:

[0487] list_B[0] is 'T11'; list_B[-1] is 'T6';

[0488] closest_A1 is 'T12'; closest_A2 is 'T5';

[0489] closest_obj is 'T5'; check_obj is 'T6';

[0490] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0491] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5'];

[0492] Loop 6:

[0493] list_B[0] is 'T11'; list_B[-1] is 'T5';

[0494] closest_A1 is 'T12'; closest_A2 is 'T4';

[0495] closest_obj is 'T4'; check_obj is 'T5';

[0496] closest_2 is ['T5','T3']; closest_1 is ['T5'];

[0497] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4'];

[0498] Loop 7:

[0499] list_B[0] is 'T11'; list_B[-1] is 'T4';

[0500] closest_A1 is 'T12'; closest_A2 is 'T3';

[0501] closest_obj is 'T3'; check_obj is 'T4';

[0502] closest_2 is ['T2','T4']; closest_1 is ['T2'];

[0503] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3'];

[0504] Loop 8:

[0505] list_B[0] is 'T11'; list_B[-1] is 'T3';

[0506] closest_A1 is 'T12'; closest_A2 is 'T2';

[0507] closest_obj is 'T2'; check_obj is 'T3';

[0508] closest_2 is ['T3','T1']; closest_1 is ['T3'];

[0509] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2'];

[0510] Loop 9:

[0511] list_B[0] is 'T11'; list_B[-1] is 'T2';

[0512] closest_A1 is 'T12'; closest_A2 is 'T1';

[0513] closest_obj is 'T1'; check_obj is 'T2';

[0514] closest_2 is ['T2','T3']; closest_1 is ['T2'];

[0515] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0516] Loop 10:

[0517] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0518] closest_A1 is 'T12'; closest_A2 is 'T12';

[0519] closest_obj is 'T12'; check_obj is 'T11';

[0520] closest_2 is ['T11','T10']; closest_1 is ['T11'];

[0521] Execute step ③; list_B is ['T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0522] Loop 11:

[0523] list_B[0] is 'T12'; list_B[-1] is 'T1';

[0524] closest_A1 is 'T9'; closest_A2 is 'T9';

[0525] closest_obj is 'T9'; check_obj is 'T12';

[0526] closest_2 is ['T8','T10']; closest_1 is ['T8'];

[0527] Execute step ②; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0528] Steps 512 and 514:

[0529] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0530] The result of step 516 is shown in Figure 8 .

[0531] [Example 5]

[0532] (1) Program used in this exemplary embodiment:

[0533] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 3 The sort loop body in ;

[0534] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj)>=len(list_B) / 2.

[0535] (2) Program data input:

[0536] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0537] Sort starting teeth ( Figure 5, step 504): list_B = ['T10'];

[0538] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0539] The schematic diagram of steps 502, 504 and 506 is shown in Figure 8 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0540] (3) Program data processing:

[0541] When the user clicks the Run button, the program will automatically perform the following steps.

[0542] Step 510:

[0543] (Note: ① represents step 322; ② represents step 324; ③ represents step 328; ④ represents step 330)

[0544] Loop 1:

[0545] list_B[0] is 'T10'; list_B[-1] is 'T10';

[0546] closest_A1 is 'T8'; closest_A2 is 'T8';

[0547] closest_obj is 'T8';

[0548] closest_2 is ['T10','T7']; closest_1 is ['T10'];

[0549] Execute step ④; list_B is ['T10', 'T8'];

[0550] Loop 2:

[0551] list_B[0] is 'T10'; list_B[-1] is 'T8';

[0552] closest_A1 is 'T11'; closest_A2 is 'T7';

[0553] closest_obj is 'T11';

[0554] closest_2 is ['T10','T12']; closest_1 is ['T10'];

[0555] Execute step ③; list_B is ['T11', 'T10', 'T8'];

[0556] Loop 3:

[0557] list_B[0] is 'T11'; list_B[-1] is 'T8';

[0558] closest_A1 is 'T12'; closest_A2 is 'T7';

[0559] closest_obj is 'T7';

[0560] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0561] Execute step ④; list_B is ['T11','T10','T8','T7'];

[0562] Loop 4:

[0563] list_B[0] is 'T11'; list_B[-1] is 'T7';

[0564] closest_A1 is 'T12'; closest_A2 is 'T6';

[0565] closest_obj is 'T6';

[0566] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0567] Execute step ④; list_B is ['T11','T10','T8','T7','T6'];

[0568] Loop 5:

[0569] list_B[0] is 'T11'; list_B[-1] is 'T6';

[0570] closest_A1 is 'T12'; closest_A2 is 'T5';

[0571] closest_obj is 'T5';

[0572] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0573] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5'];

[0574] Loop 6:

[0575] list_B[0] is 'T11'; list_B[-1] is 'T5';

[0576] closest_A1 is 'T12'; closest_A2 is 'T4';

[0577] closest_obj is 'T4';

[0578] closest_2 is ['T5','T3']; closest_1 is ['T5'];

[0579] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4'];

[0580] Loop 7:

[0581] list_B[0] is 'T11'; list_B[-1] is 'T4';

[0582] closest_A1 is 'T12'; closest_A2 is 'T3';

[0583] closest_obj is 'T3';

[0584] closest_2 is ['T2','T4']; closest_1 is ['T2'];

[0585] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3'];

[0586] Loop 8:

[0587] list_B[0] is 'T11'; list_B[-1] is 'T3';

[0588] closest_A1 is 'T12'; closest_A2 is 'T2';

[0589] closest_obj is 'T2';

[0590] closest_2 is ['T3','T1']; closest_1 is ['T3'];

[0591] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2'];

[0592] Loop 9:

[0593] list_B[0] is 'T11'; list_B[-1] is 'T2';

[0594] closest_A1 is 'T12'; closest_A2 is 'T1';

[0595] closest_obj is 'T1';

[0596] closest_2 is ['T2','T3']; closest_1 is ['T2'];

[0597] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0598] Loop 10:

[0599] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0600] closest_A1 is 'T12'; closest_A2 is 'T12';

[0601] closest_obj is 'T12';

[0602] closest_2 is ['T11','T10']; closest_1 is ['T11'];

[0603] Execute step ③; list_B is ['T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0604] Loop 11:

[0605] list_B[0] is 'T12'; list_B[-1] is 'T1';

[0606] closest_A1 is 'T9'; closest_A2 is 'T9';

[0607] closest_obj is 'T9';

[0608] closest_2 is ['T8','T10']; closest_1 is ['T8'];

[0609] Execute step ②; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0610] Steps 512 and 514:

[0611] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0612] The result of step 516 is shown in Figure 8 .

[0613] [Example 6]

[0614] (1) Program used in this exemplary embodiment:

[0615] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 4 The sort loop body in ;

[0616] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj)>=len(list_B) / 2.

[0617] (2) Program data input:

[0618] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0619] Sort starting teeth ( Figure 5 , step 504): list_B = ['T10'];

[0620] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0621] The schematic diagram of steps 502, 504 and 506 is shown in Fig. 9 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0622] (3) Program data processing:

[0623] When the user clicks the Run button, the program will automatically perform the following steps.

[0624] Step 510:

[0625] (Note: ③ represents step 412; ④ represents step 414)

[0626] Loop 1:

[0627] list_B[0] is 'T10'; list_B[-1] is 'T10';

[0628] closest_A1 is 'T8'; closest_A2 is 'T8';

[0629] closest_obj is 'T8';

[0630] Execute step ④; list_B is ['T10', 'T8'];

[0631] Loop 2:

[0632] list_B[0] is 'T10'; list_B[-1] is 'T8';

[0633] closest_A1 is 'T11'; closest_A2 is 'T7';

[0634] closest_obj is 'T11';

[0635] Execute step ③; list_B is ['T11', 'T10', 'T8'];

[0636] Loop 3:

[0637] list_B[0] is 'T11'; list_B[-1] is 'T8';

[0638] closest_A1 is 'T12'; closest_A2 is 'T7';

[0639] closest_obj is 'T7';

[0640] Execute step ④; list_B is ['T11','T10','T8','T7'];

[0641] Loop 4:

[0642] list_B[0] is 'T11'; list_B[-1] is 'T7';

[0643] closest_A1 is 'T12'; closest_A2 is 'T6';

[0644] closest_obj is 'T6';

[0645] Execute step ④; list_B is ['T11','T10','T8','T7','T6'];

[0646] Loop 5:

[0647] list_B[0] is 'T11'; list_B[-1] is 'T6';

[0648] closest_A1 is 'T12'; closest_A2 is 'T5';

[0649] closest_obj is 'T5';

[0650] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5'];

[0651] Loop 6:

[0652] list_B[0] is 'T11'; list_B[-1] is 'T5';

[0653] closest_A1 is 'T12'; closest_A2 is 'T4';

[0654] closest_obj is 'T4';

[0655] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4'];

[0656] Loop 7:

[0657] list_B[0] is 'T11'; list_B[-1] is 'T4';

[0658] closest_A1 is 'T12'; closest_A2 is 'T3';

[0659] closest_obj is 'T3';

[0660] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3'];

[0661] Loop 8:

[0662] list_B[0] is 'T11'; list_B[-1] is 'T3';

[0663] closest_A1 is 'T12'; closest_A2 is 'T2';

[0664] closest_obj is 'T2';

[0665] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2'];

[0666] Loop 9:

[0667] list_B[0] is 'T11'; list_B[-1] is 'T2';

[0668] closest_A1 is 'T12'; closest_A2 is 'T1';

[0669] closest_obj is 'T1';

[0670] Execute step ④; list_B is ['T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0671] Loop 10:

[0672] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0673] closest_A1 is 'T12'; closest_A2 is 'T12';

[0674] closest_obj is 'T12';

[0675] Execute step ③; list_B is ['T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'];

[0676] Loop 11:

[0677] list_B[0] is 'T12'; list_B[-1] is 'T1';

[0678] closest_A1 is 'T9'; closest_A2 is 'T9';

[0679] closest_obj is 'T9';

[0680] Execute step ③; list_B is ['T9','T12','T11','T10','T8','T7','T6','T5','T4','T3','T2','T1'].

[0681] Steps 512 and 514:

[0682] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T10','T11','T12','T9'].

[0683] The result of step 516 is shown in Fig. 9 .

[0684] After the program is executed, manual intervention is performed: the name of tooth 'T9' is changed to '23', the name of tooth 'T10' is changed to '24', the name of tooth 'T11' is changed to '25', and the name of tooth 'T12' is changed to '26'.

[0685] [Example 7]

[0686] (1) Program used in this exemplary embodiment:

[0687] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 2 The sort loop body in ;

[0688] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0689] (2) Program data input:

[0690] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0691] Sort starting teeth ( Figure 5 , step 504): list_B = ['T3'];

[0692] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0693] The schematic diagram of steps 502, 504 and 506 is shown in Fig.10 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0694] (3) Program data processing:

[0695] When the user clicks the Run button, the program will automatically perform the following steps.

[0696] Step 510:

[0697] (Note: ① represents step 222; ② represents step 224; ③ represents step 228; ④ represents step 230)

[0698] Loop 1:

[0699] list_B[0] is 'T3'; list_B[-1] is 'T3';

[0700] closest_A1 is 'T2'; closest_A2 is 'T2';

[0701] closest_obj is 'T2'; check_obj is 'T3';

[0702] closest_2 is ['T3','T1']; closest_1 is ['T3'];

[0703] Execute step ④; list_B is ['T3', 'T2'];

[0704] Loop 2:

[0705] list_B[0] is 'T3'; list_B[-1] is 'T2';

[0706] closest_A1 is 'T4'; closest_A2 is 'T1';

[0707] closest_obj is 'T4'; check_obj is 'T3';

[0708] closest_2 is ['T5','T3']; closest_1 is ['T5'];

[0709] Execute step ③; list_B is ['T4', 'T3', 'T2'];

[0710] Loop 3:

[0711] list_B[0] is 'T4'; list_B[-1] is 'T2';

[0712] closest_A1 is 'T5'; closest_A2 is 'T1';

[0713] closest_obj is 'T5'; check_obj is 'T4';

[0714] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0715] Execute step ③; list_B is ['T5','T4','T3','T2'];

[0716] Loop 4:

[0717] list_B[0] is 'T5'; list_B[-1] is 'T2';

[0718] closest_A1 is 'T6'; closest_A2 is 'T1';

[0719] closest_obj is 'T6'; check_obj is 'T5';

[0720] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0721] Execute step ③; list_B is ['T6','T5','T4','T3','T2'];

[0722] Loop 5:

[0723] list_B[0] is 'T6'; list_B[-1] is 'T2';

[0724] closest_A1 is 'T7'; closest_A2 is 'T1';

[0725] closest_obj is 'T7'; check_obj is 'T6';

[0726] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0727] Execute step ③; list_B is ['T7','T6','T5','T4','T3','T2'];

[0728] Loop 6:

[0729] list_B[0] is 'T7'; list_B[-1] is 'T2';

[0730] closest_A1 is 'T8'; closest_A2 is 'T1';

[0731] closest_obj is 'T8'; check_obj is 'T7';

[0732] closest_2 is ['T7','T9']; closest_1 is ['T7'];

[0733] Execute step ③; list_B is ['T8','T7','T6','T5','T4','T3','T2'];

[0734] Loop 7:

[0735] list_B[0] is 'T8'; list_B[-1] is 'T2';

[0736] closest_A1 is 'T9'; closest_A2 is 'T1';

[0737] closest_obj is 'T1'; check_obj is 'T2';

[0738] closest_2 is ['T2','T3']; closest_1 is ['T2'];

[0739] Execute step ④; list_B is ['T8','T7','T6','T5','T4','T3','T2','T1'];

[0740] Loop 8:

[0741] list_B[0] is 'T8'; list_B[-1] is 'T1';

[0742] closest_A1 is 'T9'; closest_A2 is 'T10';

[0743] closest_obj is 'T9'; check_obj is 'T8';

[0744] closest_2 is ['T8','T10']; closest_1 is ['T8'];

[0745] Execute step ③; list_B is ['T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0746] Loop 9:

[0747] list_B[0] is 'T9'; list_B[-1] is 'T1';

[0748] closest_A1 is 'T10'; closest_A2 is 'T10';

[0749] closest_obj is 'T10'; check_obj is 'T9';

[0750] closest_2 is ['T11','T9']; closest_1 is ['T11'];

[0751] Execute step ③; list_B is ['T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0752] Loop 10:

[0753] list_B[0] is 'T10'; list_B[-1] is 'T1';

[0754] closest_A1 is 'T11'; closest_A2 is 'T11';

[0755] closest_obj is 'T11'; check_obj is 'T10';

[0756] closest_2 is ['T10','T12']; closest_1 is ['T10'];

[0757] Execute step ③; list_B is ['T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0758] Loop 11:

[0759] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0760] closest_A1 is 'T12'; closest_A2 is 'T12';

[0761] closest_obj is 'T12'; check_obj is 'T11';

[0762] closest_2 is ['T11','T10']; closest_1 is ['T11'];

[0763] Execute step ③; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0764] Steps 512 and 514:

[0765] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0766] The result of step 516 is shown in Fig.10 .

[0767] [Example 8]

[0768] (1) Program used in this exemplary embodiment:

[0769] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 3 The sort loop body in ;

[0770] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0771] (2) Program data input:

[0772] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0773] Sort starting teeth ( Figure 5 , step 504): list_B = ['T3'];

[0774] Preset Name ( Figure 5 , step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0775] The schematic diagram of steps 502, 504 and 506 is shown in Fig.10 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0776] (3) Program data processing:

[0777] When the user clicks the Run button, the program will automatically perform the following steps.

[0778] Step 510:

[0779] (Note: ① represents step 322; ② represents step 324; ③ represents step 328; ④ represents step 330)

[0780] Loop 1:

[0781] list_B[0] is 'T3'; list_B[-1] is 'T3';

[0782] closest_A1 is 'T2'; closest_A2 is 'T2';

[0783] closest_obj is 'T2';

[0784] closest_2 is ['T3','T1']; closest_1 is ['T3'];

[0785] Execute step ④; list_B is ['T3', 'T2'];

[0786] Loop 2:

[0787] list_B[0] is 'T3'; list_B[-1] is 'T2';

[0788] closest_A1 is 'T4'; closest_A2 is 'T1';

[0789] closest_obj is 'T4';

[0790] closest_2 is ['T5','T3']; closest_1 is ['T5'];

[0791] Execute step ③; list_B is ['T4', 'T3', 'T2'];

[0792] Loop 3:

[0793] list_B[0] is 'T4'; list_B[-1] is 'T2';

[0794] closest_A1 is 'T5'; closest_A2 is 'T1';

[0795] closest_obj is 'T5';

[0796] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0797] Execute step ③; list_B is ['T5','T4','T3','T2'];

[0798] Loop 4:

[0799] list_B[0] is 'T5'; list_B[-1] is 'T2';

[0800] closest_A1 is 'T6'; closest_A2 is 'T1';

[0801] closest_obj is 'T6';

[0802] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0803] Execute step ③; list_B is ['T6','T5','T4','T3','T2'];

[0804] Loop 5:

[0805] list_B[0] is 'T6'; list_B[-1] is 'T2';

[0806] closest_A1 is 'T7'; closest_A2 is 'T1';

[0807] closest_obj is 'T7';

[0808] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0809] Execute step ③; list_B is ['T7','T6','T5','T4','T3','T2'];

[0810] Loop 6:

[0811] list_B[0] is 'T7'; list_B[-1] is 'T2';

[0812] closest_A1 is 'T8'; closest_A2 is 'T1';

[0813] closest_obj is 'T8';

[0814] closest_2 is ['T7','T9']; closest_1 is ['T7'];

[0815] Execute step ③; list_B is ['T8','T7','T6','T5','T4','T3','T2'];

[0816] Loop 7:

[0817] list_B[0] is 'T8'; list_B[-1] is 'T2';

[0818] closest_A1 is 'T9'; closest_A2 is 'T1';

[0819] closest_obj is 'T1';

[0820] closest_2 is ['T2','T3']; closest_1 is ['T2'];

[0821] Execute step ④; list_B is ['T8','T7','T6','T5','T4','T3','T2','T1'];

[0822] Loop 8:

[0823] list_B[0] is 'T8'; list_B[-1] is 'T1';

[0824] closest_A1 is 'T9'; closest_A2 is 'T10';

[0825] closest_obj is 'T9';

[0826] closest_2 is ['T8','T10']; closest_1 is ['T8'];

[0827] Execute step ③; list_B is ['T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0828] Loop 9:

[0829] list_B[0] is 'T9'; list_B[-1] is 'T1';

[0830] closest_A1 is 'T10'; closest_A2 is 'T10';

[0831] closest_obj is 'T10';

[0832] closest_2 is ['T11','T9']; closest_1 is ['T11'];

[0833] Execute step ③; list_B is ['T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0834] Loop 10:

[0835] list_B[0] is 'T10'; list_B[-1] is 'T1';

[0836] closest_A1 is 'T11'; closest_A2 is 'T11';

[0837] closest_obj is 'T11';

[0838] closest_2 is ['T10','T12']; closest_1 is ['T10'];

[0839] Execute step ③; list_B is ['T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0840] Loop 11:

[0841] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0842] closest_A1 is 'T12'; closest_A2 is 'T12';

[0843] closest_obj is 'T12';

[0844] closest_2 is ['T11','T10']; closest_1 is ['T11'];

[0845] Execute step ③; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0846] Steps 512 and 514:

[0847] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0848] The result of step 516 is shown in Fig.10 .

[0849] [Example 9]

[0850] (1) Program used in this exemplary embodiment:

[0851] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 4 The sort loop body in ;

[0852] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0853] (2) Program data input:

[0854] Tooth to be named ( Figure 5 , step 502): list_A = ['T2', 'T4', 'T11', 'T7', 'T9', 'T6', 'T8', 'T3', 'T1', 'T5', 'T12', 'T10'];

[0855] Sort starting teeth ( Figure 5 , step 504): list_B = ['T3'];

[0856] Preset Name ( Figure 5, step 506): list_C = ['16','15','14','13','12','11','21','22','23','24','25','26'].

[0857] The schematic diagram of steps 502, 504 and 506 is shown in Fig.10 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0858] (3) Program data processing:

[0859] When the user clicks the Run button, the program will automatically perform the following steps.

[0860] Step 510:

[0861] (Note: ③ represents step 412; ④ represents step 414)

[0862] Loop 1:

[0863] list_B[0] is 'T3'; list_B[-1] is 'T3';

[0864] closest_A1 is 'T2'; closest_A2 is 'T2';

[0865] closest_obj is 'T2';

[0866] Execute step ④; list_B is ['T3', 'T2'];

[0867] Loop 2:

[0868] list_B[0] is 'T3'; list_B[-1] is 'T2';

[0869] closest_A1 is 'T4'; closest_A2 is 'T1';

[0870] closest_obj is 'T4';

[0871] Execute step ③; list_B is ['T4', 'T3', 'T2'];

[0872] Loop 3:

[0873] list_B[0] is 'T4'; list_B[-1] is 'T2';

[0874] closest_A1 is 'T5'; closest_A2 is 'T1';

[0875] closest_obj is 'T5';

[0876] Execute step ③; list_B is ['T5','T4','T3','T2'];

[0877] Loop 4:

[0878] list_B[0] is 'T5'; list_B[-1] is 'T2';

[0879] closest_A1 is 'T6'; closest_A2 is 'T1';

[0880] closest_obj is 'T6';

[0881] Execute step ③; list_B is ['T6','T5','T4','T3','T2'];

[0882] Loop 5:

[0883] list_B[0] is 'T6'; list_B[-1] is 'T2';

[0884] closest_A1 is 'T7'; closest_A2 is 'T1';

[0885] closest_obj is 'T7';

[0886] Execute step ③; list_B is ['T7','T6','T5','T4','T3','T2'];

[0887] Loop 6:

[0888] list_B[0] is 'T7'; list_B[-1] is 'T2';

[0889] closest_A1 is 'T8'; closest_A2 is 'T1';

[0890] closest_obj is 'T8';

[0891] Execute step ③; list_B is ['T8','T7','T6','T5','T4','T3','T2'];

[0892] Loop 7:

[0893] list_B[0] is 'T8'; list_B[-1] is 'T2';

[0894] closest_A1 is 'T9'; closest_A2 is 'T1';

[0895] closest_obj is 'T1';

[0896] Execute step ④; list_B is ['T8','T7','T6','T5','T4','T3','T2','T1'];

[0897] Loop 8:

[0898] list_B[0] is 'T8'; list_B[-1] is 'T1';

[0899] closest_A1 is 'T9'; closest_A2 is 'T10';

[0900] closest_obj is 'T9';

[0901] Execute step ③; list_B is ['T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0902] Loop 9:

[0903] list_B[0] is 'T9'; list_B[-1] is 'T1';

[0904] closest_A1 is 'T10'; closest_A2 is 'T10';

[0905] closest_obj is 'T10';

[0906] Execute step ③; list_B is ['T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0907] Loop 10:

[0908] list_B[0] is 'T10'; list_B[-1] is 'T1';

[0909] closest_A1 is 'T11'; closest_A2 is 'T11';

[0910] closest_obj is 'T11';

[0911] Execute step ③; list_B is ['T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'];

[0912] Loop 11:

[0913] list_B[0] is 'T11'; list_B[-1] is 'T1';

[0914] closest_A1 is 'T12'; closest_A2 is 'T12';

[0915] closest_obj is 'T12';

[0916] Execute step ③; list_B is ['T12','T11','T10','T9','T8','T7','T6','T5','T4','T3','T2','T1'].

[0917] Steps 512 and 514:

[0918] List B (reversed) is ['T1','T2','T3','T4','T5','T6','T7','T8','T9','T10','T11','T12'].

[0919] The result of step 516 is shown in Fig.10 .

[0920] [Example 10]

[0921] (1) Program used in this exemplary embodiment:

[0922] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 2 The sort loop body in ;

[0923] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0924] (2) Program data input:

[0925] Tooth to be named ( Figure 5 , step 502): list_A = ['T7', 'T9', 'T2', 'T11', 'T4', 'T1', 'T8', 'T6', 'T12', 'T5'];

[0926] Sort starting teeth ( Figure 5 , step 504): list_B = ['T4'];

[0927] Preset Name ( Figure 5 , step 506): list_C = ['16','15','13','12','11','21','22','23','25','26'].

[0928] The schematic diagram of steps 502, 504 and 506 is shown in Fig.11 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0929] (3) Program data processing:

[0930] When the user clicks the Run button, the program will automatically perform the following steps.

[0931] Step 510:

[0932] (Note: ① represents step 222; ② represents step 224; ③ represents step 228; ④ represents step 230)

[0933] Loop 1:

[0934] list_B[0] is 'T4'; list_B[-1] is 'T4';

[0935] closest_A1 is 'T5'; closest_A2 is 'T5';

[0936] closest_obj is 'T5'; check_obj is 'T4';

[0937] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[0938] Execute step ④; list_B is ['T4', 'T5'];

[0939] Loop 2:

[0940] list_B[0] is 'T4'; list_B[-1] is 'T5';

[0941] closest_A1 is 'T6'; closest_A2 is 'T6';

[0942] closest_obj is 'T6'; check_obj is 'T5';

[0943] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[0944] Execute step ④; list_B is ['T4','T5','T6'];

[0945] Loop 3:

[0946] list_B[0] is 'T4'; list_B[-1] is 'T6';

[0947] closest_A1 is 'T2'; closest_A2 is 'T7';

[0948] closest_obj is 'T7'; check_obj is 'T6';

[0949] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[0950] Execute step ④; list_B is ['T4','T5','T6','T7'];

[0951] Loop 4:

[0952] list_B[0] is 'T4'; list_B[-1] is 'T7';

[0953] closest_A1 is 'T2'; closest_A2 is 'T8';

[0954] closest_obj is 'T8'; check_obj is 'T7';

[0955] closest_2 is ['T7','T9']; closest_1 is ['T7'];

[0956] Execute step ④; list_B is ['T4','T5','T6','T7','T8'];

[0957] Loop 5:

[0958] list_B[0] is 'T4'; list_B[-1] is 'T8';

[0959] closest_A1 is 'T2'; closest_A2 is 'T9';

[0960] closest_obj is 'T9'; check_obj is 'T8';

[0961] closest_2 is ['T8','T11']; closest_1 is ['T8'];

[0962] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9'];

[0963] Loop 6:

[0964] list_B[0] is 'T4'; list_B[-1] is 'T9';

[0965] closest_A1 is 'T2'; closest_A2 is 'T11';

[0966] closest_obj is 'T11'; check_obj is 'T9';

[0967] closest_2 is ['T12','T9']; closest_1 is ['T12'];

[0968] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9','T11'];

[0969] Loop 7:

[0970] list_B[0] is 'T4'; list_B[-1] is 'T11';

[0971] closest_A1 is 'T2'; closest_A2 is 'T12';

[0972] closest_obj is 'T12'; check_obj is 'T11';

[0973] closest_2 is ['T11','T9']; closest_1 is ['T11'];

[0974] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9','T11','T12'];

[0975] Loop 8:

[0976] list_B[0] is 'T4'; list_B[-1] is 'T12';

[0977] closest_A1 is 'T2'; closest_A2 is 'T2';

[0978] closest_obj is 'T2'; check_obj is 'T4';

[0979] closest_2 is ['T1','T4']; closest_1 is ['T1'];

[0980] Execute step ③; list_B is ['T2','T4','T5','T6','T7','T8','T9','T11','T12'];

[0981] Loop 9:

[0982] list_B[0] is 'T2'; list_B[-1] is 'T12';

[0983] closest_A1 is 'T1'; closest_A2 is 'T1';

[0984] closest_obj is 'T1'; check_obj is 'T2';

[0985] closest_2 is ['T2','T4']; closest_1 is ['T2'];

[0986] Execute step ③; list_B is ['T1','T2','T4','T5','T6','T7','T8','T9','T11','T12'].

[0987] Step 512:

[0988] List B is ['T1','T2','T4','T5','T6','T7','T8','T9','T11','T12'].

[0989] The result of step 516 is shown in Fig.11 .

[0990] [Example 11]

[0991] (1) Program used in this exemplary embodiment:

[0992] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 3 The sort loop body in ;

[0993] Based on the tooth batch naming method ( Figure 5) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[0994] (2) Program data input:

[0995] Tooth to be named ( Figure 5 , step 502): list_A = ['T7', 'T9', 'T2', 'T11', 'T4', 'T1', 'T8', 'T6', 'T12', 'T5'];

[0996] Sort starting teeth ( Figure 5 , step 504): list_B = ['T4'];

[0997] Preset Name ( Figure 5 , step 506): list_C = ['16','15','13','12','11','21','22','23','25','26'].

[0998] The schematic diagram of steps 502, 504 and 506 is shown in Fig.11 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[0999] (3) Program data processing:

[1000] When the user clicks the Run button, the program will automatically perform the following steps.

[1001] Step 510:

[1002] (Note: ① represents step 322; ② represents step 324; ③ represents step 328; ④ represents step 330)

[1003] Loop 1:

[1004] list_B[0] is 'T4'; list_B[-1] is 'T4';

[1005] closest_A1 is 'T5'; closest_A2 is 'T5';

[1006] closest_obj is 'T5';

[1007] closest_2 is ['T6','T4']; closest_1 is ['T6'];

[1008] Execute step ④; list_B is ['T4', 'T5'];

[1009] Loop 2:

[1010] list_B[0] is 'T4'; list_B[-1] is 'T5';

[1011] closest_A1 is 'T6'; closest_A2 is 'T6';

[1012] closest_obj is 'T6';

[1013] closest_2 is ['T5','T7']; closest_1 is ['T5'];

[1014] Execute step ④; list_B is ['T4','T5','T6'];

[1015] Loop 3:

[1016] list_B[0] is 'T4'; list_B[-1] is 'T6';

[1017] closest_A1 is 'T2'; closest_A2 is 'T7';

[1018] closest_obj is 'T7';

[1019] closest_2 is ['T8','T6']; closest_1 is ['T8'];

[1020] Execute step ④; list_B is ['T4','T5','T6','T7'];

[1021] Loop 4:

[1022] list_B[0] is 'T4'; list_B[-1] is 'T7';

[1023] closest_A1 is 'T2'; closest_A2 is 'T8';

[1024] closest_obj is 'T8';

[1025] closest_2 is ['T7','T9']; closest_1 is ['T7'];

[1026] Execute step ④; list_B is ['T4','T5','T6','T7','T8'];

[1027] Loop 5:

[1028] list_B[0] is 'T4'; list_B[-1] is 'T8';

[1029] closest_A1 is 'T2'; closest_A2 is 'T9';

[1030] closest_obj is 'T9';

[1031] closest_2 is ['T8','T11']; closest_1 is ['T8'];

[1032] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9'];

[1033] Loop 6:

[1034] list_B[0] is 'T4'; list_B[-1] is 'T9';

[1035] closest_A1 is 'T2'; closest_A2 is 'T11';

[1036] closest_obj is 'T11';

[1037] closest_2 is ['T12','T9']; closest_1 is ['T12'];

[1038] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9','T11'];

[1039] Loop 7:

[1040] list_B[0] is 'T4'; list_B[-1] is 'T11';

[1041] closest_A1 is 'T2'; closest_A2 is 'T12';

[1042] closest_obj is 'T12';

[1043] closest_2 is ['T11','T9']; closest_1 is ['T11'];

[1044] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9','T11','T12'];

[1045] Loop 8:

[1046] list_B[0] is 'T4'; list_B[-1] is 'T12';

[1047] closest_A1 is 'T2'; closest_A2 is 'T2';

[1048] closest_obj is 'T2';

[1049] closest_2 is ['T1','T4']; closest_1 is ['T1'];

[1050] Execute step ③; list_B is ['T2','T4','T5','T6','T7','T8','T9','T11','T12'];

[1051] Loop 9:

[1052] list_B[0] is 'T2'; list_B[-1] is 'T12';

[1053] closest_A1 is 'T1'; closest_A2 is 'T1';

[1054] closest_obj is 'T1';

[1055] closest_2 is ['T2','T4']; closest_1 is ['T2'];

[1056] Execute step ③; list_B is ['T1','T2','T4','T5','T6','T7','T8','T9','T11','T12'].

[1057] Step 512:

[1058] List B is ['T1','T2','T4','T5','T6','T7','T8','T9','T11','T12'].

[1059] The result of step 516 is shown in Fig.11 .

[1060] [Example 12]

[1061] (1) Program used in this exemplary embodiment:

[1062] Based on the tooth sorting method ( Figure 1 ) step 108 uses Figure 4 The sort loop body in ;

[1063] Based on the tooth batch naming method ( Figure 5 ) The judgment condition of step 512 is list_B.index(act_obj) <len(list_B) / 2。

[1064] (2) Program data input:

[1065] Tooth to be named ( Figure 5 , step 502): list_A = ['T7', 'T9', 'T2', 'T11', 'T4', 'T1', 'T8', 'T6', 'T12', 'T5'];

[1066] Sort starting teeth ( Figure 5 , step 504): list_B = ['T4'];

[1067] Preset Name ( Figure 5 , step 506): list_C = ['16','15','13','12','11','21','22','23','25','26'].

[1068] The schematic diagram of steps 502, 504 and 506 is shown in Fig.11 Optionally, the input method of step 502 is to automatically treat all teeth that are not hidden as teeth to be named. Optionally, the input method of step 504 is for the user to select the starting tooth for sorting by clicking. Optionally, the input method of step 506 is for the user to select a preset name through a multiple-selection box.

[1069] (3) Program data processing:

[1070] When the user clicks the Run button, the program will automatically perform the following steps.

[1071] Step 510:

[1072] (Note: ③ represents step 412; ④ represents step 414)

[1073] Loop 1:

[1074] list_B[0] is 'T4'; list_B[-1] is 'T4';

[1075] closest_A1 is 'T5'; closest_A2 is 'T5';

[1076] closest_obj is 'T5';

[1077] Execute step ④; list_B is ['T4', 'T5'];

[1078] Loop 2:

[1079] list_B[0] is 'T4'; list_B[-1] is 'T5';

[1080] closest_A1 is 'T6'; closest_A2 is 'T6';

[1081] closest_obj is 'T6';

[1082] Execute step ④; list_B is ['T4','T5','T6'];

[1083] Loop 3:

[1084] list_B[0] is 'T4'; list_B[-1] is 'T6';

[1085] closest_A1 is 'T2'; closest_A2 is 'T7';

[1086] closest_obj is 'T7';

[1087] Execute step ④; list_B is ['T4','T5','T6','T7'];

[1088] Loop 4:

[1089] list_B[0] is 'T4'; list_B[-1] is 'T7';

[1090] closest_A1 is 'T2'; closest_A2 is 'T8';

[1091] closest_obj is 'T8';

[1092] Execute step ④; list_B is ['T4','T5','T6','T7','T8'];

[1093] Loop 5:

[1094] list_B[0] is 'T4'; list_B[-1] is 'T8';

[1095] closest_A1 is 'T2'; closest_A2 is 'T9';

[1096] closest_obj is 'T9';

[1097] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9'];

[1098] Loop 6:

[1099] list_B[0] is 'T4'; list_B[-1] is 'T9';

[1100] closest_A1 is 'T2'; closest_A2 is 'T11';

[1101] closest_obj is 'T11';

[1102] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9','T11'];

[1103] Loop 7:

[1104] list_B[0] is 'T4'; list_B[-1] is 'T11';

[1105] closest_A1 is 'T2'; closest_A2 is 'T12';

[1106] closest_obj is 'T12';

[1107] Execute step ④; list_B is ['T4','T5','T6','T7','T8','T9','T11','T12'];

[1108] Loop 8:

[1109] list_B[0] is 'T4'; list_B[-1] is 'T12';

[1110] closest_A1 is 'T2'; closest_A2 is 'T2';

[1111] closest_obj is 'T2';

[1112] Execute step ③; list_B is ['T2','T4','T5','T6','T7','T8','T9','T11','T12'];

[1113] Loop 9:

[1114] list_B[0] is 'T2'; list_B[-1] is 'T12';

[1115] closest_A1 is 'T1'; closest_A2 is 'T1';

[1116] closest_obj is 'T1';

[1117] Execute step ③; list_B is ['T1','T2','T4','T5','T6','T7','T8','T9','T11','T12'].

[1118] Step 512:

[1119] List B is ['T1','T2','T4','T5','T6','T7','T8','T9','T11','T12'].

[1120] The result of step 516 is shown in Fig.11 .

[1121] [Extended Example]

[1122] The above exemplary embodiments 1-12 show a method for batch naming of teeth, in which a method for sorting teeth is called.

[1123] This extended embodiment includes the following two steps:

[1124] (1) Add the anatomical part name to the tooth landmark name ( Fig.12 , Fig.13 );

[1125] (2) Add the tooth preset name to the tooth marker name ( Fig.14 , Fig.15 ).

[1126] Fig.12 The present invention provides a flowchart of a method for adding an anatomical part name to a tooth landmark name, which can be performed by a device, wherein the device can be implemented by software and / or hardware, and can generally be integrated into an electronic device. Fig.12 As shown, the method includes:

[1127] Step 1202: Add the tooth marking points to the list list_D based on the order in which the user places the tooth marking points (see the schematic diagram for details). Fig.13 );

[1128] Step 1204, add the anatomical part name to the list list_E: list_E = ['M', 'D', 'O', 'G']; wherein 'M' represents mesial, 'D' represents distal, 'O' represents the occlusal end point of the clinical crown long axis, and 'G' represents the gingival end point of the clinical crown long axis;

[1129] Add the anatomical part name to the tooth marking point name through a for loop: Step 1206 initializes the loop variable, Step 1208 makes a loop judgment, and Steps 1210 and 1212 are the steps to implement "add the anatomical part name to the tooth marking point name" (for a schematic diagram of the result, please refer to Fig.13 ). Step 1214 increments the loop variable.

[1130] Among them, in Step 1208, i < len(list_D) means that the value of the loop variable i is less than the number of tooth marking points; in Step 1210, the function of j = i - len(list_E) * int(i / len(list_E)) is to convert the order i (the i value is 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,...) of the user placing the tooth marking points into the index j of the list list_E according to the length len(list_E) of the list list_E (that is, the number of anatomical part names) (if the length of the list list_E is 4, the converted j value is 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,...); in Step 1212, list_D[i].name = list_E[j] + '_' + list_D[i].name means that the name of the (i + 1)-th tooth marking point = the name of the (j + 1)-th anatomical part name + the separator '_' + the name of the (i + 1)-th tooth marking point. Among them, both i and j are natural numbers.

[1131] Fig.14 It is a schematic flowchart of a method for adding a preset tooth name to a tooth marking point name provided by an embodiment of the present disclosure. This method can be executed by a device, where the device can be implemented by software and / or hardware and is generally integrated in an electronic device. As Fig.14 shown, this method includes:

[1132] Step 1402, add the tooth to the list parent_objects (for a schematic diagram, please refer to Fig.15 ).

[1133] Step 1404, add the tooth marking point to the list list_F;

[1134] Step 1406, create an empty list list_G = [];

[1135] Add the preset tooth name to the tooth marking point name through a for loop: Step 1408 initializes the outer loop variable, Step 1410 makes an outer loop judgment, Steps 1412 and 1414 initialize the inner loop variable, Step 1416 makes an inner loop judgment, and Steps 1418 and 1420 are the steps to implement "add the preset tooth name to the tooth marking point name" (for a schematic diagram of the result, please refer to Fig.15 ) Step 1422 is to add tooth marking points whose names already have tooth preset names to the list list_G, step 1424 is to increment the inner loop variable, and step 1426 is to increment the outer loop variable.

[1136] Among them, step 1410 and i < len(parent_objects) mean that the value of the loop variable i is less than the number of teeth; step 1412 and child_objects = [obj for obj in list_F if obj not in list_G] mean that the remaining list of tooth marking points to be named (child_objects) includes teeth that are in the list of all tooth marking points to be named (list_F) but not in the list of named tooth marking points (list_G); step 1416 and j < len(child_objects) mean that the value of the loop variable j is less than the number of remaining tooth marking points to be named; step 1418 and child_objects[j] intersecting with parent_object[i] mean that the (j + 1)-th remaining tooth marking point to be named and the (i + 1)-th tooth have collisions in their three-dimensional meshes; step 1420 and child_object[j].name = parent_object[i].name + '_' + child_object[j].name.split('_')[0] mean that the name of the (j + 1)-th remaining tooth marking point to be named = the preset name of the (i + 1)-th tooth + separator '_' + the anatomical part name in the name of the (j + 1)-th remaining tooth marking point to be named. Among them, both i and j are natural numbers.

[1137] After completing the above steps (adding anatomical part names to tooth marking point names and adding tooth preset names to tooth marking point names), there are both tooth preset names and anatomical part names in the tooth marking point names. At this time, based on a method for calculating the change in tooth movement angle and visualizing the tooth position angle value (CN 115153909 B), the angle values of all tooth positions can be calculated in batches.

[1138] The above description is only a preferred embodiment of the present disclosure and an explanation of the applied technical principles. Those skilled in the art should understand that the scope of disclosure involved in the present disclosure is not limited to the technical solution formed by the specific combination of the above technical features, but also covers other technical solutions formed by any combination of the above technical features or their equivalent features without departing from the above disclosure concept. For example, the technical solutions formed by mutually replacing the above features with the (but not limited to) technical features with similar functions disclosed in the present disclosure.

[1139] In addition, although each operation is described in a specific order, this should not be understood as requiring these operations to be performed in the specific order shown or in a sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. In this regard, each box in a flow chart or block diagram may represent a module, a program segment, or a part of a code, and a part of this module, a program segment, or a code comprises one or more executable instructions for realizing the logical function of a provision. It should be noted that in some implementations as replacements, the functions marked in the box may also occur in a sequence different from that marked in the accompanying drawings. For example, two boxes represented in succession may actually be performed substantially in parallel, and they may sometimes be performed in reverse order, depending on the functions involved. Similarly, although several specific implementation details are included in the above discussion, these should not be interpreted as limiting the scope of the present disclosure. Certain features described in the context of a separate embodiment may also be implemented in a single embodiment in combination. On the contrary, the various features described in the context of a single embodiment may also be implemented in multiple embodiments individually or in any suitable sub-combination.

[1140] Although the subject matter has been described in language specific to structural features and / or methodological logical actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. On the contrary, the specific features and actions described above are merely example forms of implementing the claims.

Claims

1. A tooth sorting method, characterized in that: include: Obtain a list of all teeth to be sorted list_A and a list of sorted teeth list_B; the list of all teeth to be sorted list_A records all teeth to be sorted; the list of sorted teeth list_B records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted; Based on the configured sorting loop body, determine the target tooth object closest_obj, determine the sorting position of the target tooth object closest_obj in the sorted tooth list list_B, and record the target tooth object closest_obj into the sorted tooth list list_B based on the sorting position to form sorted teeth; The determining of the target tooth object closest_obj comprises: determining a remaining tooth list to be sorted, wherein the remaining tooth list to be sorted includes teeth in the list of all teeth to be sorted list_A but not in the sorted tooth list list_B; determining the head closest tooth closest_A1, the head distance min_distance_A1, the tail closest tooth closest_A2 and the tail distance min_distance_A2 according to the sorted tooth list list_B and the remaining tooth list to be sorted; and determining the target tooth object closest_obj from the head closest tooth closest_A1 and the tail closest tooth closest_A2 according to the head distance min_distance_A1 and the tail distance min_distance_A2; The method of determining the closest tooth to the head closest_A1, the head distance min_distance_A1, the closest tooth to the tail closest_A2 and the tail distance min_distance_A2 according to the sorted tooth list list_B and the remaining tooth list to be sorted includes: determining the first sorted tooth list_B[0] and the last sorted tooth list_B[-1] in the sorted tooth list_B; finding out the tooth closest to the first sorted tooth list_B[0] from the remaining tooth list to be sorted and recording it as the closest tooth to the head closest_A1, determining the distance between the closest tooth to the head closest_A1 and the first sorted tooth list_B[0] and recording it as the head distance min_distance_A1; finding out the tooth closest to the last sorted tooth list_B[-1] from the remaining tooth list to be sorted and recording it as the closest tooth to the tail closest_A2, determining the distance between the closest tooth to the tail closest_A2 and the last sorted tooth list_B[-1] and recording it as the tail distance min_distance_A2.

2. The tooth sorting method according to claim 1, characterized in that: The step of determining a target tooth object closest_obj from the tooth closest_A1 and the tooth closest_A2 according to the head distance min_distance_A1 and the tail distance min_distance_A2 comprises: Determine whether the head distance min_distance_A1 is smaller than the tail distance min_distance_A2; According to the result of the determination, the target tooth object closest_obj is determined.

3. The tooth sorting method according to claim 2, characterized in that: Determining the target tooth object closest_obj according to the result of the judgment includes: In response to the fact that the head distance min_distance_A1 is smaller than the tail distance min_distance_A2, the head closest tooth closest_A1 is determined as the target tooth object closest_obj; In response to the fact that the leading distance min_distance_A1 is not smaller than the trailing distance min_distance_A2, the trailing closest tooth closest_A2 is determined as the target tooth object closest_obj.

4. The tooth sorting method according to claim 1, characterized in that: The determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B comprises: According to the head distance min_distance_A1 and the tail distance min_distance_A2, determine the check tooth object check_obj from the first sorted tooth list_B[0] and the last sorted tooth list_B[-1]; Filter out the tooth and the two teeth closest to the target tooth object closest_obj from the list of all teeth to be sorted list_A, and add the one and two teeth closest to the first closest tooth list closest_1 and the second closest tooth list closest_2 respectively; The sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined according to the check tooth object check_obj, the first closest tooth list closest_1, the second closest tooth list closest_2, the sorted tooth list list_B, the head distance min_distance_A1 and the tail distance min_distance_A2.

5. The tooth sorting method according to claim 4, characterized in that: The step of determining a check tooth object check_obj from the first sorted tooth list_B[0] and the last sorted tooth list_B[-1] according to the head distance min_distance_A1 and the tail distance min_distance_A2 comprises: Determine whether the head distance min_distance_A1 is smaller than the tail distance min_distance_A2; According to the result of the determination, a check tooth object check_obj is determined.

6. The tooth sorting method according to claim 5, characterized in that: Determining the check tooth object check_obj according to the result of the judgment includes: In response to the fact that the head distance min_distance_A1 is less than the tail distance min_distance_A2, the first sorted tooth list_B[0] is determined as the check tooth object check_obj; In response to the fact that the leading distance min_distance_A1 is not less than the trailing distance min_distance_A2, the last sorted tooth list_B[-1] is determined as the check tooth object check_obj.

7. The tooth sorting method according to claim 4, characterized in that: The step of determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the check tooth object check_obj, the first closest tooth list closest_1, the second closest tooth list closest_2, the sorted tooth list list_B, the head distance min_distance_A1, and the tail distance min_distance_A2 comprises: Determine whether the sorted tooth list list_B includes the second closest tooth list closest_2, and whether the element in the first closest tooth list closest_1 is not the check tooth object check_obj; According to the result of the judgment, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined.

8. The tooth sorting method according to claim 7, characterized in that: The step of determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the result of the judgment comprises: In response to the sorted tooth list list_B including the second closest tooth list closest_2, and the element in the first closest tooth list closest_1 is not the check tooth object check_obj, it is determined whether the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B is less than the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B; In response to the sorted tooth list list_B including the second closest tooth list closest_2, and the element in the first closest tooth list closest_1 is not the check tooth object check_obj is not established, it is determined whether the head distance min_distance_A1 is less than the tail distance min_distance_A2; According to the result of the judgment, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined.

9. The tooth sorting method according to claim 8, characterized in that: The step of determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the result of the judgment comprises: In response to the fact that the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B is less than the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the position after the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B; In response to the fact that the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B is less than the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B is not established, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the position after the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B; In response to the fact that the head distance min_distance_A1 is smaller than the tail distance min_distance_A2, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the beginning of the sorted tooth list list_B; In response to the fact that the head distance min_distance_A1 is less than the tail distance min_distance_A2 is not true, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the end of the sorted tooth list list_B.

10. The tooth sorting method according to claim 1, characterized in that: The determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B comprises: Filter out the tooth and the two teeth closest to the target tooth object closest_obj from the list of all teeth to be sorted list_A, and add the one and two teeth closest to the first closest tooth list closest_1 and the second closest tooth list closest_2 respectively; The sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined according to the first closest tooth list closest_1, the second closest tooth list closest_2, the sorted tooth list list_B, the head distance min_distance_A1 and the tail distance min_distance_A2.

11. The tooth sorting method according to claim 10, characterized in that: The determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the first closest tooth list closest_1, the second closest tooth list closest_2, the sorted tooth list list_B, the head distance min_distance_A1 and the tail distance min_distance_A2 comprises: Determine whether the sorted tooth list list_B contains the second closest tooth list closest_2, and the element in the first closest tooth list closest_1 is not the first sorted tooth list_B[0], and the element in the first closest tooth list closest_1 is not the last sorted tooth list_B[-1]; According to the result of the judgment, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined.

12. The tooth sorting method according to claim 11, characterized in that: The step of determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the result of the judgment comprises: In response to the fact that the sorted tooth list list_B includes the second closest tooth list closest_2, and the element in the first closest tooth list closest_1 is not the first sorted tooth list_B[0], and the element in the first closest tooth list closest_1 is not the last sorted tooth list_B[-1], it is determined whether the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B is less than the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B; In response to the sorted tooth list list_B including the second closest tooth list closest_2, and the element in the first closest tooth list closest_1 is not the first sorted tooth list_B[0], and the element in the first closest tooth list closest_1 is not the last sorted tooth list_B[-1] is not true, then it is determined whether the head distance min_distance_A1 is less than the tail distance min_distance_A2; According to the result of the judgment, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined.

13. The tooth sorting method according to claim 12, characterized in that: The step of determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the result of the judgment comprises: In response to the fact that the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B is less than the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the position after the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B; In response to the fact that the index of the first element in the second closest tooth list closest_2 in the sorted tooth list list_B is less than the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B is not established, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the position after the index of the second element in the second closest tooth list closest_2 in the sorted tooth list list_B; In response to the fact that the head distance min_distance_A1 is smaller than the tail distance min_distance_A2, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the beginning of the sorted tooth list list_B; In response to the fact that the head distance min_distance_A1 is less than the tail distance min_distance_A2 is not true, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the end of the sorted tooth list list_B.

14. The tooth sorting method according to claim 1, characterized in that: The determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B comprises: According to the head distance min_distance_A1 and the tail distance min_distance_A2, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined.

15. The tooth sorting method according to claim 14, characterized in that: The determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the head distance min_distance_A1 and the tail distance min_distance_A2 includes: Determine whether the head distance min_distance_A1 is smaller than the tail distance min_distance_A2; According to the result of the judgment, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is determined.

16. The tooth sorting method according to claim 15, characterized in that: The step of determining the sorting position of the target tooth object closest_obj in the sorted tooth list list_B according to the result of the judgment comprises: In response to the fact that the head distance min_distance_A1 is smaller than the tail distance min_distance_A2, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the beginning of the sorted tooth list list_B; In response to the fact that the head distance min_distance_A1 is less than the tail distance min_distance_A2 is not true, the sorting position of the target tooth object closest_obj in the sorted tooth list list_B is the end of the sorted tooth list list_B.

17. A method for batch naming of teeth, characterized in that: include: Obtain a list of all teeth to be sorted list_A, a list of sorted teeth list_B, and a list of tooth names list_C; the list of all teeth to be sorted list_A records all teeth to be sorted, and the teeth to be sorted are also teeth to be named; the sorted teeth list_B records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted; The tooth name list list_C records the preset names of the teeth to be named, and the preset names recorded in the tooth name list list_C are arranged continuously, and the length of the tooth name list list_C is equal to the length of the list of all teeth to be sorted list_A; before executing the tooth sorting method described in claim 1, the sorted tooth list list_B has and only has one element, which is the sorting starting tooth act_obj, and the sorting starting tooth act_obj is any tooth among all the teeth to be sorted; Execute the tooth sorting method according to claim 1; Determine whether it is necessary to reverse the elements in the sorted tooth list_B according to the index of the sorting starting tooth act_obj in the sorted tooth list list_B and the length of the sorted tooth list list_B; According to the index order of the elements in the list, the preset names recorded in the tooth name list list_C are assigned to the teeth in the sorted tooth list list_B.

18. The method for batch naming of teeth according to claim 17, characterized in that: The determining whether it is necessary to reverse the elements in the sorted tooth list_B according to the index of the sorting starting tooth act_obj in the sorted tooth list list_B and the length of the sorted tooth list list_B comprises: Determine whether the index of the sorting starting tooth act_obj in the sorted tooth list list_B is less than half of the length of the sorted tooth list list_B; According to the result of the judgment, it is determined whether it is necessary to perform a reverse operation on the elements in the sorted teeth list list_B.

19. The method for batch naming of teeth according to claim 18, characterized in that: The step of determining whether it is necessary to reverse the elements in the sorted tooth list list_B according to the result of the judgment comprises: In response to the index of the sorting start tooth act_obj in the sorted tooth list list_B being less than half of the length of the sorted tooth list list_B, the elements in the sorted tooth list list_B are not reversed; In response to the fact that the index of the sorting start tooth act_obj in the sorted tooth list list_B is less than half of the length of the sorted tooth list list_B is not established, reversing the elements in the sorted tooth list list_B is performed.

20. The method for batch naming of teeth according to claim 17, characterized in that: The determining whether it is necessary to reverse the elements in the sorted tooth list_B according to the index of the sorting starting tooth act_obj in the sorted tooth list list_B and the length of the sorted tooth list list_B comprises: Determine whether the index of the sorting starting tooth act_obj in the sorted tooth list list_B is greater than or equal to half of the length of the sorted tooth list list_B; According to the result of the judgment, it is determined whether it is necessary to perform a reverse operation on the elements in the sorted teeth list list_B.

21. The method for batch naming of teeth according to claim 20, characterized in that: The step of determining whether it is necessary to reverse the elements in the sorted tooth list list_B according to the result of the judgment comprises: In response to the index of the sorting start tooth act_obj in the sorted tooth list list_B being greater than or equal to half of the length of the sorted tooth list list_B, the elements in the sorted tooth list list_B are not reversed; In response to the fact that the index of the sorting start tooth act_obj in the sorted tooth list list_B is not greater than or equal to half of the length of the sorted tooth list list_B, reversing the elements in the sorted tooth list list_B is performed.

22. A tooth sorting device, characterized in that: include: The first module is used to obtain a list of all teeth to be sorted list_A and a list of sorted teeth list_B; the list of all teeth to be sorted list_A records all teeth to be sorted; the sorted teeth list_B records sorted teeth, and the sorted teeth are a subset of all teeth to be sorted; The second module is used to determine the target tooth object closest_obj based on the configured sorting loop body, determine the sorting position of the target tooth object closest_obj in the sorted tooth list list_B, and record the target tooth object closest_obj into the sorted tooth list list_B based on the sorting position to form sorted teeth; The determining of the target tooth object closest_obj comprises: determining a remaining tooth list to be sorted, the remaining tooth list to be sorted includes teeth in the list of all teeth to be sorted list_A but not in the sorted tooth list list_B; determining the head nearest tooth closest_A1, the head distance min_distance_A1, the tail nearest tooth closest_A2 and the tail distance min_distance_A2 according to the sorted tooth list list_B and the remaining tooth list to be sorted; and determining the target tooth object closest_obj from the head nearest tooth closest_A1 and the tail nearest tooth closest_A2 according to the head distance min_distance_A1 and the tail distance min_distance_A2.

23. A device for batch naming of teeth, characterized in that: include: The third module is used to obtain the list of all teeth to be sorted list_A, the list of sorted teeth list_B and the list of tooth names list_C; The list of all teeth to be sorted list_A records all teeth to be sorted, and the teeth to be sorted are also teeth to be named; the sorted teeth list_B records sorted teeth, and the sorted teeth are a subset of the teeth to be sorted; The tooth name list list_C records the preset names of the teeth to be named, and the preset names recorded in the tooth name list list_C are arranged continuously, and the length of the tooth name list list_C is equal to the length of the list of all teeth to be sorted list_A; before calling the tooth sorting device described in claim 22, the sorted tooth list list_B has and only has one element, which is the sorting starting tooth act_obj, and the sorting starting tooth act_obj is any tooth among all the teeth to be sorted; A fourth module is used to call the tooth sorting device according to claim 22; The fifth module is used to determine whether it is necessary to execute the reverse operation of the elements in the sorted tooth list_B according to the index of the sorting starting tooth act_obj in the sorted tooth list list_B and the length of the sorted tooth list list_B; The sixth module is used to assign the preset names recorded in the tooth name list list_C to the teeth in the sorted tooth list list_B according to the index order of the elements in the list.

24. An electronic device, characterized in that: The electronic device comprises: processor; a memory for storing instructions executable by the processor; The processor is used to read the executable instructions from the memory and execute the executable instructions to implement any method described in claims 1-21.

25. A computer readable medium, characterized in that The computer-readable medium stores a computer program, and the computer program is used to execute the method according to any one of claims 1 to 21.

Images