def contain_bounding_box_3D(self, bounding_box):
try:
if (not self.get_prim()):
raise Errors.CantBeNoneError(
'Prim cant be none',
'We need a prim to calculate tbn some steps after')
except Errors.CantBeNoneError as e:
Errors.Error.display_exception(e)
exit()
inside = True
if (not self.get_rectangle_tangent_space()):
self.convert_3D_to_2D(self.get_prim())
this_point_relative = self.get_tbn_class().get_point_which_is_relative(
)
this_tbn_inverse_matrix = self.get_tbn_class().get_tbn_inverse()
param_bounding_box_points_in_this_tangent_space = []
for point in bounding_box.get_points_object_space():
point_relative = GeoMath.vecSub(point, this_point_relative)
point_tangent_space = this_tbn_inverse_matrix.mulPoint3ToMatrix3(
point_relative)
param_bounding_box_points_in_this_tangent_space.append(
list(point_tangent_space))
for point in param_bounding_box_points_in_this_tangent_space:
logging.debug("Rectangle tangent space" +
str(self.get_rectangle_tangent_space()))
inside = GeoMath.pointInPoints(point,
self.get_rectangle_tangent_space())
if (not inside):
break
return inside
def intersect_bounding_box_with_limits_3D(self,
bounding_box,
DISPLAY=False):
try:
if (not self.get_prim()):
raise Errors.CantBeNoneError(
'Prim cant be none',
'We need a prim to calculate tbn some steps after')
except Errors.CantBeNoneError as e:
Errors.Error.display_exception(e)
exit()
if (not self.get_points_tangent_space()):
self.convert_3D_to_2D(self.get_prim())
this_point_relative = self.get_tbn_class().get_point_which_is_relative(
)
this_tbn_inverse_matrix = self.get_tbn_class().get_tbn_inverse()
param_bounding_box_points_in_this_tangent_space = []
for point in bounding_box.get_rectangle_object_space():
point_relative = GeoMath.vecSub(point, this_point_relative)
point_tangent_space = this_tbn_inverse_matrix.mulPoint3ToMatrix3(
point_relative)
param_bounding_box_points_in_this_tangent_space.append(
point_tangent_space)
intersections = GeoMath.getIntersectionsBetweenEdges2D(self.get_edges_tangent_space(), \
GeoMath.getEdgesFromPoints(param_bounding_box_points_in_this_tangent_space))
#=======================================================================
# work in object space because we only has to know if the bounding boxes
# share some edge between
#=======================================================================
edges_shared_between_bounding_boxes = \
GeoMath.getEdgesBetweenEdges(self.get_edges_tangent_space(), \
GeoMath.getEdgesFromPoints(param_bounding_box_points_in_this_tangent_space))
if (DISPLAY):
# TEMP: exit
1 / 0
exit()
for intersection in intersections:
this_tbn_matrix = self.get_tbn_class().get_tbn()
point_object_space = this_tbn_matrix.mulPoint3ToMatrix3(
intersection)
point_absolute = GeoMath.vecPlus(point_object_space,
this_point_relative)
self.to_display_intersections.append(point_absolute)
self.display_intersections()
return intersections, edges_shared_between_bounding_boxes
def create_3D_to_2D_rectangle(self, prim):
try:
if (not prim):
raise Errors.CantBeNoneError(
'Prim cant be none', 'We need a' +
' prim to calculate tbn some' + ' steps after')
except Errors.CantBeNoneError as e:
Errors.Error.display_exception(e)
exit()
tbn_class = CreateTBN.CreateTBN(prim)
tbn_class.do(scale=True)
tbn_matrix = tbn_class.get_tbn()
tbn_inverse_matrix = tbn_class.get_tbn_inverse()
temporary_list = []
for point in self.get_points_object_space():
point_relative = GeoMath.vecSub(
point, tbn_class.get_point_which_is_relative())
point_tangent_space = tbn_inverse_matrix.mulPoint3ToMatrix3(
point_relative)
temporary_list.append(point_tangent_space)
self.set_points_tangent_space(temporary_list)
self.calculate_bounding_box_tangent_space()
#=======================================================================
# Tranform to object space
#=======================================================================
rectangle_tangent_space = self.create_rectangle('tangent')
rectangle_object_space = []
for point_tangent_space in rectangle_tangent_space:
point_object_space_relative = tbn_matrix.mulPoint3ToMatrix3(
point_tangent_space)
point_object_space = GeoMath.vecPlus(
point_object_space_relative,
tbn_class.get_point_which_is_relative())
rectangle_object_space.append(point_object_space)
self.set_rectangle_object_space(rectangle_object_space)
bounding_box_object_space_size = GeoMath.vecSub(
rectangle_object_space[2], rectangle_object_space[0])
self.set_vector_size_object_space(bounding_box_object_space_size)
self.set_rectangle_tangent_space(rectangle_tangent_space)
self.set_edges_object_space(
GeoMath.getEdgesFromPoints(rectangle_object_space))
self.set_edges_tangent_space(
GeoMath.getEdgesFromPoints(rectangle_tangent_space))
self.tbn_class = tbn_class
def intersect_bounding_box_3D(self, bounding_box, DISPLAY=False):
try:
if (not self.get_prim()):
raise Errors.CantBeNoneError(
'Prim cant be none',
'We need a prim to calculate tbn some steps after')
except Errors.CantBeNoneError as e:
Errors.Error.display_exception(e)
exit()
if (not self.get_points_tangent_space()):
self.create_3D_to_2D_rectangle(self.get_prim())
this_point_relative = self.get_tbn_class().get_point_which_is_relative(
)
this_tbn_inverse_matrix = self.get_tbn_class().get_tbn_inverse()
param_bounding_box_points_in_this_tangent_space = []
for point in bounding_box.get_rectangle_object_space():
point_relative = GeoMath.vecSub(point, this_point_relative)
this_tbn_inverse_matrix.printAttributes()
point_tangent_space = this_tbn_inverse_matrix.mulPoint3ToMatrix3(
point_relative)
param_bounding_box_points_in_this_tangent_space.append(
point_tangent_space)
intersections = GeoMath.getIntersectionsBetweenEdges2D(
GeoMath.getEdgesFromPoints(self.get_rectangle_tangent_space()),
GeoMath.getEdgesFromPoints(
param_bounding_box_points_in_this_tangent_space))
if (DISPLAY):
# TEMP: exit
1 / 0
exit()
for intersection in intersections:
this_tbn_matrix = self.get_tbn_class().get_tbn()
point_object_space = this_tbn_matrix.mulPoint3ToMatrix3(
intersection)
point_absolute = GeoMath.vecPlus(point_object_space,
this_point_relative)
self.to_display_intersections.append(point_absolute)
self.display_intersections()
return intersections
def intersect_bounding_box_without_limits_3D(self,
bounding_box,
DISPLAY=False):
global littleEpsilon
try:
if (not self.get_prim()):
raise Errors.CantBeNoneError(
'Prim cant be none',
'We need a prim to calculate tbn some steps after')
except Errors.CantBeNoneError as e:
Errors.Error.display_exception(e)
exit()
if (not self.get_points_tangent_space()):
self.convert_3D_to_2D(self.get_prim())
this_point_relative = self.get_tbn_class().get_point_which_is_relative(
)
this_tbn_inverse_matrix = self.get_tbn_class().get_tbn_inverse()
param_bounding_box_points_in_this_tangent_space = []
for point in bounding_box.get_rectangle_object_space():
point_relative = GeoMath.vecSub(point, this_point_relative)
point_tangent_space = this_tbn_inverse_matrix.mulPoint3ToMatrix3(
point_relative)
param_bounding_box_points_in_this_tangent_space.append(
point_tangent_space)
intersections = GeoMath.getIntersectionsBetweenEdges2D(self.get_edges_tangent_space(), \
GeoMath.getEdgesFromPoints(param_bounding_box_points_in_this_tangent_space))
if (intersections):
#===============================================================
# Check if the limits are touching and if it are touching it,
# check if the intersection is in there. If it is in there,
# the intersection lie in the limit, so we dont consider an
# intersection
#===============================================================
edges_shared_between_bounding_boxes = \
GeoMath.getEdgesBetweenEdges(self.get_edges_tangent_space(), \
GeoMath.getEdgesFromPoints(param_bounding_box_points_in_this_tangent_space))
inside = False
print "Edges shared between"
print edges_shared_between_bounding_boxes
for intersection in intersections:
inside = GeoMath.pointInEdges(
intersection, edges_shared_between_bounding_boxes)
if (not inside):
break
#===============================================================
# If all intersections lie in the edges shared between bounding
# boxes we discart its
#===============================================================
if (inside):
intersections = []
else:
# check if intersections are in the corner, because we consider corner as limit
shared_points_between_bounding_boxes = GeoMath.getSharedPoints(
self.get_rectangle_tangent_space(),
param_bounding_box_points_in_this_tangent_space)
# If all intersections lie in the corner we doen't consider intersections as intersections
true_intersections = list(intersections)
for intersection in intersections:
for corner in shared_points_between_bounding_boxes:
if (GeoMath.vecModul(
GeoMath.vecSub(corner, intersection)) <=
littleEpsilon):
true_intersections.remove(intersection)
break
intersections = true_intersections
if (DISPLAY):
# TEMP: exit
1 / 0
exit()
for intersection in intersections:
this_tbn_matrix = self.get_tbn_class().get_tbn()
point_object_space = this_tbn_matrix.mulPoint3ToMatrix3(
intersection)
point_absolute = GeoMath.vecPlus(point_object_space,
this_point_relative)
self.to_display_intersections.append(point_absolute)
self.display_intersections()
return intersections