mirror of
https://git.mirrors.martin98.com/https://github.com/Ultimaker/Cura
synced 2025-04-21 05:09:37 +08:00
302 lines
16 KiB
Python
302 lines
16 KiB
Python
# Copyright (c) 2020 Ultimaker B.V.
|
|
# Cura is released under the terms of the LGPLv3 or higher.
|
|
|
|
import os.path
|
|
from UM.View.View import View
|
|
from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
|
|
from UM.Scene.Selection import Selection
|
|
from UM.Resources import Resources
|
|
from PyQt5.QtGui import QOpenGLContext, QImage
|
|
from PyQt5.QtCore import QSize
|
|
|
|
import numpy as np
|
|
import time
|
|
|
|
from UM.Application import Application
|
|
from UM.Logger import Logger
|
|
from UM.Message import Message
|
|
from UM.Math.Color import Color
|
|
from UM.PluginRegistry import PluginRegistry
|
|
from UM.Platform import Platform
|
|
from UM.Event import Event
|
|
|
|
from UM.View.RenderBatch import RenderBatch
|
|
from UM.View.GL.OpenGL import OpenGL
|
|
|
|
from UM.i18n import i18nCatalog
|
|
|
|
from cura.Settings.ExtruderManager import ExtruderManager
|
|
|
|
from cura import XRayPass
|
|
|
|
import math
|
|
|
|
catalog = i18nCatalog("cura")
|
|
|
|
|
|
class SolidView(View):
|
|
"""Standard view for mesh models."""
|
|
|
|
_show_xray_warning_preference = "view/show_xray_warning"
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
application = Application.getInstance()
|
|
application.getPreferences().addPreference("view/show_overhang", True)
|
|
application.globalContainerStackChanged.connect(self._onGlobalContainerChanged)
|
|
self._enabled_shader = None
|
|
self._disabled_shader = None
|
|
self._non_printing_shader = None
|
|
self._support_mesh_shader = None
|
|
|
|
self._xray_shader = None
|
|
self._xray_pass = None
|
|
self._xray_composite_shader = None
|
|
self._composite_pass = None
|
|
|
|
self._extruders_model = None
|
|
self._theme = None
|
|
self._support_angle = 90
|
|
|
|
self._global_stack = None
|
|
|
|
self._old_composite_shader = None
|
|
self._old_layer_bindings = None
|
|
|
|
self._next_xray_checking_time = time.time()
|
|
self._xray_checking_update_time = 1.0 # seconds
|
|
self._xray_warning_cooldown = 60 * 10 # reshow Model error message every 10 minutes
|
|
self._xray_warning_message = Message(
|
|
catalog.i18nc("@info:status", "Your model is not manifold. The highlighted areas indicate either missing or extraneous surfaces."),
|
|
lifetime = 60 * 5, # leave message for 5 minutes
|
|
title = catalog.i18nc("@info:title", "Model errors"),
|
|
)
|
|
application.getPreferences().addPreference(self._show_xray_warning_preference, True)
|
|
|
|
application.engineCreatedSignal.connect(self._onGlobalContainerChanged)
|
|
|
|
def _onGlobalContainerChanged(self) -> None:
|
|
if self._global_stack:
|
|
try:
|
|
self._global_stack.propertyChanged.disconnect(self._onPropertyChanged)
|
|
except TypeError:
|
|
pass
|
|
for extruder_stack in ExtruderManager.getInstance().getActiveExtruderStacks():
|
|
extruder_stack.propertyChanged.disconnect(self._onPropertyChanged)
|
|
|
|
self._global_stack = Application.getInstance().getGlobalContainerStack()
|
|
if self._global_stack:
|
|
self._global_stack.propertyChanged.connect(self._onPropertyChanged)
|
|
for extruder_stack in ExtruderManager.getInstance().getActiveExtruderStacks():
|
|
extruder_stack.propertyChanged.connect(self._onPropertyChanged)
|
|
self._onPropertyChanged("support_angle", "value") # Force an re-evaluation
|
|
|
|
def _onPropertyChanged(self, key: str, property_name: str) -> None:
|
|
if key != "support_angle" or property_name != "value":
|
|
return
|
|
# As the rendering is called a *lot* we really, dont want to re-evaluate the property every time. So we store em!
|
|
global_container_stack = Application.getInstance().getGlobalContainerStack()
|
|
if global_container_stack:
|
|
support_extruder_nr = int(global_container_stack.getExtruderPositionValueWithDefault("support_extruder_nr"))
|
|
try:
|
|
support_angle_stack = global_container_stack.extruderList[support_extruder_nr]
|
|
except IndexError:
|
|
pass
|
|
else:
|
|
self._support_angle = support_angle_stack.getProperty("support_angle", "value")
|
|
|
|
def _checkSetup(self):
|
|
if not self._extruders_model:
|
|
self._extruders_model = Application.getInstance().getExtrudersModel()
|
|
|
|
if not self._theme:
|
|
self._theme = Application.getInstance().getTheme()
|
|
|
|
if not self._enabled_shader:
|
|
self._enabled_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "overhang.shader"))
|
|
self._enabled_shader.setUniformValue("u_overhangColor", Color(*self._theme.getColor("model_overhang").getRgb()))
|
|
|
|
if not self._disabled_shader:
|
|
self._disabled_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "striped.shader"))
|
|
self._disabled_shader.setUniformValue("u_diffuseColor1", Color(*self._theme.getColor("model_unslicable").getRgb()))
|
|
self._disabled_shader.setUniformValue("u_diffuseColor2", Color(*self._theme.getColor("model_unslicable_alt").getRgb()))
|
|
self._disabled_shader.setUniformValue("u_width", 50.0)
|
|
|
|
if not self._non_printing_shader:
|
|
self._non_printing_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "transparent_object.shader"))
|
|
self._non_printing_shader.setUniformValue("u_diffuseColor", Color(*self._theme.getColor("model_non_printing").getRgb()))
|
|
self._non_printing_shader.setUniformValue("u_opacity", 0.6)
|
|
|
|
if not self._support_mesh_shader:
|
|
self._support_mesh_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "striped.shader"))
|
|
self._support_mesh_shader.setUniformValue("u_vertical_stripes", True)
|
|
self._support_mesh_shader.setUniformValue("u_width", 5.0)
|
|
|
|
if not Application.getInstance().getPreferences().getValue(self._show_xray_warning_preference):
|
|
self._xray_shader = None
|
|
self._xray_composite_shader = None
|
|
if self._composite_pass and 'xray' in self._composite_pass.getLayerBindings():
|
|
self._composite_pass.setLayerBindings(self._old_layer_bindings)
|
|
self._composite_pass.setCompositeShader(self._old_composite_shader)
|
|
self._old_layer_bindings = None
|
|
self._old_composite_shader = None
|
|
self._xray_warning_message.hide()
|
|
else:
|
|
if not self._xray_shader:
|
|
self._xray_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "xray.shader"))
|
|
|
|
if not self._xray_composite_shader:
|
|
self._xray_composite_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "xray_composite.shader"))
|
|
theme = Application.getInstance().getTheme()
|
|
self._xray_composite_shader.setUniformValue("u_background_color", Color(*theme.getColor("viewport_background").getRgb()))
|
|
self._xray_composite_shader.setUniformValue("u_outline_color", Color(*theme.getColor("model_selection_outline").getRgb()))
|
|
self._xray_composite_shader.setUniformValue("u_flat_error_color_mix", 0.) # Don't show flat error color in solid-view.
|
|
|
|
renderer = self.getRenderer()
|
|
if not self._composite_pass or not 'xray' in self._composite_pass.getLayerBindings():
|
|
# Currently the RenderPass constructor requires a size > 0
|
|
# This should be fixed in RenderPass's constructor.
|
|
self._xray_pass = XRayPass.XRayPass(1, 1)
|
|
|
|
renderer.addRenderPass(self._xray_pass)
|
|
|
|
if not self._composite_pass:
|
|
self._composite_pass = self.getRenderer().getRenderPass("composite")
|
|
|
|
self._old_layer_bindings = self._composite_pass.getLayerBindings()
|
|
self._composite_pass.setLayerBindings(["default", "selection", "xray"])
|
|
self._old_composite_shader = self._composite_pass.getCompositeShader()
|
|
self._composite_pass.setCompositeShader(self._xray_composite_shader)
|
|
|
|
def beginRendering(self):
|
|
scene = self.getController().getScene()
|
|
renderer = self.getRenderer()
|
|
|
|
self._checkSetup()
|
|
|
|
global_container_stack = Application.getInstance().getGlobalContainerStack()
|
|
if global_container_stack:
|
|
if Application.getInstance().getPreferences().getValue("view/show_overhang"):
|
|
# Make sure the overhang angle is valid before passing it to the shader
|
|
if self._support_angle is not None and self._support_angle >= 0 and self._support_angle <= 90:
|
|
self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(90 - self._support_angle)))
|
|
else:
|
|
self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) #Overhang angle of 0 causes no area at all to be marked as overhang.
|
|
else:
|
|
self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0)))
|
|
|
|
for node in DepthFirstIterator(scene.getRoot()):
|
|
if not node.render(renderer):
|
|
if node.getMeshData() and node.isVisible() and not node.callDecoration("getLayerData"):
|
|
uniforms = {}
|
|
shade_factor = 1.0
|
|
|
|
per_mesh_stack = node.callDecoration("getStack")
|
|
|
|
extruder_index = node.callDecoration("getActiveExtruderPosition")
|
|
if extruder_index is None:
|
|
extruder_index = "0"
|
|
extruder_index = int(extruder_index)
|
|
|
|
try:
|
|
material_color = self._extruders_model.getItem(extruder_index)["color"]
|
|
except KeyError:
|
|
material_color = self._extruders_model.defaultColors[0]
|
|
|
|
if extruder_index != ExtruderManager.getInstance().activeExtruderIndex:
|
|
# Shade objects that are printed with the non-active extruder 25% darker
|
|
shade_factor = 0.6
|
|
|
|
try:
|
|
# Colors are passed as rgb hex strings (eg "#ffffff"), and the shader needs
|
|
# an rgba list of floats (eg [1.0, 1.0, 1.0, 1.0])
|
|
uniforms["diffuse_color"] = [
|
|
shade_factor * int(material_color[1:3], 16) / 255,
|
|
shade_factor * int(material_color[3:5], 16) / 255,
|
|
shade_factor * int(material_color[5:7], 16) / 255,
|
|
1.0
|
|
]
|
|
|
|
# Color the currently selected face-id. (Disable for now.)
|
|
#face = Selection.getHoverFace()
|
|
uniforms["hover_face"] = -1 #if not face or node != face[0] else face[1]
|
|
except ValueError:
|
|
pass
|
|
|
|
if node.callDecoration("isNonPrintingMesh"):
|
|
if per_mesh_stack and (node.callDecoration("isInfillMesh") or node.callDecoration("isCuttingMesh")):
|
|
renderer.queueNode(node, shader = self._non_printing_shader, uniforms = uniforms, transparent = True)
|
|
else:
|
|
renderer.queueNode(node, shader = self._non_printing_shader, transparent = True)
|
|
elif getattr(node, "_outside_buildarea", False):
|
|
renderer.queueNode(node, shader = self._disabled_shader)
|
|
elif per_mesh_stack and node.callDecoration("isSupportMesh"):
|
|
# Render support meshes with a vertical stripe that is darker
|
|
shade_factor = 0.6
|
|
uniforms["diffuse_color_2"] = [
|
|
uniforms["diffuse_color"][0] * shade_factor,
|
|
uniforms["diffuse_color"][1] * shade_factor,
|
|
uniforms["diffuse_color"][2] * shade_factor,
|
|
1.0
|
|
]
|
|
renderer.queueNode(node, shader = self._support_mesh_shader, uniforms = uniforms)
|
|
else:
|
|
renderer.queueNode(node, shader = self._enabled_shader, uniforms = uniforms)
|
|
if node.callDecoration("isGroup") and Selection.isSelected(node):
|
|
renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(), mode = RenderBatch.RenderMode.LineLoop)
|
|
|
|
def endRendering(self):
|
|
# check whether the xray overlay is showing badness
|
|
if time.time() > self._next_xray_checking_time\
|
|
and Application.getInstance().getPreferences().getValue(self._show_xray_warning_preference):
|
|
self._next_xray_checking_time = time.time() + self._xray_checking_update_time
|
|
|
|
xray_img = self._xray_pass.getOutput()
|
|
xray_img = xray_img.convertToFormat(QImage.Format_RGB888)
|
|
|
|
# We can't just read the image since the pixels are aligned to internal memory positions.
|
|
# xray_img.byteCount() != xray_img.width() * xray_img.height() * 3
|
|
# The byte count is a little higher sometimes. We need to check the data per line, but fast using Numpy.
|
|
# See https://stackoverflow.com/questions/5810970/get-raw-data-from-qimage for a description of the problem.
|
|
# We can't use that solution though, since it doesn't perform well in Python.
|
|
class QImageArrayView:
|
|
"""
|
|
Class that ducktypes to be a Numpy ndarray.
|
|
"""
|
|
def __init__(self, qimage):
|
|
bits_pointer = qimage.bits()
|
|
if bits_pointer is None: # If this happens before there is a window.
|
|
self.__array_interface__ = {
|
|
"shape": (0, 0),
|
|
"typestr": "|u4",
|
|
"data": (0, False),
|
|
"strides": (1, 3),
|
|
"version": 3
|
|
}
|
|
else:
|
|
self.__array_interface__ = {
|
|
"shape": (qimage.height(), qimage.width()),
|
|
"typestr": "|u4", # Use 4 bytes per pixel rather than 3, since Numpy doesn't support 3.
|
|
"data": (int(bits_pointer), False),
|
|
"strides": (qimage.bytesPerLine(), 3), # This does the magic: For each line, skip the correct number of bytes. Bytes per pixel is always 3 due to QImage.Format.Format_RGB888.
|
|
"version": 3
|
|
}
|
|
array = np.asarray(QImageArrayView(xray_img)).view(np.dtype({
|
|
"r": (np.uint8, 0, "red"),
|
|
"g": (np.uint8, 1, "green"),
|
|
"b": (np.uint8, 2, "blue"),
|
|
"a": (np.uint8, 3, "alpha") # Never filled since QImage was reformatted to RGB888.
|
|
}), np.recarray)
|
|
if np.any(np.mod(array.r, 2)):
|
|
self._next_xray_checking_time = time.time() + self._xray_warning_cooldown
|
|
self._xray_warning_message.show()
|
|
Logger.log("i", "X-Ray overlay found non-manifold pixels.")
|
|
|
|
def event(self, event):
|
|
if event.type == Event.ViewDeactivateEvent:
|
|
if self._composite_pass and 'xray' in self._composite_pass.getLayerBindings():
|
|
self.getRenderer().removeRenderPass(self._xray_pass)
|
|
self._composite_pass.setLayerBindings(self._old_layer_bindings)
|
|
self._composite_pass.setCompositeShader(self._old_composite_shader)
|
|
self._xray_warning_message.hide()
|