Upload 4 files

mesh_service/part_level.csv

@@ -0,0 +1,301 @@
+part_id,num_fillet,num_hole,num_plane,smallest_fillet_r,smallest_hole_r,load_face,load_direction,load_scale,global_size_initial,global_size_final,converged,top2_features,local_refine_needed,local_size,,thickness,maxsize,load_id
+1,4,4,6,3.0226,2.4,bend_bottom,-1,low,3.775,2.4160000000000004,0,"FILLET,FACE",1,0.7644375000000001,,3.02,25.399999618530273,1
+1,4,4,6,3.0226,2.4,bend_bottom,-1,medium,3.775,2.4160000000000004,1,"FILLET,FACE",1,1.0192500000000002,,3.02,25.399999618530273,2
+1,4,4,6,3.0226,2.4,bend_bottom,-1,high,3.775,2.4160000000000004,1,"FILLET,FACE",1,1.0192500000000002,,3.02,25.399999618530273,3
+1,4,4,6,3.0226,2.4,tension,-1,low,3.775,2.4160000000000004,1,"CIRC_HOLE,FACE",1,0.7644375000000001,,3.02,25.399999618530273,4
+1,4,4,6,3.0226,2.4,tension,-1,medium,3.775,2.4160000000000004,1,"CIRC_HOLE,FACE",1,0.7644375000000001,,3.02,25.399999618530273,5
+1,4,4,6,3.0226,2.4,tension,-1,high,3.775,2.4160000000000004,1,"CIRC_HOLE,FACE",1,0.7644375000000001,,3.02,25.399999618530273,6
+1,4,4,6,3.0226,2.4,bend_bottom,1,low,3.775,2.4160000000000004,1,"FILLET,FACE",1,1.0192500000000002,,3.02,25.399999618530273,7
+1,4,4,6,3.0226,2.4,bend_bottom,1,medium,3.775,2.4160000000000004,1,"FILLET,FACE",1,1.0192500000000002,,3.02,25.399999618530273,8
+1,4,4,6,3.0226,2.4,bend_bottom,1,high,3.775,2.4160000000000004,1,"FILLET,FACE",1,1.0192500000000002,,3.02,25.399999618530273,9
+1,4,4,6,3.0226,2.4,tension,1,low,3.775,2.4160000000000004,1,"CIRC_HOLE,FACE",1,1.0192500000000002,,3.02,25.399999618530273,10
+1,4,4,6,3.0226,2.4,tension,1,medium,3.775,2.4160000000000004,1,"CIRC_HOLE,CIRC_HOLE",1,0.7644375000000001,,3.02,25.399999618530273,11
+1,4,4,6,3.0226,2.4,tension,1,high,3.775,2.4160000000000004,1,"CIRC_HOLE,CIRC_HOLE",1,1.0192500000000002,,3.02,25.399999618530273,12
+2,2,4,9,0.80264,2.4,bend_bottom,-1,low,2.5,1.6,1,"FILLET,FACE",1,0.675,,2,23.012399673461914,13
+2,2,4,9,0.80264,2.4,bend_bottom,-1,medium,2.5,1.6,1,"FILLET,FACE",1,0.675,,2,23.012399673461914,14
+2,2,4,9,0.80264,2.4,bend_bottom,-1,high,2.5,1.6,1,"FILLET,FACE",1,0.675,,2,23.012399673461914,15
+2,2,4,9,0.80264,2.4,tension,-1,low,2.5,1.6,1,"CIRC_HOLE,CIRC_HOLE",1,0.5062500000000001,,2,23.012399673461914,16
+2,2,4,9,0.80264,2.4,tension,-1,medium,2.5,1.6,1,"CIRC_HOLE,CIRC_HOLE",1,0.5062500000000001,,2,23.012399673461914,17
+2,2,4,9,0.80264,2.4,tension,-1,high,2.5,1.6,1,"CIRC_HOLE,CIRC_HOLE",1,0.5062500000000001,,2,23.012399673461914,18
+2,2,4,9,0.80264,2.4,bend_bottom,1,low,2.5,1.6,1,"FILLET,FACE",1,0.675,,2,23.012399673461914,19
+2,2,4,9,0.80264,2.4,bend_bottom,1,medium,2.5,1.6,1,"FILLET,FACE",1,0.675,,2,23.012399673461914,20
+2,2,4,9,0.80264,2.4,bend_bottom,1,high,2.5,1.6,1,"FILLET,FACE",1,0.675,,2,23.012399673461914,21
+2,2,4,9,0.80264,2.4,tension,1,low,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.675,,2,23.012399673461914,22
+2,2,4,9,0.80264,2.4,tension,1,medium,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.37968750000000007,,2,23.012399673461914,23
+2,2,4,9,0.80264,2.4,tension,1,high,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.675,,2,23.012399673461914,24
+8,3,8,17,0.66675,3.5433,bend_bottom,-1,low,3.3375,1.8773437499999999,1,"FACE,FACE",1,1.8773437499999999,,2.67,63.5,25
+8,3,8,17,0.66675,3.5433,bend_bottom,-1,medium,3.3375,1.8773437499999999,1,"FACE,FACE",1,1.8773437499999999,,2.67,63.5,26
+8,3,8,17,0.66675,3.5433,bend_bottom,-1,high,3.3375,1.8773437499999999,1,"FACE,FACE",1,1.8773437499999999,,2.67,63.5,27
+8,3,8,17,0.66675,3.5433,tension,-1,low,3.3375,2.136,1,"CIRC_HOLE,FACE",1,0.67584375,,2.67,63.5,28
+8,3,8,17,0.66675,3.5433,tension,-1,medium,3.3375,2.136,0,"CIRC_HOLE,FACE",1,0.67584375,,2.67,63.5,29
+8,3,8,17,0.66675,3.5433,tension,-1,high,3.3375,2.136,0,"CIRC_HOLE,FACE",1,0.67584375,,2.67,63.5,30
+8,3,8,17,0.66675,3.5433,bend_bottom,1,low,3.3375,2.136,1,"FACE,CIRC_HOLE",1,0.901125,,2.67,63.5,31
+8,3,8,17,0.66675,3.5433,bend_bottom,1,medium,3.3375,2.136,1,"FACE,CIRC_HOLE",1,0.901125,,2.67,63.5,32
+8,3,8,17,0.66675,3.5433,bend_bottom,1,high,3.3375,2.136,1,"FACE,CIRC_HOLE",1,0.901125,,2.67,63.5,33
+8,3,8,17,0.66675,3.5433,tension,1,low,3.3375,2.136,1,"CIRC_HOLE,FACE",1,0.901125,,2.67,63.5,34
+8,3,8,17,0.66675,3.5433,tension,1,medium,3.3375,2.136,1,"CIRC_HOLE,FACE",1,0.901125,,2.67,63.5,35
+8,3,8,17,0.66675,3.5433,tension,1,high,3.3375,2.136,1,"CIRC_HOLE,FACE",1,0.901125,,2.67,63.5,36
+12,1,12,21,2.032,2.7432,bend_bottom,-1,low,6.35,2.143125,0,"FACE,FACE",1,1.60734375,,4,127,37
+12,1,12,21,2.032,2.7432,bend_bottom,-1,medium,6.35,2.143125,0,"FACE,FACE",1,1.60734375,,4,127,38
+12,1,12,21,2.032,2.7432,bend_bottom,-1,high,6.35,2.143125,0,"FACE,FACE",1,1.60734375,,4,127,39
+12,1,12,21,2.032,2.7432,tension,-1,low,6.35,4.064,1,"CIRC_HOLE,FACE",1,2.286,,4,127,40
+12,1,12,21,2.032,2.7432,tension,-1,medium,6.35,4.064,1,"CIRC_HOLE,FACE",1,2.286,,4,127,41
+12,1,12,21,2.032,2.7432,tension,-1,high,6.35,4.064,1,"CIRC_HOLE,FACE",1,2.286,,4,127,42
+12,1,12,21,2.032,2.7432,bend_bottom,1,low,6.35,3.2512000000000003,1,"CIRC_HOLE,FACE",1,0.7715250000000001,,4,127,43
+12,1,12,21,2.032,2.7432,bend_bottom,1,medium,6.35,3.2512000000000003,1,"CIRC_HOLE,FACE",1,0.7715250000000001,,4,127,44
+12,1,12,21,2.032,2.7432,bend_bottom,1,high,6.35,3.2512000000000003,0,"FACE,CIRC_HOLE",1,1.0287000000000002,,4,127,45
+12,1,12,21,2.032,2.7432,tension,1,low,6.35,4.064,1,"CIRC_HOLE,FACE",1,2.286,,4,127,46
+12,1,12,21,2.032,2.7432,tension,1,medium,6.35,4.064,1,"CIRC_HOLE,FACE",1,2.286,,4,127,47
+12,1,12,21,2.032,2.7432,tension,1,high,6.35,4.064,1,"CIRC_HOLE,FACE",1,2.286,,4,127,48
+13,1,12,21,2.413,2.8956,bend_bottom,-1,low,7.619999694824244,4.286249828338637,1,"FILLET,FACE",1,2.4110155284404837,,4.83,152.3999938964849,49
+13,1,12,21,2.413,2.8956,bend_bottom,-1,medium,7.619999694824244,4.286249828338637,1,"FILLET,FACE",1,2.4110155284404837,,4.83,152.3999938964849,50
+13,1,12,21,2.413,2.8956,bend_bottom,-1,high,7.619999694824244,4.286249828338637,1,"FILLET,FACE",1,2.4110155284404837,,4.83,152.3999938964849,51
+13,1,12,21,2.413,2.8956,tension,-1,low,7.619999694824244,3.9014398437500137,1,"FACE,CIRC_HOLE",1,1.2344399505615278,,4.83,152.3999938964849,52
+13,1,12,21,2.413,2.8956,tension,-1,medium,7.619999694824244,3.9014398437500137,1,"FACE,CIRC_HOLE",1,1.2344399505615278,,4.83,152.3999938964849,53
+13,1,12,21,2.413,2.8956,tension,-1,high,7.619999694824244,3.9014398437500137,1,"FACE,CIRC_HOLE",1,1.2344399505615278,,4.83,152.3999938964849,54
+13,1,12,21,2.413,2.8956,bend_bottom,1,low,7.619999694824244,3.9014398437500137,0,"CIRC_HOLE,FACE",1,1.2344399505615278,,4.83,152.3999938964849,55
+13,1,12,21,2.413,2.8956,bend_bottom,1,medium,7.619999694824244,3.9014398437500137,0,"CIRC_HOLE,FACE",1,1.2344399505615278,,4.83,152.3999938964849,56
+13,1,12,21,2.413,2.8956,bend_bottom,1,high,7.619999694824244,4.286249828338637,1,"FACE,CIRC_HOLE",1,3.2146873712539783,,4.83,152.3999938964849,57
+13,1,12,21,2.413,2.8956,tension,1,low,7.619999694824244,3.9014398437500137,0,"FACE,CIRC_HOLE",1,1.2344399505615278,,4.83,152.3999938964849,58
+13,1,12,21,2.413,2.8956,tension,1,medium,7.619999694824244,3.9014398437500137,0,"FACE,CIRC_HOLE",1,1.2344399505615278,,4.83,152.3999938964849,59
+13,1,12,21,2.413,2.8956,tension,1,high,7.619999694824244,3.9014398437500137,0,"FACE,CIRC_HOLE",1,1.2344399505615278,,4.83,152.3999938964849,60
+14,0,12,22,4.191,2.921,bend_bottom,-1,low,10.159999525547027,4.286249799840152,1,"FACE,FACE",1,4.286249799840152,,5.6,203.19999051094055,61
+14,0,12,22,4.191,2.921,bend_bottom,-1,medium,10.159999525547027,4.286249799840152,1,"FACE,FACE",1,4.286249799840152,,5.6,203.19999051094055,62
+14,0,12,22,4.191,2.921,bend_bottom,-1,high,10.159999525547027,6.095999715328216,1,"FACE,FACE",1,4.571999786496162,,5.6,203.19999051094055,63
+14,0,12,22,4.191,2.921,tension,-1,low,10.159999525547027,6.502399696350098,1,"CIRC_HOLE,FACE",1,3.6575998291969305,,5.6,203.19999051094055,64
+14,0,12,22,4.191,2.921,tension,-1,medium,10.159999525547027,6.502399696350098,1,"CIRC_HOLE,FACE",1,3.6575998291969305,,5.6,203.19999051094055,65
+14,0,12,22,4.191,2.921,tension,-1,high,10.159999525547027,6.502399696350098,1,"CIRC_HOLE,FACE",1,3.6575998291969305,,5.6,203.19999051094055,66
+14,0,12,22,4.191,2.921,bend_bottom,1,low,10.159999525547027,5.201919757080079,1,"CIRC_HOLE,FACE",1,1.6459199231386188,,5.6,203.19999051094055,67
+14,0,12,22,4.191,2.921,bend_bottom,1,medium,10.159999525547027,5.201919757080079,1,"CIRC_HOLE,FACE",1,1.6459199231386188,,5.6,203.19999051094055,68
+14,0,12,22,4.191,2.921,bend_bottom,1,high,10.159999525547027,5.201919757080079,1,"CIRC_HOLE,FACE",1,1.6459199231386188,,5.6,203.19999051094055,69
+14,0,12,22,4.191,2.921,tension,1,low,10.159999525547027,6.502399696350098,1,"CIRC_HOLE,FACE",1,3.6575998291969305,,5.6,203.19999051094055,70
+14,0,12,22,4.191,2.921,tension,1,medium,10.159999525547027,6.502399696350098,1,"CIRC_HOLE,FACE",1,3.6575998291969305,,5.6,203.19999051094055,71
+14,0,12,22,4.191,2.921,tension,1,high,10.159999525547027,6.502399696350098,1,"CIRC_HOLE,FACE",1,3.6575998291969305,,5.6,203.19999051094055,72
+15,1,16,25,3.175,2.7432,bend_bottom,-1,low,12.7,6.096,0,"FILLET,FACE",1,2.57175,,6.35,254,73
+15,1,16,25,3.175,2.7432,bend_bottom,-1,medium,12.7,6.096,0,"FILLET,FACE",1,2.57175,,6.35,254,74
+15,1,16,25,3.175,2.7432,bend_bottom,-1,high,12.7,6.096,0,"FILLET,CIRC_HOLE",1,1.9288125000000003,,6.35,254,75
+15,1,16,25,3.175,2.7432,tension,-1,low,12.7,6.502400000000001,1,"CIRC_HOLE,FACE",1,2.7432000000000003,,6.35,254,76
+15,1,16,25,3.175,2.7432,tension,-1,medium,12.7,6.502400000000001,1,"CIRC_HOLE,FACE",1,2.7432000000000003,,6.35,254,77
+15,1,16,25,3.175,2.7432,tension,-1,high,12.7,6.502400000000001,1,"CIRC_HOLE,FACE",1,2.7432000000000003,,6.35,254,78
+15,1,16,25,3.175,2.7432,bend_bottom,1,low,12.7,5.201920000000001,1,"CIRC_HOLE,FACE",1,1.6459200000000003,,6.35,254,79
+15,1,16,25,3.175,2.7432,bend_bottom,1,medium,12.7,5.201920000000001,1,"CIRC_HOLE,FACE",1,1.6459200000000003,,6.35,254,80
+15,1,16,25,3.175,2.7432,bend_bottom,1,high,12.7,5.201920000000001,1,"CIRC_HOLE,FACE",1,1.6459200000000003,,6.35,254,81
+15,1,16,25,3.175,2.7432,tension,1,low,12.7,6.502400000000001,1,"CIRC_HOLE,FACE",1,2.7432000000000003,,6.35,254,82
+15,1,16,25,3.175,2.7432,tension,1,medium,12.7,6.502400000000001,1,"CIRC_HOLE,FACE",1,2.7432000000000003,,6.35,254,83
+15,1,16,25,3.175,2.7432,tension,1,high,12.7,6.502400000000001,1,"CIRC_HOLE,FACE",1,2.7432000000000003,,6.35,254,84
+16,2,4,40,1.524,2.3495,bend_bottom,-1,low,2.5,1.6,0,"FACE,FILLET",1,0.5062500000000001,,2,25.399999499320984,85
+16,2,4,40,1.524,2.3495,bend_bottom,-1,medium,2.5,1.6,0,"FACE,FILLET",1,0.5062500000000001,,2,25.399999499320984,86
+16,2,4,40,1.524,2.3495,bend_bottom,-1,high,2.5,1.6,0,"FACE,FILLET",1,0.5062500000000001,,2,25.399999499320984,87
+16,2,4,40,1.524,2.3495,tension,-1,low,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.5062500000000001,,2,25.399999499320984,88
+16,2,4,40,1.524,2.3495,tension,-1,medium,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.675,,2,25.399999499320984,89
+16,2,4,40,1.524,2.3495,tension,-1,high,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.5062500000000001,,2,25.399999499320984,90
+16,2,4,40,1.524,2.3495,bend_bottom,1,low,2.5,1.6,0,"FACE,FILLET",1,0.5062500000000001,,2,25.399999499320984,91
+16,2,4,40,1.524,2.3495,bend_bottom,1,medium,2.5,1.6,0,"FACE,FILLET",1,0.5062500000000001,,2,25.399999499320984,92
+16,2,4,40,1.524,2.3495,bend_bottom,1,high,2.5,1.6,0,"FACE,FILLET",1,0.5062500000000001,,2,25.399999499320984,93
+16,2,4,40,1.524,2.3495,tension,1,low,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.675,,2,25.399999499320984,94
+16,2,4,40,1.524,2.3495,tension,1,medium,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.675,,2,25.399999499320984,95
+16,2,4,40,1.524,2.3495,tension,1,high,2.5,1.6,1,"CIRC_HOLE,FACE",1,0.675,,2,25.399999499320984,96
+17,2,8,16,0.889,2.3495,bend_bottom,-1,low,2.225,1.4240000000000004,0,"FILLET,FACE",1,0.4505625000000001,,1.78,38.099998474121094,97
+17,2,8,16,0.889,2.3495,bend_bottom,-1,medium,2.225,1.4240000000000004,0,"FILLET,FACE",1,0.4505625000000001,,1.78,38.099998474121094,98
+17,2,8,16,0.889,2.3495,bend_bottom,-1,high,2.225,1.4240000000000004,0,"FILLET,FACE",1,0.4505625000000001,,1.78,38.099998474121094,99
+17,2,8,16,0.889,2.3495,tension,-1,low,2.225,1.4240000000000004,1,"FACE,CIRC_HOLE",1,0.6007500000000001,,1.78,38.099998474121094,100
+17,2,8,16,0.889,2.3495,tension,-1,medium,2.225,1.4240000000000004,1,"CIRC_HOLE,FACE",1,0.6007500000000001,,1.78,38.099998474121094,101
+17,2,8,16,0.889,2.3495,tension,-1,high,2.225,1.4240000000000004,1,"CIRC_HOLE,FACE",1,0.6007500000000001,,1.78,38.099998474121094,102
+17,2,8,16,0.889,2.3495,bend_bottom,1,low,2.225,1.4240000000000004,1,"FILLET,CIRC_HOLE",1,0.1900810546875,,1.78,38.099998474121094,103
+17,2,8,16,0.889,2.3495,bend_bottom,1,medium,2.225,1.4240000000000004,1,"FILLET,CIRC_HOLE",1,0.1900810546875,,1.78,38.099998474121094,104
+17,2,8,16,0.889,2.3495,bend_bottom,1,high,2.225,1.4240000000000004,1,"FILLET,FACE",1,0.4505625000000001,,1.78,38.099998474121094,105
+17,2,8,16,0.889,2.3495,tension,1,low,2.225,1.4240000000000004,1,"FACE,CIRC_HOLE",1,0.6007500000000001,,1.78,38.099998474121094,106
+17,2,8,16,0.889,2.3495,tension,1,medium,2.225,1.4240000000000004,1,"FACE,CIRC_HOLE",1,0.6007500000000001,,1.78,38.099998474121094,107
+17,2,8,16,0.889,2.3495,tension,1,high,2.225,1.4240000000000004,1,"CIRC_HOLE,FACE",1,0.6007500000000001,,1.78,38.099998474121094,108
+18,2,8,16,1.3335,2.159,bend_bottom,-1,low,2.5399999648332594,1.4287499802187085,1,"FILLET,FACE",1,0.8036718638730235,,1.78,50.79999929666519,109
+18,2,8,16,1.3335,2.159,bend_bottom,-1,medium,2.5399999648332594,1.4287499802187085,1,"FILLET,FACE",1,0.8036718638730235,,1.78,50.79999929666519,110
+18,2,8,16,1.3335,2.159,bend_bottom,-1,high,2.5399999648332594,1.4287499802187085,1,"FILLET,FACE",1,0.8036718638730235,,1.78,50.79999929666519,111
+18,2,8,16,1.3335,2.159,tension,-1,low,2.5399999648332594,1.625599977493286,1,"FACE,CIRC_HOLE",1,0.6857999905049801,,1.78,50.79999929666519,112
+18,2,8,16,1.3335,2.159,tension,-1,medium,2.5399999648332594,1.625599977493286,1,"FACE,CIRC_HOLE",1,0.6857999905049801,,1.78,50.79999929666519,113
+18,2,8,16,1.3335,2.159,tension,-1,high,2.5399999648332594,1.625599977493286,1,"CIRC_HOLE,FACE",1,0.6857999905049801,,1.78,50.79999929666519,114
+18,2,8,16,1.3335,2.159,bend_bottom,1,low,2.5399999648332594,1.5239999788999556,0,"FACE,CIRC_HOLE",1,0.6429374910984187,,1.78,50.79999929666519,115
+18,2,8,16,1.3335,2.159,bend_bottom,1,medium,2.5399999648332594,1.5239999788999556,0,"FACE,CIRC_HOLE",1,0.6429374910984187,,1.78,50.79999929666519,116
+18,2,8,16,1.3335,2.159,bend_bottom,1,high,2.5399999648332594,1.5239999788999556,0,"FACE,CIRC_HOLE",1,0.6429374910984187,,1.78,50.79999929666519,117
+18,2,8,16,1.3335,2.159,tension,1,low,2.5399999648332594,1.625599977493286,1,"FACE,CIRC_HOLE",1,0.6857999905049801,,1.78,50.79999929666519,118
+18,2,8,16,1.3335,2.159,tension,1,medium,2.5399999648332594,1.625599977493286,1,"FACE,CIRC_HOLE",1,0.6857999905049801,,1.78,50.79999929666519,119
+18,2,8,16,1.3335,2.159,tension,1,high,2.5399999648332594,1.625599977493286,1,"FACE,CIRC_HOLE",1,0.6857999905049801,,1.78,50.79999929666519,120
+19,2,8,16,1.3335,2.159,bend_bottom,-1,low,3.174999812245369,1.1429999324083329,0,"FACE,FILLET",1,0.6429374619796873,,1.78,63.49999624490738,121
+19,2,8,16,1.3335,2.159,bend_bottom,-1,medium,3.174999812245369,1.1429999324083329,0,"FACE,FILLET",1,0.6429374619796873,,1.78,63.49999624490738,122
+19,2,8,16,1.3335,2.159,bend_bottom,-1,high,3.174999812245369,1.1429999324083329,0,"FACE,FILLET",1,0.6429374619796873,,1.78,63.49999624490738,123
+19,2,8,16,1.3335,2.159,tension,-1,low,3.174999812245369,1.6255999038696292,1,"CIRC_HOLE,FACE",1,0.6857999594449999,,1.78,63.49999624490738,124
+19,2,8,16,1.3335,2.159,tension,-1,medium,3.174999812245369,1.6255999038696292,1,"CIRC_HOLE,FACE",1,0.6857999594449999,,1.78,63.49999624490738,125
+19,2,8,16,1.3335,2.159,tension,-1,high,3.174999812245369,1.6255999038696292,1,"CIRC_HOLE,FACE",1,0.6857999594449999,,1.78,63.49999624490738,126
+19,2,8,16,1.3335,2.159,bend_bottom,1,low,3.174999812245369,1.5239999098777774,0,"FACE,CIRC_HOLE",1,0.6429374619796873,,1.78,63.49999624490738,127
+19,2,8,16,1.3335,2.159,bend_bottom,1,medium,3.174999812245369,1.1429999324083329,0,"FACE,FILLET",1,0.6429374619796873,,1.78,63.49999624490738,128
+19,2,8,16,1.3335,2.159,bend_bottom,1,high,3.174999812245369,1.1429999324083329,0,"FACE,FILLET",1,0.6429374619796873,,1.78,63.49999624490738,129
+19,2,8,16,1.3335,2.159,tension,1,low,3.174999812245369,1.6255999038696292,1,"CIRC_HOLE,FACE",1,0.6857999594449999,,1.78,63.49999624490738,130
+19,2,8,16,1.3335,2.159,tension,1,medium,3.174999812245369,1.6255999038696292,1,"CIRC_HOLE,FACE",1,0.6857999594449999,,1.78,63.49999624490738,131
+19,2,8,16,1.3335,2.159,tension,1,high,3.174999812245369,1.6255999038696292,1,"FACE,CIRC_HOLE",1,0.5143499695837499,,1.78,63.49999624490738,132
+20,1,8,17,1.905,2.2479,bend_bottom,-1,low,3.810000014305115,2.4384000091552736,1,"FILLET,FACE",1,0.7715250028967857,,2.54,76.2000002861023,133
+20,1,8,17,1.905,2.2479,bend_bottom,-1,medium,3.810000014305115,2.4384000091552736,1,"FILLET,FACE",1,0.7715250028967857,,2.54,76.2000002861023,134
+20,1,8,17,1.905,2.2479,bend_bottom,-1,high,3.810000014305115,2.4384000091552736,1,"FILLET,FACE",1,0.7715250028967857,,2.54,76.2000002861023,135
+20,1,8,17,1.905,2.2479,tension,-1,low,3.810000014305115,2.4384000091552736,1,"CIRC_HOLE,FACE",1,0.7715250028967857,,2.54,76.2000002861023,136
+20,1,8,17,1.905,2.2479,tension,-1,medium,3.810000014305115,2.4384000091552736,1,"CIRC_HOLE,FACE",1,0.7715250028967857,,2.54,76.2000002861023,137
+20,1,8,17,1.905,2.2479,tension,-1,high,3.810000014305115,2.4384000091552736,1,"CIRC_HOLE,FACE",1,0.7715250028967857,,2.54,76.2000002861023,138
+20,1,8,17,1.905,2.2479,bend_bottom,1,low,3.810000014305115,2.4384000091552736,1,"FACE,CIRC_HOLE",1,1.028700003862381,,2.54,76.2000002861023,139
+20,1,8,17,1.905,2.2479,bend_bottom,1,medium,3.810000014305115,2.4384000091552736,1,"FACE,CIRC_HOLE",1,1.3716000051498414,,2.54,76.2000002861023,140
+20,1,8,17,1.905,2.2479,bend_bottom,1,high,3.810000014305115,2.4384000091552736,1,"FILLET,FACE",1,0.7715250028967857,,2.54,76.2000002861023,141
+20,1,8,17,1.905,2.2479,tension,1,low,3.810000014305115,2.4384000091552736,1,"CIRC_HOLE,FACE",1,0.7715250028967857,,2.54,76.2000002861023,142
+20,1,8,17,1.905,2.2479,tension,1,medium,3.810000014305115,2.4384000091552736,1,"CIRC_HOLE,FACE",1,0.7715250028967857,,2.54,76.2000002861023,143
+20,1,8,17,1.905,2.2479,tension,1,high,3.810000014305115,2.4384000091552736,1,"FACE,CIRC_HOLE",1,0.7715250028967857,,2.54,76.2000002861023,144
+21,1,8,17,2.4765,2.8067,bend_bottom,-1,low,5.079999870061874,1.6073437088867648,1,"FACE,FACE",1,1.6073437088867648,,3.3,101.59999740123749,145
+21,1,8,17,2.4765,2.8067,bend_bottom,-1,medium,5.079999870061874,1.6073437088867648,0,"FACE,FACE",1,1.6073437088867648,,3.3,101.59999740123749,146
+21,1,8,17,2.4765,2.8067,bend_bottom,-1,high,5.079999870061874,2.8574999269098043,1,"FACE,CIRC_HOLE",1,2.8574999269098043,,3.3,101.59999740123749,147
+21,1,8,17,2.4765,2.8067,tension,-1,low,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,148
+21,1,8,17,2.4765,2.8067,tension,-1,medium,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,149
+21,1,8,17,2.4765,2.8067,tension,-1,high,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,150
+21,1,8,17,2.4765,2.8067,bend_bottom,1,low,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,151
+21,1,8,17,2.4765,2.8067,bend_bottom,1,medium,5.079999870061874,3.0479999220371248,1,"CIRC_HOLE,FACE",1,1.7144999561458827,,3.3,101.59999740123749,152
+21,1,8,17,2.4765,2.8067,bend_bottom,1,high,5.079999870061874,3.0479999220371248,1,"CIRC_HOLE,FACE",1,1.7144999561458827,,3.3,101.59999740123749,153
+21,1,8,17,2.4765,2.8067,tension,1,low,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,154
+21,1,8,17,2.4765,2.8067,tension,1,medium,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,155
+21,1,8,17,2.4765,2.8067,tension,1,high,5.079999870061874,3.2511999168395995,0,"CIRC_HOLE,FACE",1,1.0286999736875297,,3.3,101.59999740123749,156
+22,1,12,21,2.286,3.1242,bend_bottom,-1,low,7.619999694824219,3.2146873712539668,1,"FACE,FACE",1,3.2146873712539668,,4.57,152.39999389648438,157
+22,1,12,21,2.286,3.1242,bend_bottom,-1,medium,7.619999694824219,3.2146873712539668,1,"FACE,FACE",1,3.2146873712539668,,4.57,152.39999389648438,158
+22,1,12,21,2.286,3.1242,bend_bottom,-1,high,7.619999694824219,3.2146873712539668,1,"FACE,CIRC_HOLE",1,3.2146873712539668,,4.57,152.39999389648438,159
+22,1,12,21,2.286,3.1242,tension,-1,low,7.619999694824219,3.901439843750001,1,"CIRC_HOLE,FACE",1,1.6459199340820316,,4.57,152.39999389648438,160
+22,1,12,21,2.286,3.1242,tension,-1,medium,7.619999694824219,3.901439843750001,1,"CIRC_HOLE,FACE",1,1.6459199340820316,,4.57,152.39999389648438,161
+22,1,12,21,2.286,3.1242,tension,-1,high,7.619999694824219,3.901439843750001,1,"CIRC_HOLE,FACE",1,1.6459199340820316,,4.57,152.39999389648438,162
+22,1,12,21,2.286,3.1242,bend_bottom,1,low,7.619999694824219,3.901439843750001,0,"FACE,CIRC_HOLE",1,1.2344399505615238,,4.57,152.39999389648438,163
+22,1,12,21,2.286,3.1242,bend_bottom,1,medium,7.619999694824219,3.901439843750001,0,"FACE,CIRC_HOLE",1,1.2344399505615238,,4.57,152.39999389648438,164
+22,1,12,21,2.286,3.1242,bend_bottom,1,high,7.619999694824219,3.901439843750001,0,"FACE,CIRC_HOLE",1,1.2344399505615238,,4.57,152.39999389648438,165
+22,1,12,21,2.286,3.1242,tension,1,low,7.619999694824219,3.901439843750001,1,"CIRC_HOLE,FACE",1,1.6459199340820316,,4.57,152.39999389648438,166
+22,1,12,21,2.286,3.1242,tension,1,medium,7.619999694824219,3.901439843750001,1,"CIRC_HOLE,FACE",1,1.6459199340820316,,4.57,152.39999389648438,167
+22,1,12,21,2.286,3.1242,tension,1,high,7.619999694824219,3.901439843750001,1,"CIRC_HOLE,FACE",1,1.6459199340820316,,4.57,152.39999389648438,168
+25,5,8,17,1.27,1.55,bend_bottom,-1,low,3.125,2.34375,0,"FILLET,FACE",1,0.988769531,,2.5,30.162500381469727,169
+25,5,8,17,1.27,1.55,bend_bottom,-1,medium,3.125,2.34375,0,"FILLET,FACE",1,0.988769531,,2.5,30.162500381469727,170
+25,5,8,17,1.27,1.55,bend_bottom,-1,high,3.125,2.34375,0,"FILLET,FACE",1,0.988769531,,2.5,30.162500381469727,171
+25,5,8,17,1.27,1.55,tension,-1,low,3.125,2,0,"CIRC_HOLE,FACE",1,0.6328125,,2.5,30.162500381469727,172
+25,5,8,17,1.27,1.55,tension,-1,medium,3.125,2,0,"CIRC_HOLE,FACE",1,0.6328125,,2.5,30.162500381469727,173
+25,5,8,17,1.27,1.55,tension,-1,high,3.125,2,1,"CIRC_HOLE,FACE",1,0.6328125,,2.5,30.162500381469727,174
+25,5,8,17,1.27,1.55,bend_bottom,1,low,3.125,2.34375,0,"FILLET,FACE",1,0.988769531,,2.5,30.162500381469727,175
+25,5,8,17,1.27,1.55,bend_bottom,1,medium,3.125,2.34375,0,"FILLET,FACE",1,0.988769531,,2.5,30.162500381469727,176
+25,5,8,17,1.27,1.55,bend_bottom,1,high,3.125,2.34375,0,"FILLET,FACE",1,0.988769531,,2.5,30.162500381469727,177
+25,5,8,17,1.27,1.55,tension,1,low,3.125,2,0,"CIRC_HOLE,FACE",1,0.6328125,,2.5,30.162500381469727,178
+25,5,8,17,1.27,1.55,tension,1,medium,3.125,2,0,"CIRC_HOLE,FACE",1,0.6328125,,2.5,30.162500381469727,179
+25,5,8,17,1.27,1.55,tension,1,high,3.125,2,0,"FACE,CIRC_HOLE",1,0.6328125,,2.5,30.162500381469727,180
+26,5,8,17,0.81,1.55,bend_bottom,-1,low,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,44.84687423706055,181
+26,5,8,17,0.81,1.55,bend_bottom,-1,medium,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,44.84687423706055,182
+26,5,8,17,0.81,1.55,bend_bottom,-1,high,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,44.84687423706055,183
+26,5,8,17,0.81,1.55,tension,-1,low,3.75,2.4000000000000004,1,"CIRC_HOLE,FACE",1,1.0125000000000002,,3,44.84687423706055,184
+26,5,8,17,0.81,1.55,tension,-1,medium,3.75,2.4000000000000004,1,"CIRC_HOLE,FACE",1,1.0125000000000002,,3,44.84687423706055,185
+26,5,8,17,0.81,1.55,tension,-1,high,3.75,2.4000000000000004,0,"CIRC_HOLE,FACE",1,0.7593750000000001,,3,44.84687423706055,186
+26,5,8,17,0.81,1.55,bend_bottom,1,low,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,44.84687423706055,187
+26,5,8,17,0.81,1.55,bend_bottom,1,medium,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,44.84687423706055,188
+26,5,8,17,0.81,1.55,bend_bottom,1,high,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,44.84687423706055,189
+26,5,8,17,0.81,1.55,tension,1,low,3.75,2.4000000000000004,1,"CIRC_HOLE,FACE",1,1.35,,3,44.84687423706055,190
+26,5,8,17,0.81,1.55,tension,1,medium,3.75,2.4000000000000004,1,"FACE,CIRC_HOLE",1,1.35,,3,44.84687423706055,191
+26,5,8,17,0.81,1.55,tension,1,high,3.75,2.4000000000000004,1,"FACE,CIRC_HOLE",1,1.35,,3,44.84687423706055,192
+27,5,8,17,0.81,1.75,bend_bottom,-1,low,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,59.928123474121094,193
+27,5,8,17,0.81,1.75,bend_bottom,-1,medium,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,59.928123474121094,194
+27,5,8,17,0.81,1.75,bend_bottom,-1,high,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,59.928123474121094,195
+27,5,8,17,0.81,1.75,tension,-1,low,3.75,2.4000000000000004,1,"CIRC_HOLE,FACE",1,1.35,,3,59.928123474121094,196
+27,5,8,17,0.81,1.75,tension,-1,medium,3.75,2.4000000000000004,1,"CIRC_HOLE,FACE",1,1.35,,3,59.928123474121094,197
+27,5,8,17,0.81,1.75,tension,-1,high,3.75,2.4000000000000004,1,"CIRC_HOLE,FACE",1,1.35,,3,59.928123474121094,198
+27,5,8,17,0.81,1.75,bend_bottom,1,low,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,59.928123474121094,199
+27,5,8,17,0.81,1.75,bend_bottom,1,medium,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,59.928123474121094,200
+27,5,8,17,0.81,1.75,bend_bottom,1,high,3.75,2.4000000000000004,0,"FILLET,FACE",1,0.7593750000000001,,3,59.928123474121094,201
+27,5,8,17,0.81,1.75,tension,1,low,3.75,2.4000000000000004,0,"CIRC_HOLE,FACE",1,0.7593750000000001,,3,59.928123474121094,202
+27,5,8,17,0.81,1.75,tension,1,medium,3.75,2.4000000000000004,0,"CIRC_HOLE,FACE",1,0.7593750000000001,,3,59.928123474121094,203
+27,5,8,17,0.81,1.75,tension,1,high,3.75,2.4000000000000004,0,"CIRC_HOLE,FACE",1,0.7593750000000001,,3,59.928123474121094,204
+29,0,4,17,16,2.1,bend_bottom,-1,low,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,205
+29,0,4,17,16,2.1,bend_bottom,-1,medium,4.375,2.8000000000000003,0,"CIRC_HOLE,FACE",1,0.6644531250000001,,3.5,23,206
+29,0,4,17,16,2.1,bend_bottom,-1,high,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,0.49833984375000007,,3.5,23,207
+29,0,4,17,16,2.1,tension,-1,low,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,208
+29,0,4,17,16,2.1,tension,-1,medium,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,209
+29,0,4,17,16,2.1,tension,-1,high,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,210
+29,0,4,17,16,2.1,bend_bottom,1,low,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,211
+29,0,4,17,16,2.1,bend_bottom,1,medium,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,212
+29,0,4,17,16,2.1,bend_bottom,1,high,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,213
+29,0,4,17,16,2.1,tension,1,low,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,214
+29,0,4,17,16,2.1,tension,1,medium,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,215
+29,0,4,17,16,2.1,tension,1,high,4.375,2.8000000000000003,1,"CIRC_HOLE,FACE",1,1.1812500000000001,,3.5,23,216
+36,2,16,12,0.762,1.7526,bend_bottom,-1,low,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.3847500000000001,,1.52,34.92500197887421,217
+36,2,16,12,0.762,1.7526,bend_bottom,-1,medium,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.3847500000000001,,1.52,34.92500197887421,218
+36,2,16,12,0.762,1.7526,bend_bottom,-1,high,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.3847500000000001,,1.52,34.92500197887421,219
+36,2,16,12,0.762,1.7526,tension,-1,low,1.9,1.2160000000000002,1,"CIRC_HOLE,CIRC_HOLE",1,0.28856250000000006,,1.52,34.92500197887421,220
+36,2,16,12,0.762,1.7526,tension,-1,medium,1.9,1.2160000000000002,1,"CIRC_HOLE,CIRC_HOLE",1,0.28856250000000006,,1.52,34.92500197887421,221
+36,2,16,12,0.762,1.7526,tension,-1,high,1.9,1.2160000000000002,1,"CIRC_HOLE,CIRC_HOLE",1,0.28856250000000006,,1.52,34.92500197887421,222
+36,2,16,12,0.762,1.7526,bend_bottom,1,low,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.3847500000000001,,1.52,34.92500197887421,223
+36,2,16,12,0.762,1.7526,bend_bottom,1,medium,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.3847500000000001,,1.52,34.92500197887421,224
+36,2,16,12,0.762,1.7526,bend_bottom,1,high,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.5130000000000001,,1.52,34.92500197887421,225
+36,2,16,12,0.762,1.7526,tension,1,low,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.6840000000000002,,1.52,34.92500197887421,226
+36,2,16,12,0.762,1.7526,tension,1,medium,1.9,1.2160000000000002,1,"CIRC_HOLE,FACE",1,0.6840000000000002,,1.52,34.92500197887421,227
+36,2,16,12,0.762,1.7526,tension,1,high,1.9,1.2160000000000002,1,"CIRC_HOLE,CIRC_HOLE",1,0.6840000000000002,,1.52,34.92500197887421,228
+37,2,8,12,0.762,1.7526,bend_bottom,-1,low,1.9050000607967377,1.2192000389099122,0,"FACE,CIRC_HOLE",1,0.3857625123113394,,1.52,38.10000121593475,229
+37,2,8,12,0.762,1.7526,bend_bottom,-1,medium,1.9050000607967377,1.2192000389099122,0,"FACE,CIRC_HOLE",1,0.3857625123113394,,1.52,38.10000121593475,230
+37,2,8,12,0.762,1.7526,bend_bottom,-1,high,1.9050000607967377,1.2192000389099122,0,"FACE,CIRC_HOLE",1,0.3857625123113394,,1.52,38.10000121593475,231
+37,2,8,12,0.762,1.7526,tension,-1,low,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,CIRC_HOLE",1,0.2893218842335046,,1.52,38.10000121593475,232
+37,2,8,12,0.762,1.7526,tension,-1,medium,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,CIRC_HOLE",1,0.2893218842335046,,1.52,38.10000121593475,233
+37,2,8,12,0.762,1.7526,tension,-1,high,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,CIRC_HOLE",1,0.21699141317512843,,1.52,38.10000121593475,234
+37,2,8,12,0.762,1.7526,bend_bottom,1,low,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,FACE",1,0.3857625123113394,,1.52,38.10000121593475,235
+37,2,8,12,0.762,1.7526,bend_bottom,1,medium,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,FACE",1,0.3857625123113394,,1.52,38.10000121593475,236
+37,2,8,12,0.762,1.7526,bend_bottom,1,high,1.9050000607967377,1.2192000389099122,1,"FACE,FILLET",1,0.3857625123113394,,1.52,38.10000121593475,237
+37,2,8,12,0.762,1.7526,tension,1,low,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,FACE",1,0.5143500164151192,,1.52,38.10000121593475,238
+37,2,8,12,0.762,1.7526,tension,1,medium,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,CIRC_HOLE",1,0.5143500164151192,,1.52,38.10000121593475,239
+37,2,8,12,0.762,1.7526,tension,1,high,1.9050000607967377,1.2192000389099122,1,"CIRC_HOLE,FACE",1,0.5143500164151192,,1.52,38.10000121593475,240
+43,6,16,8,0.6985,2.0828,bend_bottom,-1,low,3.5,2.24,0,"FACE,CIRC_HOLE",1,0.7087500000000001,,2.8,66.674999833107,241
+43,6,16,8,0.6985,2.0828,bend_bottom,-1,medium,3.5,2.24,0,"FACE,CIRC_HOLE",1,0.7087500000000001,,2.8,66.674999833107,242
+43,6,16,8,0.6985,2.0828,bend_bottom,-1,high,3.5,2.24,1,"FILLET,FACE",1,0.7087500000000001,,2.8,66.674999833107,243
+43,6,16,8,0.6985,2.0828,tension,-1,low,3.5,2.24,1,"CIRC_HOLE,CIRC_HOLE",1,0.7087500000000001,,2.8,66.674999833107,244
+43,6,16,8,0.6985,2.0828,tension,-1,medium,3.5,2.24,1,"CIRC_HOLE,CIRC_HOLE",1,0.7087500000000001,,2.8,66.674999833107,245
+43,6,16,8,0.6985,2.0828,tension,-1,high,3.5,2.24,1,"CIRC_HOLE,CIRC_HOLE",1,0.7087500000000001,,2.8,66.674999833107,246
+43,6,16,8,0.6985,2.0828,bend_bottom,1,low,3.5,2.24,0,"CIRC_HOLE,FACE",1,0.7087500000000001,,2.8,66.674999833107,247
+43,6,16,8,0.6985,2.0828,bend_bottom,1,medium,3.5,2.24,0,"FILLET,FACE",1,0.7087500000000001,,2.8,66.674999833107,248
+43,6,16,8,0.6985,2.0828,bend_bottom,1,high,3.5,2.24,1,"FILLET,FACE",1,0.7087500000000001,,2.8,66.674999833107,249
+43,6,16,8,0.6985,2.0828,tension,1,low,3.5,2.24,1,"CIRC_HOLE,CIRC_HOLE",1,0.398671875,,2.8,66.674999833107,250
+43,6,16,8,0.6985,2.0828,tension,1,medium,3.5,2.24,1,"CIRC_HOLE,CIRC_HOLE",1,0.398671875,,2.8,66.674999833107,251
+43,6,16,8,0.6985,2.0828,tension,1,high,3.5,2.24,1,"CIRC_HOLE,FACE",1,0.7087500000000001,,2.8,66.674999833107,252
+44,6,16,8,0.6985,2.0828,bend_bottom,-1,low,4.603749686479569,2.7622498118877417,1,"CIRC_HOLE,FACE",1,1.5537655191868547,,2.8,92.07499372959137,253
+44,6,16,8,0.6985,2.0828,bend_bottom,-1,medium,4.603749686479569,2.5896091986447574,0,"FILLET,FACE",1,1.456655174237676,,2.8,92.07499372959137,254
+44,6,16,8,0.6985,2.0828,bend_bottom,-1,high,4.603749686479569,2.5896091986447574,0,"FILLET,FACE",1,1.456655174237676,,2.8,92.07499372959137,255
+44,6,16,8,0.6985,2.0828,tension,-1,low,4.603749686479569,2.946399799346924,1,"FACE,CIRC_HOLE",1,1.657349887132645,,2.8,92.07499372959137,256
+44,6,16,8,0.6985,2.0828,tension,-1,medium,4.603749686479569,2.946399799346924,1,"FACE,CIRC_HOLE",1,1.657349887132645,,2.8,92.07499372959137,257
+44,6,16,8,0.6985,2.0828,tension,-1,high,4.603749686479569,2.946399799346924,1,"FACE,CIRC_HOLE",1,1.657349887132645,,2.8,92.07499372959137,258
+44,6,16,8,0.6985,2.0828,bend_bottom,1,low,4.603749686479569,2.7622498118877417,0,"CIRC_HOLE,FACE",1,1.165324139390141,,2.8,92.07499372959137,259
+44,6,16,8,0.6985,2.0828,bend_bottom,1,medium,4.603749686479569,2.5896091986447574,0,"FILLET,FACE",1,1.456655174237676,,2.8,92.07499372959137,260
+44,6,16,8,0.6985,2.0828,bend_bottom,1,high,4.603749686479569,2.5896091986447574,0,"FILLET,FACE",1,1.456655174237676,,2.8,92.07499372959137,261
+44,6,16,8,0.6985,2.0828,tension,1,low,4.603749686479569,2.946399799346924,1,"FACE,CIRC_HOLE",1,1.657349887132645,,2.8,92.07499372959137,262
+44,6,16,8,0.6985,2.0828,tension,1,medium,4.603749686479569,2.946399799346924,1,"FACE,CIRC_HOLE",1,1.657349887132645,,2.8,92.07499372959137,263
+44,6,16,8,0.6985,2.0828,tension,1,high,4.603749686479569,2.946399799346924,1,"FACE,CIRC_HOLE",1,1.657349887132645,,2.8,92.07499372959137,264
+50,1,0,25,3.0988,0,bend_bottom,-1,low,7.75,4.960000000000001,1,"FILLET,FACE",1,1.5693750000000002,,6.2,65.02399444580078,265
+50,1,0,25,3.0988,0,bend_bottom,-1,medium,7.75,4.960000000000001,1,"FILLET,FACE",1,1.5693750000000002,,6.2,65.02399444580078,266
+50,1,0,25,3.0988,0,bend_bottom,-1,high,7.75,4.960000000000001,1,"FILLET,FACE",1,1.5693750000000002,,6.2,65.02399444580078,267
+50,1,0,25,3.0988,0,tension,-1,low,7.75,3.26953125,1,"FACE,FACE",1,3.26953125,,6.2,65.02399444580078,268
+50,1,0,25,3.0988,0,tension,-1,medium,7.75,3.26953125,1,"FACE,FACE",1,3.26953125,,6.2,65.02399444580078,269
+50,1,0,25,3.0988,0,tension,-1,high,7.75,3.26953125,1,"FACE,FACE",1,3.26953125,,6.2,65.02399444580078,270
+50,1,0,25,3.0988,0,bend_bottom,1,low,7.75,4.960000000000001,1,"FILLET,FACE",1,1.5693750000000002,,6.2,65.02399444580078,271
+50,1,0,25,3.0988,0,bend_bottom,1,medium,7.75,4.960000000000001,1,"FILLET,FACE",1,1.5693750000000002,,6.2,65.02399444580078,272
+50,1,0,25,3.0988,0,bend_bottom,1,high,7.75,4.960000000000001,1,"FILLET,FACE",1,1.5693750000000002,,6.2,65.02399444580078,273
+50,1,0,25,3.0988,0,tension,1,low,7.75,3.26953125,1,"FACE,FACE",1,3.26953125,,6.2,65.02399444580078,274
+50,1,0,25,3.0988,0,tension,1,medium,7.75,3.26953125,1,"FACE,FACE",1,3.26953125,,6.2,65.02399444580078,275
+50,1,0,25,3.0988,0,tension,1,high,7.75,3.26953125,1,"FACE,FACE",1,3.26953125,,6.2,65.02399444580078,276
+51,2,16,12,1.397,2.0828,bend_bottom,-1,low,3.968749839067459,2.539999897003174,1,"FACE,CIRC_HOLE",1,1.071562456548214,,2.8,79.37499678134918,277
+51,2,16,12,1.397,2.0828,bend_bottom,-1,medium,3.968749839067459,2.2324217844754455,1,"FACE,FILLET",1,1.255737253767438,,2.8,79.37499678134918,278
+51,2,16,12,1.397,2.0828,bend_bottom,-1,high,3.968749839067459,2.2324217844754455,1,"FACE,FILLET",1,1.255737253767438,,2.8,79.37499678134918,279
+51,2,16,12,1.397,2.0828,tension,-1,low,3.968749839067459,2.539999897003174,1,"CIRC_HOLE,CIRC_HOLE",1,0.8036718424111605,,2.8,79.37499678134918,280
+51,2,16,12,1.397,2.0828,tension,-1,medium,3.968749839067459,2.539999897003174,0,"CIRC_HOLE,CIRC_HOLE",1,0.4520654113562778,,2.8,79.37499678134918,281
+51,2,16,12,1.397,2.0828,tension,-1,high,3.968749839067459,2.539999897003174,0,"CIRC_HOLE,CIRC_HOLE",1,0.4520654113562778,,2.8,79.37499678134918,282
+51,2,16,12,1.397,2.0828,bend_bottom,1,low,3.968749839067459,2.3812499034404757,0,"FILLET,FACE",1,1.0045898030139506,,2.8,79.37499678134918,283
+51,2,16,12,1.397,2.0828,bend_bottom,1,medium,3.968749839067459,2.2324217844754455,1,"FACE,FILLET",1,1.255737253767438,,2.8,79.37499678134918,284
+51,2,16,12,1.397,2.0828,bend_bottom,1,high,3.968749839067459,2.2324217844754455,1,"FACE,FILLET",1,1.255737253767438,,2.8,79.37499678134918,285
+51,2,16,12,1.397,2.0828,tension,1,low,3.968749839067459,2.539999897003174,1,"CIRC_HOLE,CIRC_HOLE",1,0.8036718424111605,,2.8,79.37499678134918,286
+51,2,16,12,1.397,2.0828,tension,1,medium,3.968749839067459,2.539999897003174,1,"CIRC_HOLE,CIRC_HOLE",1,0.8036718424111605,,2.8,79.37499678134918,287
+51,2,16,12,1.397,2.0828,tension,1,high,3.968749839067459,2.539999897003174,1,"CIRC_HOLE,CIRC_HOLE",1,1.4287499420642855,,2.8,79.37499678134918,288
+52,2,20,12,1.397,2.0828,bend_bottom,-1,low,6.032500296831131,3.0886401519775397,1,"FACE,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,289
+52,2,20,12,1.397,2.0828,bend_bottom,-1,medium,6.032500296831131,3.0886401519775397,1,"FACE,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,290
+52,2,20,12,1.397,2.0828,bend_bottom,-1,high,6.032500296831131,3.393281416967511,1,"FACE,FACE",1,3.393281416967511,,2.8,120.65000593662262,291
+52,2,20,12,1.397,2.0828,tension,-1,low,6.032500296831131,3.0886401519775397,1,"CIRC_HOLE,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,292
+52,2,20,12,1.397,2.0828,tension,-1,medium,6.032500296831131,3.0886401519775397,1,"CIRC_HOLE,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,293
+52,2,20,12,1.397,2.0828,tension,-1,high,6.032500296831131,3.0886401519775397,1,"CIRC_HOLE,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,294
+52,2,20,12,1.397,2.0828,bend_bottom,1,low,6.032500296831131,3.0886401519775397,1,"FILLET,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,295
+52,2,20,12,1.397,2.0828,bend_bottom,1,medium,6.032500296831131,2.316480113983155,0,"FACE,CIRC_HOLE",1,0.9772650480866434,,2.8,120.65000593662262,296
+52,2,20,12,1.397,2.0828,bend_bottom,1,high,6.032500296831131,3.393281416967511,1,"FACE,FACE",1,3.393281416967511,,2.8,120.65000593662262,297
+52,2,20,12,1.397,2.0828,tension,1,low,6.032500296831131,3.0886401519775397,1,"CIRC_HOLE,CIRC_HOLE",1,1.3030200641155245,,2.8,120.65000593662262,298
+52,2,20,12,1.397,2.0828,tension,1,medium,6.032500296831131,3.0886401519775397,1,"CIRC_HOLE,FACE",1,0.9772650480866434,,2.8,120.65000593662262,299
+52,2,20,12,1.397,2.0828,tension,1,high,6.032500296831131,2.4709121215820318,0,"CIRC_HOLE,CIRC_HOLE",1,0.5863590288519861,,2.8,120.65000593662262,300

