def _rotateCamera(self, x: float, y: float) -> None:
camera = self._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
self._scene.getSceneLock().acquire()
dx = math.radians(x * 180.0)
dy = math.radians(y * 180.0)
diff = camera.getPosition() - self._origin
my = Matrix()
my.setByRotationAxis(dx, Vector.Unit_Y)
mx = Matrix(my.getData())
mx.rotateByAxis(dy, Vector.Unit_Y.cross(diff).normalized())
n = diff.multiply(mx)
try:
angle = math.acos(Vector.Unit_Y.dot(n.normalized()))
except ValueError:
return
if angle < 0.1 or angle > math.pi - 0.1:
n = diff.multiply(my)
n += self._origin
camera.setPosition(n)
camera.lookAt(self._origin)
self._scene.getSceneLock().release()
def _rotateCamera(self, x: float, y: float) -> None:
"""Rotate the camera in response to a mouse event.
:param x: Amount by which the camera should be rotated horizontally, expressed in pixelunits
:param y: Amount by which the camera should be rotated vertically, expressed in pixelunits
"""
camera = self._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
dx = math.radians(x * 180.0)
dy = math.radians(y * 180.0)
diff = camera.getPosition() - self._origin
my = Matrix()
my.setByRotationAxis(dx, Vector.Unit_Y)
mx = Matrix(my.getData())
mx.rotateByAxis(dy, Vector.Unit_Y.cross(diff).normalized())
n = diff.multiply(mx)
try:
angle = math.acos(Vector.Unit_Y.dot(n.normalized()))
except ValueError:
return
if angle < 0.1 or angle > math.pi - 0.1:
n = diff.multiply(my)
n += self._origin
camera.setPosition(n)
camera.lookAt(self._origin)
def _rotateCamera(self, x, y):
camera = self._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
self._scene.acquireLock()
dx = math.radians(x * 180.0)
dy = math.radians(y * 180.0)
diff = camera.getPosition() - self._origin
my = Matrix()
my.setByRotationAxis(dx, Vector.Unit_Y)
mx = Matrix(my.getData())
mx.rotateByAxis(dy, Vector.Unit_Y.cross(diff).normalized())
n = diff.multiply(mx)
try:
angle = math.acos(Vector.Unit_Y.dot(n.normalized()))
except ValueError:
return
if angle < 0.1 or angle > math.pi - 0.1:
n = diff.multiply(my)
n += self._origin
camera.setPosition(n)
camera.lookAt(self._origin)
self._scene.releaseLock()
def _rotateCamera(self, x, y):
camera = self._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
self._scene.acquireLock()
dx = math.radians(x * 180.0)
dy = math.radians(y * 180.0)
diff = camera.getPosition() - self._origin
diff_flat = Vector(diff.x, 0.0, diff.z).getNormalized()
try:
new_angle = math.acos(diff_flat.dot(diff.getNormalized())) + dy
except ValueError:
return
m = Matrix()
m.setByRotationAxis(dx, Vector.Unit_Y)
if new_angle < (math.pi / 2 - 0.01):
m.rotateByAxis(dy, Vector.Unit_Y.cross(diff).normalize())
n = diff.multiply(m)
n += self._origin
camera.setPosition(n)
camera.lookAt(self._origin)
self._scene.releaseLock()
def _rotateCameraConstrained(angleAzim: float, angleIncl: float) -> None:
if SpaceMouseTool._rotationLocked:
return
camera = SpaceMouseTool._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
# we need to compute the translation and lookAt in one step as we otherwise get artifacts
# from first setting the camera to a new position and then telling it to look at the
# rotation center
up = Vector.Unit_Y
target = SpaceMouseTool._cameraTool.getOrigin()
oldEye = camera.getWorldPosition()
camToTarget = (target - oldEye).normalized()
# compute angle between up axis and current camera ray
try:
angleToY = math.acos(up.dot(camToTarget))
except ValueError:
return
# compute new position of camera
rotMat = Matrix()
rotMat.rotateByAxis(angleAzim, up, target.getData())
# prevent camera from rotating to close to the poles
if (angleToY > 0.1 or angleIncl > 0) and (angleToY < math.pi - 0.1
or angleIncl < 0):
rotMat.rotateByAxis(angleIncl,
up.cross(camToTarget).normalized(),
target.getData())
newEye = oldEye.preMultiply(rotMat)
# look at (from UM.Scene.SceneNode)
f = (target - newEye).normalized()
s = f.cross(up).normalized()
u = s.cross(f).normalized()
# construct new matrix for camera including the new position and orientation from looking at
# the rotation center
newTrafo = Matrix([[s.x, u.x, -f.x, newEye.x],
[s.y, u.y, -f.y, newEye.y],
[s.z, u.z, -f.z, newEye.z], [0.0, 0.0, 0.0, 1.0]])
camera.setTransformation(newTrafo)
def _createPolygon(self, layer_thickness: float, path: List[List[Union[float, int]]], extruder_offsets: List[float]) -> bool:
countvalid = 0
for point in path:
if point[8] > 0:
countvalid += 1
if countvalid >= 2:
# we know what to do now, no need to count further
continue
if countvalid < 2:
return False
try:
self._layer_data_builder.addLayer(self._layer_number)
self._layer_data_builder.setLayerHeight(self._layer_number, path[0][2])
self._layer_data_builder.setLayerThickness(self._layer_number, layer_thickness)
this_layer = self._layer_data_builder.getLayer(self._layer_number)
except ValueError:
return False
count = len(path)
line_types = numpy.empty((count - 1, 1), numpy.int32)
line_widths = numpy.empty((count - 1, 1), numpy.float32)
line_thicknesses = numpy.empty((count - 1, 1), numpy.float32)
line_feedrates = numpy.empty((count - 1, 1), numpy.float32)
line_widths[:, 0] = 0.35 # Just a guess
line_thicknesses[:, 0] = layer_thickness
points = numpy.empty((count, 6), numpy.float32)
extrusion_values = numpy.empty((count, 1), numpy.float32)
i = 0
for point in path:
matrix = Matrix([[point[0], point[1], point[2], 1]])
vector_matrix = Matrix([[0,0,1,1]])
matrix.rotateByAxis(radians(point[3]), Vector.Unit_X)
matrix.rotateByAxis(radians(point[4]), Vector.Unit_Y)
matrix.rotateByAxis(radians(point[5]), Vector.Unit_Z)
vector_matrix.rotateByAxis(radians(point[3]), Vector.Unit_X)
vector_matrix.rotateByAxis(radians(point[4]), Vector.Unit_Y)
vector_matrix.rotateByAxis(radians(point[5]), Vector.Unit_Z)
#points[i, :] = [point[0] + extruder_offsets[0], point[2], -point[1] - extruder_offsets[1]]
points[i, :] = [matrix.at(0,0) + extruder_offsets[0], matrix.at(0,2), -matrix.at(0,1)-extruder_offsets[1],
-vector_matrix.at(0,1), vector_matrix.at(0,2), -vector_matrix.at(0,0)]
extrusion_values[i] = point[7]
if i > 0:
line_feedrates[i - 1] = point[6]
line_types[i - 1] = point[8]
if point[8] in [LayerPolygon.MoveCombingType, LayerPolygon.MoveRetractionType]:
line_widths[i - 1] = 0.1
line_thicknesses[i - 1] = 0.0 # Travels are set as zero thickness lines
else:
line_widths[i - 1] = self._calculateLineWidth(points[i], points[i-1], extrusion_values[i], extrusion_values[i-1], layer_thickness)
i += 1
this_poly = LayerPolygon(self._extruder_number, line_types, points, line_widths, line_thicknesses, line_feedrates)
this_poly.buildCache()
this_layer.polygons.append(this_poly)
return True
def _rotateCamera(self, x, y):
camera = self._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
self._scene.acquireLock()
dx = math.radians(x * 180.0)
dy = math.radians(y * 180.0)
diff = camera.getPosition() - self._origin
m = Matrix()
m.setByRotationAxis(dx, Vector.Unit_Y)
m.rotateByAxis(dy, Vector.Unit_Y.cross(diff).normalize())
n = diff.multiply(m)
n += self._origin
camera.setPosition(n)
camera.lookAt(self._origin)
self._scene.releaseLock()
def _rotateCamera(self, yaw: float, pitch: float, roll: float) -> None:
camera = self._scene.getActiveCamera()
if not camera or not camera.isEnabled():
return
dyaw = math.radians(yaw * 180.0)
dpitch = math.radians(pitch * 180.0)
droll = math.radians(roll * 180.0)
diff = camera.getPosition() - self._camera_tool._origin
myaw = Matrix()
myaw.setByRotationAxis(dyaw, Vector.Unit_Y)
mpitch = Matrix(myaw.getData())
mpitch.rotateByAxis(dpitch, Vector.Unit_Y.cross(diff))
n = diff.multiply(mpitch)
try:
angle = math.acos(Vector.Unit_Y.dot(n.normalized()))
except ValueError:
return
if angle < 0.1 or angle > math.pi - 0.1:
n = diff.multiply(myaw)
n += self._camera_tool._origin
camera.setPosition(n)
if abs(self._roll + droll) < math.pi * 0.45:
self._roll += droll
mroll = Matrix()
mroll.setByRotationAxis(self._roll, (n - self._camera_tool._origin))
camera.lookAt(self._camera_tool._origin, Vector.Unit_Y.multiply(mroll))
