def collect_interface(edge, face):
surface = BRepAdaptor_Surface(face)
curve2d = BRepAdaptor_Curve2d(edge, face)
fp = curve2d.FirstParameter()
lp = curve2d.LastParameter()
return surface, curve2d, fp, lp
def collect_interface(edge, face):
surface = BRepAdaptor_Surface(face)
curve2d = BRepAdaptor_Curve2d(edge, face)
curve3d = BRepAdaptor_Curve(edge)
fp = curve2d.FirstParameter()
lp = curve2d.LastParameter()
assert fp == curve3d.FirstParameter()
assert lp == curve3d.LastParameter()
p_length = lp - fp
return surface, curve2d, curve3d, fp, lp, p_length
def compute_halfway_on_shared_edge(sv0, sv1):
def get_shared_edge(sv0, sv1):
for sv0_edge_with_p in sv0.edges_with_p:
sv0_edge, sv0_p = sv0_edge_with_p
for sv1_edge_with_p in sv1.edges_with_p:
sv1_edge, sv1_p = sv1_edge_with_p
if sv0_edge == sv1_edge:
u0 = min(sv0_p, sv1_p)
u1 = max(sv0_p, sv1_p)
return sv0_edge, u0, u1
return None, -1, -1
assert sv0.face_id == sv1.face_id
assert not sv0.edges_with_p is None
assert not sv1.edges_with_p is None
shared_edge, u0, u1 = get_shared_edge(sv0, sv1)
if shared_edge is None:
raise Exception(
'compute_halfway_on_shared_edge() error - no shared edge')
curve = BRepAdaptor_Curve2d(shared_edge, sv0.face)
u01_length = GCPnts_AbscissaPoint.Length(curve, u0, u1)
abscissa_point = GCPnts_AbscissaPoint(curve, u01_length / 2, u0)
assert abscissa_point.IsDone()
p = abscissa_point.Parameter()
uv = curve.Value(p)
xyz = BRepAdaptor_Surface(sv0.face).Value(uv.X(), uv.Y())
sv_halfway = SuperVertex(x=xyz.X(),
y=xyz.Y(),
z=xyz.Z(),
u=uv.X(),
v=uv.Y())
sv_halfway.face_id = sv0.face_id
sv_halfway.face = sv0.face
sv_halfway.edges_with_p = [(shared_edge, p)]
if sv0.face.Orientation() == TopAbs_REVERSED:
sv_halfway.reverse_u()
return sv_halfway
def extract_trims_curves(self):
# Read in the Trim Curves
trim_curves = []
trims = ShapeAnalysis_FreeBoundsProperties(self.face)
trims.Perform()
num_loops = trims.NbClosedFreeBounds()
num_open_loops = trims.NbOpenFreeBounds()
if num_open_loops > 0:
print('Warning: Face has open boundaries')
for n_boundary in range(num_loops):
boundary_data = trims.ClosedFreeBound(n_boundary + 1)
boundary_wire = boundary_data.FreeBound()
loop = []
c_id = 1
top_ex = TopExp_Explorer(boundary_wire, TopAbs_EDGE)
while (top_ex.More()):
edge = topods.Edge(top_ex.Current())
curve_adapter = BRepAdaptor_Curve2d(edge, self.face)
curve_factory = CurveFactory()
if curve_factory is not None:
c = curve_factory.create_curve_object(
curve_adapter, self.face, self.surf, c_id)
curve = c.extract_curve_data(self.f_id)
c_id = c_id + 1
if curve is None:
continue
loop.append(curve)
top_ex.Next()
# nurbs_surface.trim_curves.append(loop)
trim_curves.append(loop)
trim_dict = {}
trim_dict['count'] = len(trim_curves)
trim_dict['data'] = []
for loop in trim_curves:
trim_dict['data'].append(loop)
return trim_dict
def mesh_model(model, res_path, convert=True, all_edges=True):
fil = model.split("/")[-1][:-5]
folder = "/".join(model.split("/")[:-1])
with fileinput.FileInput(model, inplace=True) as fi:
for line in fi:
print(line.replace(
"UNCERTAINTY_MEASURE_WITH_UNIT( LENGTH_MEASURE( 1.00000000000000E-06 )",
"UNCERTAINTY_MEASURE_WITH_UNIT( LENGTH_MEASURE( 1.00000000000000E-17 )"
),
end='')
occ_steps = read_step_file(model)
bt = BRep_Tool()
for occ_cnt in range(len(occ_steps)):
if convert:
try:
nurbs_converter = BRepBuilderAPI_NurbsConvert(
occ_steps[occ_cnt])
nurbs_converter.Perform(occ_steps[occ_cnt])
nurbs = nurbs_converter.Shape()
except:
print("Conversion failed")
continue
else:
nurbs = occ_steps[occ_cnt]
mesh = BRepMesh_IncrementalMesh(occ_steps[occ_cnt], 0.9, False, 0.5,
True)
mesh.Perform()
if not mesh.IsDone():
print("Mesh is not done.")
continue
occ_topo = TopologyExplorer(nurbs)
occ_top = Topo(nurbs)
occ_topo1 = TopologyExplorer(occ_steps[occ_cnt])
occ_top1 = Topo(occ_steps[occ_cnt])
d1_feats = []
d2_feats = []
t_curves = []
tr_curves = []
stats = {}
stats["model"] = model
total_edges = 0
total_surfs = 0
stats["curves"] = []
stats["surfs"] = []
c_cnt = 0
t_cnt = 0
# Iterate over edges
for edge in occ_topo.edges():
curve = BRepAdaptor_Curve(edge)
stats["curves"].append(edge_map[curve.GetType()])
d1_feat = convert_curve(curve)
if edge_map[curve.GetType()] == "Other":
continue
for f in occ_top.faces_from_edge(edge):
if f == None:
print("Broken face")
continue
su = BRepAdaptor_Surface(f)
c = BRepAdaptor_Curve2d(edge, f)
t_curve = {
"surface": f,
"3dcurve": edge,
"3dcurve_id": c_cnt,
"2dcurve_id": t_cnt
}
t_curves.append(t_curve)
tr_curves.append(convert_2dcurve(c))
t_cnt += 1
d1_feats.append(d1_feat)
c_cnt += 1
total_edges += 1
patches = []
faces1 = list(occ_topo1.faces())
# Iterate over faces
for fci, face in enumerate(occ_topo.faces()):
surf = BRepAdaptor_Surface(face)
stats["surfs"].append(surf_map[surf.GetType()])
d2_feat = convert_surface(surf)
if surf_map[surf.GetType()] == "Other":
continue
for tc in t_curves:
if tc["surface"] == face:
patch = {
"3dcurves": [],
"2dcurves": [],
"orientations": [],
"surf_orientation": face.Orientation(),
"wire_ids": [],
"wire_orientations": []
}
for wc, fw in enumerate(occ_top.wires_from_face(face)):
patch["wire_orientations"].append(fw.Orientation())
if all_edges:
edges = [
i for i in WireExplorer(fw).ordered_edges()
]
else:
edges = list(occ_top.edges_from_wire(fw))
for fe in edges:
for ttc in t_curves:
if ttc["3dcurve"].IsSame(fe) and tc[
"surface"] == ttc["surface"]:
patch["3dcurves"].append(ttc["3dcurve_id"])
patch["2dcurves"].append(ttc["2dcurve_id"])
patch["wire_ids"].append(wc)
orientation = fe.Orientation()
patch["orientations"].append(orientation)
patches.append(patch)
break
location = TopLoc_Location()
facing = (bt.Triangulation(faces1[fci], location))
if facing != None:
tab = facing.Nodes()
tri = facing.Triangles()
verts = []
for i in range(1, facing.NbNodes() + 1):
verts.append(list(tab.Value(i).Coord()))
faces = []
for i in range(1, facing.NbTriangles() + 1):
index1, index2, index3 = tri.Value(i).Get()
faces.append([index1 - 1, index2 - 1, index3 - 1])
os.makedirs(res_path, exist_ok=True)
igl.write_triangle_mesh(
"%s/%s_%03i_mesh_%04i.obj" % (res_path, fil, occ_cnt, fci),
np.array(verts), np.array(faces))
d2_feat["faces"] = faces
d2_feat["verts"] = verts
else:
print("Missing triangulation")
continue
d2_feats.append(d2_feat)
total_surfs += 1
bbox = get_boundingbox(occ_steps[occ_cnt], use_mesh=False)
xmin, ymin, zmin, xmax, ymax, zmax = bbox[:6]
bbox1 = [
"%.2f" % xmin,
"%.2f" % ymin,
"%.2f" % zmin,
"%.2f" % xmax,
"%.2f" % ymax,
"%.2f" % zmax,
"%.2f" % (xmax - xmin),
"%.2f" % (ymax - ymin),
"%.2f" % (zmax - zmin)
]
stats["#edges"] = total_edges
stats["#surfs"] = total_surfs
# Fix possible orientation problems
if convert:
for p in patches:
# Check orientation of first curve
if len(p["2dcurves"]) >= 2:
cur = tr_curves[p["2dcurves"][0]]
nxt = tr_curves[p["2dcurves"][1]]
c_ori = p["orientations"][0]
n_ori = p["orientations"][1]
if c_ori == 0:
pole0 = np.array(cur["poles"][0])
pole1 = np.array(cur["poles"][-1])
else:
pole0 = np.array(cur["poles"][-1])
pole1 = np.array(cur["poles"][0])
if n_ori == 0:
pole2 = np.array(nxt["poles"][0])
pole3 = np.array(nxt["poles"][-1])
else:
pole2 = np.array(nxt["poles"][-1])
pole3 = np.array(nxt["poles"][0])
d02 = np.abs(pole0 - pole2)
d12 = np.abs(pole1 - pole2)
d03 = np.abs(pole0 - pole3)
d13 = np.abs(pole1 - pole3)
amin = np.argmin([d02, d12, d03, d13])
if amin == 0 or amin == 2: # Orientation of first curve incorrect, fix
p["orientations"][0] = abs(c_ori - 1)
# Fix all orientations
for i in range(len(p["2dcurves"]) - 1):
cur = tr_curves[p["2dcurves"][i]]
nxt = tr_curves[p["2dcurves"][i + 1]]
c_ori = p["orientations"][i]
n_ori = p["orientations"][i + 1]
if c_ori == 0:
pole1 = np.array(cur["poles"][-1])
else:
pole1 = np.array(cur["poles"][0])
if n_ori == 0:
pole2 = np.array(nxt["poles"][0])
pole3 = np.array(nxt["poles"][-1])
else:
pole2 = np.array(nxt["poles"][-1])
pole3 = np.array(nxt["poles"][0])
d12 = np.abs(pole1 - pole2)
d13 = np.abs(pole1 - pole3)
amin = np.min([d12, d13])
if amin == 1: # Incorrect orientation, flip
p["orientations"][i + 1] = abs(n_ori - 1)
features = {
"curves": d1_feats,
"surfaces": d2_feats,
"trim": tr_curves,
"topo": patches,
"bbox": bbox1
}
os.makedirs(res_path, exist_ok=True)
fip = fil + "_features2"
with open("%s/%s_%03i.yml" % (res_path, fip, occ_cnt), "w") as fili:
yaml.dump(features, fili, indent=2)
fip = fil + "_features"
with open("%s/%s_%03i.yml" % (res_path, fip, occ_cnt), "w") as fili:
features2 = copy.deepcopy(features)
for sf in features2["surfaces"]:
del sf["faces"]
del sf["verts"]
yaml.dump(features2, fili, indent=2)
# res_path = folder.replace("/step/", "/stat/")
# fip = fil + "_stats"
# with open("%s/%s_%03i.yml"%(res_path, fip, occ_cnt), "w") as fili:
# yaml.dump(stats, fili, indent=2)
print("Writing results for %s with %i parts." % (model, len(occ_steps)))
def mesh_model(model, max_size=1e-5, tolerance=1e-7, repair=False, terminal=1):
# In/Output definitions
fil = model.split("/")[-1][:-5]
folder = "/".join(model.split("/")[:-1])
scale_factor = 1000.0
verts = []
norms = []
faces = []
curvs = []
vert_map = {}
d1_feats = []
d2_feats = []
t_curves = []
#norm_map = {}
with fileinput.FileInput(model, inplace=True) as fi:
for line in fi:
print(line.replace(
"UNCERTAINTY_MEASURE_WITH_UNIT( LENGTH_MEASURE( 1.00000000000000E-06 )",
"UNCERTAINTY_MEASURE_WITH_UNIT( LENGTH_MEASURE( 1.00000000000000E-17 )"
),
end='')
stats = {}
# OCC definitions
occ_steps = read_step_file(model)
stats["#parts"] = len(occ_steps)
stats["model"] = model
print("Reading step %s with %i parts." % (model, len(occ_steps)))
#tot = 0
#for s in occ_steps:
# occ_topo = TopologyExplorer(s)
# print(s)
# print(len(list(occ_topo.edges())))
# tot += len(list(occ_topo.edges()))
occ_cnt = 0
bbox = get_boundingbox(occ_steps[occ_cnt], use_mesh=True)
diag = np.sqrt(bbox[6]**2 + bbox[7]**2 + bbox[8]**2)
max_length = diag * max_size #, 9e-06
tolerance = diag * tolerance
#print(fil, diag, max_length, tolerance)
stats["bbox"] = bbox
stats["max_length"] = float(max_length)
stats["tolerance"] = float(tolerance)
stats["diag"] = float(diag)
occ_topo = TopologyExplorer(occ_steps[occ_cnt])
occ_top = Topo(occ_steps[occ_cnt])
occ_props = GProp_GProps()
occ_brt = BRep_Tool()
# Gmsh definitions
gmsh.initialize()
gmsh.clear()
gmsh.option.setNumber("General.Terminal", terminal)
gmsh.option.setNumber("Geometry.Tolerance", tolerance)
gmsh.option.setNumber("Geometry.OCCFixDegenerated", 0)
gmsh.option.setNumber("Geometry.OCCFixSmallEdges", 0)
gmsh.option.setNumber("Geometry.OCCFixSmallFaces", 0)
gmsh.option.setNumber("Geometry.OCCSewFaces", 0)
gmsh.option.setNumber("Mesh.CharacteristicLengthMax", max_length)
gmsh.open(model)
# Gmsh meshing
#gmsh.model.mesh.generate(1)
#gmsh.model.mesh.refine()
#gmsh.model.mesh.refine()
gmsh.model.mesh.generate(2)
#gmsh.write("results/" + file + ".stl")
gmsh_edges = gmsh.model.getEntities(1)
gmsh_surfs = gmsh.model.getEntities(2)
#print("O", tot, "G", len(gmsh_edges))
#continue
gmsh_entities = gmsh.model.getEntities()
#gmsh.model.occ.synchronize()
#print(dir(gmsh.model.occ))
total_edges = 0
total_surfs = 0
for l in range(len(occ_steps)):
topo = TopologyExplorer(occ_steps[l])
total_edges += len(list(topo.edges()))
total_surfs += len(list(topo.faces()))
vol = brepgprop_VolumeProperties(occ_steps[l], occ_props, tolerance)
#print(dir(occ_props), dir(occ_props.PrincipalProperties()), dir(occ_props.volume()), occ_props.Mass())
sur = brepgprop_SurfaceProperties(occ_steps[l], occ_props, tolerance)
#print(vol, "Test", sur)
stats["#edges"] = total_edges
stats["#surfs"] = total_surfs
stats["volume"] = vol
stats["surface"] = sur
stats["curves"] = []
stats["surfs"] = []
stats["#points"] = 0
print("Number of surfaces: %i, Number of curves: %i" %
(total_surfs, total_edges))
#print(total_edges, total_surfs, len(gmsh_edges), len(gmsh_surfs))
if not total_edges == len(gmsh_edges):
print("Skipping due to wrong EDGES", model)
return
if not total_surfs == len(gmsh_surfs):
print("Skipping due to wrong SURFS", model)
return
#print("Reading curvature")
v_cnt = 1
v_nodes = []
occ_offset = 0
invalid_model = False
c_cnt = 0
#v_cont_cnt = 0
#print(len(list(occ_topo.edges())), len(list(occ_topo.solids())), len(list(occ_topo.faces())), len(list(occ_topo.vertices())))
for e in gmsh_entities[:]:
#print(e)
nodeTags, nodeCoords, nodeParams = gmsh.model.mesh.getNodes(
e[0], e[1], True)
elemTypes, elemTags, elemNodeTags = gmsh.model.mesh.getElements(
e[0], e[1])
n_id = e[1] - occ_offset
#print(e, occ_offset, n_id)
#print(e, nodeTags, nodeCoords, nodeParams, gmsh.model.getType(e[0], e[1]), elemTypes, elemTags, elemNodeTags)
if e[0] == 0: # Process points
#print(e[1], nodeCoords)
vert_map[e[1]] = v_cnt
verts.append([
nodeCoords[0] * 1000.0, nodeCoords[1] * 1000.0,
nodeCoords[2] * 1000.0
])
v_cnt += 1
stats["#points"] += 1
#pass
if e[0] == 1: # Process contours
if n_id - 1 == len(list(occ_topo.edges())):
#print("CNT", occ_cnt)
occ_cnt += 1
occ_offset = e[1] - 1
n_id = 1
occ_topo = TopologyExplorer(occ_steps[occ_cnt])
occ_top = Topo(occ_steps[occ_cnt])
#print("Defunct curve", n_id, len(list(occ_topo.edges())))
#continue
#print(n_id)
curve = BRepAdaptor_Curve(list(occ_topo.edges())[n_id - 1])
# Add type and parametric nodes/indices
#print("type", edge_map[curve.GetType()])
if gmsh.model.getType(e[0], e[1]) == "Unknown":
#print("Skipping OtherCurve", nodeTags)
continue
for i, n in enumerate(nodeTags):
if n >= v_cnt:
vert_map[n] = v_cnt
verts.append([
nodeCoords[i * 3] * 1000.0,
nodeCoords[i * 3 + 1] * 1000.0,
nodeCoords[i * 3 + 2] * 1000.0
])
v_cnt += 1
else:
print(n, v_cnt)
#print(v_ind, type(v_ind), v_par, type(v_par))
stats["curves"].append(edge_map[curve.GetType()])
#print(n_id, edge_map[curve.GetType()], gmsh.model.getType(e[0], e[1]))
#print(list(occ_topo.edges()), n_id-1)
c_type = edge_map[curve.GetType()] #gmsh.model.getType(e[0], e[1])
if not gmsh.model.getType(e[0], e[1]) == edge_map[curve.GetType()]:
print("Skipped due to non matching edges ", model,
gmsh.model.getType(e[0], e[1]),
edge_map[curve.GetType()])
#invalid_model = True
#break
d1_feat = convert_curve(curve)
edg = list(occ_topo.edges())[n_id - 1]
for f in occ_top.faces_from_edge(edg):
#ee = (e)
#print(dir(ee))
#d1_feat = {}
su = BRepAdaptor_Surface(f)
c = BRepAdaptor_Curve2d(edg, f)
t_curve = {
"surface": f,
"3dcurve": c_cnt,
"2dcurve": convert_2dcurve(c)
}
#print(edge_map[c.GetType()], surf_map[su.GetType()], edge_map[curve.GetType()])
#d1f = convert_2dcurve(c)
#print(d1f)
#ccnt += 1
#print(d1_feat)
t_curves.append(t_curve)
if len(elemNodeTags) > 0:
#v_ind = [int(elemNodeTags[0][0]) - 1] # first vertex
v_ind = [int(nodeTags[-2]) - 1]
for no in nodeTags[:-2]:
v_ind.append(int(no) - 1) # interior vertices
v_ind.append(int(nodeTags[-1]) - 1)
#v_ind.append(int(elemNodeTags[0][-1]) - 1) # last vertex
d1_feat["vert_indices"] = v_ind
#v_par = [float(curve.FirstParameter())] # first param
v_par = [float(nodeParams[-2] * scale_factor)]
for no in nodeParams[:-2]:
v_par.append(float(no * scale_factor)) # interior params
v_par.append(float(nodeParams[-1] * scale_factor))
#v_par.append(float(curve.LastParameter())) # last param
d1_feat["vert_parameters"] = v_par
else:
print("No nodetags", edge_map[curve.GetType()], elemNodeTags)
#print("VERTS", len(d1_feat["vert_indices"]), len(d1_feat["vert_parameters"]))
d1_feats.append(d1_feat)
c_cnt += 1
#t_curve = curve.Trim(curve.FirstParameter(), curve.LastParameter(), 0.0001).GetObject()
#print(curve.FirstParameter(), curve.LastParameter())
#print("Processing surfaces")
gmsh_entities = gmsh.model.getEntities(2)
n_cnt = 1
occ_offset = 0
occ_cnt = 0
occ_topo = TopologyExplorer(occ_steps[occ_cnt])
occ_top = Topo(occ_steps[occ_cnt])
f_cnt = 0
f_sum = 0
first_face = True
mean_curv = 0.0
curv_cnt = 0
gaus_curv = 0.0
s_cnt = 0
for e in gmsh_entities[:]:
#print(e)
nodeTags, nodeCoords, nodeParams = gmsh.model.mesh.getNodes(
e[0], e[1], True)
elemTypes, elemTags, elemNodeTags = gmsh.model.mesh.getElements(
e[0], e[1])
n_id = e[1] - occ_offset
#print(e, occ_offset, n_id)
#print(e, nodeTags, nodeCoords, nodeParams, gmsh.model.getType(e[0], e[1]), elemTypes, elemTags, elemNodeTags)
if e[0] == 2:
#print(e, gmsh.model.getType(e[0], e[1]), elemTypes)
if n_id - 1 == len(list(occ_topo.faces())):
#print("CNT", occ_cnt)
occ_cnt += 1
occ_offset = e[1] - 1
n_id = 1
occ_topo = TopologyExplorer(occ_steps[occ_cnt])
occ_top = Topo(occ_steps[occ_cnt])
if "getNormals" in dir(gmsh.model):
nls = gmsh.model.getNormals(e[1], nodeParams)
else:
nls = gmsh.model.getNormal(e[1], nodeParams)
curvMax, curvMin, dirMax, dirMin = gmsh.model.getPrincipalCurvatures(
e[1], nodeParams)
#surf = BRepAdaptor_Surface(list(occ_topo.faces())[n_id-1])
norm_map = {}
for i, n in enumerate(nodeTags):
norms.append([nls[i * 3], nls[i * 3 + 1], nls[i * 3 + 2]])
curvs.append([
curvMin[i], curvMax[i], dirMin[i * 3], dirMin[i * 3 + 1],
dirMin[i * 3 + 2], dirMax[i * 3], dirMax[i * 3 + 1],
dirMax[i * 3 + 2]
])
curv_cnt += 1
mean_curv += (curvMin[i] + curvMax[i]) / 2.0
gaus_curv += (curvMin[i] * curvMax[i])
norm_map[n] = n_cnt
n_cnt += 1
if n in vert_map.keys():
v = verts[vert_map[n] - 1]
#print("Vert contained", n)
#v_cont_cnt += 1
# assert(v[0] == nodeCoords[i*3] * 1000.0 and v[1] == nodeCoords[i*3+1] * 1000.0 and v[2] == nodeCoords[i*3+2] * 1000.0)
continue
else:
vert_map[n] = v_cnt
#occ_node = surf.Value(nodeParams[i], nodeParams[i+1])
#vertices.append([occ_node.X(), occ_node.Y(), occ_node.Z()])
verts.append([
nodeCoords[i * 3] * 1000.0, nodeCoords[i * 3 + 1] * 1000.0,
nodeCoords[i * 3 + 2] * 1000.0
])
#print("S", occ_node.Coord(), [nodeCoords[i*3]*1000, nodeCoords[i*3+1]*1000, nodeCoords[i*3+2]*1000])
#print(occ_node.Coord(), nodeCoords[i*3:(i+1)*3])
v_cnt += 1
d2_faces = []
for i, t in enumerate(elemTypes):
for j in range(len(elemTags[i])):
faces.append([
vert_map[elemNodeTags[i][j * 3]],
vert_map[elemNodeTags[i][j * 3 + 1]],
vert_map[elemNodeTags[i][j * 3 + 2]],
norm_map[elemNodeTags[i][j * 3]],
norm_map[elemNodeTags[i][j * 3 + 1]],
norm_map[elemNodeTags[i][j * 3 + 2]]
])
d2_faces.append(f_cnt)
f_cnt += 1
#print(len(list(occ_topo.faces())), n_id-1)
surf = BRepAdaptor_Surface(list(occ_topo.faces())[n_id - 1])
#print("type", edge_map[curve.GetType()])
#if gmsh.model.getType(e[0], e[1]) == "Unknown":
# print("Skipping OtherCurve", nodeTags)
# continue
#print(surf)
g_type = gmsh_map[gmsh.model.getType(e[0], e[1])]
if g_type != "Other" and not g_type == surf_map[surf.GetType()]:
print("Skipped due to non matching surfaces ", model, g_type,
surf_map[surf.GetType()])
#invalid_model = True
#break
stats["surfs"].append(surf_map[surf.GetType()])
d2_feat = convert_surface(surf)
d2_feat["face_indices"] = d2_faces
for tc in t_curves:
if tc["surface"] == list(occ_topo.faces())[n_id - 1]:
tc["surface"] = s_cnt
if len(elemNodeTags) > 0:
#print(len(elemNodeTags[0]), len(nodeTags), len(nodeParams))
v_ind = [] #int(elemNodeTags[0][0])] # first vertex
for no in nodeTags:
v_ind.append(int(no) - 1) # interior vertices
#v_ind.append(int(elemNodeTags[0][-1])) # last vertex
d2_feat["vert_indices"] = v_ind
v_par = [] #float(surf.FirstParameter())] # first param
for io in range(int(len(nodeParams) / 2)):
v_par.append([
float(nodeParams[io * 2] * scale_factor),
float(nodeParams[io * 2 + 1] * scale_factor)
]) # interior params
#v_par.append(float(surf.LastParameter())) # last param
d2_feat["vert_parameters"] = v_par
else:
print("No nodetags", edge_map[curve.GetType()], elemNodeTags)
f_sum += len(d2_feat["face_indices"])
d2_feats.append(d2_feat)
s_cnt += 1
if invalid_model:
return
stats["#sharp"] = 0
stats["gaus_curv"] = float(gaus_curv / curv_cnt)
stats["mean_curv"] = float(mean_curv / curv_cnt)
if not f_sum == len(faces):
print("Skipping due to wrong FACES", model)
return
if True:
vert2norm = {}
for f in faces:
#print(f)
for fii in range(3):
if f[fii] in vert2norm:
vert2norm[f[fii]].append(f[fii + 3])
else:
vert2norm[f[fii]] = [f[fii + 3]]
for d1f in d1_feats:
sharp = True
for vi in d1f["vert_indices"][1:-1]:
#print(vi, vert2norm.keys())
nos = list(set(vert2norm[vi + 1]))
if len(nos) == 2:
n0 = np.array(norms[nos[0]])
n1 = np.array(norms[nos[1]])
#print(np.linalg.norm(n0), np.linalg.norm(n1))
if np.abs(n0.dot(n1)) > 0.95:
sharp = False
#break
else:
sharp = False
if sharp:
stats["#sharp"] += 1
d1f["sharp"] = sharp
stats["#verts"] = len(verts)
stats["#faces"] = len(faces)
stats["#norms"] = len(norms)
#with open("results/" + file + ".json", "w") as fil:
# json.dump(d1_feats, fil, sort_keys=True, indent=2)
#with open("results/" + file + "_faces.json", "w") as fil:
# json.dump(d2_feats, fil, sort_keys=True, indent=2)
features = {"curves": d1_feats, "surfaces": d2_feats, "trim": t_curves}
if True:
res_path = folder.replace("/step/", "/feat/")
fip = fil.replace("_step_", "_features_")
print("%s/%s.yml" % (res_path, fip))
with open("%s/%s.yml" % (res_path, fip), "w") as fili:
yaml.dump(features, fili, indent=2)
res_path = folder.replace("/step/", "/stat/")
fip = fil.replace("_step_", "_stats_")
with open("%s/%s.yml" % (res_path, fip), "w") as fili:
yaml.dump(stats, fili, indent=2)
print("Generated model with %i vertices and %i faces." %
(len(verts), len(faces)))
res_path = folder.replace("/step/", "/obj/")
fip = fil.replace("_step_", "_trimesh_")
with open("%s/%s.obj" % (res_path, fip), "w") as fili:
for v in verts:
fili.write("v %f %f %f\n" % (v[0], v[1], v[2]))
for vn in norms:
#print(np.linalg.norm(vn))
fili.write("vn %f %f %f\n" % (vn[0], vn[1], vn[2]))
for vn in curvs:
fili.write(
"vc %f %f %f %f %f %f %f %f\n" %
(vn[0], vn[1], vn[2], vn[3], vn[4], vn[5], vn[6], vn[7]))
for f in faces:
fili.write("f %i//%i %i//%i %i//%i\n" %
(f[0], f[3], f[1], f[4], f[2], f[5]))
faces = np.array(faces)
face_indices = faces[:, :3] - 1
norm_indices = faces[:, 3:] - 1
gmsh.clear()
gmsh.finalize()
#print(curvs)
return {
"statistics": stats,
"features": features,
"vertices": np.array(verts),
"normals": np.array(norms),
"curvatures": np.array(curvs),
"face_indices": face_indices,
"normal_indices": norm_indices,
"trim": t_curves
}