mesh_service/run_interface.py

@@ -0,0 +1,1150 @@
+## MVP 1 FILE!
+from .step_feature_detection import (
+    load_step_model,
+    load_step_unit,
+    detect_faces,
+    detect_circular_holes,
+    detect_non_circular_holes,
+    detect_fillets,
+    mode_thickness,
+    detect_all_edges,
+    detect_all_faces,
+)
+import os, json
+import pandas as pd
+import gmsh
+from OCP.Bnd import Bnd_Box
+from OCP.BRepBndLib import BRepBndLib
+import joblib
+from OCP.TopExp import TopExp_Explorer
+from OCP.TopAbs import TopAbs_FACE
+from OCP.TopoDS import TopoDS
+import torch
+from torch import nn
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
+import plotly.graph_objects as go
+
+
+# ---------------------------------------------------------------------
+# Matplotlib static PNG plotter (unchanged)
+# ---------------------------------------------------------------------
+def plot_mesh(
+    nodes,
+    elements,
+    title,
+    highlight_faces=None,
+    face_to_nodes=None,
+    save_path="mesh.png",
+):
+    """
+    Static 3D line-plot of the surface mesh for PNG export.
+    nodes: (N,3)
+    elements: list[(etype, conn)], conn is array of 0-based node indices
+    """
+    fig = plt.figure(figsize=(7, 7))
+    ax = fig.add_subplot(111, projection="3d")
+    ax.view_init(elev=20, azim=45)
+
+    # normal mesh (black)
+    for (etype, conn) in elements:
+        for e in conn:
+            pts = nodes[e][:, :3]
+            pts = np.vstack([pts, pts[0]])
+            ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], "k-", linewidth=0.4)
+
+    # optional red overlay for selected faces
+    if highlight_faces and face_to_nodes:
+        for sf in highlight_faces:
+            if sf not in face_to_nodes:
+                continue
+            face_nodes = face_to_nodes[sf]
+            for fn in face_nodes:
+                pts = nodes[fn][:, :3]
+                pts = np.vstack([pts, pts[0]])
+                ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], "r-", linewidth=1.2)
+
+    ax.set_title(title)
+    ax.set_axis_off()
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+
+
+# ---------------------------------------------------------------------
+# Face list helper for GUI (unchanged)
+# ---------------------------------------------------------------------
+def extract_faces_for_gui(step_path):
+    """
+    Load the STEP file, detect faces, and return a list of
+    label/metadata dicts that the GUI can use.
+    """
+    shape = load_step_model(step_path)
+    faces = detect_all_faces(shape)
+
+    face_list = []
+    for f in faces:
+        center = f["center"]
+        normal = f["normal"]
+        area = f.get("area", 0.0)
+        label = f"Face {f['face_id']} | normal={np.round(normal,3)} | area={area:.2f}"
+
+        face_list.append(
+            {
+                "label": label,
+                "face_id": f["face_id"],
+                "center": list(center),
+                "normal": list(normal),
+                "area": float(area),
+            }
+        )
+
+    return face_list
+
+
+# ---------------------------------------------------------------------
+# Helpers for Plotly 3D mesh
+# ---------------------------------------------------------------------
+def mesh_edges_from_triangles(triangles):
+    """
+    Given (M,3) triangle connectivity, return unique edges as (E,2).
+    """
+    edges = set()
+    for tri in triangles:
+        a, b, c = tri
+        edges.add(tuple(sorted((a, b))))
+        edges.add(tuple(sorted((b, c))))
+        edges.add(tuple(sorted((c, a))))
+    return np.array(list(edges), dtype=int)
+
+
+def make_plotly_mesh(
+    nodes,
+    triangles,
+    title="Refined Mesh",
+    view_mode="wireframe",
+    refined_tri_mask=None,
+    vertex_refinement_values=None,
+):
+    """
+    Build an interactive Plotly figure.
+
+    Parameters
+    ----------
+    nodes : (N,3) ndarray
+    triangles : (M,3) ndarray of 0-based node indices
+    view_mode : {"wireframe", "highlight", "heatmap"}
+        - "wireframe": light-blue surface + black edges
+        - "highlight": base surface + red overlay on refined triangles
+        - "heatmap": surface colored by vertex_refinement_values
+    refined_tri_mask : (M,) bool array
+        True for triangles in locally-refined region (used in "highlight").
+    vertex_refinement_values : (N,) array
+        Per-node refinement intensity used for "heatmap".
+        Higher values → more refined → hotter colors.
+    """
+    nodes = np.asarray(nodes)
+    triangles = np.asarray(triangles, dtype=int)
+    edges = mesh_edges_from_triangles(triangles)
+    n_nodes = nodes.shape[0]
+
+    if refined_tri_mask is None:
+        refined_tri_mask = np.zeros(triangles.shape[0], dtype=bool)
+
+    if vertex_refinement_values is None:
+        vertex_refinement_values = np.zeros(n_nodes, dtype=float)
+
+    fig = go.Figure()
+
+    # ----------------------------------------
+    # Base surface for all modes
+    # ----------------------------------------
+    if view_mode == "heatmap":
+        # Heatmap using per-vertex refinement values
+        fig.add_trace(
+            go.Mesh3d(
+                x=nodes[:, 0],
+                y=nodes[:, 1],
+                z=nodes[:, 2],
+                i=triangles[:, 0],
+                j=triangles[:, 1],
+                k=triangles[:, 2],
+                intensity=vertex_refinement_values,
+                colorscale="Turbo",
+                showscale=True,
+                flatshading=True,
+                opacity=0.9,
+                showlegend=False,
+                name="Local mesh size heatmap",
+            )
+        )
+    else:
+        # Simple uniform surface color
+        fig.add_trace(
+            go.Mesh3d(
+                x=nodes[:, 0],
+                y=nodes[:, 1],
+                z=nodes[:, 2],
+                i=triangles[:, 0],
+                j=triangles[:, 1],
+                k=triangles[:, 2],
+                color="lightblue",
+                flatshading=True,
+                lighting=dict(
+                    ambient=0.6, diffuse=0.8, specular=0.2, roughness=0.9
+                ),
+                lightposition=dict(x=0, y=0, z=1),
+                opacity=0.45 if view_mode == "wireframe" else 0.55,
+                showlegend=False,
+                showscale=False,
+                name="Surface",
+            )
+        )
+
+    # ----------------------------------------
+    # Highlight overlay (local refinement in red)
+    # ----------------------------------------
+    if view_mode == "highlight" and refined_tri_mask.any():
+        ref_tris = triangles[refined_tri_mask]
+        fig.add_trace(
+            go.Mesh3d(
+                x=nodes[:, 0],
+                y=nodes[:, 1],
+                z=nodes[:, 2],
+                i=ref_tris[:, 0],
+                j=ref_tris[:, 1],
+                k=ref_tris[:, 2],
+                color="red",
+                opacity=0.9,
+                flatshading=True,
+                showscale=False,
+                name="Locally refined",
+            )
+        )
+
+    # ----------------------------------------
+    # Wireframe edges for all modes
+    # ----------------------------------------
+    edge_width = 2 if view_mode != "heatmap" else 1
+    edge_color = "black" if view_mode != "heatmap" else "rgba(0,0,0,0.4)"
+
+    for e0, e1 in edges:
+        fig.add_trace(
+            go.Scatter3d(
+                x=[nodes[e0, 0], nodes[e1, 0]],
+                y=[nodes[e0, 1], nodes[e1, 1]],
+                z=[nodes[e0, 2], nodes[e1, 2]],
+                mode="lines",
+                line=dict(color=edge_color, width=edge_width),
+                showlegend=False,
+            )
+        )
+
+    fig.update_layout(
+        title=title,
+        scene=dict(aspectmode="data"),
+        margin=dict(l=0, r=0, t=30, b=0),
+    )
+
+    return fig
+
+
+# ---------------------------------------------------------------------
+# Main pipeline
+# ---------------------------------------------------------------------
+def get_result(
+    step_path,
+    thickness,
+    load_face,
+    load_direction,
+    load_scale,
+    selected_face_label=None,
+    faces_json=None,
+    view_mode="wireframe",  # NEW optional flag, default keeps current behavior
+):
+    # -----------------------------------------------------------------
+    # STEP → JSON features
+    # -----------------------------------------------------------------
+    def step_to_json(step_path, thickness, part_id=None):
+        shape = load_step_model(step_path)
+        part_id = part_id or os.path.splitext(os.path.basename(step_path))[0]
+        circular_holes = detect_circular_holes(shape)
+        fillets = detect_fillets(shape)
+        faces = detect_all_faces(shape)
+        print(f"Detected {len(faces)} faces")
+
+        features = {
+            "part_id": part_id,
+            "thickness": thickness,
+            "circular_holes": circular_holes,
+            "fillets": fillets,
+            "faces": faces,
+        }
+        out_path = "output/example.json"
+        with open(out_path, "w") as f:
+            json.dump(features, f, indent=2)
+
+    step_to_json(step_path, thickness)
+
+    # -----------------------------------------------------------------
+    # Load geometry into gmsh
+    # -----------------------------------------------------------------
+    gmsh.open(step_path)
+    gmsh.model.occ.synchronize()
+
+    surfaces = gmsh.model.getEntities(dim=2)
+    surface_info = []
+    for dim, tag in surfaces:
+        mass_props = gmsh.model.occ.getMass(dim, tag)
+        com = gmsh.model.occ.getCenterOfMass(dim, tag)
+        surface_info.append({"tag": tag, "center": com, "area": mass_props})
+
+    with open("output/example.json") as f:
+        features = json.load(f)
+    faces = features["faces"]
+
+    num_fillet = len(features["fillets"])
+    num_hole = len(features["circular_holes"])
+    num_faces = len(features["faces"])
+    num_plane = num_faces - num_fillet - num_hole
+
+    smallest_fillet_r = min(
+        (f["radius"] for f in features["fillets"]), default=0.0
+    )
+    smallest_hole_r = min(
+        (h["radius"] for h in features["circular_holes"]), default=0.0
+    )
+
+    print(
+        f"num_fillet: {num_fillet}, num_hole: {num_hole}, num_plane: {num_plane}"
+    )
+    print(
+        f"smallest_fillet_r: {smallest_fillet_r}, smallest_hole_r: {smallest_hole_r}"
+    )
+
+    # -----------------------------------------------------------------
+    # Bounding box → max dimension
+    # -----------------------------------------------------------------
+    def detect_maxsize(shape):
+        bbox = Bnd_Box()
+        BRepBndLib.Add_s(shape, bbox)
+        xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
+        size_x = xmax - xmin
+        size_y = ymax - ymin
+        size_z = zmax - zmin
+        maxsize = max(size_x, size_y, size_z)
+        return maxsize, (size_x, size_y, size_z)
+
+    shape = load_step_model(step_path)
+    maxsize, (sx, sy, sz) = detect_maxsize(shape)
+    print("maxsize:", maxsize)
+
+    # -----------------------------------------------------------------
+    # Heuristic face roles (bottom/left/front/back)
+    # -----------------------------------------------------------------
+    def find_the_faces(step_path):
+        shape = load_step_model(step_path)
+        faces_local = detect_all_faces(shape)
+        z_vals = [f["center"][2] for f in faces_local]
+        x_vals = [f["center"][0] for f in faces_local]
+        y_vals = [f["center"][1] for f in faces_local]
+
+        idx_bottom = z_vals.index(min(z_vals))
+        idx_left = x_vals.index(min(x_vals))
+        idx_front = y_vals.index(min(y_vals))
+        idx_back = y_vals.index(max(y_vals))
+
+        return {
+            "bottom": faces_local[idx_bottom],
+            "left": faces_local[idx_left],
+            "front": faces_local[idx_front],
+            "back": faces_local[idx_back],
+            "bottom_idx": idx_bottom,
+            "left_idx": idx_left,
+            "front_idx": idx_front,
+            "back_idx": idx_back,
+        }
+
+    face_dict = find_the_faces(step_path)
+
+    part_row = {
+        "num_fillet": num_fillet,
+        "num_hole": num_hole,
+        "num_plane": num_plane,
+        "smallest_fillet_r": smallest_fillet_r,
+        "smallest_hole_r": smallest_hole_r,
+        "maxsize": maxsize,
+        "thickness": thickness,
+        "load_face": load_face,
+        "load_direction": load_direction,
+        "load_scale": load_scale,
+    }
+    df_part = pd.DataFrame([part_row])
+
+    # classify face types
+    face_type_dict = {}
+    for hole in features["circular_holes"]:
+        for f in hole["faces"]:
+            face_type_dict[f["face_id"]] = "CIRC_HOLE"
+    for fillet in features["fillets"]:
+        for f in fillet["faces"]:
+            face_type_dict[f["face_id"]] = "FILLET"
+    for f in features["faces"]:
+        if f["face_id"] not in face_type_dict:
+            face_type_dict[f["face_id"]] = "FACE"
+
+    # -----------------------------------------------------------------
+    # Choose load/fixed faces (GUI-aware)
+    # -----------------------------------------------------------------
+    load_face_data = None
+    fix_face_data = None
+
+    if selected_face_label is not None and faces_json is not None and faces_json != "":
+        faces_from_gui = json.loads(faces_json)
+        label_to_face = {f["label"]: f for f in faces_from_gui}
+
+        if selected_face_label not in label_to_face:
+            raise ValueError(
+                f"Selected load face '{selected_face_label}' not found in faces_json."
+            )
+
+        load_face_data = label_to_face[selected_face_label]
+
+        load_center = np.array(load_face_data["center"], dtype=float)
+        all_faces_gui = list(label_to_face.values())
+        distances = [
+            np.linalg.norm(np.array(f["center"], dtype=float) - load_center)
+            for f in all_faces_gui
+        ]
+        fix_face_data = all_faces_gui[int(np.argmax(distances))]
+    else:
+        if load_face == "bend_bottom":
+            load_face_data = face_dict["bottom"]
+            fix_face_data = face_dict["left"]
+        elif load_face == "tension":
+            load_face_data = face_dict["back"]
+            fix_face_data = face_dict["front"]
+        else:
+            raise ValueError(
+                f"No GUI selection and unsupported load_face value '{load_face}'."
+            )
+
+    load_face_center = np.array(load_face_data["center"])
+    load_face_normal = np.array(load_face_data["normal"])
+    fix_face_center = np.array(fix_face_data["center"])
+    fix_face_normal = np.array(fix_face_data["normal"])
+
+    # -----------------------------------------------------------------
+    # BBox per CAD face
+    # -----------------------------------------------------------------
+    def get_face_bbox_dict(shape):
+        bbox_dict = {}
+        exp = TopExp_Explorer(shape, TopAbs_FACE)
+        face_id = 0
+        while exp.More():
+            face_shape = exp.Current()
+            face = TopoDS.Face_s(face_shape)
+            bbox = Bnd_Box()
+            BRepBndLib.Add_s(face, bbox)
+            xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
+            bbox_dx = xmax - xmin
+            bbox_dy = ymax - ymin
+            bbox_dz = zmax - zmin
+            bbox_dict[face_id] = (bbox_dx, bbox_dy, bbox_dz)
+            face_id += 1
+            exp.Next()
+        return bbox_dict
+
+    shape = load_step_model(step_path)
+    bbox_dict = get_face_bbox_dict(shape)
+
+    # -----------------------------------------------------------------
+    # Build per-face feature table
+    # -----------------------------------------------------------------
+    rows1 = []
+    for f in faces:
+        row = {}
+        row["face_id"] = f["face_id"]
+        row["ftype"] = face_type_dict[f["face_id"]]
+        row["cx"], row["cy"], row["cz"] = f["center"]
+        row["nx"], row["ny"], row["nz"] = f["normal"]
+        row["area"] = f.get("area")
+        if f["face_id"] == load_face_data["face_id"]:
+            row["role"] = "load"
+        elif f["face_id"] == fix_face_data["face_id"]:
+            row["role"] = "fixed"
+        else:
+            row["role"] = "free"
+        dx, dy, dz = bbox_dict[f["face_id"]]
+        row["bbox_dx"] = dx
+        row["bbox_dy"] = dy
+        row["bbox_dz"] = dz
+
+        fc = np.array(f["center"])
+        row["dist_load"] = np.linalg.norm(fc - np.array(load_face_center))
+        row["nlx"], row["nly"], row["nlz"] = load_face_normal
+        row["dist_fixed"] = np.linalg.norm(fc - np.array(fix_face_center))
+        row["nfx"], row["nfy"], row["nfz"] = fix_face_normal
+
+        row["load_face"] = load_face
+        row["load_direction"] = load_direction
+        row["load_scale"] = load_scale
+        row["maxsize"] = maxsize
+        row["thickness"] = thickness
+        rows1.append(row)
+    df_feature = pd.DataFrame(rows1)
+
+    df_feature = df_feature.fillna(0.0)
+    df_part = df_part.fillna(0.0)
+
+    # -----------------------------------------------------------------
+    # Model 1: refine_needed classifier
+    # -----------------------------------------------------------------
+    class RefineClassifier(nn.Module):
+        def __init__(self, in_dim):
+            super().__init__()
+            self.encoder = nn.Sequential(
+                nn.Linear(in_dim, 256),
+                nn.BatchNorm1d(256),
+                nn.ReLU(),
+                nn.Dropout(0.2),
+                nn.Linear(256, 128),
+                nn.BatchNorm1d(128),
+                nn.ReLU(),
+                nn.Dropout(0.1),
+                nn.Linear(128, 64),
+                nn.ReLU(),
+            )
+            self.head = nn.Linear(64, 1)
+
+        def forward(self, x):
+            h = self.encoder(x)
+            return self.head(h)
+
+    preprocessor1 = joblib.load("saved_model/preprocessor1.pkl")
+    feature_cols1 = [
+        c
+        for c in df_feature.columns
+        if c
+        not in [
+            "part_id",
+            "refine_needed",
+            "converged",
+            "local_size",
+            "global_size_initial",
+            "global_size_final",
+            "load_id",
+        ]
+    ]
+    X1 = preprocessor1.transform(df_feature[feature_cols1])
+    X1_t = torch.tensor(
+        X1.toarray() if hasattr(X1, "toarray") else X1, dtype=torch.float32
+    )
+
+    model1 = RefineClassifier(X1_t.shape[1])
+    state_dict = torch.load("saved_model/model1.pt", map_location="cpu")
+    model1.load_state_dict(state_dict)
+    model1.eval()
+
+    with torch.no_grad():
+        logits1 = model1(X1_t)
+        probs1 = torch.sigmoid(logits1).cpu().numpy().flatten()
+    df_feature["refine_prob"] = probs1
+
+    top2 = df_feature.sort_values("refine_prob", ascending=False).head(2)
+    df_feature.drop(columns=["refine_prob"], inplace=True)
+
+    # -----------------------------------------------------------------
+    # Model 2: part-level convergence
+    # -----------------------------------------------------------------
+    preprocessor2 = joblib.load("saved_model/preprocessor2.pkl")
+
+    feature_cols = [
+        col
+        for col in df_feature.columns
+        if col
+        not in [
+            "part_id",
+            "load_id",
+            "refine_needed",
+            "converged",
+            "local_size",
+            "global_size_initial",
+            "global_size_final",
+        ]
+    ]
+    part_level_cols = [
+        col
+        for col in df_part.columns
+        if col
+        not in [
+            "part_id",
+            "converged",
+            "load_id",
+            "top2_features",
+            "global_size_initial",
+            "global_size_final",
+            "local_refine_needed",
+            "local_size",
+        ]
+    ]
+
+    def extract_supervised_features_model2():
+        part_row_local = df_part.iloc[0]
+        feat_rows = df_feature
+
+        # fixed
+        fixed_row = feat_rows[feat_rows.role == "fixed"]
+        if len(fixed_row):
+            X_fixed = preprocessor1.transform(fixed_row[feature_cols])
+            with torch.no_grad():
+                fixed_prob = torch.sigmoid(
+                    model1(torch.tensor(X_fixed, dtype=torch.float32))
+                ).item()
+            fixed_feats = list(fixed_row.iloc[0][feature_cols]) + [fixed_prob]
+        else:
+            fixed_feats = [0] * (len(feature_cols) + 1)
+
+        # load
+        load_row = feat_rows[feat_rows.role == "load"]
+        if len(load_row):
+            X_load = preprocessor1.transform(load_row[feature_cols])
+            with torch.no_grad():
+                load_prob = torch.sigmoid(
+                    model1(torch.tensor(X_load, dtype=torch.float32))
+                ).item()
+            load_feats = list(load_row.iloc[0][feature_cols]) + [load_prob]
+        else:
+            load_feats = [0] * (len(feature_cols) + 1)
+
+        # free
+        free_rows = feat_rows[feat_rows.role == "free"]
+        if len(free_rows):
+            X_free = preprocessor1.transform(free_rows[feature_cols])
+            with torch.no_grad():
+                free_probs = torch.sigmoid(
+                    model1(torch.tensor(X_free, dtype=torch.float32))
+                ).cpu().numpy().flatten()
+            best_idx = np.argmax(free_probs)
+            free_feats = (
+                list(free_rows.iloc[best_idx][feature_cols])
+                + [free_probs[best_idx]]
+            )
+        else:
+            free_feats = [0] * (len(feature_cols) + 1)
+
+        global_feats = list(part_row_local[part_level_cols])
+        return fixed_feats + load_feats + free_feats + global_feats
+
+    col_names = (
+        [f"fixed_{c}" for c in feature_cols]
+        + ["fixed_refine_prob"]
+        + [f"load_{c}" for c in feature_cols]
+        + ["load_refine_prob"]
+        + [f"free_{c}" for c in feature_cols]
+        + ["free_refine_prob"]
+        + part_level_cols
+    )
+
+    row = extract_supervised_features_model2()
+    df_sup = pd.DataFrame([row], columns=col_names)
+
+    missing_cols = set(preprocessor2.feature_names_in_) - set(df_sup.columns)
+    for c in missing_cols:
+        df_sup[c] = 0.0
+    df_sup = df_sup[preprocessor2.feature_names_in_]
+
+    X2 = preprocessor2.transform(df_sup)
+    print("X2 contains NaN?", np.isnan(X2).any())
+    X2_t = torch.tensor(
+        X2.toarray() if hasattr(X2, "toarray") else X2, dtype=torch.float32
+    )
+
+    class ConvergeClassifier(nn.Module):
+        def __init__(self, in_dim):
+            super().__init__()
+            self.encoder = nn.Sequential(
+                nn.Linear(in_dim, 64),
+                nn.BatchNorm1d(64),
+                nn.ReLU(),
+                nn.Dropout(0.2),
+                nn.Linear(64, 32),
+                nn.ReLU(),
+            )
+            self.head = nn.Linear(32, 2)
+
+        def forward(self, x):
+            h = self.encoder(x)
+            return self.head(h)
+
+    model2 = ConvergeClassifier(X2_t.shape[1])
+    state_dict = torch.load("saved_model/model2.pt", map_location="cpu")
+    model2.load_state_dict(state_dict)
+    model2.eval()
+
+    with torch.no_grad():
+        logits2 = model2(X2_t)
+        probs2 = torch.softmax(logits2, dim=1).cpu().numpy()
+        preds2 = probs2.argmax(1)
+
+    print("Model 2 (part-level converge) predictions:")
+    print("Probability not converged:", probs2[:, 0])
+    print("Probability converged:", probs2[:, 1])
+    print("Predicted class (0: unconverged, 1: converged):", preds2)
+
+    # -----------------------------------------------------------------
+    # Model 3: local size regressor
+    # -----------------------------------------------------------------
+    class LocalRefineRegressor(nn.Module):
+        def __init__(self, in_dim):
+            super().__init__()
+            self.encoder = nn.Sequential(
+                nn.Linear(in_dim, 256),
+                nn.BatchNorm1d(256),
+                nn.ReLU(),
+                nn.Dropout(0.2),
+                nn.Linear(256, 128),
+                nn.BatchNorm1d(128),
+                nn.ReLU(),
+                nn.Dropout(0.1),
+                nn.Linear(128, 64),
+                nn.ReLU(),
+            )
+            self.head = nn.Linear(64, 1)
+
+        def forward(self, x):
+            h = self.encoder(x)
+            return self.head(h)
+
+    preprocessor3 = joblib.load("saved_model/preprocessor3.pkl")
+    feature_cols3 = [
+        c
+        for c in df_feature.columns
+        if c
+        not in [
+            "part_id",
+            "refine_needed",
+            "converged",
+            "local_size",
+            "global_size_initial",
+            "global_size_final",
+            "load_id",
+        ]
+    ]
+    X3 = preprocessor3.transform(df_feature[feature_cols3])
+    X3_t = torch.tensor(
+        X3.toarray() if hasattr(X3, "toarray") else X3, dtype=torch.float32
+    )
+
+    model3 = LocalRefineRegressor(X3_t.shape[1])
+    state_dict = torch.load("saved_model/model3.pt", map_location="cpu")
+    model3.load_state_dict(state_dict)
+    model3.eval()
+
+    with torch.no_grad():
+        logits1 = model1(X1_t)
+        probs1 = torch.sigmoid(logits1).cpu().numpy().flatten()
+    df_feature["refine_prob"] = probs1
+
+    top2 = df_feature.sort_values("refine_prob", ascending=False).head(2)
+
+    with torch.no_grad():
+        local_size_pred = model3(X3_t).cpu().numpy().flatten()
+    df_feature["predicted_local_size"] = local_size_pred
+
+    top2_with_local_size = top2.copy()
+    top2_with_local_size["predicted_local_size"] = df_feature.loc[
+        top2.index, "predicted_local_size"
+    ]
+
+    print("Top-2 faces needing refinement and their predicted local sizes:")
+    print(
+        top2_with_local_size[
+            ["face_id", "ftype", "predicted_local_size"]
+        ].to_string(index=False)
+    )
+    df_feature.drop(columns=["refine_prob", "predicted_local_size"], inplace=True)
+
+    # -----------------------------------------------------------------
+    # Model 4: global size regressor
+    # -----------------------------------------------------------------
+    preprocessor4 = joblib.load("saved_model/preprocessor4.pkl")
+
+    feature_cols = [
+        col
+        for col in df_feature.columns
+        if col
+        not in [
+            "part_id",
+            "load_id",
+            "refine_needed",
+            "converged",
+            "local_size",
+            "global_size_initial",
+            "global_size_final",
+        ]
+    ]
+    part_level_cols = [
+        col
+        for col in df_part.columns
+        if col
+        not in [
+            "part_id",
+            "converged",
+            "load_id",
+            "top2_features",
+            "global_size_initial",
+            "global_size_final",
+            "local_refine_needed",
+            "local_size",
+        ]
+    ]
+
+    def extract_supervised_features_model4():
+        part_row_local = df_part.iloc[0]
+        feat_rows = df_feature
+
+        fixed_row = feat_rows[feat_rows.role == "fixed"]
+        if len(fixed_row):
+            X_fixed = preprocessor1.transform(fixed_row[feature_cols])
+            with torch.no_grad():
+                fixed_prob = torch.sigmoid(
+                    model1(torch.tensor(X_fixed, dtype=torch.float32))
+                ).item()
+            fixed_feats = list(fixed_row.iloc[0][feature_cols]) + [fixed_prob]
+        else:
+            fixed_feats = [0] * (len(feature_cols) + 1)
+
+        load_row = feat_rows[feat_rows.role == "load"]
+        if len(load_row):
+            X_load = preprocessor1.transform(load_row[feature_cols])
+            with torch.no_grad():
+                load_prob = torch.sigmoid(
+                    model1(torch.tensor(X_load, dtype=torch.float32))
+                ).item()
+            load_feats = list(load_row.iloc[0][feature_cols]) + [load_prob]
+        else:
+            load_feats = [0] * (len(feature_cols) + 1)
+
+        free_rows = feat_rows[feat_rows.role == "free"]
+        if len(free_rows):
+            X_free = preprocessor1.transform(free_rows[feature_cols])
+            with torch.no_grad():
+                free_probs = torch.sigmoid(
+                    model1(torch.tensor(X_free, dtype=torch.float32))
+                ).cpu().numpy().flatten()
+            best_idx = np.argmax(free_probs)
+            free_feats = (
+                list(free_rows.iloc[best_idx][feature_cols])
+                + [free_probs[best_idx]]
+            )
+        else:
+            free_feats = [0] * (len(feature_cols) + 1)
+
+        global_feats = list(part_row_local[part_level_cols])
+        return fixed_feats + load_feats + free_feats + global_feats
+
+    col_names = (
+        [f"fixed_{c}" for c in feature_cols]
+        + ["fixed_refine_prob"]
+        + [f"load_{c}" for c in feature_cols]
+        + ["load_refine_prob"]
+        + [f"free_{c}" for c in feature_cols]
+        + ["free_refine_prob"]
+        + part_level_cols
+    )
+    row = extract_supervised_features_model4()
+    df_sup = pd.DataFrame([row], columns=col_names)
+
+    missing_cols = set(preprocessor4.feature_names_in_) - set(df_sup.columns)
+    for c in missing_cols:
+        df_sup[c] = 0.0
+    df_sup = df_sup[preprocessor4.feature_names_in_]
+
+    X4 = preprocessor4.transform(df_sup)
+    X4_t = torch.tensor(
+        X4.toarray() if hasattr(X4, "toarray") else X4, dtype=torch.float32
+    )
+
+    class GlobalSizeRegressor(nn.Module):
+        def __init__(self, in_dim):
+            super().__init__()
+            self.encoder = nn.Sequential(
+                nn.Linear(in_dim, 64),
+                nn.BatchNorm1d(64),
+                nn.ReLU(),
+                nn.Dropout(0.2),
+                nn.Linear(64, 32),
+                nn.ReLU(),
+            )
+            self.head = nn.Linear(32, 1)
+
+        def forward(self, x):
+            h = self.encoder(x)
+            return self.head(h)
+
+    model4 = GlobalSizeRegressor(X4_t.shape[1])
+    state_dict = torch.load("saved_model/model4.pt", map_location="cpu")
+    model4.load_state_dict(state_dict)
+    model4.eval()
+
+    with torch.no_grad():
+        pred4 = model4(X4_t).item()
+
+    print("Model 4 (part-level global_size) prediction:")
+    print(f"Predicted global_size_final: {pred4:.4f}")
+
+    # -----------------------------------------------------------------
+    # Human-readable sentence
+    # -----------------------------------------------------------------
+    prob_converged = probs2[0, 1]
+    pred_class = preds2[0]
+    global_size = pred4
+    face1, face2 = top2_with_local_size.itertuples(index=False)
+
+    if prob_converged > 0.7:
+        converge_text = "very likely to converge"
+    elif prob_converged > 0.45:
+        converge_text = "likely to converge"
+    else:
+        converge_text = "unlikely to converge"
+
+    sentence = (
+        f"The model predicts that the simulation is {converge_text} "
+        f"(confidence: {prob_converged:.2%}). "
+        f"To improve accuracy, local refinement will be applied on a {face1.ftype.lower()} (ID {face1.face_id}) "
+        f"and a {face2.ftype.lower()} (ID {face2.face_id}), "
+        f"with predicted mesh sizes {face1.predicted_local_size:.3f} mm and {face2.predicted_local_size:.3f} mm respectively. "
+        f"The overall global mesh size is set to {global_size:.3f} mm."
+    )
+    print(sentence)
+
+    # -----------------------------------------------------------------
+    # Baseline global-only mesh (for PNG)
+    # -----------------------------------------------------------------
+    gmsh.model.mesh.clear()
+    gmsh.option.setNumber("Mesh.Optimize", 1)
+    gmsh.option.setNumber("Mesh.OptimizeNetgen", 1)
+    gmsh.option.setNumber("Mesh.Smoothing", 10)
+    gmsh.option.setNumber("Mesh.Algorithm", 5)
+    gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0)
+    gmsh.option.setNumber("Mesh.MeshSizeFromPoints", 0)
+    gmsh.option.setNumber("Mesh.CharacteristicLengthMin", 0)
+    gmsh.option.setNumber("Mesh.CharacteristicLengthMax", float(global_size))
+
+    gmsh.model.mesh.generate(2)
+    node_tags_b, node_coords_b, _ = gmsh.model.mesh.getNodes()
+    nodes_b = node_coords_b.reshape(-1, 3)
+
+    types_b, elem_tags_list_b, node_tags_list_b = gmsh.model.mesh.getElements(
+        dim=2
+    )
+
+    elements_b = []
+    for etype, ntags in zip(types_b, node_tags_list_b):
+        name, dim, order, nnode, *_ = gmsh.model.mesh.getElementProperties(etype)
+        if nnode in (3, 4):
+            conn = ntags.reshape(-1, nnode).astype(int) - 1
+            elements_b.append((etype, conn))
+
+    plot_mesh(
+        nodes_b,
+        elements_b,
+        title="Baseline Mesh (Global Only)",
+        highlight_faces=None,
+        face_to_nodes=None,
+        save_path="output/mesh_global_only.png",
+    )
+
+    # -----------------------------------------------------------------
+    # Refined mesh with background field
+    # -----------------------------------------------------------------
+    gmsh.model.mesh.clear()
+    gmsh.option.setNumber("Mesh.Optimize", 1)
+    gmsh.option.setNumber("Mesh.OptimizeNetgen", 1)
+    gmsh.option.setNumber("Mesh.Smoothing", 10)
+    gmsh.option.setNumber("Mesh.Algorithm", 5)
+    gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0)
+
+    gmsh.option.setNumber("Mesh.CharacteristicLengthMin", global_size / 4)
+    gmsh.option.setNumber("Mesh.CharacteristicLengthMax", float(global_size))
+
+    face_ids = top2_with_local_size["face_id"].tolist()
+    local_sizes = top2_with_local_size["predicted_local_size"].round(3).tolist()
+
+    # Collect curves for distance
+    curve_ids = []
+    for fid in face_ids:
+        surf = fid - 1
+        boundary = gmsh.model.getBoundary([(2, surf)], oriented=False)
+        for (dim, ctag) in boundary:
+            if dim == 1:
+                curve_ids.append(ctag)
+
+    # Distance field
+    f_dist = gmsh.model.mesh.field.add("Distance")
+    gmsh.model.mesh.field.setNumbers(f_dist, "CurvesList", curve_ids)
+    gmsh.model.mesh.field.setNumber(f_dist, "Sampling", 200)
+
+    # Threshold field
+    min_local = min(local_sizes) * 2
+    f_th = gmsh.model.mesh.field.add("Threshold")
+    gmsh.model.mesh.field.setNumber(f_th, "InField", f_dist)
+    gmsh.model.mesh.field.setNumber(f_th, "SizeMin", float(min_local))
+    gmsh.model.mesh.field.setNumber(f_th, "SizeMax", float(global_size))
+    gmsh.model.mesh.field.setNumber(f_th, "DistMin", 0.0)
+    gmsh.model.mesh.field.setNumber(f_th, "DistMax", global_size * 2.0)
+
+    # Min field (clamped)
+    f_min = gmsh.model.mesh.field.add("Min")
+    gmsh.model.mesh.field.setNumbers(f_min, "FieldsList", [f_th])
+
+    gmsh.model.mesh.field.setAsBackgroundMesh(f_min)
+
+    gmsh.model.occ.synchronize()
+    gmsh.model.mesh.generate(2)
+    gmsh.model.mesh.optimize("Netgen")
+    gmsh.model.occ.synchronize()
+
+    # -----------------------------------------------------------------
+    # Extract FE mesh nodes & triangles (compact indexing)
+    # -----------------------------------------------------------------
+    all_node_tags, all_node_coords, _ = gmsh.model.mesh.getNodes()
+    all_nodes = all_node_coords.reshape(-1, 3)
+
+    types_all, elem_tags_all, elem_nodes_all = gmsh.model.mesh.getElements()
+
+    used_node_tags = np.unique(
+        np.concatenate([arr for arr in elem_nodes_all])
+    )
+    used_idx = used_node_tags - 1
+    nodes_r = all_nodes[used_idx]
+
+    tag_to_new_index = {tag: i for i, tag in enumerate(used_node_tags)}
+
+    triangle_list = []
+    for etype, conn in zip(types_all, elem_nodes_all):
+        name, dim, order, nnode, *_ = gmsh.model.mesh.getElementProperties(etype)
+        if dim != 2:
+            continue
+
+        if nnode == 3:
+            raw = conn.reshape(-1, 3)
+            remapped = np.vectorize(tag_to_new_index.get)(raw)
+            triangle_list.extend(remapped)
+        elif nnode == 4:
+            raw = conn.reshape(-1, 4)
+            remapped = np.vectorize(tag_to_new_index.get)(raw)
+            for quad in remapped:
+                triangle_list.append([quad[0], quad[1], quad[2]])
+                triangle_list.append([quad[0], quad[2], quad[3]])
+
+    triangle_array = np.array(triangle_list, dtype=int)
+
+    print("Triangles extracted:", triangle_array.shape)
+    print("FE MESH NODES:", len(nodes_r))
+    print("FE MESH TRIANGLES:", len(triangle_array))
+
+    # For PNG plotter
+    elements_r = [(0, triangle_array)]
+
+    # -----------------------------------------------------------------
+    # Mapping gmsh surfaces → local node indices (for PNG highlight)
+    # -----------------------------------------------------------------
+    face_to_nodes = {}
+    for (dim, sid) in gmsh.model.getEntities(dim=2):
+        etypes_s, elem_tags_s, ntags_s = gmsh.model.mesh.getElements(
+            dim=2, tag=sid
+        )
+        surface_conn_local = []
+        for etype, ntags in zip(etypes_s, ntags_s):
+            _, _, _, nnode, *_ = gmsh.model.mesh.getElementProperties(etype)
+            if nnode in (3, 4):
+                raw = ntags.reshape(-1, nnode)
+                # map gmsh node tags → compact indices
+                mapped = np.vectorize(tag_to_new_index.get)(raw)
+                surface_conn_local.extend(mapped)
+        face_to_nodes[sid] = surface_conn_local
+
+    highlight_gmsh_ids = [fid - 1 for fid in face_ids]
+
+    # -----------------------------------------------------------------
+    # Local refinement mask (which triangles are "near" refined faces)
+    # -----------------------------------------------------------------
+    refined_nodes_set = set()
+    for sid in highlight_gmsh_ids:
+        if sid in face_to_nodes:
+            for conn in face_to_nodes[sid]:
+                for n in conn:
+                    refined_nodes_set.add(int(n))
+
+    refined_tri_mask = np.zeros(triangle_array.shape[0], dtype=bool)
+    for t_idx, tri in enumerate(triangle_array):
+        if any(int(v) in refined_nodes_set for v in tri):
+            refined_tri_mask[t_idx] = True
+
+    # -----------------------------------------------------------------
+    # Heatmap: per-vertex "local mesh size" (smaller → more refined)
+    # -----------------------------------------------------------------
+    n_nodes = nodes_r.shape[0]
+    n_tris = triangle_array.shape[0]
+
+    tri_sizes = np.zeros(n_tris, dtype=float)
+    for t_idx, (a, b, c) in enumerate(triangle_array):
+        pa, pb, pc = nodes_r[[a, b, c]]
+        area = 0.5 * np.linalg.norm(np.cross(pb - pa, pc - pa))
+        # characteristic length ~ sqrt(area)
+        tri_sizes[t_idx] = np.sqrt(area + 1e-16)
+
+    vertex_sum = np.zeros(n_nodes, dtype=float)
+    vertex_count = np.zeros(n_nodes, dtype=float)
+    for t_idx, tri in enumerate(triangle_array):
+        s = tri_sizes[t_idx]
+        for v in tri:
+            vertex_sum[v] += s
+            vertex_count[v] += 1.0
+
+    vertex_size = vertex_sum / np.maximum(vertex_count, 1.0)
+
+    smin, smax = float(vertex_size.min()), float(vertex_size.max())
+    if smax > smin:
+        # invert so small elements → high intensity
+        vertex_refinement_values = 1.0 - (vertex_size - smin) / (smax - smin)
+    else:
+        vertex_refinement_values = np.zeros_like(vertex_size)
+
+    # -----------------------------------------------------------------
+    # Save refined mesh PNG with red outlines on refined faces
+    # -----------------------------------------------------------------
+    plot_mesh(
+        nodes_r,
+        elements_r,
+        title="Refined Mesh (Local + Global)",
+        highlight_faces=highlight_gmsh_ids,
+        face_to_nodes=face_to_nodes,
+        save_path="output/mesh_refined.png",
+    )
+
+    gmsh.write("output/mesh_refined.msh")
+
+    # -----------------------------------------------------------------
+    # Interactive Plotly figure (wireframe / highlight / heatmap)
+    # -----------------------------------------------------------------
+    interactive_fig = make_plotly_mesh(
+        nodes_r,
+        triangle_array,
+        title="Refined Mesh (Local + Global)",
+        view_mode=view_mode,
+        refined_tri_mask=refined_tri_mask,
+        vertex_refinement_values=vertex_refinement_values,
+    )
+
+    msh_path = "output/mesh_refined.msh"
+    return (
+        sentence,
+        "output/mesh_global_only.png",
+        "output/mesh_refined.png",
+        interactive_fig,
+        msh_path,
+    )

