def createGroupOperationForArrange(nodes_to_arrange: List["SceneNode"],
build_volume: "BuildVolume",
fixed_nodes: Optional[List["SceneNode"]] = None,
factor = 10000,
add_new_nodes_in_scene: bool = False) -> Tuple[GroupedOperation, int]:
scene_root = Application.getInstance().getController().getScene().getRoot()
found_solution_for_all, node_items = findNodePlacement(nodes_to_arrange, build_volume, fixed_nodes, factor)
not_fit_count = 0
grouped_operation = GroupedOperation()
for node, node_item in zip(nodes_to_arrange, node_items):
if add_new_nodes_in_scene:
grouped_operation.addOperation(AddSceneNodeOperation(node, scene_root))
if node_item.binId() == 0:
# We found a spot for it
rotation_matrix = Matrix()
rotation_matrix.setByRotationAxis(node_item.rotation(), Vector(0, -1, 0))
grouped_operation.addOperation(RotateOperation(node, Quaternion.fromMatrix(rotation_matrix)))
grouped_operation.addOperation(TranslateOperation(node, Vector(node_item.translation().x() / factor, 0,
node_item.translation().y() / factor)))
else:
# We didn't find a spot
grouped_operation.addOperation(
TranslateOperation(node, Vector(200, node.getWorldPosition().y, -not_fit_count * 20), set_position = True))
not_fit_count += 1
return grouped_operation, not_fit_count
def lookAt(self, target, up=Vector.Unit_Y):
if not self._enabled:
return
eye = self.getWorldPosition()
f = (target - eye).normalize()
up.normalize()
s = f.cross(up).normalize()
u = s.cross(f).normalize()
m = Matrix([[s.x, u.x, -f.x, 0.0], [s.y, u.y, -f.y, 0.0], [s.z, u.z, -f.z, 0.0], [0.0, 0.0, 0.0, 1.0]])
if self._parent:
self._orientation = self._parent._getDerivedOrientation() * Quaternion.fromMatrix(m)
else:
self._orientation = Quaternion.fromMatrix(m)
self._transformChanged()
def lookAt(self, target, up=Vector.Unit_Y):
if not self._enabled:
return
eye = self.getWorldPosition()
f = (target - eye).normalize()
up.normalize()
s = f.cross(up).normalize()
u = s.cross(f).normalize()
m = Matrix([[s.x, u.x, -f.x, 0.0], [s.y, u.y, -f.y, 0.0],
[s.z, u.z, -f.z, 0.0], [0.0, 0.0, 0.0, 1.0]])
if self._parent:
self._orientation = self._parent._getDerivedOrientation(
) * Quaternion.fromMatrix(m)
else:
self._orientation = Quaternion.fromMatrix(m)
self._transformChanged()
def test_fromMatrix(self):
m = Matrix()
m.setByRotationAxis(math.pi / 2, Vector.Unit_Z)
q1 = Quaternion.fromMatrix(m)
q2 = Quaternion()
q2.setByAngleAxis(math.pi / 2, Vector.Unit_Z)
self.assertTrue(Float.fuzzyCompare(q1.x, q2.x, 1e-6))
self.assertTrue(Float.fuzzyCompare(q1.y, q2.y, 1e-6))
self.assertTrue(Float.fuzzyCompare(q1.z, q2.z, 1e-6))
self.assertTrue(Float.fuzzyCompare(q1.w, q2.w, 1e-6))
def test_fromMatrix(self):
m = Matrix()
m.setByRotationAxis(math.pi / 2, Vector.Unit_Z)
q1 = Quaternion.fromMatrix(m)
q2 = Quaternion()
q2.setByAngleAxis(math.pi / 2, Vector.Unit_Z)
self.assertTrue(Float.fuzzyCompare(q1.x, q2.x, 1e-6))
self.assertTrue(Float.fuzzyCompare(q1.y, q2.y, 1e-6))
self.assertTrue(Float.fuzzyCompare(q1.z, q2.z, 1e-6))
self.assertTrue(Float.fuzzyCompare(q1.w, q2.w, 1e-6))
def arrange(nodes_to_arrange: List["SceneNode"],
build_volume: "BuildVolume",
fixed_nodes: Optional[List["SceneNode"]] = None,
factor=10000,
add_new_nodes_in_scene: bool = False) -> bool:
"""
Find placement for a set of scene nodes, and move them by using a single grouped operation.
:param nodes_to_arrange: The list of nodes that need to be moved.
:param build_volume: The build volume that we want to place the nodes in. It gets size & disallowed areas from this.
:param fixed_nodes: List of nods that should not be moved, but should be used when deciding where the others nodes
are placed.
:param factor: The library that we use is int based. This factor defines how accuracte we want it to be.
:param add_new_nodes_in_scene: Whether to create new scene nodes before applying the transformations and rotations
:return: found_solution_for_all: Whether the algorithm found a place on the buildplate for all the objects
"""
scene_root = Application.getInstance().getController().getScene().getRoot()
found_solution_for_all, node_items = findNodePlacement(
nodes_to_arrange, build_volume, fixed_nodes, factor)
not_fit_count = 0
grouped_operation = GroupedOperation()
for node, node_item in zip(nodes_to_arrange, node_items):
if add_new_nodes_in_scene:
grouped_operation.addOperation(
AddSceneNodeOperation(node, scene_root))
if node_item.binId() == 0:
# We found a spot for it
rotation_matrix = Matrix()
rotation_matrix.setByRotationAxis(node_item.rotation(),
Vector(0, -1, 0))
grouped_operation.addOperation(
RotateOperation(node, Quaternion.fromMatrix(rotation_matrix)))
grouped_operation.addOperation(
TranslateOperation(
node,
Vector(node_item.translation().x() / factor, 0,
node_item.translation().y() / factor)))
else:
# We didn't find a spot
grouped_operation.addOperation(
TranslateOperation(node,
Vector(200,
node.getWorldPosition().y,
-not_fit_count * 20),
set_position=True))
not_fit_count += 1
grouped_operation.push()
return found_solution_for_all
def lookAt(self, target: Vector, up: Vector = Vector.Unit_Y):
if not self._enabled:
return
eye = self.getWorldPosition()
f = (target - eye).normalized()
up = up.normalized()
s = f.cross(up).normalized()
u = s.cross(f).normalized()
m = Matrix([[s.x, u.x, -f.x, 0.0], [s.y, u.y, -f.y, 0.0],
[s.z, u.z, -f.z, 0.0], [0.0, 0.0, 0.0, 1.0]])
self.setOrientation(Quaternion.fromMatrix(m))
def lookAt(self, target: Vector, up: Vector = Vector.Unit_Y):
if not self._enabled:
return
eye = self.getWorldPosition()
f = (target - eye).normalized()
up = up.normalized()
s = f.cross(up).normalized()
u = s.cross(f).normalized()
m = Matrix([
[ s.x, u.x, -f.x, 0.0],
[ s.y, u.y, -f.y, 0.0],
[ s.z, u.z, -f.z, 0.0],
[ 0.0, 0.0, 0.0, 1.0]
])
self.setOrientation(Quaternion.fromMatrix(m))
def lookAt(self, target: Vector, up: Vector = Vector.Unit_Y) -> None:
"""Rotate this scene node in such a way that it is looking at target.
:param target: :type{Vector} The target to look at.
:param up: :type{Vector} The vector to consider up. Defaults to Vector.Unit_Y, i.e. (0, 1, 0).
"""
if not self._enabled:
return
eye = self.getWorldPosition()
f = (target - eye).normalized()
up = up.normalized()
s = f.cross(up).normalized()
u = s.cross(f).normalized()
m = Matrix([[s.x, u.x, -f.x, 0.0], [s.y, u.y, -f.y, 0.0],
[s.z, u.z, -f.z, 0.0], [0.0, 0.0, 0.0, 1.0]])
self.setOrientation(Quaternion.fromMatrix(m))
