def write_polys():
print('... Writing polys')
for cell, d_cell in d_cells.items():
write_vtp_file(d_cell['poly'], str(output_folder / cell))
for parentid_contact, d_contact in d_cell['contacts'].items():
if d_contact.get('contact_area') is None:
continue
write_vtp_file(
d_contact['contact_area'],
str(output_folder / '{0}_contact_area({1}->{2}).vtp'.format(
cell, d_cell['parentid'], parentid_contact)))
write_vtp_file(
d_contact['cutting_plane'],
str(output_folder / '{0}_cutting_plane({1}->{2}).vtp'.format(
cell, d_cell['parentid'], parentid_contact)))
write_vtp_file(
d_contact['border_points'],
str(output_folder / '{0}_border_points({1}->{2}).vtp'.format(
cell, d_cell['parentid'], parentid_contact)))
if 'cut_plane' in d_contact:
d_contact['cut_plane'].export(file_obj=str(
output_folder / '{0}_cut_{3} ({1}->{2}).stl'.format(
cell, d_cell['parentid'], parentid_contact,
d_contact['type_cut_plane'])),
file_type='stl')
if 'cut_plane_inverted_normal' in d_contact:
d_contact['cut_plane_inverted_normal'].export(file_obj=str(
output_folder / '{0}_cut_{3} ({1}->{2}).stl'.format(
cell, d_cell['parentid'], parentid_contact,
d_contact['type_cut_plane_inverted_normal'])),
file_type='stl')
return
def write_vtp_files():
for cell_1_i, d_cell2_contactinfo in dd_cell1_cell2_contactinfo.items():
for cell_2_i, contactinfo in d_cell2_contactinfo.items():
poly_collision = extract_selection_vtp(
poly_in=d_cellname_poly[cell_1_i],
l_cell_idx=[*contactinfo.d_idx_l_idx_triangles] +
contactinfo.l_triangles_popped)
write_vtp_file(poly_collision,
str(output_folder / "{0}_contact_{1}.vtp".format(
cell_1_i, cell_2_i))) #with holes
poly_holes_filled = extract_selection_vtp(
poly_in=d_cellname_poly[cell_1_i],
l_cell_idx=[*contactinfo.d_idx_l_idx_triangles] +
contactinfo.l_triangles_idx_hole +
contactinfo.l_triangles_popped)
write_vtp_file(poly_holes_filled,
str(output_folder /
"{0}_contact_filled{1}.vtp".format(
cell_1_i, cell_2_i))) #without holes
write_vtp_file(
d_cellname_poly[cell_1_i],
str(output_folder / "{0}_enriched.vtp".format(cell_1_i)))
return
def remove_shared_triangles_between_contactareas(cell):
if verbose:
print(
'remove_shared_triangles_between_contactareas ({0})'.format(cell))
#build up datastructure d_idx_triangle_l_contactarea
wdo_1 = dsa.WrapDataObject(d_cellname_poly[cell])
d_idx_triangle_l_contactarea = {}
for cell2_i, contactinfo_i in dd_cell1_cell2_contactinfo[cell].items():
for idx_triangle_1_i in contactinfo_i.d_idx_l_idx_triangles.keys():
d_idx_triangle_l_contactarea.setdefault(idx_triangle_1_i,
[]).append(cell2_i)
#remove shared triangles from contactareas
l_triangles_popped = []
for idx_triangle_i, l_contactarea_i in d_idx_triangle_l_contactarea.items(
):
if len(l_contactarea_i) > 1:
l_triangles_popped.append(idx_triangle_i)
for contactarea_i in l_contactarea_i:
dd_cell1_cell2_contactinfo[cell][
contactarea_i].d_idx_l_idx_triangles.pop(idx_triangle_i)
dd_cell1_cell2_contactinfo[cell][
contactarea_i].l_triangles_popped.append(idx_triangle_i)
if verbose:
print(
'triangle {0} has been removed from contactarea {2} of cell {1} because it was shared with another contactarea from the same cell'
.format(idx_triangle_i, cell, contactarea_i))
if verbose:
poly_popped = extract_selection_vtp(poly_in=d_cellname_poly[cell],
l_cell_idx=l_triangles_popped)
write_vtp_file(poly_popped,
str(output_folder / "popped_{0}.vtp".format(cell)))
return
input_file_vtp = vtp_i
break
input_file_vtp = vtp_i
#part1 : enrich embryo vtp with contactID
# - contact index is the index of the contacting triangle (from the other cell)
# - contactID is the parent index of the contacting cell
print('vtp file {0} will be used for enriching of contactinformation'.format(
input_file_vtp)) if input_file_vtp else print(
'no vtp file found ! at {0}'.format(input_file_vtp))
poly_in = read_vtp_file(input_file_vtp)
poly_out = enrich_embryo_with_contactID(poly_in)
path_file = str(output_folder / (input_file_vtp.stem + "_enriched.vtp"))
write_vtp_file(poly_out, path_file)
if verbose: print("output written : {0}".format(path_file))
#part2 : make contactarea network graph
#-step1) build datastructure containing all contact pair data dd_cell1_cell2_contactinfo
class DictOfDicts(dict):
"""Implementation of perl's autovivification feature."""
def __getitem__(self, item):
try:
return dict.__getitem__(self, item)
except KeyError:
value = self[item] = type(self)()
return value
d_parentID_cellID[k],
'parentID',
fallback=99))
for k in a_parentIDs
}
if timestep: # update mapping to include cell division via tab 3 => embID cellID time_divided daughter_cell
d_parentID_map = update_mapping_for_cell_division(
d_parentID_map, timestep, d_parentID_cellID)
poly_enriched = enrich_embryo_with_contactID(poly_in, d_parentID_map)
else:
poly_enriched = enrich_embryo_with_contactID(poly_in)
# write VTP file per cell
d_parentID_VTP = extract_parentID_selection_from_VTP(poly_enriched,
verbose=True)
for parent_ID_i, vtp_i in d_parentID_VTP.items():
write_vtp_file(
vtp_i, str(output_folder / "cell_parent{0}.vtp".format(parent_ID_i)))
if write_stl_files:
write_stl_file(vtp_i,
str(output_folder /
"cell_parent{0}.stl".format(parent_ID_i)),
scale=1.0e6)
#write vtp embryo
write_vtp_file(poly_enriched, str(output_folder / "selected_embryo.vtp"))
write_vtp_file(poly_in,
str(output_folder / "selected_embryo(not enriched).vtp"))
field_type="CELL",
inverse_selection=False,
verbose=False)
wdo_total_contactarea = dsa.WrapDataObject(poly_totalcontactarea)
a_contactIndex = np.copy(
dsa.WrapDataObject(
d_cellname_poly[cell_i]).CellData['parentIndex'].__array__()
) #a_contactIndex = the array that will be used to enrich the cellVTP with contacting cellids, initialize with parentID
s_idx_triangles_unassigned = set(
wdo_total_contactarea.CellData['SelectionCellIds'].__array__(
)) #SelectionCellIds are the indices of 1 level up (cell level)
write_vtp_file(poly_totalcontactarea,
str(output_folder /
"poly_totalcontactarea{0}.vtp".format(cell_i))) #TEMP
#step2 : gather pointsets of the different contactareas of the cell, and label them
for cell_2_i, contactinfo in dd_cell1_cell2_contactinfo[cell_i].items():
poly_collision = extract_selection_vtp(
poly_in=d_cellname_poly[cell_i],
l_cell_idx=[*contactinfo.d_idx_l_idx_triangles])
wdo_contact_area = dsa.WrapDataObject(contactinfo.poly_collision)
contactinfo.s_points = set(
list(wdo_contact_area.PointData['SelectionPointIds'].__array__()))
# d_vi_arealabel.update({k:cell_2_i for k in contactinfo.s_points}) # construct index to link a point index with contactarea (contactarea has cell2 as a label)
for k in contactinfo.s_points:
d_vi_arealabel.setdefault(k, []).append(
cell_2_i
if __name__ == '__main__':
matplotlib.use('Agg')
try:
prm = read_parms()
prm['output_folder'].mkdir(parents=True, exist_ok=True)
input_file_vtp = _select_input_file(prm)
poly_embryo = read_vtp_file(input_file_vtp)
d_parentid_cellname, df_canonical_parentid = _map_parentIndex(prm)
_add_parentid(poly_embryo, d_parentid_cellname)
d_parentid_canonical = _add_canonical_parentid(
poly_embryo, df_canonical_parentid)
_add_contactid(poly_embryo)
_add_canonical_contactid(poly_embryo, d_parentid_canonical)
_add_lineageid(poly_embryo, prm['input_file_lineageId'])
p_out = str(prm['output_folder'] /
(input_file_vtp.stem + "_enriched.vtp"))
write_vtp_file(poly_embryo, p_out)
if prm['verbose']:
print("output written : {0}".format(p_out))
except Exception as e:
print(f"", flush=True)
traceback.print_exc()
exit(1)
# write VTP file per cell
d_parentID_VTP = extract_parentID_selection_from_VTP(poly_in, verbose=False)
for parent_ID_i, vtp_i in d_parentID_VTP.items():
l_cell_name = list_unique_values(vtp_i,
attribute='cellName',
field_type="CELL",
repr=True)
if l_cell_name:
cell_name = l_cell_name[0]
else:
# fallback naming via parentid
cell_name = f"cell_parent{str(parent_ID_i).zfill(3)}"
write_vtp_file(vtp_i, str(prm['output_folder'] / f"{cell_name}.vtp"))
print(f"VTP file written to output {cell_name}.vtp", flush=True)
if prm['write_stl_files']:
try:
write_stl_file(vtp_i,
str(prm['output_folder'] / f"{cell_name}.stl"),
scale=1.0e6)
print(f"STL file written to output {cell_name}.stl", flush=True)
except:
print(traceback.print_exc())
# write vtp embryo
print(f"Start writing selected_embryo to output...", flush=True)
write_vtp_file(poly_in, str(prm['output_folder'] / "selected_embryo.vtp"))
print(f"selected_embryo.vtp written to output", flush=True)
with open(prm['output_folder'] / f"ref_{prm['timestamp']}", 'w') as f:
filename=str(output_folder / "Seeding"),
select_all=True,
start_index=get_latest_file()[1] +
1).execute()
log_chronology_txt("After final runtime : engaging contactdetection")
# read in clean VTP to fix indices
poly_embryo = read_vtp_file(output_folder / get_latest_file()[0])
d_oldix_newix, _ = get_map_oldix_newix(type='triangles')
add_array_with_mapper(poly_embryo,
name_array_source='contact_index',
name_array_dest='contact_index',
mapper=d_oldix_newix,
field_type="CELL")
d_oldix_newix, _ = get_map_oldix_newix(type='nodes')
add_array_with_mapper(poly_embryo,
name_array_source='vertexIndices',
name_array_dest='vertexIndices',
mapper=d_oldix_newix,
field_type="CELL")
write_vtp_file(poly_embryo, output_folder / get_latest_file()[0])
log_chronology_txt(
"After final runtime : fixing indices due to remeshing => end of simulation"
)
#save centroids
np.savetxt(str(output_folder / "cell_centroids.csv"),
np.array(cells('x')),
delimiter=",")
logging.info(f'runtime_mpacts_pics = {time.time() -tic}')