mesh_service/step_feature_detection.py

@@ -0,0 +1,1075 @@
+import math
+import json
+from OCP.STEPControl import STEPControl_Reader
+from OCP.TopAbs import TopAbs_FACE, TopAbs_EDGE, TopAbs_IN, TopAbs_REVERSED, TopAbs_VERTEX
+from OCP.TopExp import TopExp_Explorer, TopExp
+from OCP.TopoDS import TopoDS, TopoDS_Face, TopoDS_Edge
+from OCP.BRepAdaptor import BRepAdaptor_Surface, BRepAdaptor_Curve
+from OCP.BRep import BRep_Tool
+from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane, GeomAbs_Circle, GeomAbs_Line
+from OCP.BRepGProp import BRepGProp
+from OCP.GProp import GProp_GProps
+from OCP.BRepClass3d import BRepClass3d_SolidClassifier
+from OCP.gp import gp_Pnt, gp_Vec
+import numpy as np
+from OCP.Bnd import Bnd_Box
+from OCP.BRepBndLib import BRepBndLib
+from collections import Counter
+
+def face_bbox_center(face):
+    box = Bnd_Box()
+    BRepBndLib.Add_s(face, box)
+    xmin, ymin, zmin, xmax, ymax, zmax = box.Get()
+    return [
+        (xmin + xmax) / 2,
+        (ymin + ymax) / 2,
+        (zmin + zmax) / 2
+    ]
+
+
+def load_step_model(step_path):
+    """Load a STEP file and return the shape object."""
+    reader = STEPControl_Reader()
+    status = reader.ReadFile(step_path)
+    if status != 1:
+        raise RuntimeError(f"Failed to load STEP file: {step_path}")
+    reader.TransferRoot()
+    shape = reader.Shape()
+    return shape
+
+def load_step_unit(step_path):
+    with open(step_path, "r") as f:
+        for line in f:
+            if "SI_UNIT" in line:
+                print("STEP file unit info:", line.strip())
+                return line.strip()
+
+def detect_faces(shape):
+    faces = []
+    exp = TopExp_Explorer(shape, TopAbs_FACE)
+    idx = 0
+    while exp.More():
+        face_shape = exp.Current()
+        face = TopoDS.Face_s(face_shape)
+        surf = BRep_Tool.Surface_s(face)
+        faces.append({"face": face, "surface": surf})
+        idx = idx+1
+        exp.Next()
+    return faces
+
+
+def is_hole(face, shape):
+    """
+    Determine if a cylindrical face is a hole (concave) rather than a boss (convex).
+    Basic approach: check if the face normal points toward the solid interior.
+    """
+    # Get a point and normal on the cylindrical surface
+    adaptor = BRepAdaptor_Surface(face, True)
+    u_min, u_max = adaptor.FirstUParameter(), adaptor.LastUParameter()
+    v_min, v_max = adaptor.FirstVParameter(), adaptor.LastVParameter()
+    u_mid = (u_min + u_max) / 2
+    v_mid = (v_min + v_max) / 2
+    
+    # Get point and normal vector at mid-parameter
+    point = adaptor.Value(u_mid, v_mid)
+    d1u = gp_Vec()
+    d1v = gp_Vec()
+    adaptor.D1(u_mid, v_mid, point, d1u, d1v)
+    
+    # Calculate normal vector (cross product of partial derivatives)
+    normal = d1u.Crossed(d1v)
+    normal.Normalize()
+    
+    # Offset point along normal direction
+    offset = 0.01  # Small offset distance
+    test_point = gp_Pnt(
+        point.X() + normal.X() * offset,
+        point.Y() + normal.Y() * offset,
+        point.Z() + normal.Z() * offset
+    )
+    
+    # Check if the offset point is inside or outside the solid
+    classifier = BRepClass3d_SolidClassifier(shape)
+    classifier.Perform(test_point, 1e-7)
+    
+    # If normal points outward, offset point should be outside -> this is a hole
+    # If normal points outward, offset point is still inside -> this is a boss
+    return classifier.State() == TopAbs_IN
+
+
+def compute_face_angle_span(face, axis_location, axis_direction):
+    axis_loc = np.array(axis_location, dtype=float)
+    axis_dir = np.array(axis_direction, dtype=float)
+    axis_dir = axis_dir / np.linalg.norm(axis_dir)
+    ref = np.array([1.0, 0.0, 0.0], dtype=float)
+    if abs(np.dot(ref, axis_dir)) > 0.9:
+        ref = np.array([0.0, 1.0, 0.0], dtype=float)
+
+    e1 = np.cross(axis_dir, ref)
+    e1 = e1 / np.linalg.norm(e1)
+    e2 = np.cross(axis_dir, e1)
+    e2 = e2 / np.linalg.norm(e2)
+
+    angles = []
+
+    edge_exp = TopExp_Explorer(face, TopAbs_EDGE)
+    while edge_exp.More():
+        edge_shape = edge_exp.Current()
+        vert_exp = TopExp_Explorer(edge_shape, TopAbs_VERTEX)
+        while vert_exp.More():
+            vert_shape = vert_exp.Current()
+            vertex = TopoDS.Vertex_s(vert_shape)
+            p = BRep_Tool.Pnt_s(vertex)
+            v = np.array([p.X(), p.Y(), p.Z()], dtype=float) - axis_loc
+
+            v_proj = v - np.dot(v, axis_dir) * axis_dir
+            norm_v = np.linalg.norm(v_proj)
+            if norm_v < 1e-6:
+                vert_exp.Next()
+                continue
+
+            x = np.dot(v_proj, e1)
+            y = np.dot(v_proj, e2)
+            theta = math.atan2(y, x)
+            angles.append(theta)
+
+            vert_exp.Next()
+        edge_exp.Next()
+
+    if not angles:
+        return 0.0
+
+    angles = np.array(angles)
+    angles = np.mod(angles, 2.0 * math.pi)
+    angles.sort()
+
+    diffs = np.diff(angles)
+    wrap_gap = (angles[0] + 2.0 * math.pi) - angles[-1]
+    max_gap = max(diffs.max(initial=0.0), wrap_gap)
+
+    coverage_rad = 2.0 * math.pi - max_gap
+    coverage_deg = math.degrees(coverage_rad)
+    return float(coverage_deg)
+    
+
+def detect_circular_holes(shape, min_radius=0.5, max_radius=50.0, merge_tolerance=1e-3):
+    """
+    Detect all cylindrical (round) holes, including through-holes and blind holes.
+    Merges faces belonging to the same hole.
+    Returns: List of dicts with center, radius, normal, area, etc.
+    """
+    candidate_faces = []
+    idx = 0
+    
+    for fdict in detect_faces(shape):
+        face = fdict["face"]
+        surf = fdict["surface"]
+        
+        # Check if surface type is cylindrical
+        surface_type = surf.DynamicType().Name()
+        if "Cylindrical" not in surface_type:
+            continue
+        
+        # Use BRepAdaptor_Surface to get cylinder parameters
+        adaptor = BRepAdaptor_Surface(face, True)
+        
+        # Confirm it's a cylinder type
+        if adaptor.GetType() != GeomAbs_Cylinder:
+            continue
+            
+        cylinder = adaptor.Cylinder()
+        radius = cylinder.Radius()
+        
+        # Only consider reasonable hole sizes
+        if not (min_radius <= radius <= max_radius):
+            continue
+        
+        # **Key judgment: check if it's a hole (not a boss)**
+        if not is_hole(face, shape):
+            continue  # Skip bosses/shafts
+        
+        # Get axis direction and location
+        axis_direction = cylinder.Axis().Direction()
+        axis_location = cylinder.Axis().Location()
+        axis_dir_vec = [axis_direction.X(), axis_direction.Y(), axis_direction.Z()]
+        axis_loc_vec = [axis_location.X(), axis_location.Y(), axis_location.Z()]
+        
+        # Calculate surface area and center
+        gprops = GProp_GProps()
+        BRepGProp.SurfaceProperties_s(face, gprops)
+        area = gprops.Mass()
+        center = gprops.CentreOfMass()
+
+        angle_span = compute_face_angle_span(face, axis_loc_vec, axis_dir_vec)
+        
+        candidate_faces.append({
+            "face_id": idx,
+            "face": face,
+            "radius": float(radius),
+            "center": [center.X(), center.Y(), center.Z()],
+            "axis_direction": [axis_direction.X(), axis_direction.Y(), axis_direction.Z()],
+            "axis_location": [axis_location.X(), axis_location.Y(), axis_location.Z()],
+            "area": float(area),
+            "angle_span": float(angle_span)
+        })
+
+        idx = idx+1
+    
+    # Group faces that belong to the same hole
+    holes = merge_coaxial_cylinders(candidate_faces, merge_tolerance)
+    
+    print(f"Detected {len(holes)} circular holes (from {len(candidate_faces)} cylindrical faces)")
+    return holes
+
+
+def merge_coaxial_cylinders(faces, tolerance=1e-3, angle_threshold_deg=350.0):
+    """
+    Merge cylindrical faces that share the same axis (belong to same hole).
+    Two cylinders belong to the same hole if:
+    1. They have the same radius (within tolerance)
+    2. They are coaxial (share the same axis)
+    """
+    if not faces:
+        return []
+    
+    merged_holes = []
+    used = [False] * len(faces)
+    
+    for i, face1 in enumerate(faces):
+        if used[i]:
+            continue
+        
+        # Start a new hole group
+        hole_group = [face1]
+        used[i] = True
+        
+        # Find all faces belonging to the same hole
+        for j, face2 in enumerate(faces):
+            if used[j] or i == j:
+                continue
+            
+            # Check if same radius
+            if abs(face1["radius"] - face2["radius"]) > tolerance:
+                continue
+            
+            # Check if coaxial
+            if are_coaxial(face1, face2, tolerance):
+                hole_group.append(face2)
+                used[j] = True
+        
+        total_angle = sum(f.get("angle_span", 0.0) for f in hole_group)
+        total_angle = min(total_angle, 360)
+        if total_angle < angle_threshold_deg:
+            continue
+        
+        # Compute merged hole properties
+        merged_hole = merge_hole_group(hole_group, i)
+        merged_holes.append(merged_hole)
+    
+    return merged_holes
+
+
+def are_coaxial(face1, face2, tolerance=1e-3):
+    """
+    Check if two cylindrical faces are coaxial (share the same axis).
+    """
+    import numpy as np
+    
+    # Get axis directions
+    dir1 = np.array(face1["axis_direction"])
+    dir2 = np.array(face2["axis_direction"])
+    
+    # Normalize
+    dir1 = dir1 / np.linalg.norm(dir1)
+    dir2 = dir2 / np.linalg.norm(dir2)
+    
+    # Check if parallel (dot product close to ±1)
+    dot_product = abs(np.dot(dir1, dir2))
+    if abs(dot_product - 1.0) > tolerance:
+        return False
+    
+    # Check if axes are coincident
+    # Distance from point on axis1 to axis2
+    loc1 = np.array(face1["axis_location"])
+    loc2 = np.array(face2["axis_location"])
+    
+    # Vector from loc1 to loc2
+    vec = loc2 - loc1
+    
+    # Distance from loc2 to axis1 (perpendicular distance)
+    distance = np.linalg.norm(vec - np.dot(vec, dir1) * dir1)
+    
+    return distance < tolerance
+
+
+def merge_hole_group(hole_group, id):
+    """
+    Merge multiple faces belonging to the same hole into one hole feature,
+    and record all involved faces for downstream mapping.
+    """
+    import numpy as np
+
+    representative = hole_group[0]
+    total_area = sum(face["area"] for face in hole_group)
+
+    centers = np.array([face["center"] for face in hole_group])
+    areas = np.array([face["area"] for face in hole_group])
+    avg_center = np.average(centers, axis=0, weights=areas)
+
+    # Clean up floating point errors
+    avg_center = np.round(avg_center, decimals=6)
+    faces_info = [
+        {
+            "face_id": face.get("face_id"),
+            "center": [round(x, 6) for x in face["center"]],
+            "area": round(face["area"], 6),
+            "angle_span": round(face.get("angle_span", 0.0), 4),
+            "normal": [round(x, 6) for x in face.get("normal", [0,0,0])]
+        }
+        for face in hole_group
+    ]
+
+    return {
+        "name": f"CIRC_HOLE_{id}",
+        "type": "circular_hole",
+        "radius": round(representative["radius"], 6),
+        "center": avg_center.tolist(),
+        "normal": representative["axis_direction"],
+        "area": round(total_area, 6),
+        "num_faces": len(hole_group),
+        "faces": faces_info
+    }
+
+
+
+def detect_non_circular_holes(shape, min_area=1.0, max_area=1000.0, distance_threshold=10.0):
+    """
+    Detect non-circular holes (rectangular holes, slots, elongated holes).
+    Strategy: Find groups of planar faces that form a closed pocket.
+    """
+    result = []
+    planar_faces = []
+    
+    # 1. Collect all planar faces that might be part of a hole
+    for fdict in detect_faces(shape):
+        face = fdict["face"]
+        surf = fdict["surface"]
+        
+        surface_type = surf.DynamicType().Name()
+        if "Plane" not in surface_type:
+            continue
+        
+        # Check if this plane is a hole (concave)
+        if not is_hole(face, shape):
+            continue
+        
+        # Get face properties
+        adaptor = BRepAdaptor_Surface(face, True)
+        
+        # Confirm it's a plane type
+        if adaptor.GetType() != GeomAbs_Plane:
+            continue
+        
+        plane = adaptor.Plane()
+        normal = plane.Axis().Direction()
+        
+        gprops = GProp_GProps()
+        BRepGProp.SurfaceProperties_s(face, gprops)
+        area = gprops.Mass()
+        center = gprops.CentreOfMass()
+        
+        # Filter by area
+        if not (min_area <= area <= max_area):
+            continue
+        
+        planar_faces.append({
+            "face": face,
+            "center": [center.X(), center.Y(), center.Z()],
+            "normal": [normal.X(), normal.Y(), normal.Z()],
+            "area": float(area)
+        })
+    
+    # 2. Group adjacent planar faces that might form a hole
+    holes = group_planar_holes(planar_faces, distance_threshold)
+    
+    # 3. Classify hole type (rectangular, slot, etc.)
+    for hole_group in holes:
+        hole_type = classify_planar_hole(hole_group)
+        result.append(hole_type)
+    
+    print(f"Detected {len(result)} non-circular holes (from {len(planar_faces)} planar faces)")
+    return result
+
+
+def group_planar_holes(faces, distance_threshold=10.0):
+    """
+    Group planar faces that are close to each other and might form a hole.
+    """
+    if not faces:
+        return []
+    
+    groups = []
+    used = [False] * len(faces)
+    
+    for i, face1 in enumerate(faces):
+        if used[i]:
+            continue
+        
+        # Start a new group
+        group = [face1]
+        used[i] = True
+        
+        # Find nearby faces with similar normal direction
+        for j, face2 in enumerate(faces):
+            if used[j] or i == j:
+                continue
+            
+            # Check if normals are similar (parallel faces)
+            normal1 = np.array(face1["normal"])
+            normal2 = np.array(face2["normal"])
+            
+            # Normalize
+            normal1 = normal1 / np.linalg.norm(normal1)
+            normal2 = normal2 / np.linalg.norm(normal2)
+            
+            dot = abs(np.dot(normal1, normal2))
+            
+            if dot > 0.9:  # Nearly parallel
+                # Check distance between centers
+                center1 = np.array(face1["center"])
+                center2 = np.array(face2["center"])
+                distance = np.linalg.norm(center2 - center1)
+                
+                if distance < distance_threshold:
+                    group.append(face2)
+                    used[j] = True
+        
+        groups.append(group)
+    
+    return groups
+
+
+def classify_planar_hole(face_group):
+    """
+    Classify a group of planar faces into hole types.
+    Simple classification based on number of faces and geometry.
+    """
+    num_faces = len(face_group)
+    
+    # Calculate total area and average center
+    total_area = sum(f["area"] for f in face_group)
+    centers = np.array([f["center"] for f in face_group])
+    avg_center = np.mean(centers, axis=0)
+    
+    # Use the first face's normal as representative
+    representative_normal = face_group[0]["normal"]
+    
+    # Simple classification based on number of faces
+    if num_faces == 1:
+        hole_type = "simple_pocket"
+    elif num_faces == 4:
+        hole_type = "rectangular_hole"
+    elif num_faces == 2:
+        hole_type = "slot"
+    elif num_faces >= 5:
+        hole_type = "complex_pocket"
+    else:
+        hole_type = "irregular_hole"
+    
+    return {
+        "type": hole_type,
+        "center": np.round(avg_center, 6).tolist(),
+        "normal": representative_normal,
+        "area": round(total_area, 6),
+        "num_faces": num_faces
+    }
+
+def detect_fillets(shape, min_radius=0.1, max_radius=50.0,
+                   classify_type=True, hole_merge_tolerance=1e-3,
+                   fillet_merge_tolerance=1e-3,
+                   min_total_angle_deg=3.0,
+                   max_total_angle_deg=330.0):
+    hole_features = detect_circular_holes(
+        shape,
+        min_radius=min_radius,
+        max_radius=max_radius,
+        merge_tolerance=hole_merge_tolerance
+    )
+
+    hole_cylinders = []
+    for h in hole_features:
+        hole_cylinders.append({
+            "radius": h["radius"],
+            "axis_direction": h["normal"],
+            "axis_location": h["center"],
+        })
+
+    fillet_candidates = []
+    face_idx = 0
+
+    for fdict in detect_faces(shape):
+        face = fdict["face"]
+        surf = fdict["surface"]
+
+        surface_type = surf.DynamicType().Name()
+        if "Cylindrical" not in surface_type:
+            continue
+
+        adaptor = BRepAdaptor_Surface(face, True)
+        if adaptor.GetType() != GeomAbs_Cylinder:
+            continue
+
+        cylinder = adaptor.Cylinder()
+        radius = cylinder.Radius()
+
+        if not (min_radius <= radius <= max_radius):
+            continue
+
+        axis_direction = cylinder.Axis().Direction()
+        axis_location = cylinder.Axis().Location()
+        axis_dir_vec = [axis_direction.X(), axis_direction.Y(), axis_direction.Z()]
+        axis_loc_vec = [axis_location.X(), axis_location.Y(), axis_location.Z()]
+
+        is_on_hole_cylinder = False
+        for hc in hole_cylinders:
+            if abs(hc["radius"] - radius) > hole_merge_tolerance:
+                continue
+
+            if are_coaxial(
+                hc,
+                {"axis_direction": axis_dir_vec, "axis_location": axis_loc_vec},
+                tolerance=hole_merge_tolerance,
+            ):
+                is_on_hole_cylinder = True
+                break
+
+        if is_on_hole_cylinder:
+            continue
+
+        gprops = GProp_GProps()
+        BRepGProp.SurfaceProperties_s(face, gprops)
+        area = gprops.Mass()
+        center = gprops.CentreOfMass()
+
+        if not is_fillet_surface(face, shape, radius, area,
+                                 full_angle_threshold_deg=330.0,
+                                 min_angle_threshold_deg=3.0):
+            continue
+
+        angle_span = compute_face_angle_span(face, axis_loc_vec, axis_dir_vec)
+
+        if classify_type:
+            if is_internal_fillet(face, shape):
+                fillet_type = "internal_fillet"
+            else:
+                fillet_type = "external_fillet"
+        else:
+            fillet_type = "fillet"
+
+        fillet_candidates.append({
+            "face_id": face_idx,
+            "face": face,
+            "name": f"FILLET_FACE_{face_idx}",
+            "type": fillet_type,
+            "radius": float(radius),
+            "center": [center.X(), center.Y(), center.Z()],
+            "axis_direction": axis_dir_vec,
+            "axis_location": axis_loc_vec,
+            "area": float(area),
+            "angle_span": float(angle_span),
+        })
+
+        face_idx += 1
+
+    merged_fillets = merge_coaxial_fillets(
+        fillet_candidates,
+        tolerance=fillet_merge_tolerance,
+        min_total_angle_deg=min_total_angle_deg,
+        max_total_angle_deg=max_total_angle_deg,
+    )
+
+    print(f"Detected {len(merged_fillets)} fillet features (from {len(fillet_candidates)} cylindrical faces)")
+
+    return merged_fillets
+
+
+def is_fillet_surface(face, shape, radius, area,
+                      full_angle_threshold_deg=330.0,
+                      min_angle_threshold_deg=3.0):
+
+    adaptor = BRepAdaptor_Surface(face, True)
+    if adaptor.GetType() != GeomAbs_Cylinder:
+        return False
+
+    cylinder = adaptor.Cylinder()
+    axis_direction = cylinder.Axis().Direction()
+    axis_location = cylinder.Axis().Location()
+
+    axis_dir_vec = [axis_direction.X(), axis_direction.Y(), axis_direction.Z()]
+    axis_loc_vec = [axis_location.X(), axis_location.Y(), axis_location.Z()]
+
+    angle_span = compute_face_angle_span(face, axis_loc_vec, axis_dir_vec)
+
+    if angle_span >= full_angle_threshold_deg:
+        return False
+
+    if angle_span <= min_angle_threshold_deg:
+        return False
+
+    return True
+
+
+def is_internal_fillet(face, shape):
+    """
+    Determine if a cylindrical fillet is internal (concave) or external (convex)
+    WITHOUT using adaptor.Normal (which does not exist).
+
+    Method:
+      - Get point P(u,v) on surface
+      - Compute radial direction = (P - axis_location) - projection onto axis_dir
+      - Normal = normalized radial direction
+      - Offset P slightly along normal, test if inside solid
+    """
+    adaptor = BRepAdaptor_Surface(face, True)
+
+    # Must be cylinder
+    if adaptor.GetType() != GeomAbs_Cylinder:
+        return False
+
+    cylinder = adaptor.Cylinder()
+
+    # Cylinder axis
+    axis = cylinder.Axis()
+    axis_loc = axis.Location()
+    axis_dir = axis.Direction()
+    axis_dir_vec = gp_Vec(axis_dir.X(), axis_dir.Y(), axis_dir.Z())
+    axis_dir_vec.Normalize()
+
+    # Pick midpoint parameter
+    u_min, u_max = adaptor.FirstUParameter(), adaptor.LastUParameter()
+    v_min, v_max = adaptor.FirstVParameter(), adaptor.LastVParameter()
+    u_mid = 0.5 * (u_min + u_max)
+    v_mid = 0.5 * (v_min + v_max)
+
+    # Point on surface
+    p = adaptor.Value(u_mid, v_mid)
+
+    # Compute radial vector: r = (p - axis_loc) - projection onto axis_dir
+    vec_p_axis = gp_Vec(p.X() - axis_loc.X(),
+                        p.Y() - axis_loc.Y(),
+                        p.Z() - axis_loc.Z())
+    # Projection length
+    proj_len = vec_p_axis.Dot(axis_dir_vec)
+    # Projection vector
+    proj_vec = gp_Vec(axis_dir_vec.X() * proj_len,
+                      axis_dir_vec.Y() * proj_len,
+                      axis_dir_vec.Z() * proj_len)
+    # Radial direction (perpendicular to axis)
+    radial_vec = gp_Vec(vec_p_axis.X() - proj_vec.X(),
+                        vec_p_axis.Y() - proj_vec.Y(),
+                        vec_p_axis.Z() - proj_vec.Z())
+    radial_vec.Normalize()
+
+    # Normal = radial direction
+    normal = radial_vec
+
+    # Offset point slightly along normal
+    offset = 1e-4
+    offset_p = gp_Pnt(p.X() + normal.X() * offset,
+                      p.Y() + normal.Y() * offset,
+                      p.Z() + normal.Z() * offset)
+
+    # Test whether it's inside
+    classifier = BRepClass3d_SolidClassifier(shape)
+    classifier.Perform(offset_p, 1e-7)
+
+    # If offset point is inside → normal pointing inward → concave fillet
+    return classifier.State() == TopAbs_IN
+
+
+def merge_coaxial_fillets(faces, tolerance=1e-3,
+                          min_total_angle_deg=3.0,
+                          max_total_angle_deg=330.0):
+    if not faces:
+        return []
+
+    import numpy as np
+
+    merged_fillets = []
+    used = [False] * len(faces)
+
+    for i, f1 in enumerate(faces):
+        if used[i]:
+            continue
+
+        group = [f1]
+        used[i] = True
+
+        for j, f2 in enumerate(faces):
+            if used[j] or i == j:
+                continue
+            if f1.get("type") != f2.get("type"):
+                continue
+
+            if abs(f1["radius"] - f2["radius"]) > tolerance:
+                continue
+
+            if not are_coaxial(f1, f2, tolerance=tolerance):
+                continue
+
+            group.append(f2)
+            used[j] = True
+
+        total_angle = sum(g.get("angle_span", 0.0) for g in group)
+        total_angle = min(total_angle, 360.0)
+
+        if total_angle < min_total_angle_deg:
+            continue
+
+        if total_angle > max_total_angle_deg:
+            continue
+
+        merged = merge_fillet_coaxial_group(group, len(merged_fillets), total_angle)
+        merged_fillets.append(merged)
+
+    return merged_fillets
+
+
+def merge_fillet_coaxial_group(fillet_group, group_index, total_angle):
+    if not fillet_group:
+        return {}
+
+    areas = np.array([f["area"] for f in fillet_group], dtype=float)
+    radii = np.array([f["radius"] for f in fillet_group], dtype=float)
+    centers = np.array([f["center"] for f in fillet_group], dtype=float)
+    axis_dirs = np.array([f["axis_direction"] for f in fillet_group], dtype=float)
+    axis_locs = np.array([f["axis_location"] for f in fillet_group], dtype=float)
+
+    total_area = float(areas.sum()) if areas.size > 0 else 0.0
+
+    if total_area > 0:
+        avg_center = (centers * areas[:, None]).sum(axis=0) / total_area
+        avg_radius = float((radii * areas).sum() / total_area)
+        avg_axis_dir = (axis_dirs * areas[:, None]).sum(axis=0) / total_area
+        avg_axis_loc = (axis_locs * areas[:, None]).sum(axis=0) / total_area
+    else:
+        avg_center = centers.mean(axis=0)
+        avg_radius = float(radii.mean())
+        avg_axis_dir = axis_dirs.mean(axis=0)
+        avg_axis_loc = axis_locs.mean(axis=0)
+
+    norm = np.linalg.norm(avg_axis_dir)
+    if norm > 0:
+        avg_axis_dir = avg_axis_dir / norm
+
+    avg_center = np.round(avg_center, 6)
+    avg_axis_dir = np.round(avg_axis_dir, 6)
+    avg_axis_loc = np.round(avg_axis_loc, 6)
+
+    faces_info = [
+        {
+            "face_id": f.get("face_id"),
+            "center": [round(x, 6) for x in f["center"]],
+            "area": round(f["area"], 6),
+            "angle_span": round(f.get("angle_span", 0.0), 4),
+            "normal": [round(x, 6) for x in f.get("axis_direction", avg_axis_dir.tolist())],
+        }
+        for f in fillet_group
+    ]
+
+    fillet_type = fillet_group[0].get("type", "fillet")
+
+    return {
+        "name": f"FILLET_{group_index}",
+        "type": fillet_type,
+        "radius": round(avg_radius, 6),
+        "center": [float(x) for x in avg_center],
+        "normal": [float(x) for x in avg_axis_dir],
+        "axis_direction": [float(x) for x in avg_axis_dir],
+        "axis_location": [float(x) for x in avg_axis_loc],
+        "area": round(total_area, 6),
+        "num_faces": len(fillet_group),
+        "total_angle": round(float(total_angle), 4),
+        "faces": faces_info,
+    }
+
+
+
+# def classify_fillets_by_size(fillets):
+#     """
+#     Classify fillets into categories based on radius for FEA mesh refinement.
+#     """
+#     classification = {
+#         "small": [],    # R < 2mm - need very fine mesh
+#         "medium": [],   # 2mm <= R < 5mm - need fine mesh
+#         "large": []     # R >= 5mm - standard mesh
+#     }
+    
+#     for fillet in fillets:
+#         radius = fillet["radius"]
+#         if radius < 2.0:
+#             classification["small"].append(fillet)
+#         elif radius < 5.0:
+#             classification["medium"].append(fillet)
+#         else:
+#             classification["large"].append(fillet)
+    
+#     print(f"\nFillet Classification:")
+#     print(f"  Small fillets (R<2mm): {len(classification['small'])}")
+#     print(f"  Medium fillets (2-5mm): {len(classification['medium'])}")
+#     print(f"  Large fillets (R>5mm): {len(classification['large'])}")
+    
+#     return classification
+
+def detect_thickness(shape, sample_density=3, min_thickness=0.01, max_thickness=100.0):
+    from OCP.BRepClass3d import BRepClass3d_SolidClassifier
+    from OCP.gp import gp_Pnt
+    thickness_results = []
+    exp = TopExp_Explorer(shape, TopAbs_FACE)
+    classifier = BRepClass3d_SolidClassifier(shape)
+    while exp.More():
+        face_shape = exp.Current()
+        face = TopoDS.Face_s(face_shape)
+        adaptor = BRepAdaptor_Surface(face, True)
+        umin, umax = adaptor.FirstUParameter(), adaptor.LastUParameter()
+        vmin, vmax = adaptor.FirstVParameter(), adaptor.LastVParameter()
+        for i in range(sample_density):
+            for j in range(sample_density):
+                u = umin + (umax - umin) * i / (sample_density - 1)
+                v = vmin + (vmax - vmin) * j / (sample_density - 1)
+                pnt = adaptor.Value(u, v)
+
+                p = gp_Pnt()
+                du = gp_Vec()
+                dv = gp_Vec()
+                adaptor.D1(u, v, p, du, dv)
+
+                normal_vec = du.Crossed(dv)
+                normal_vec.Normalize()
+                if normal_vec.Magnitude() < 1e-8:
+                    continue
+                normal_vec.Normalize()
+                thickness = shoot_ray_find_thickness(
+                    shape, pnt, normal_vec, min_thickness, max_thickness
+                )
+                if thickness:
+                    thickness_results.append({
+                        "point": [pnt.X(), pnt.Y(), pnt.Z()],
+                        "normal": [normal_vec.X(), normal_vec.Y(), normal_vec.Z()],
+                        "thickness": thickness
+                    })
+        exp.Next()
+    return thickness_results
+
+def shoot_ray_find_thickness(shape, point, normal, min_thickness, max_thickness):
+    from OCP.gp import gp_Pnt, gp_Vec
+    from OCP.BRepClass3d import BRepClass3d_SolidClassifier
+
+    step = min_thickness / 2
+    max_dist = max_thickness
+    for dist in np.arange(step, max_dist, step):
+        test_point = gp_Pnt(
+            point.X() + normal.X() * dist,
+            point.Y() + normal.Y() * dist,
+            point.Z() + normal.Z() * dist,
+        )
+        classifier = BRepClass3d_SolidClassifier(shape)
+        classifier.Perform(test_point, 1e-7)
+        if classifier.State() != TopAbs_IN:
+            pos_thick = dist
+            break
+    else:
+        pos_thick = max_dist
+    for dist in np.arange(step, max_dist, step):
+        test_point = gp_Pnt(
+            point.X() - normal.X() * dist,
+            point.Y() - normal.Y() * dist,
+            point.Z() - normal.Z() * dist,
+        )
+        classifier = BRepClass3d_SolidClassifier(shape)
+        classifier.Perform(test_point, 1e-7)
+        if classifier.State() != TopAbs_IN:
+            neg_thick = dist
+            break
+    else:
+        neg_thick = max_dist
+    return pos_thick + neg_thick
+
+def mode_thickness(shape, decimal=2, threshold=0.1):
+    thickness_results = detect_thickness(shape, sample_density=3, min_thickness=0.01, max_thickness=100.0)
+    vals = [round(float(r['thickness']), decimal) for r in thickness_results if float(r['thickness']) >= threshold]
+    counter = Counter(vals)
+    mode_val, count = counter.most_common(1)[0]
+    return mode_val
+
+def detect_all_edges(shape):
+    """
+    Detect all UNIQUE edges shared by two faces.
+    Stores: name, start point, end point, angle, normals, type.
+    """
+
+    # 1. Collect all faces
+    faces = []
+    face_exp = TopExp_Explorer(shape, TopAbs_FACE)
+    while face_exp.More():
+        faces.append(TopoDS.Face_s(face_exp.Current()))
+        face_exp.Next()
+
+    results = []
+    seen = set()      # edge deduplication via TShape()
+    idx = 0           # MUST initialize once
+
+    # 2. Iterate edges
+    edge_exp = TopExp_Explorer(shape, TopAbs_EDGE)
+    while edge_exp.More():
+        edge = TopoDS.Edge_s(edge_exp.Current())
+
+        # --- dedup by underlying TShape ---
+        tid = hash(edge.TShape())
+        if tid in seen:
+            edge_exp.Next()
+            continue
+        seen.add(tid)
+
+        # --- find adjacent faces ---
+        adjacent_faces = []
+        for face in faces:
+            ex2 = TopExp_Explorer(face, TopAbs_EDGE)
+            while ex2.More():
+                if ex2.Current().IsSame(edge):
+                    adjacent_faces.append(face)
+                    break
+                ex2.Next()
+
+        if len(adjacent_faces) != 2:
+            edge_exp.Next()
+            continue
+
+        # --- compute normals & dihedral angle ---
+        normals = []
+        for face in adjacent_faces:
+            adaptor = BRepAdaptor_Surface(face, True)
+            u = 0.5 * (adaptor.FirstUParameter() + adaptor.LastUParameter())
+            v = 0.5 * (adaptor.FirstVParameter() + adaptor.LastVParameter())
+            du = gp_Vec()
+            dv = gp_Vec()
+            temp_p = gp_Pnt()
+            adaptor.D1(u, v, temp_p, du, dv)
+            n = du.Crossed(dv)
+            if n.Magnitude() > 1e-6:
+                n.Normalize()
+                normals.append(n)
+            else:
+                normals.append(None)
+
+        if None in normals:
+            edge_exp.Next()
+            continue
+
+        # angle
+        import numpy as np
+        dot = np.clip(normals[0].Dot(normals[1]), -1.0, 1.0)
+        angle_deg = float(np.degrees(np.arccos(dot)))
+
+        # skip perfectly smooth edges
+        if abs(angle_deg - 180.0) < 1e-3:
+            edge_exp.Next()
+            continue
+
+        # --- get start / end points ---
+        verts = []
+        vexp = TopExp_Explorer(edge, TopAbs_VERTEX)
+        while vexp.More():
+            v = TopoDS.Vertex_s(vexp.Current())
+            p = BRep_Tool.Pnt_s(v)
+            verts.append([p.X(), p.Y(), p.Z()])
+            vexp.Next()
+
+        if len(verts) < 2:
+            edge_exp.Next()
+            continue
+
+        start = verts[0]
+        end   = verts[-1]
+
+        # --- classify edge type ---
+        curve_adaptor = BRepAdaptor_Curve(edge)
+        from OCP.GeomAbs import GeomAbs_Line, GeomAbs_Circle
+        t = curve_adaptor.GetType()
+
+        if t == GeomAbs_Line:
+            e_type = "line"
+        elif t == GeomAbs_Circle:
+            e_type = "circle"
+        else:
+            e_type = "other"
+
+        # --- store result ---
+        results.append({
+            "name": f"EDGE_{idx}",
+            "start": start,
+            "end": end,
+            "angle": angle_deg,
+            "normals": [
+                [normals[0].X(), normals[0].Y(), normals[0].Z()],
+                [normals[1].X(), normals[1].Y(), normals[1].Z()]
+            ],
+            "edge_type": e_type
+        })
+
+        idx += 1      # safe!
+
+        edge_exp.Next()
+
+    return results
+
+
+
+
+def detect_all_faces(shape):
+    faces = []
+    face_exp = TopExp_Explorer(shape, TopAbs_FACE)
+    face_id = 0
+
+    while face_exp.More():
+        face_shape = face_exp.Current()
+        face = TopoDS.Face_s(face_shape)
+
+        adaptor = BRepAdaptor_Surface(face, True)
+
+        # sample param
+        umin, umax = adaptor.FirstUParameter(), adaptor.LastUParameter()
+        vmin, vmax = adaptor.FirstVParameter(), adaptor.LastVParameter()
+        u = (umin + umax) * 0.5
+        v = (vmin + vmax) * 0.5
+
+        # center
+        
+
+        # normal
+        du = gp_Vec()
+        dv = gp_Vec()
+        temp_p = gp_Pnt()
+        adaptor.D1(u, v, temp_p, du, dv)
+        normal = du.Crossed(dv)
+        if normal.Magnitude() > 1e-8:
+            normal.Normalize()
+
+        # --- NEW: compute area ---
+        gprops = GProp_GProps()
+        BRepGProp.SurfaceProperties_s(face, gprops)
+        area = gprops.Mass()
+        center = face_bbox_center(face)
+
+        faces.append({
+            "name": f"FACE_{face_id}",
+            "face_id": face_id,
+            "center": center,
+            "normal": [normal.X(), normal.Y(), normal.Z()],
+            "area": float(area)     # ← added
+        })
+
+        face_id += 1
+        face_exp.Next()
+
+    return faces