def inradius(self, eddy):
dist = PVector.Subtract(self.loc, eddy.loc)
dist2d = PVector(dist.X, dist.Y, 0).Length
if dist2d >= eddy.buffer:
return 0
elif dist2d <= eddy.core:
return -1
else:
return dist2d
def gettarget_2d(self, eddies):
target_2d = PVector(0, 0, 0)
for i in xrange(len(eddies)):
v = PVector.Subtract(eddies[i].loc, self.loc)
v2d = PVector(
v.X, v.Y,
0) # 2d planer target, X Y are the most important factors
dist2d = v2d.Length
# compute the sum of the arraction vector / distance
v2d.Unitize()
v2d = PVector.Multiply(v2d,
float(eddies[i].gravity / pow(dist2d, 1.0)))
# add vector to attraction vector collection
target_2d = PVector.Add(target_2d, v2d)
#Limit the target length
target_2d = toplimit(target_2d, self.toplimit)
target_2d = lowerlimit(target_2d, self.lowerlimit)
self.target = target_2d
def aggregate_field(self, num):
added = 0
loops = 0
while added < num:
## avoid endless loops
loops += 1
if loops > num * 100:
break
## if no part is present in the aggregation, add first random part
if len(self.aggregated_parts) == 0 and self.prev_num == 0:
first_part = self.parts[random.choice(self.parts.keys())]
start_point = None
if self.multiple_fields:
f_name = first_part.field
if (self.mode == 2 or self.mode
== 3) and len(self.global_constraints) > 0:
start_point = self.field[f_name].return_highest_pt(
constraints=self.global_constraints)
else:
start_point = self.field[f_name].return_highest_pt()
else:
if (self.mode == 2 or self.mode
== 3) and len(self.global_constraints) > 0:
start_point = self.field.return_highest_pt(
constraints=self.global_constraints)
else:
start_point = self.field.return_highest_pt()
mov_vec = Vector3d.Subtract(Vector3d(start_point),
Vector3d(first_part.center))
move_transform = Transform.Translation(mov_vec.X, mov_vec.Y,
mov_vec.Z)
first_part_trans = first_part.transform(move_transform)
for conn in first_part_trans.connections:
conn.generate_rules_table(self.rules)
first_part_trans.id = 0
self.aggregated_parts.append(first_part_trans)
## compute all possible next parts and append to list
self.compute_next_w_field(first_part_trans)
added += 1
else:
## if no part is available, exit the aggregation routine and return an error message
if self.queue_count == 0:
msg = "Could not place " + str(num - added) + " parts"
return msg
next_data = self.aggregation_queue[self.queue_count - 1]
next_part = self.parts[next_data[0]]
next_center = Point3d(next_part.center)
orientTransform = next_data[2]
global_check, coll_check, add_coll_check, missing_sup_check, global_const_check = self.check_all_constraints(
next_part, orientTransform)
if not global_check:
next_part_trans = next_part.transform(orientTransform)
next_part_trans.reset_part(self.rules)
for conn in next_part_trans.connections:
conn.generate_rules_table(self.rules)
next_part_trans.id = len(self.aggregated_parts)
self.aggregated_parts[next_data[1]].children.append(
next_part_trans.id)
next_part_trans.parent = self.aggregated_parts[
next_data[1]].id
self.aggregated_parts.append(next_part_trans)
## compute all possible next parts and append to list
self.compute_next_w_field(next_part_trans)
added += 1
## TO FIX --> do not remove rules when only caused by missing supports
self.aggregation_queue.pop()
self.queue_values.pop()
self.queue_count -= 1
