def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return minW = -self._width / 2 maxW = self._width / 2 minH = 0.0 maxH = self._height minD = -self._depth / 2 maxD = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(minW, minH, minD), Vector(maxW, minH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, maxH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(maxW, maxH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, maxH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(maxW, minH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(minW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, maxD), Vector(maxW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, maxD), Vector(maxW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, minH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, minH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(minW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, maxH, minD), Vector(maxW, maxH, maxD), color = self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad( Vector(minW, minH, minD), Vector(maxW, minH, minD), Vector(maxW, minH, maxD), Vector(minW, minH, maxD) ) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) if self._disallowed_areas: mb = MeshBuilder() for area in self._disallowed_areas: mb.addQuad( area[0], area[1], area[2], area[3], color = Color(174, 174, 174, 255) ) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum = Vector(minW, minH - 1.0, minD), maximum = Vector(maxW, maxH, maxD))
def __init__(self, parent=None): super().__init__(parent) self._handle_width = 8 self._handle_height = 14 self._handle_position = 20 mb = MeshBuilder() mb.addPyramid(width=self._handle_width, height=self._handle_height, depth=self._handle_width, center=Vector(0, self._handle_position, 0), color=ToolHandle.YAxisColor) mb.addPyramid(width=self._handle_width, height=self._handle_height, depth=self._handle_width, center=Vector(0, -self._handle_position, 0), color=ToolHandle.YAxisColor, axis=Vector.Unit_X, angle=180) mb.addPyramid(width=self._handle_width, height=self._handle_height, depth=self._handle_width, center=Vector(self._handle_position, 0, 0), color=ToolHandle.XAxisColor, axis=Vector.Unit_Z, angle=90) mb.addPyramid(width=self._handle_width, height=self._handle_height, depth=self._handle_width, center=Vector(-self._handle_position, 0, 0), color=ToolHandle.XAxisColor, axis=Vector.Unit_Z, angle=-90) mb.addPyramid(width=self._handle_width, height=self._handle_height, depth=self._handle_width, center=Vector(0, 0, -self._handle_position), color=ToolHandle.ZAxisColor, axis=Vector.Unit_X, angle=90) mb.addPyramid(width=self._handle_width, height=self._handle_height, depth=self._handle_width, center=Vector(0, 0, self._handle_position), color=ToolHandle.ZAxisColor, axis=Vector.Unit_X, angle=-90) self.setSolidMesh(mb.getData()) self.setSelectionMesh(mb.getData())
def __init__(self, parent=None): super().__init__(parent) self._inner_radius = 40 self._outer_radius = 40.5 self._line_width = 0.5 self._active_inner_radius = 37 self._active_outer_radius = 44 self._active_line_width = 3 #SOLIDMESH mb = MeshBuilder() mb.addDonut(inner_radius=self._inner_radius, outer_radius=self._outer_radius, width=self._line_width, color=ToolHandle.ZAxisColor) mb.addDonut(inner_radius=self._inner_radius, outer_radius=self._outer_radius, width=self._line_width, axis=Vector.Unit_X, angle=math.pi / 2, color=ToolHandle.YAxisColor) mb.addDonut(inner_radius=self._inner_radius, outer_radius=self._outer_radius, width=self._line_width, axis=Vector.Unit_Y, angle=math.pi / 2, color=ToolHandle.XAxisColor) self.setSolidMesh(mb.getData()) #SELECTIONMESH mb = MeshBuilder() mb.addDonut(inner_radius=self._active_inner_radius, outer_radius=self._active_outer_radius, width=self._active_line_width, color=ToolHandle.ZAxisColor) mb.addDonut(inner_radius=self._active_inner_radius, outer_radius=self._active_outer_radius, width=self._active_line_width, axis=Vector.Unit_X, angle=math.pi / 2, color=ToolHandle.YAxisColor) mb.addDonut(inner_radius=self._active_inner_radius, outer_radius=self._active_outer_radius, width=self._active_line_width, axis=Vector.Unit_Y, angle=math.pi / 2, color=ToolHandle.XAxisColor) self.setSelectionMesh(mb.getData())
def __init__(self, parent = None): super().__init__(parent) mb = MeshBuilder() mb.addArc( radius = 20, axis = Vector.Unit_X, color = ToolHandle.XAxisColor ) mb.addArc( radius = 20, axis = Vector.Unit_Y, color = ToolHandle.YAxisColor ) mb.addArc( radius = 20, axis = Vector.Unit_Z, color = ToolHandle.ZAxisColor ) self.setLineMesh(mb.getData()) mb = MeshBuilder() mb.addDonut( inner_radius = 18, outer_radius = 21, width = 1, color = ToolHandle.ZAxisColor ) mb.addDonut( inner_radius = 18, outer_radius = 21, width = 1, axis = Vector.Unit_X, angle = math.pi / 2, color = ToolHandle.YAxisColor ) mb.addDonut( inner_radius = 18, outer_radius = 21, width = 1, axis = Vector.Unit_Y, angle = math.pi / 2, color = ToolHandle.XAxisColor ) self.setSelectionMesh(mb.getData())
def createMeshOrJumps(self, make_mesh): builder = MeshBuilder() for polygon in self._polygons: if make_mesh and (polygon.type == Polygon.MoveCombingType or polygon.type == Polygon.MoveRetractionType): continue if not make_mesh and not (polygon.type == Polygon.MoveCombingType or polygon.type == Polygon.MoveRetractionType): continue poly_color = polygon.getColor() points = numpy.copy(polygon.data) if polygon.type == Polygon.InfillType or polygon.type == Polygon.SkinType or polygon.type == Polygon.SupportInfillType: points[:,1] -= 0.01 if polygon.type == Polygon.MoveCombingType or polygon.type == Polygon.MoveRetractionType: points[:,1] += 0.01 # Calculate normals for the entire polygon using numpy. normals = numpy.copy(points) normals[:,1] = 0.0 # We are only interested in 2D normals # Calculate the edges between points. # The call to numpy.roll shifts the entire array by one so that # we end up subtracting each next point from the current, wrapping # around. This gives us the edges from the next point to the current # point. normals[:] = normals[:] - numpy.roll(normals, -1, axis = 0) # Calculate the length of each edge using standard Pythagoras lengths = numpy.sqrt(normals[:,0] ** 2 + normals[:,2] ** 2) # The normal of a 2D vector is equal to its x and y coordinates swapped # and then x inverted. This code does that. normals[:,[0, 2]] = normals[:,[2, 0]] normals[:,0] *= -1 # Normalize the normals. normals[:,0] /= lengths normals[:,2] /= lengths # Scale all by the line width of the polygon so we can easily offset. normals *= (polygon.lineWidth / 2) #TODO: Use numpy magic to perform the vertex creation to speed up things. for i in range(len(points)): start = points[i - 1] end = points[i] normal = normals[i - 1] point1 = Vector(data = start - normal) point2 = Vector(data = start + normal) point3 = Vector(data = end + normal) point4 = Vector(data = end - normal) builder.addQuad(point1, point2, point3, point4, color = poly_color) return builder.getData()
def createMesh(self): builder = MeshBuilder() for polygon in self._polygons: poly_color = polygon.getColor() points = numpy.copy(polygon.data) if polygon.type == Polygon.InfillType or polygon.type == Polygon.SkinType or polygon.type == Polygon.SupportInfillType: points[:, 1] -= 0.01 # Calculate normals for the entire polygon using numpy. normals = numpy.copy(points) normals[:, 1] = 0.0 # We are only interested in 2D normals # Calculate the edges between points. # The call to numpy.roll shifts the entire array by one so that # we end up subtracting each next point from the current, wrapping # around. This gives us the edges from the next point to the current # point. normals[:] = normals[:] - numpy.roll(normals, -1, axis=0) # Calculate the length of each edge using standard Pythagoras lengths = numpy.sqrt(normals[:, 0]**2 + normals[:, 2]**2) # The normal of a 2D vector is equal to its x and y coordinates swapped # and then x inverted. This code does that. normals[:, [0, 2]] = normals[:, [2, 0]] normals[:, 0] *= -1 # Normalize the normals. normals[:, 0] /= lengths normals[:, 2] /= lengths # Scale all by the line width of the polygon so we can easily offset. normals *= (polygon.lineWidth / 2) #TODO: Use numpy magic to perform the vertex creation to speed up things. for i in range(len(points)): start = points[i - 1] end = points[i] normal = normals[i - 1] point1 = Vector(data=start - normal) point2 = Vector(data=start + normal) point3 = Vector(data=end + normal) point4 = Vector(data=end - normal) builder.addQuad(point1, point2, point3, point4, color=poly_color) return builder.getData()
def createHullMesh(self, hull_points): # Input checking. if len(hull_points) < 3: return None mesh_builder = MeshBuilder() point_first = Vector(hull_points[0][0], self._mesh_height, hull_points[0][1]) point_previous = Vector(hull_points[1][0], self._mesh_height, hull_points[1][1]) for point in hull_points[2:]: # Add the faces in the order of a triangle fan. point_new = Vector(point[0], self._mesh_height, point[1]) mesh_builder.addFace(point_first, point_previous, point_new, color = self._color) point_previous = point_new # Prepare point_previous for the next triangle. return mesh_builder.getData()
def createHullMesh(self, hull_points): #Input checking. if len(hull_points) < 3: return None mesh_builder = MeshBuilder() point_first = Vector(hull_points[0][0], self._mesh_height, hull_points[0][1]) point_previous = Vector(hull_points[1][0], self._mesh_height, hull_points[1][1]) for point in hull_points[2:]: #Add the faces in the order of a triangle fan. point_new = Vector(point[0], self._mesh_height, point[1]) mesh_builder.addFace(point_first, point_previous, point_new, color = self._color) point_previous = point_new #Prepare point_previous for the next triangle. return mesh_builder.getData()
def createMeshOrJumps(self, make_mesh): builder = MeshBuilder() for polygon in self._polygons: if make_mesh and (polygon.type == Polygon.MoveCombingType or polygon.type == Polygon.MoveRetractionType): continue if not make_mesh and not (polygon.type == Polygon.MoveCombingType or polygon.type == Polygon.MoveRetractionType): continue poly_color = polygon.getColor() points = numpy.copy(polygon.data) if polygon.type == Polygon.InfillType or polygon.type == Polygon.SkinType or polygon.type == Polygon.SupportInfillType: points[:, 1] -= 0.01 if polygon.type == Polygon.MoveCombingType or polygon.type == Polygon.MoveRetractionType: points[:, 1] += 0.01 normals = polygon.getNormals() # Scale all by the line width of the polygon so we can easily offset. normals *= (polygon.lineWidth / 2) #TODO: Use numpy magic to perform the vertex creation to speed up things. for i in range(len(points)): start = points[i - 1] end = points[i] normal = normals[i - 1] point1 = Vector(data=start - normal) point2 = Vector(data=start + normal) point3 = Vector(data=end + normal) point4 = Vector(data=end - normal) builder.addQuad(point1, point2, point3, point4, color=poly_color) return builder.getData()
def createMeshOrJumps(self, make_mesh): builder = MeshBuilder() for polygon in self._polygons: if make_mesh and (polygon.type == LayerPolygon.MoveCombingType or polygon.type == LayerPolygon.MoveRetractionType): continue if not make_mesh and not (polygon.type == LayerPolygon.MoveCombingType or polygon.type == LayerPolygon.MoveRetractionType): continue poly_color = polygon.getColor() points = numpy.copy(polygon.data) if polygon.type == LayerPolygon.InfillType or polygon.type == LayerPolygon.SkinType or polygon.type == LayerPolygon.SupportInfillType: points[:,1] -= 0.01 if polygon.type == LayerPolygon.MoveCombingType or polygon.type == LayerPolygon.MoveRetractionType: points[:,1] += 0.01 normals = polygon.getNormals() # Scale all by the line width of the polygon so we can easily offset. normals *= (polygon.lineWidth / 2) #TODO: Use numpy magic to perform the vertex creation to speed up things. for i in range(len(points)): start = points[i - 1] end = points[i] normal = normals[i - 1] point1 = Vector(data = start - normal) point2 = Vector(data = start + normal) point3 = Vector(data = end + normal) point4 = Vector(data = end - normal) builder.addQuad(point1, point2, point3, point4, color = poly_color) return builder.getData()
def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return minW = -self._width / 2 maxW = self._width / 2 minH = 0.0 maxH = self._height minD = -self._depth / 2 maxD = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(minW, minH, minD), Vector(maxW, minH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, maxH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(maxW, maxH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, maxH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(maxW, minH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(minW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, maxD), Vector(maxW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, maxD), Vector(maxW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, minH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, minH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(minW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, maxH, minD), Vector(maxW, maxH, maxD), color=self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad(Vector(minW, minH, minD), Vector(maxW, minH, minD), Vector(maxW, minH, maxD), Vector(minW, minH, maxD)) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) disallowed_area_height = 0.2 disallowed_area_size = 0 if self._disallowed_areas: mb = MeshBuilder() color = Color(0.0, 0.0, 0.0, 0.15) for polygon in self._disallowed_areas: points = polygon.getPoints() first = Vector(self._clamp(points[0][0], minW, maxW), disallowed_area_height, self._clamp(points[0][1], minD, maxD)) previous_point = Vector(self._clamp(points[0][0], minW, maxW), disallowed_area_height, self._clamp(points[0][1], minD, maxD)) for point in points: new_point = Vector(self._clamp(point[0], minW, maxW), disallowed_area_height, self._clamp(point[1], minD, maxD)) mb.addFace(first, previous_point, new_point, color=color) previous_point = new_point # Find the largest disallowed area to exclude it from the maximum scale bounds size = abs(numpy.max(points[:, 1]) - numpy.min(points[:, 1])) disallowed_area_size = max(size, disallowed_area_size) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum=Vector(minW, minH - 1.0, minD), maximum=Vector(maxW, maxH, maxD)) skirt_size = 0.0 profile = Application.getInstance().getMachineManager( ).getActiveProfile() if profile: skirt_size = self._getSkirtSize(profile) scale_to_max_bounds = AxisAlignedBox( minimum=Vector(minW + skirt_size, minH, minD + skirt_size + disallowed_area_size), maximum=Vector(maxW - skirt_size, maxH, maxD - skirt_size - disallowed_area_size)) Application.getInstance().getController().getScene( )._maximum_bounds = scale_to_max_bounds
def __init__(self, parent = None): super().__init__(parent) mb = MeshBuilder() mb.addPyramid( width = 4, height = 7, depth = 4, center = Vector(0, 10, 0), color = ToolHandle.YAxisColor ) mb.addPyramid( width = 4, height = 7, depth = 4, center = Vector(0, -10, 0), color = ToolHandle.YAxisColor, axis = Vector.Unit_X, angle = 180 ) mb.addPyramid( width = 4, height = 7, depth = 4, center = Vector(10, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = 90 ) mb.addPyramid( width = 4, height = 7, depth = 4, center = Vector(-10, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = -90 ) mb.addPyramid( width = 4, height = 7, depth = 4, center = Vector(0, 0, -10), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = 90 ) mb.addPyramid( width = 4, height = 7, depth = 4, center = Vector(0, 0, 10), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = -90 ) self.setSolidMesh(mb.getData()) self.setSelectionMesh(mb.getData())
def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return min_w = -self._width / 2 max_w = self._width / 2 min_h = 0.0 max_h = self._height min_d = -self._depth / 2 max_d = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(min_w, min_h, min_d), Vector(max_w, min_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, max_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, min_d), Vector(max_w, max_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, max_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, max_d), Vector(max_w, min_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, max_d), Vector(min_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, max_d), Vector(max_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, max_d), Vector(max_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, min_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, min_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, min_d), Vector(min_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, max_h, min_d), Vector(max_w, max_h, max_d), color = self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad( Vector(min_w, min_h - 0.2, min_d), Vector(max_w, min_h - 0.2, min_d), Vector(max_w, min_h - 0.2, max_d), Vector(min_w, min_h - 0.2, max_d) ) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) disallowed_area_height = 0.1 disallowed_area_size = 0 if self._disallowed_areas: mb = MeshBuilder() color = Color(0.0, 0.0, 0.0, 0.15) for polygon in self._disallowed_areas: points = polygon.getPoints() first = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height, self._clamp(points[0][1], min_d, max_d)) previous_point = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height, self._clamp(points[0][1], min_d, max_d)) for point in points: new_point = Vector(self._clamp(point[0], min_w, max_w), disallowed_area_height, self._clamp(point[1], min_d, max_d)) mb.addFace(first, previous_point, new_point, color = color) previous_point = new_point # Find the largest disallowed area to exclude it from the maximum scale bounds size = abs(numpy.max(points[:, 1]) - numpy.min(points[:, 1])) disallowed_area_size = max(size, disallowed_area_size) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum = Vector(min_w, min_h - 1.0, min_d), maximum = Vector(max_w, max_h, max_d)) skirt_size = 0.0 profile = Application.getInstance().getMachineManager().getActiveProfile() if profile: skirt_size = self._getSkirtSize(profile) scale_to_max_bounds = AxisAlignedBox( minimum = Vector(min_w + skirt_size, min_h, min_d + skirt_size + disallowed_area_size), maximum = Vector(max_w - skirt_size, max_h, max_d - skirt_size - disallowed_area_size) ) Application.getInstance().getController().getScene()._maximum_bounds = scale_to_max_bounds
def __init__(self, parent=None): super().__init__(parent) self._line_width = 0.5 self._line_length = 40 self._handle_position = 40 self._handle_width = 4 self._active_line_width = 0.8 self._active_line_length = 40 self._active_handle_position = 40 self._active_handle_width = 15 #SOLIDMESH -> LINES mb = MeshBuilder() mb.addCube(width=self._line_width, height=self._line_length, depth=self._line_width, center=Vector(0, self._handle_position / 2, 0), color=ToolHandle.YAxisColor) mb.addCube(width=self._line_length, height=self._line_width, depth=self._line_width, center=Vector(self._handle_position / 2, 0, 0), color=ToolHandle.XAxisColor) mb.addCube(width=self._line_width, height=self._line_width, depth=self._line_length, center=Vector(0, 0, self._handle_position / 2), color=ToolHandle.ZAxisColor) #SOLIDMESH -> HANDLES mb.addCube(width=self._handle_width, height=self._handle_width, depth=self._handle_width, center=Vector(0, 0, 0), color=ToolHandle.AllAxisColor) mb.addCube(width=self._handle_width, height=self._handle_width, depth=self._handle_width, center=Vector(0, self._handle_position, 0), color=ToolHandle.YAxisColor) mb.addCube(width=self._handle_width, height=self._handle_width, depth=self._handle_width, center=Vector(self._handle_position, 0, 0), color=ToolHandle.XAxisColor) mb.addCube(width=self._handle_width, height=self._handle_width, depth=self._handle_width, center=Vector(0, 0, self._handle_position), color=ToolHandle.ZAxisColor) self.setSolidMesh(mb.getData()) #SELECTIONMESH -> LINES mb = MeshBuilder() mb.addCube(width=self._active_line_width, height=self._active_line_length, depth=self._active_line_width, center=Vector(0, self._active_handle_position / 2, 0), color=ToolHandle.YAxisColor) mb.addCube(width=self._active_line_length, height=self._active_line_width, depth=self._active_line_width, center=Vector(self._active_handle_position / 2, 0, 0), color=ToolHandle.XAxisColor) mb.addCube(width=self._active_line_width, height=self._active_line_width, depth=self._active_line_length, center=Vector(0, 0, self._active_handle_position / 2), color=ToolHandle.ZAxisColor) #SELECTIONMESH -> HANDLES mb.addCube(width=self._active_handle_width, height=self._active_handle_width, depth=self._active_handle_width, center=Vector(0, 0, 0), color=ToolHandle.AllAxisColor) mb.addCube(width=self._active_handle_width, height=self._active_handle_width, depth=self._active_handle_width, center=Vector(0, self._active_handle_position, 0), color=ToolHandle.YAxisColor) mb.addCube(width=self._active_handle_width, height=self._active_handle_width, depth=self._active_handle_width, center=Vector(self._active_handle_position, 0, 0), color=ToolHandle.XAxisColor) mb.addCube(width=self._active_handle_width, height=self._active_handle_width, depth=self._active_handle_width, center=Vector(0, 0, self._active_handle_position), color=ToolHandle.ZAxisColor) self.setSelectionMesh(mb.getData())
def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return minW = -self._width / 2 maxW = self._width / 2 minH = 0.0 maxH = self._height minD = -self._depth / 2 maxD = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(minW, minH, minD), Vector(maxW, minH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, maxH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(maxW, maxH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, maxH, minD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(maxW, minH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(minW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, maxD), Vector(maxW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, maxD), Vector(maxW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, minH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, minH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(minW, maxH, maxD), color = self.VolumeOutlineColor) mb.addLine(Vector(maxW, maxH, minD), Vector(maxW, maxH, maxD), color = self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad( Vector(minW, minH, minD), Vector(maxW, minH, minD), Vector(maxW, minH, maxD), Vector(minW, minH, maxD) ) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) disallowed_area_size = 0 if self._disallowed_areas: mb = MeshBuilder() for polygon in self._disallowed_areas: points = polygon.getPoints() mb.addQuad( Vector(points[0, 0], 0.1, points[0, 1]), Vector(points[1, 0], 0.1, points[1, 1]), Vector(points[2, 0], 0.1, points[2, 1]), Vector(points[3, 0], 0.1, points[3, 1]), color = Color(174, 174, 174, 255) ) # Find the largest disallowed area to exclude it from the maximum scale bounds size = abs(numpy.max(points[:, 1]) - numpy.min(points[:, 1])) disallowed_area_size = max(size, disallowed_area_size) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum = Vector(minW, minH - 1.0, minD), maximum = Vector(maxW, maxH, maxD)) settings = Application.getInstance().getActiveMachine() skirt_size = 0.0 if settings.getSettingValueByKey("adhesion_type") == "None": skirt_size = settings.getSettingValueByKey("skirt_line_count") * settings.getSettingValueByKey("skirt_line_width") + settings.getSettingValueByKey("skirt_gap") elif settings.getSettingValueByKey("adhesion_type") == "Brim": skirt_size = settings.getSettingValueByKey("brim_line_count") * settings.getSettingValueByKey("skirt_line_width") else: skirt_size = settings.getSettingValueByKey("skirt_line_width") skirt_size += settings.getSettingValueByKey("skirt_line_width") scale_to_max_bounds = AxisAlignedBox( minimum = Vector(minW + skirt_size, minH, minD + skirt_size + disallowed_area_size), maximum = Vector(maxW - skirt_size, maxH, maxD - skirt_size - disallowed_area_size) ) Application.getInstance().getController().getScene()._maximum_bounds = scale_to_max_bounds
def _rebuild(self): mb = MeshBuilder() #SOLIDMESH -> LINES if self.YAxis in self._enabled_axis: mb.addCube(width=self._lineWidth, height=self._lineLength, depth=self._lineWidth, center=Vector(0, self._handlePosition / 2, 0), color=ToolHandle.YAxisColor) if self.XAxis in self._enabled_axis: mb.addCube(width=self._lineLength, height=self._lineWidth, depth=self._lineWidth, center=Vector(self._handlePosition / 2, 0, 0), color=ToolHandle.XAxisColor) if self.ZAxis in self._enabled_axis: mb.addCube(width=self._lineWidth, height=self._lineWidth, depth=self._lineLength, center=Vector(0, 0, self._handlePosition / 2), color=ToolHandle.ZAxisColor) #SOLIDMESH -> HANDLES if self.YAxis in self._enabled_axis: mb.addPyramid(width=self._handleWidth, height=self._handleHeight, depth=self._handleWidth, center=Vector(0, self._handlePosition, 0), color=ToolHandle.YAxisColor) if self.XAxis in self._enabled_axis: mb.addPyramid(width=self._handleWidth, height=self._handleHeight, depth=self._handleWidth, center=Vector(self._handlePosition, 0, 0), color=ToolHandle.XAxisColor, axis=Vector.Unit_Z, angle=90) if self.ZAxis in self._enabled_axis: mb.addPyramid(width=self._handleWidth, height=self._handleHeight, depth=self._handleWidth, center=Vector(0, 0, self._handlePosition), color=ToolHandle.ZAxisColor, axis=Vector.Unit_X, angle=-90) self.setSolidMesh(mb.getData()) mb = MeshBuilder() #ACTIVEMESH -> LINES if self.YAxis in self._enabled_axis: mb.addCube(width=self._activeLineWidth, height=self._activeLineLength, depth=self._activeLineWidth, center=Vector(0, self._activeHandlePosition / 2, 0), color=ToolHandle.YAxisColor) if self.XAxis in self._enabled_axis: mb.addCube(width=self._activeLineLength, height=self._activeLineWidth, depth=self._activeLineWidth, center=Vector(self._activeHandlePosition / 2, 0, 0), color=ToolHandle.XAxisColor) if self.ZAxis in self._enabled_axis: mb.addCube(width=self._activeLineWidth, height=self._activeLineWidth, depth=self._activeLineLength, center=Vector(0, 0, self._activeHandlePosition / 2), color=ToolHandle.ZAxisColor) #SELECTIONMESH -> HANDLES mb.addCube(width=self._activeHandleWidth, height=self._activeHandleWidth, depth=self._activeHandleWidth, center=Vector(0, 0, 0), color=ToolHandle.AllAxisColor) mb.addCube(width=self._activeHandleWidth, height=self._activeHandleWidth, depth=self._activeHandleWidth, center=Vector(0, self._activeHandlePosition, 0), color=ToolHandle.YAxisColor) mb.addCube(width=self._activeHandleWidth, height=self._activeHandleWidth, depth=self._activeHandleWidth, center=Vector(self._activeHandlePosition, 0, 0), color=ToolHandle.XAxisColor) mb.addCube(width=self._activeHandleWidth, height=self._activeHandleWidth, depth=self._activeHandleWidth, center=Vector(0, 0, self._activeHandlePosition), color=ToolHandle.ZAxisColor) self.setSelectionMesh(mb.getData())
def __init__(self, parent = None): super().__init__(parent) lines = MeshData() lines.addVertex(0, 0, 0) lines.addVertex(0, 20, 0) lines.addVertex(0, 0, 0) lines.addVertex(20, 0, 0) lines.addVertex(0, 0, 0) lines.addVertex(0, 0, 20) lines.setVertexColor(0, ToolHandle.YAxisColor) lines.setVertexColor(1, ToolHandle.YAxisColor) lines.setVertexColor(2, ToolHandle.XAxisColor) lines.setVertexColor(3, ToolHandle.XAxisColor) lines.setVertexColor(4, ToolHandle.ZAxisColor) lines.setVertexColor(5, ToolHandle.ZAxisColor) self.setLineMesh(lines) mb = MeshBuilder() mb.addCube( width = 2, height = 2, depth = 2, center = Vector(0, 0, 0), color = ToolHandle.AllAxisColor ) mb.addCube( width = 2, height = 2, depth = 2, center = Vector(0, 20, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = 2, height = 2, depth = 2, center = Vector(20, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = 2, height = 2, depth = 2, center = Vector(0, 0, 20), color = ToolHandle.ZAxisColor ) self.setSolidMesh(mb.getData()) mb = MeshBuilder() mb.addCube( width = 4, height = 20, depth = 4, center = Vector(0, 10, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = 4, height = 4, depth = 4, center = Vector(0, 20, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = 20, height = 4, depth = 4, center = Vector(10, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = 4, height = 4, depth = 4, center = Vector(20, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = 4, height = 4, depth = 20, center = Vector(0, 0, 10), color = ToolHandle.ZAxisColor ) mb.addCube( width = 4, height = 4, depth = 4, center = Vector(0, 0, 20), color = ToolHandle.ZAxisColor ) mb.addCube( width = 8, height = 8, depth = 8, center = Vector(0, 0, 0), color = ToolHandle.AllAxisColor ) self.setSelectionMesh(mb.getData())
def __init__(self, parent = None): super().__init__(parent) self._innerRadius = 40 self._outerRadius = 40.5 self._lineWidth = 0.5 self._activeInnerRadius = 37 self._activeOuterRadius = 44 self._activeLineWidth = 3 #SOLIDMESH mb = MeshBuilder() mb.addDonut( inner_radius = self._innerRadius, outer_radius = self._outerRadius, width = self._lineWidth, color = ToolHandle.ZAxisColor ) mb.addDonut( inner_radius = self._innerRadius, outer_radius = self._outerRadius, width = self._lineWidth, axis = Vector.Unit_X, angle = math.pi / 2, color = ToolHandle.YAxisColor ) mb.addDonut( inner_radius = self._innerRadius, outer_radius = self._outerRadius, width = self._lineWidth, axis = Vector.Unit_Y, angle = math.pi / 2, color = ToolHandle.XAxisColor ) self.setSolidMesh(mb.getData()) #SELECTIONMESH mb = MeshBuilder() mb.addDonut( inner_radius = self._activeInnerRadius, outer_radius = self._activeOuterRadius, width = self._activeLineWidth, color = ToolHandle.ZAxisColor ) mb.addDonut( inner_radius = self._activeInnerRadius, outer_radius = self._activeOuterRadius, width = self._activeLineWidth, axis = Vector.Unit_X, angle = math.pi / 2, color = ToolHandle.YAxisColor ) mb.addDonut( inner_radius = self._activeInnerRadius, outer_radius = self._activeOuterRadius, width = self._activeLineWidth, axis = Vector.Unit_Y, angle = math.pi / 2, color = ToolHandle.XAxisColor ) self.setSelectionMesh(mb.getData())
def _rebuild(self): lines = MeshData() offset = 0 if self.YAxis in self._enabled_axis: lines.addVertex(0, 0, 0) lines.addVertex(0, 20, 0) lines.setVertexColor(offset, ToolHandle.YAxisColor) lines.setVertexColor(offset + 1, ToolHandle.YAxisColor) offset += 2 if self.XAxis in self._enabled_axis: lines.addVertex(0, 0, 0) lines.addVertex(20, 0, 0) lines.setVertexColor(offset, ToolHandle.XAxisColor) lines.setVertexColor(offset + 1, ToolHandle.XAxisColor) offset += 2 if self.ZAxis in self._enabled_axis: lines.addVertex(0, 0, 0) lines.addVertex(0, 0, 20) lines.setVertexColor(offset, ToolHandle.ZAxisColor) lines.setVertexColor(offset + 1, ToolHandle.ZAxisColor) offset += 2 self.setLineMesh(lines) mb = MeshBuilder() if self.YAxis in self._enabled_axis: mb.addPyramid( width = 2, height = 4, depth = 2, center = Vector(0, 20, 0), color = ToolHandle.YAxisColor ) if self.XAxis in self._enabled_axis: mb.addPyramid( width = 2, height = 4, depth = 2, center = Vector(20, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = 90 ) if self.ZAxis in self._enabled_axis: mb.addPyramid( width = 2, height = 4, depth = 2, center = Vector(0, 0, 20), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = -90 ) self.setSolidMesh(mb.getData()) mb = MeshBuilder() if self.YAxis in self._enabled_axis: mb.addCube( width = 4, height = 20, depth = 4, center = Vector(0, 10, 0), color = ToolHandle.YAxisColor ) mb.addPyramid( width = 4, height = 8, depth = 4, center = Vector(0, 20, 0), color = ToolHandle.YAxisColor ) if self.XAxis in self._enabled_axis: mb.addCube( width = 20, height = 4, depth = 4, center = Vector(10, 0, 0), color = ToolHandle.XAxisColor ) mb.addPyramid( width = 4, height = 8, depth = 4, center = Vector(20, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = 90 ) if self.ZAxis in self._enabled_axis: mb.addCube( width = 4, height = 4, depth = 20, center = Vector(0, 0, 10), color = ToolHandle.ZAxisColor ) mb.addPyramid( width = 4, height = 8, depth = 4, center = Vector(0, 0, 20), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = -90 ) self.setSelectionMesh(mb.getData())
def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return minW = -self._width / 2 maxW = self._width / 2 minH = 0.0 maxH = self._height minD = -self._depth / 2 maxD = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(minW, minH, minD), Vector(maxW, minH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, maxH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(maxW, maxH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, maxH, minD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(maxW, minH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, maxD), Vector(minW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, maxD), Vector(maxW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, maxD), Vector(maxW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, minH, minD), Vector(minW, minH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, minH, minD), Vector(maxW, minH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(minW, maxH, minD), Vector(minW, maxH, maxD), color=self.VolumeOutlineColor) mb.addLine(Vector(maxW, maxH, minD), Vector(maxW, maxH, maxD), color=self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad(Vector(minW, minH, minD), Vector(maxW, minH, minD), Vector(maxW, minH, maxD), Vector(minW, minH, maxD)) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) disallowed_area_size = 0 if self._disallowed_areas: mb = MeshBuilder() for polygon in self._disallowed_areas: points = polygon.getPoints() mb.addQuad(Vector(points[0, 0], 0.1, points[0, 1]), Vector(points[1, 0], 0.1, points[1, 1]), Vector(points[2, 0], 0.1, points[2, 1]), Vector(points[3, 0], 0.1, points[3, 1]), color=Color(174, 174, 174, 255)) # Find the largest disallowed area to exclude it from the maximum scale bounds size = abs(numpy.max(points[:, 1]) - numpy.min(points[:, 1])) disallowed_area_size = max(size, disallowed_area_size) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum=Vector(minW, minH - 1.0, minD), maximum=Vector(maxW, maxH, maxD)) settings = Application.getInstance().getActiveMachine() skirt_size = 0.0 if settings.getSettingValueByKey("adhesion_type") == "None": skirt_size = settings.getSettingValueByKey( "skirt_line_count") * settings.getSettingValueByKey( "skirt_line_width") + settings.getSettingValueByKey( "skirt_gap") elif settings.getSettingValueByKey("adhesion_type") == "Brim": skirt_size = settings.getSettingValueByKey( "brim_line_count") * settings.getSettingValueByKey( "skirt_line_width") else: skirt_size = settings.getSettingValueByKey("skirt_line_width") skirt_size += settings.getSettingValueByKey("skirt_line_width") scale_to_max_bounds = AxisAlignedBox( minimum=Vector(minW + skirt_size, minH, minD + skirt_size + disallowed_area_size), maximum=Vector(maxW - skirt_size, maxH, maxD - skirt_size - disallowed_area_size)) Application.getInstance().getController().getScene( )._maximum_bounds = scale_to_max_bounds
def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return min_w = -self._width / 2 max_w = self._width / 2 min_h = 0.0 max_h = self._height min_d = -self._depth / 2 max_d = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(min_w, min_h, min_d), Vector(max_w, min_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, max_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, min_d), Vector(max_w, max_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, max_h, min_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, max_d), Vector(max_w, min_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, max_d), Vector(min_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, max_d), Vector(max_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, max_d), Vector(max_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, min_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, min_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, min_d), Vector(min_w, max_h, max_d), color = self.VolumeOutlineColor) mb.addLine(Vector(max_w, max_h, min_d), Vector(max_w, max_h, max_d), color = self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad( Vector(min_w, min_h - 0.2, min_d), Vector(max_w, min_h - 0.2, min_d), Vector(max_w, min_h - 0.2, max_d), Vector(min_w, min_h - 0.2, max_d) ) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) disallowed_area_height = 0.1 disallowed_area_size = 0 if self._disallowed_areas: mb = MeshBuilder() color = Color(0.0, 0.0, 0.0, 0.15) for polygon in self._disallowed_areas: points = polygon.getPoints() first = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height, self._clamp(points[0][1], min_d, max_d)) previous_point = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height, self._clamp(points[0][1], min_d, max_d)) for point in points: new_point = Vector(self._clamp(point[0], min_w, max_w), disallowed_area_height, self._clamp(point[1], min_d, max_d)) mb.addFace(first, previous_point, new_point, color = color) previous_point = new_point # Find the largest disallowed area to exclude it from the maximum scale bounds. # This is a very nasty hack. This pretty much only works for UM machines. This disallowed area_size needs # A -lot- of rework at some point in the future: TODO if numpy.min(points[:, 1]) >= 0: # This filters out all areas that have points to the left of the centre. This is done to filter the skirt area. size = abs(numpy.max(points[:, 1]) - numpy.min(points[:, 1])) else: size = 0 disallowed_area_size = max(size, disallowed_area_size) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum = Vector(min_w, min_h - 1.0, min_d), maximum = Vector(max_w, max_h, max_d)) skirt_size = 0.0 profile = Application.getInstance().getMachineManager().getWorkingProfile() if profile: skirt_size = self._getSkirtSize(profile) # As this works better for UM machines, we only add the dissallowed_area_size for the z direction. # This is probably wrong in all other cases. TODO! # The +1 and -1 is added as there is always a bit of extra room required to work properly. scale_to_max_bounds = AxisAlignedBox( minimum = Vector(min_w + skirt_size + 1, min_h, min_d + disallowed_area_size - skirt_size + 1), maximum = Vector(max_w - skirt_size - 1, max_h, max_d - disallowed_area_size + skirt_size - 1) ) Application.getInstance().getController().getScene()._maximum_bounds = scale_to_max_bounds
def rebuild(self): if self._width == 0 or self._height == 0 or self._depth == 0: return min_w = -self._width / 2 max_w = self._width / 2 min_h = 0.0 max_h = self._height min_d = -self._depth / 2 max_d = self._depth / 2 mb = MeshBuilder() mb.addLine(Vector(min_w, min_h, min_d), Vector(max_w, min_h, min_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, max_h, min_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, min_d), Vector(max_w, max_h, min_d), color=self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, max_h, min_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, max_d), Vector(max_w, min_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, max_d), Vector(min_w, max_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, max_d), Vector(max_w, max_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, max_d), Vector(max_w, max_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, min_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, min_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(min_w, max_h, min_d), Vector(min_w, max_h, max_d), color=self.VolumeOutlineColor) mb.addLine(Vector(max_w, max_h, min_d), Vector(max_w, max_h, max_d), color=self.VolumeOutlineColor) self.setMeshData(mb.getData()) mb = MeshBuilder() mb.addQuad(Vector(min_w, min_h - 0.2, min_d), Vector(max_w, min_h - 0.2, min_d), Vector(max_w, min_h - 0.2, max_d), Vector(min_w, min_h - 0.2, max_d)) self._grid_mesh = mb.getData() for n in range(0, 6): v = self._grid_mesh.getVertex(n) self._grid_mesh.setVertexUVCoordinates(n, v[0], v[2]) disallowed_area_height = 0.1 disallowed_area_size = 0 if self._disallowed_areas: mb = MeshBuilder() color = Color(0.0, 0.0, 0.0, 0.15) for polygon in self._disallowed_areas: points = polygon.getPoints() first = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height, self._clamp(points[0][1], min_d, max_d)) previous_point = Vector( self._clamp(points[0][0], min_w, max_w), disallowed_area_height, self._clamp(points[0][1], min_d, max_d)) for point in points: new_point = Vector(self._clamp(point[0], min_w, max_w), disallowed_area_height, self._clamp(point[1], min_d, max_d)) mb.addFace(first, previous_point, new_point, color=color) previous_point = new_point # Find the largest disallowed area to exclude it from the maximum scale bounds. # This is a very nasty hack. This pretty much only works for UM machines. This disallowed area_size needs # A -lot- of rework at some point in the future: TODO if numpy.min( points[:, 1] ) >= 0: # This filters out all areas that have points to the left of the centre. This is done to filter the skirt area. size = abs( numpy.max(points[:, 1]) - numpy.min(points[:, 1])) else: size = 0 disallowed_area_size = max(size, disallowed_area_size) self._disallowed_area_mesh = mb.getData() else: self._disallowed_area_mesh = None self._aabb = AxisAlignedBox(minimum=Vector(min_w, min_h - 1.0, min_d), maximum=Vector(max_w, max_h, max_d)) skirt_size = 0.0 profile = Application.getInstance().getMachineManager( ).getWorkingProfile() if profile: skirt_size = self._getSkirtSize(profile) # As this works better for UM machines, we only add the dissallowed_area_size for the z direction. # This is probably wrong in all other cases. TODO! # The +1 and -1 is added as there is always a bit of extra room required to work properly. scale_to_max_bounds = AxisAlignedBox( minimum=Vector(min_w + skirt_size + 1, min_h, min_d + disallowed_area_size - skirt_size + 1), maximum=Vector(max_w - skirt_size - 1, max_h, max_d - disallowed_area_size + skirt_size - 1)) Application.getInstance().getController().getScene( )._maximum_bounds = scale_to_max_bounds
def _rebuild(self): mb = MeshBuilder() #SOLIDMESH -> LINES if self.YAxis in self._enabled_axis: mb.addCube( width = self._lineWidth, height = self._lineLength, depth = self._lineWidth, center = Vector(0, self._handlePosition/2, 0), color = ToolHandle.YAxisColor ) if self.XAxis in self._enabled_axis: mb.addCube( width = self._lineLength, height = self._lineWidth, depth = self._lineWidth, center = Vector(self._handlePosition/2, 0, 0), color = ToolHandle.XAxisColor ) if self.ZAxis in self._enabled_axis: mb.addCube( width = self._lineWidth, height = self._lineWidth, depth = self._lineLength, center = Vector(0, 0, self._handlePosition/2), color = ToolHandle.ZAxisColor ) #SOLIDMESH -> HANDLES if self.YAxis in self._enabled_axis: mb.addPyramid( width = self._handleWidth, height = self._handleHeight, depth = self._handleWidth, center = Vector(0, self._handlePosition, 0), color = ToolHandle.YAxisColor ) if self.XAxis in self._enabled_axis: mb.addPyramid( width = self._handleWidth, height = self._handleHeight, depth = self._handleWidth, center = Vector(self._handlePosition, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = 90 ) if self.ZAxis in self._enabled_axis: mb.addPyramid( width = self._handleWidth, height = self._handleHeight, depth = self._handleWidth, center = Vector(0, 0, self._handlePosition), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = -90 ) self.setSolidMesh(mb.getData()) mb = MeshBuilder() #ACTIVEMESH -> LINES if self.YAxis in self._enabled_axis: mb.addCube( width = self._activeLineWidth, height = self._activeLineLength, depth = self._activeLineWidth, center = Vector(0, self._activeHandlePosition/2, 0), color = ToolHandle.YAxisColor ) if self.XAxis in self._enabled_axis: mb.addCube( width = self._activeLineLength, height = self._activeLineWidth, depth = self._activeLineWidth, center = Vector(self._activeHandlePosition/2, 0, 0), color = ToolHandle.XAxisColor ) if self.ZAxis in self._enabled_axis: mb.addCube( width = self._activeLineWidth, height = self._activeLineWidth, depth = self._activeLineLength, center = Vector(0, 0, self._activeHandlePosition/2), color = ToolHandle.ZAxisColor ) #SELECTIONMESH -> HANDLES mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(0, 0, 0), color = ToolHandle.AllAxisColor ) mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(0, self._activeHandlePosition, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(self._activeHandlePosition, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(0, 0, self._activeHandlePosition), color = ToolHandle.ZAxisColor ) self.setSelectionMesh(mb.getData())
def __init__(self, parent = None): super().__init__(parent) self._handle_width = 8 self._handle_height = 14 self._handle_position = 20 mb = MeshBuilder() mb.addPyramid( width = self._handle_width, height = self._handle_height, depth = self._handle_width, center = Vector(0, self._handle_position, 0), color = ToolHandle.YAxisColor ) mb.addPyramid( width = self._handle_width, height = self._handle_height, depth = self._handle_width, center = Vector(0, -self._handle_position, 0), color = ToolHandle.YAxisColor, axis = Vector.Unit_X, angle = 180 ) mb.addPyramid( width = self._handle_width, height = self._handle_height, depth = self._handle_width, center = Vector(self._handle_position, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = 90 ) mb.addPyramid( width = self._handle_width, height = self._handle_height, depth = self._handle_width, center = Vector(-self._handle_position, 0, 0), color = ToolHandle.XAxisColor, axis = Vector.Unit_Z, angle = -90 ) mb.addPyramid( width = self._handle_width, height = self._handle_height, depth = self._handle_width, center = Vector(0, 0, -self._handle_position), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = 90 ) mb.addPyramid( width = self._handle_width, height = self._handle_height, depth = self._handle_width, center = Vector(0, 0, self._handle_position), color = ToolHandle.ZAxisColor, axis = Vector.Unit_X, angle = -90 ) self.setSolidMesh(mb.getData()) self.setSelectionMesh(mb.getData())
def __init__(self, parent = None): super().__init__(parent) self._lineWidth = 0.5 self._lineLength= 40 self._handlePosition = 40 self._handleWidth = 4 self._activeLineWidth = 0.8 self._activeLineLength = 40 self._activeHandlePosition = 40 self._activeHandleWidth = 15 #SOLIDMESH -> LINES mb = MeshBuilder() mb.addCube( width = self._lineWidth, height = self._lineLength, depth = self._lineWidth, center = Vector(0, self._handlePosition/2, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = self._lineLength, height = self._lineWidth, depth = self._lineWidth, center = Vector(self._handlePosition/2, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = self._lineWidth, height = self._lineWidth, depth = self._lineLength, center = Vector(0, 0, self._handlePosition/2), color = ToolHandle.ZAxisColor ) #SOLIDMESH -> HANDLES mb.addCube( width = self._handleWidth, height = self._handleWidth, depth = self._handleWidth, center = Vector(0, 0, 0), color = ToolHandle.AllAxisColor ) mb.addCube( width = self._handleWidth, height = self._handleWidth, depth = self._handleWidth, center = Vector(0, self._handlePosition, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = self._handleWidth, height = self._handleWidth, depth = self._handleWidth, center = Vector(self._handlePosition, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = self._handleWidth, height = self._handleWidth, depth = self._handleWidth, center = Vector(0, 0, self._handlePosition), color = ToolHandle.ZAxisColor ) self.setSolidMesh(mb.getData()) #SELECTIONMESH -> LINES mb = MeshBuilder() mb.addCube( width = self._activeLineWidth, height = self._activeLineLength, depth = self._activeLineWidth, center = Vector(0, self._activeHandlePosition/2, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = self._activeLineLength, height = self._activeLineWidth, depth = self._activeLineWidth, center = Vector(self._activeHandlePosition/2, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = self._activeLineWidth, height = self._activeLineWidth, depth = self._activeLineLength, center = Vector(0, 0, self._activeHandlePosition/2), color = ToolHandle.ZAxisColor ) #SELECTIONMESH -> HANDLES mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(0, 0, 0), color = ToolHandle.AllAxisColor ) mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(0, self._activeHandlePosition, 0), color = ToolHandle.YAxisColor ) mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(self._activeHandlePosition, 0, 0), color = ToolHandle.XAxisColor ) mb.addCube( width = self._activeHandleWidth, height = self._activeHandleWidth, depth = self._activeHandleWidth, center = Vector(0, 0, self._activeHandlePosition), color = ToolHandle.ZAxisColor ) self.setSelectionMesh(mb.getData())