My Customized Tree taiwan 8

thingiverse

Based on the provided output and specifications for building an SMC tree model, here's how you can create this SMC Tree in Python: ```python # import libraries needed for tree reconstruction and statistical analysis. from sklearn.cluster import AgglomerativeClustering from collections import Counter import matplotlib.pyplot as plt import numpy as np from itertools import permutations data = [[[[-3.6986301369863015, 31.36986301369863], [-2.328767123287671 , 31.917808219178085 ], [ -0.9589041095890412 , 31.643835616438352 ], [ 0.410958904109589 , 31.643835616438352 ], [1.7808219178082192, 31.643835616438352], [3.1506849315068495, 31.643835616438352], [4.52054794520548 , 32.19178082191781 ], [5.89041095890411 , 32.19178082191781 ], [7.260273972602739 , 32.19178082191781 ]]], [[1.38010810656289 , 32.36986301369863], [4.209492999162519 , 32.417808219178085 ], [5.309592000362319 , 31.83972602739726 ]]] for data_point in range(len(data)): root_node_id = 'r_' + str(data_point) if (len(data[data_point]) > 0): # print("Root: " +root_node_id ) clusters=[] for i in range(1,len(data[data_point])): tree_model='tree' clusters.append({"leaf_nodes": data[data_point][i] }) clusters=[ {"leaf_nodes" : data[data_point][0]}] # assign trunk nodes cluster = Counter({0:0}) # first cluster and second subtree for new edge # print the final cluster assignments: # assign root to last branch leaf_branch="branch_"+ str(data_point) # The given parameters have no implementation in python. min_leaf_support_ratio=50 # min_leaf_count # Implementation based on SMC Tree algorithm # Find all unique locations unique_locations = [] for d in data: for x, y in d[0]: unique_locations.append((x, y)) # Convert the unique locations into clusters using Hierarchical Clustering hierarchical_clustering = AgglomerativeClustering(n_clusters=len(unique_locations), affinity='euclidean', linkage='ward') locations_2d = np.array([(x,y) for x,y in unique_locations]) clusters_ids = hierarchical_clustering.fit_predict(locations_2d) # Sort clusters by number of nodes counter = Counter(clusters_ids) sorted_cluster_count=sorted(counter.items(),key=lambda x:x[1],reverse=True) print("Clustering complete. Output cluster counts:") for index,(node_id,leaf_support) in enumerate(sorted_cluster_count): # if leaf_support >=min_leaf_support_ratio : print('Node: ' + node_id+' Leaf Support ratio :'+ str(leaf_support)) # output cluster locations as tuples and number of points assigned print("\n Output Tree Locations:") counter=Counter() def generate_branch_clusters(root_cluster_assignment ,root_location) : clusters.append({root_location:"Leaf support" }) generate_branch_clusters(counter,"Location") # print the clusters # for x, y in locations: # if cluster_assignment == i: #check leaf id # tree_model='leaf '+str(i)+'\n' print(tree_model) print(" Tree Clusters: ") cluster_size_count = [] for c,cluster_list in clusters.items(): counter+=Counter() # check cluster nodes: for item in [node_tuple[0] for node_tuple in data[data_point][i]]: cluster_ids=[index for index , value in enumerate(clusters_ids) if value ==item ] # get a subset of leaf assignments and remove them from full assignment: new_assignment=set( cluster_ids)-counter new_assignment=list(new_assignment) counter+=Counter(list(item)) cluster_size_count.append((c, len(counter[cluster_ids[0]]))) print("\n" ) # count points assigned per location as clusters: tree_model='\t' # generate and display SMC output def count_and_plot(data, root_location): return data final_sm = {} locations=[] location_map={} data_map={} # loop over cluster and node to extract data for x,y in unique_locations : for point_set_index , data_point_list in enumerate(data) : #print(point_set_index) for d,leaf_node_data in enumerate(leaf_node_cluster ): try: node_leaf_tuple=tuple([y for x,y in leaf_node_data]) location_id=x+y+point_set_index if (len(location_id) <6): locations.append("0" +str(int(str(location_id)))*((6-int(len(str(location_id)))))) except IndexError as e : print( 'Point tuple missing coordinates: ' ) location_counter = count_and_plot(data,"R") tree_model="\n"+ root_node_id +" branch_"+ str ( data_point)+ ":" for node_location in unique_locations : # create tree point_tuple=list(node_location) point=point_tuple+tuple(locations[ location_map[""]]) # if point not found print: if tuple(point) not in locations : for index,unique_loc in enumerate(data[data_point][i]): leaf_branch_cluster_data=[ d['leaf_nodes'] for i , d in enumerate(clusters) ] print("\n" +root_node_id) node_leaf_count =0 # plot point if new location: node_locations= [ str(location[1])for location in leaf_leaf_tuples[i] ] try: locations.append(tuple([str(x).lstrip('0') for x in point])) def cluster_output() : data_clusters=[] def count_tree_size() : data_node_clusters=[] # traverse each branch (leaf clusters) total_cluster_count =[] node_id_counter=0 if (len(data[data_point]) >0): leaf_tuple_clusters=data_clusters[:] node_leaf_cluster=set([ d for item in leaf_leaf_tuples for d in item["Leaf Nodes"]]) def assign_branch_ids(cluster_assignments): cluster_sizes_count=[] def output_tree_location(location_map): locations=[''] final_leaf_size_locations=counter tree_leaf_output=""" # Final model based on locations leaf_branch_nodes_data.append(tree) for d in clusters[cluster_assignment]: count_cluster=(d['leaf_nodes'][0], d['leaf_nodes'][1]) data_node_clusters=[] final_leaf_branch= [data[point_index][1] for index,(x,y) in enumerate(clusters_ids )if (index% len(final_sm)) == leaf_assignment and x ==y ] # all nodes that belong to the specified node branch_size= len(leaf_cluster_assignments[branch_id]) # print locations on cluster and branches def final_model(location_map,sm) : location_node_count = [] location_node_cluster_id_pairs =[] def get_branch_cluster_data(clusters) : leaf_nodes=clusters_ids tree_clusters=[] clusters.append({"cluster_size": len(final_sm)}) tree_leaf_output= "" locations="" # output points to cluster if found: for point_tuple, location_assignment in sm.items(): # loop over cluster and assign id data_map = count_tree_cluster_counts(data ,locations,"leaf_count") # Plot data and show the resulting model plot_cluster_assignments( tree_model,"Plot of cluster assignments") cluster_assignment= 'A' branch_id= "2" data_index=-1 location_branch_pairs=[("0" + str(point), branch_id) for point in leaf_leaf_tuples[data_index]] print("Locations:") # Assign node IDs from top location_ids=[] leaf_size_counter=[] sm_count= count_tree_cluster_counts(sm,"final_sm") # cluster ID of current location location_counter=cluster_counter data_branch_pairs=[] branch_name="b"+str(leaf_cluster_assignments.index(branch_id)) # display tree clusters branch_locations="" locations="" # empty list for storing location tuples if ( len(sm)) != 0 : # find points with zero support, if present location_assignment=[] count_node_branch_ids = [tree["id"]+ ' (' +tree['Leaf Support'] +')'+'\n' for i,tuple_leaf_clusters in enumerate(location_cluster_tuples) node_location_counter=count_data() leaf_support_counter[count_locations[leaf_index]]+=1 leaf_support= Counter() data_leaf_count=np.array([[1 if tuple_point == tuple(leaf_node['node_tuple']) else 0 for (leaf_index,tuple_point) in enumerate(final_sm.keys())], tuple(leaf_node['node_tuple'])] for leaf_index,leaf_node in enumerate(data_leaf[sm_keys.index("leaf_")])]) locations= np.unique(locations , axis=1).flatten() tree_locations=[tuples_list[-1]for tuples_list in locations ] # Final output data (tuple of each location in branch) locations_count=[] # calculate count branch_counts=[branch for point, branch_id in location_branch_pairs ] branch_counts.sort() print(tree_leaf_output) count_location_ids() def final_plot(cluster_assignments , title): location_assignment=[] # Display locations as branch IDs from bottom to top leaf_location_branch=[] leaf_leaf_tuples=[] # create nodes with locations locations="" # cluster ID and node size counter for all cluster assignments if data_points in branch_name : point_cluster_assignment = Counter(data_locations[data.index("A")].sort(key=lambda tup: (tup[0] , abs(len(branch)-len(str(point)))), reverse=False) ) # calculate support from locations print(sm_counts) locations="" def plot_cluster_assignments(assignment_title, assignment_id): leaf_leaf_tuples=[location_id + tuple(location_location[0] for location_location in branch_points_dict[id]) leaf_support_counts=[] leaf_support_locations=np.array([]) location_assignment_counts = [] branch_size=1 count_cluster(node_branch_tuple_data) node_location_branch_count = [] location_sizes=[] print( "Node branch sizes: ") # Create final clusters for data_point in location_nodes: count_cluster = count_locations(locations) cluster_assignment="" location_tuples_counter=[] # keep track of tuple IDs from bottom up # check for duplicates, print node if (len(clusters_ids)>1 and len(data_location_ids)>2): branch_id ="1" count_location_ids(locations , locations_count) location_tuple_data = [] location_counts= [] # Add tuples branch_node_count=[] data_point_index=[] # Calculate branch support size, location IDs, assign from top count_leaf_branch = np.count_nonzero(locations ) leaf_branch_size=len(location_counts[0]) branch_location_pairs=[] leaf_branch_clusters=[""] # Initialize data sm_location_counter=[] locations="" locations.append(str(x) + ","+str(y)) locations.sort() # ascending sort data_cluster_id=[] leaf_count_location_counts=Counter(locations) location_count_ids() count_tree_size(cluster_assignment, leaf_cluster_assignments) branch_locations=[] # Find support points print("\n Locations") def assign_node_locations(leaf_tuple , cluster_data): locations=[] print("Branch Size: ") locations=[] locations="" locations=set(locations)