def find_face_by_mapping(tris):
# the mid point
centerPoint = SimpleMath.tuple_numproduct(
1.0 / 3.0,
SimpleMath.tuple_plus(
ModelData.dictVertices[tris[0]],
SimpleMath.tuple_plus(ModelData.dictVertices[tris[1]], ModelData.dictVertices[tris[2]]),
),
)
# mapping by distance
for fKey in ModelData.dictFaces:
fVertices = ModelData.dictFaces[fKey].get_vids()
if SimpleMath.is_point_in_triangle_3(
centerPoint,
(
ModelData.dictVertices[fVertices[0]],
ModelData.dictVertices[fVertices[1]],
ModelData.dictVertices[fVertices[2]],
),
):
return fKey
def update_stack():
#init
sortedTetIDStack = []
#building a list with all the dictTetrahedrons attached with TMP dictFaces and their volume
tmpTetIDs = {}
for fkey in ModelData.listShellFaceIDs:
#all the facets of a fixed tet are already fix
if ModelData.dictFaces[fkey].get_tag() == ClassFace.TMP:
#if (375 in ModelData.dictFaces[fkey].get_vids() or 382 in ModelData.dictFaces[fkey].get_vids()) and 371 in ModelData.dictFaces[fkey].get_vids() and 685 in ModelData.dictFaces[fkey].get_vids():
# aaa = 9
tetList = TetraFunc.find_tetids_by_faceid(fkey, 1)
tetid = tetList[0]
tetShellFaceidList = TetraFunc.get_shell_faceids_from_tetid(tetid)
tetFaceidList = TetraFunc.get_faceids_from_tetid(tetid)#all the known face of this tet
#degree of freedom
DoF = 4 - len(tetFaceidList)
#Carving differential
CDif = 0
for f in tetFaceidList:
if ModelData.dictFaces[f].get_tag() == ClassFace.TMP:
CDif = CDif + 1
CDif = CDif - DoF
#different configurations of heuristics
#no heuristics (speedup)
if not globalHeuristic['validity']:
sortedTetIDStack.append((tetid,tetShellFaceidList, tetFaceidList))
return sortedTetIDStack
#with heuristics (normal)
if not tmpTetIDs.has_key(tetid):
if globalHeuristic['volume']:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, ModelData.dictTetrahedrons[tetid].get_volume()) #volume
elif globalHeuristic['flatness']:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, ModelData.dictTetrahedrons[tetid].get_depth(ModelData.dictFaces[fkey].get_vids())/ModelData.dictFaces[fkey].get_area())#flatness
elif globalHeuristic['depth']:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, ModelData.dictTetrahedrons[tetid].get_depth(ModelData.dictFaces[fkey].get_vids()))#depth
elif globalHeuristic['distanceToCenter']:
#face center to the model center
vids = ModelData.dictFaces[fkey].get_vids()
midPt = SimpleMath.tuple_plus(ModelData.dictVertices[vids[0]], ModelData.dictVertices[vids[1]])
midPt = SimpleMath.tuple_plus(ModelData.dictVertices[vids[2]], midPt)
midPt = SimpleMath.tuple_numproduct(1.0/3.0, midPt)
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, 1.0/SimpleMath.square_dist_point_to_point(midPt, [0.0, 0.0, 0.0]))#reciprocal distanceToCenter
#tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, ModelData.dictFaces[fkey].get_area())#face area
else:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif)#simplest
else:
#update the exisiting information
if globalHeuristic['volume']:
volume = ModelData.dictTetrahedrons[tetid].get_volume()
if DoF < tmpTetIDs[tetid][3] or CDif > tmpTetIDs[tetid][4] or volume > tmpTetIDs[tetid][5]:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, 1.0/volume) #reciprocal volume
elif globalHeuristic['flatness']:
flatness = ModelData.dictTetrahedrons[tetid].get_depth(ModelData.dictFaces[fkey].get_vids())/ModelData.dictFaces[fkey].get_area()
if DoF < tmpTetIDs[tetid][3] or CDif > tmpTetIDs[tetid][4] or flatness < tmpTetIDs[tetid][5]:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, flatness)#flatness
elif globalHeuristic['depth']:
depth = ModelData.dictTetrahedrons[tetid].get_depth(ModelData.dictFaces[fkey].get_vids())
if DoF < tmpTetIDs[tetid][3] or CDif > tmpTetIDs[tetid][4] or depth < tmpTetIDs[tetid][5]:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, depth)#depth
elif globalHeuristic['distanceToCenter']:
#face center to the model center
vids = ModelData.dictFaces[fkey].get_vids()
midPt = SimpleMath.tuple_plus(ModelData.dictVertices[vids[0]], ModelData.dictVertices[vids[1]])
midPt = SimpleMath.tuple_plus(ModelData.dictVertices[vids[2]], midPt)
midPt = SimpleMath.tuple_numproduct(1.0/3.0, midPt)
dist = 1.0/SimpleMath.square_dist_point_to_point(midPt, [0.0, 0.0, 0.0])
if DoF < tmpTetIDs[tetid][3] or CDif > tmpTetIDs[tetid][4] or dist > tmpTetIDs[tetid][5]:
tmpTetIDs[tetid] = (tetShellFaceidList, tetFaceidList, ModelData.dictTetrahedrons[tetid].get_tag(), DoF, CDif, dist)#reciprocal distanceToCenter
#sort the dict by the value (volume) and number of neigbour dictFaces into a desascending order
if not globalHeuristic['volume'] and not globalHeuristic['flatness'] and not globalHeuristic['depth'] and not globalHeuristic['distanceToCenter']:
for key in tmpTetIDs:
sortedTetIDStack.append((key, tmpTetIDs[key][0], tmpTetIDs[key][1], tmpTetIDs[key][2], tmpTetIDs[key][3], tmpTetIDs[key][4]))
else:
for key in tmpTetIDs:
sortedTetIDStack.append((key, tmpTetIDs[key][0], tmpTetIDs[key][1], tmpTetIDs[key][2], tmpTetIDs[key][3], tmpTetIDs[key][4], tmpTetIDs[key][5]))
#sort firstly by fix/tmp, secondly by DoF, thirdly by Cd, lastly by volume
sortedTetIDStack = sorted(sortedTetIDStack, key=lambda tet: tet[6], reverse = False)#smaller ratio first
#sortedTetIDStack = sorted(sortedTetIDStack, key=lambda tet: tet[5], reverse = True)#large CDif first
sortedTetIDStack = sorted(sortedTetIDStack, key=lambda tet: tet[4], reverse = False)#smaller DoF first
sortedTetIDStack = sorted(sortedTetIDStack, key=lambda tet: tet[5], reverse = True)#large CDif first
sortedTetIDStack = sorted(sortedTetIDStack, key=lambda tet: tet[3], reverse = True)#TMP tetrahedron first, then INF
str_out = ("number of candidate tetrahedron: {}").format(len(sortedTetIDStack))
os.sys.stdout.write(str_out + "\r")
os.sys.stdout.flush()
return sortedTetIDStack
def reader_obj(FILEPATH):
try:
f_obj = file(FILEPATH, "r")
except:
print ("Invalide file: " + MIDFILEPATH)
return False
# read vertics and ModelData.dictFaces
statFace = 0
for line in f_obj:
if line.startswith("v") and line[1] == " ":
line = line[1:-1].strip()
vertList = map(float, line.split(" "))
add_vertexEx([vertList[0], vertList[1], vertList[2]])
elif line.startswith("f") and line[1] == " ":
indexList = []
# to filter out the /
for index in line[1:-1].strip().split(" "):
indexList.append(index.split("/")[0])
statFace = statFace + 1
if len(indexList) > 2:
# index - 1
indexList = [int(i) - 1 for i in indexList]
add_face(Class_face((indexList[0], indexList[1], indexList[2]), ClassFace.FIX))
# check the content
if len(ModelData.dictFaces) == 0 or len(ModelData.dictVertices) == 0:
print "Invalid Obj file!\n"
return False
else:
print ("Remove " + str(statFace - len(ModelData.dictFaces)) + " invalid ModelData.dictFaces")
print (
"Read "
+ str(len(ModelData.dictFaces))
+ " ModelData.dictFaces and "
+ str(len(ModelData.dictVertices))
+ " ModelData.dictVertices"
)
f_obj.close()
# optimise the coordinates by translate and scale
for key in ModelData.dictVertices:
ModelData.centerVertex = SimpleMath.tuple_plus(ModelData.centerVertex, ModelData.dictVertices[key])
ModelData.centerVertex = SimpleMath.tuple_numproduct(1.0 / len(ModelData.dictVertices), ModelData.centerVertex)
# maxpt = [-9999999999.0, -9999999999.0, -9999999999.0]
# minpt = [9999999999.0, 9999999999.0, 9999999999.0]
for key in ModelData.dictVertices:
ModelData.dictVertices[key] = SimpleMath.tuple_minus(ModelData.dictVertices[key], ModelData.centerVertex)
# if ModelData.dictVertices[key][0] > maxpt[0]:
# maxpt[0] = ModelData.dictVertices[key][0]
# if ModelData.dictVertices[key][1] > maxpt[1]:
# maxpt[1] = ModelData.dictVertices[key][1]
# if ModelData.dictVertices[key][2] > maxpt[2]:
# maxpt[2] = ModelData.dictVertices[key][2]
# if ModelData.dictVertices[key][0] < minpt[0]:
# minpt[0] = ModelData.dictVertices[key][0]
# if ModelData.dictVertices[key][1] < minpt[1]:
# minpt[1] = ModelData.dictVertices[key][1]
# if ModelData.dictVertices[key][2] < minpt[2]:
# minpt[2] = ModelData.dictVertices[key][2]
# ModelData.scaleVertex = ModelData.scaleVertex / SimpleMath.vector_length_3(SimpleMath.tuple_minus(maxpt, minpt))
# for key in ModelData.dictVertices:
# ModelData.dictVertices[key] = SimpleMath.tuple_numproduct(ModelData.scaleVertex, ModelData.dictVertices[key])
if ModelData.global_DO_TRUNCATE:
truncate_verts(ModelData.global_TOL_TRUNCATE)
print (">>>>>>Eliminate degeneracies...")
clean_duplicated_vertices()
print ("{} illshaped ModelData.dictFaces are removed").format(discard_illshaped_faces())
print (
"After cleaning redundant ModelData.dictVertices there are "
+ str(len(ModelData.dictFaces))
+ " ModelData.dictFaces and "
+ str(len(ModelData.dictVertices))
+ " ModelData.dictVertices"
)
return True
def optimise_illshaped_shellfaces():
iCount = 0
for key in ModelData.listShellFaceIDs:
if key not in ModelData.dictFaces:
continue
if (
ModelData.global_OPTIMAL_SHP
and ModelData.dictFaces[key].get_tag() != ClassFace.FLIP
and ModelData.dictFaces[key].get_area() < ModelData.global_TOL_AREA_DISCARD
):
print key
vert0 = ModelData.dictVertices[ModelData.dictFaces[key].get_vids()[0]]
vert1 = ModelData.dictVertices[ModelData.dictFaces[key].get_vids()[1]]
vert2 = ModelData.dictVertices[ModelData.dictFaces[key].get_vids()[2]]
# face collapse or flip
# calculate vectors
vector01 = SimpleMath.tuple_minus(vert0, vert1)
length01 = SimpleMath.vector_length_3(vector01)
if length01 > SimpleMath.Tol:
vector01 = SimpleMath.tuple_numproduct(1.0 / length01, vector01)
else:
iCount += 1
collapse_edge(ModelData.dictFaces[key].get_vids()[0], ModelData.dictFaces[key].get_vids()[1])
continue
vector21 = SimpleMath.tuple_minus(vert2, vert1)
length21 = SimpleMath.vector_length_3(vector21)
if length21 > SimpleMath.Tol:
vector21 = SimpleMath.tuple_numproduct(1.0 / length21, vector21)
else:
iCount += 1
collapse_edge(ModelData.dictFaces[key].get_vids()[2], ModelData.dictFaces[key].get_vids()[1])
continue
vector02 = SimpleMath.tuple_minus(vert0, vert2)
length02 = SimpleMath.vector_length_3(vector02)
if length02 > SimpleMath.Tol:
vector02 = SimpleMath.tuple_numproduct(1.0 / length02, vector02)
else:
iCount += 1
collapse_edge(ModelData.dictFaces[key].get_vids()[0], ModelData.dictFaces[key].get_vids()[2])
continue
# calculate angles
Ang012 = SimpleMath.dot_product_3(vector01, vector21)
Ang102 = SimpleMath.dot_product_3(vector01, vector02)
vector12 = SimpleMath.tuple_numproduct(-1, vector21)
Ang021 = SimpleMath.dot_product_3(vector02, vector12)
# cos value
if Ang012 < ModelData.global_TOL_LARGEST_ANGLE:
# flip 20
iCount += 1
flip_edge(ModelData.dictFaces[key].get_vids()[2], ModelData.dictFaces[key].get_vids()[0])
elif Ang102 < ModelData.global_TOL_LARGEST_ANGLE:
# flip 12
iCount += 1
flip_edge(ModelData.dictFaces[key].get_vids()[1], ModelData.dictFaces[key].get_vids()[2])
elif Ang021 < ModelData.global_TOL_LARGEST_ANGLE:
# flip 01
iCount += 1
flip_edge(ModelData.dictFaces[key].get_vids()[0], ModelData.dictFaces[key].get_vids()[1])
#
# clean_unreferenced_vertices()
print ("{} illshaped ModelData.dictFaces are optimized").format(iCount)
if iCount > 0:
return True
else:
return False
def reader_poly_with_semantics(str_filepath):
fin = file(str_filepath, "r")
# read the first line and try to extract semantics
strFirstLine = fin.readline().split()
if strFirstLine[0] == "#":
# read the building id
ModelData.strModelID = strFirstLine[1]
# whether the geometry is a solid:1 or a multisurface:0
ModelData.isSolid = fin.readline().split()[1]
# the point information
strFirstLine = int(fin.readline().split()[0])
else:
# no semanics
ModelData.strModelID = "-1"
# we assume it is a solid
ModelData.isSolid = "1"
# the point information
strFirstLine = int(strFirstLine[0])
# read all the points
for i in range(strFirstLine):
vertList = map(float, fin.readline().split()[1:4])
add_vertexEx((vertList[0], vertList[1], vertList[2]))
# read each face
nof = int(fin.readline().split()[0])
strPolygonid = ""
strPolygontype = ""
for i in range(nof):
strPolygoninfo = fin.readline().split()
numRings = int(strPolygoninfo[0])
if numRings != 1:
print ("The input has not been tesselated")
return False
if len(strPolygoninfo) >= 4:
strPolygonid = strPolygoninfo[3]
if len(strPolygoninfo) >= 6:
strPolygontype = strPolygoninfo[5]
oring = map(int, fin.readline().split())
if len(oring) > 4:
print ("The input has not been tesselated")
return False
oring.pop(0)
if len(oring) == 3:
add_face(Class_face((oring[0], oring[1], oring[2]), ClassFace.FIX, strPolygonid, strPolygontype))
# check the content
if len(ModelData.dictFaces) == 0 or len(ModelData.dictVertices) == 0:
print "Invalid Poly file!\n"
return False
else:
print ("Remove " + str(nof - len(ModelData.dictFaces)) + " invalid Faces")
print ("Read " + str(len(ModelData.dictFaces)) + " Faces and " + str(len(ModelData.dictVertices)) + " Vertices")
fin.close()
# optimise the coordinates by translate and scale
for key in ModelData.dictVertices:
ModelData.centerVertex = SimpleMath.tuple_plus(ModelData.centerVertex, ModelData.dictVertices[key])
ModelData.centerVertex = SimpleMath.tuple_numproduct(1.0 / len(ModelData.dictVertices), ModelData.centerVertex)
for key in ModelData.dictVertices:
ModelData.dictVertices[key] = SimpleMath.tuple_minus(ModelData.dictVertices[key], ModelData.centerVertex)
if ModelData.global_DO_TRUNCATE:
truncate_verts(ModelData.global_TOL_TRUNCATE)
print ("--Eliminate degeneracies")
clean_duplicated_vertices()
print ("{} illshaped ModelData.dictFaces are removed").format(discard_illshaped_faces())
print (
"After cleaning redundant ModelData.dictVertices there are "
+ str(len(ModelData.dictFaces))
+ " Faces and "
+ str(len(ModelData.dictVertices))
+ " Vertices"
)
return True
