776 lines
32 KiB
Python
776 lines
32 KiB
Python
import numpy as np
|
||
from PyQt6.QtOpenGLWidgets import QOpenGLWidget
|
||
from PyQt6.QtCore import Qt, QEvent, QThread, pyqtSignal
|
||
from PyQt6.QtGui import QTouchEvent, QSurfaceFormat
|
||
from PyQt6.QtOpenGL import QOpenGLShaderProgram, QOpenGLShader, QOpenGLBuffer
|
||
|
||
class GCodeParseWorker(QThread):
|
||
finished = pyqtSignal(dict)
|
||
|
||
def __init__(self, filepath, type_map, default_colors, type_id_map, parent=None):
|
||
super().__init__(parent)
|
||
self.filepath = filepath
|
||
self.TYPE_MAP = type_map
|
||
self.DEFAULT_COLORS = default_colors
|
||
self.TYPE_ID_MAP = type_id_map
|
||
|
||
def run(self):
|
||
points = []
|
||
colors = []
|
||
filters = []
|
||
type_segments = {}
|
||
segment_zs = {}
|
||
type_visibility = {}
|
||
|
||
x = y = z = e = 0.0
|
||
vertex_idx = 0
|
||
feature_type = 'OTHER'
|
||
current_segment_type = 'OTHER'
|
||
segment_start = 0
|
||
segment_count = {}
|
||
type_visibility['TRAVEL'] = False
|
||
|
||
relative_e = False
|
||
|
||
min_x = min_y = min_z = float('inf')
|
||
max_x = max_y = max_z = float('-inf')
|
||
|
||
current_offset = 0
|
||
max_z_seen = -999.0
|
||
z_deltas = []
|
||
last_layer_z = None
|
||
layer_map = [(0, 0)]
|
||
layer_grids = {}
|
||
segment_visibility = {}
|
||
|
||
def add_segment(t_name, start, length, z_val):
|
||
if length > 0:
|
||
type_segments.setdefault(t_name, []).append((start, length))
|
||
segment_zs[(start, length)] = z_val
|
||
|
||
try:
|
||
with open(self.filepath, 'rb') as f:
|
||
for line_bytes in f:
|
||
current_offset += len(line_bytes)
|
||
line = line_bytes.decode('utf-8', errors='ignore').strip()
|
||
if not line:
|
||
continue
|
||
if line.startswith('M82'):
|
||
relative_e = False
|
||
continue
|
||
if line.startswith('M83'):
|
||
relative_e = True
|
||
continue
|
||
|
||
if line.startswith(';'):
|
||
if line.startswith(';TYPE:'):
|
||
raw_type = line.split(':', 1)[1].strip()
|
||
else:
|
||
raw_type = line[1:].strip()
|
||
if raw_type not in self.TYPE_MAP and not any(k in raw_type.lower() for k in ('perimeter', 'infill', 'material', 'skirt/brim')):
|
||
continue
|
||
if 'Skirt/Brim' in raw_type:
|
||
raw_type = 'Skirt'
|
||
|
||
new_type = self.TYPE_MAP.get(raw_type, 'OTHER')
|
||
if new_type != feature_type:
|
||
feature_type = new_type
|
||
if feature_type not in type_visibility:
|
||
type_visibility[feature_type] = True
|
||
continue
|
||
|
||
if line.startswith(('G0', 'G1')):
|
||
new_x, new_y, new_z = x, y, z
|
||
e_val = 0.0
|
||
has_e = False
|
||
parts = line.split(';')[0].split()
|
||
for p in parts[1:]:
|
||
try:
|
||
if p.startswith('X'): new_x = float(p[1:])
|
||
elif p.startswith('Y'): new_y = float(p[1:])
|
||
elif p.startswith('Z'): new_z = float(p[1:])
|
||
elif p.startswith('E'):
|
||
e_val = float(p[1:])
|
||
has_e = True
|
||
except ValueError:
|
||
pass
|
||
|
||
if new_x == x and new_y == y and new_z == z:
|
||
if has_e:
|
||
if relative_e: e += e_val
|
||
else: e = e_val
|
||
continue
|
||
|
||
is_extrusion = False
|
||
if has_e:
|
||
if relative_e:
|
||
is_extrusion = e_val > 0
|
||
new_e = e + e_val
|
||
else:
|
||
is_extrusion = e_val > e
|
||
new_e = e_val
|
||
else:
|
||
new_e = e
|
||
|
||
if is_extrusion:
|
||
seg_type = feature_type
|
||
c = self.DEFAULT_COLORS.get(feature_type, self.DEFAULT_COLORS['OTHER'])
|
||
else:
|
||
seg_type = 'TRAVEL'
|
||
c = self.DEFAULT_COLORS['TRAVEL']
|
||
if 'TRAVEL' not in type_visibility:
|
||
type_visibility['TRAVEL'] = False
|
||
|
||
if seg_type != current_segment_type:
|
||
if vertex_idx > segment_start:
|
||
seg_len = vertex_idx - segment_start
|
||
add_segment(current_segment_type, segment_start, seg_len, z)
|
||
segment_visibility[(segment_start, seg_len)] = (current_segment_type != 'TRAVEL')
|
||
# add_segment(current_segment_type, segment_start, vertex_idx - segment_start, z)
|
||
current_segment_type = seg_type
|
||
segment_start = vertex_idx
|
||
segment_count[seg_type] = segment_count.get(seg_type, 0) + 1
|
||
|
||
if new_x < min_x: min_x = new_x
|
||
if new_x > max_x: max_x = new_x
|
||
if new_y < min_y: min_y = new_y
|
||
if new_y > max_y: max_y = new_y
|
||
if new_z < min_z: min_z = new_z
|
||
if new_z > max_z: max_z = new_z
|
||
|
||
if new_z > max_z_seen and is_extrusion:
|
||
max_z_seen = new_z
|
||
layer_map.append((current_offset, vertex_idx))
|
||
if last_layer_z is not None:
|
||
dz = round(new_z - last_layer_z, 4)
|
||
if 0.01 < dz < 2.0:
|
||
z_deltas.append(dz)
|
||
last_layer_z = new_z
|
||
|
||
# 建立二维占据网络
|
||
if is_extrusion:
|
||
grid_z = round(new_z, 2)
|
||
gx = int(new_x / 2.0)
|
||
gy = int(new_y / 2.0)
|
||
layer_grids.setdefault(grid_z,set()).add((gx, gy))
|
||
|
||
filt_z = round(new_z, 2) if is_extrusion else round(z, 2)
|
||
type_id = self.TYPE_ID_MAP.get(seg_type, 8)
|
||
curr_seg_idx = segment_count.get(seg_type, 0)
|
||
|
||
filters.extend([type_id, 1.0, curr_seg_idx, filt_z,
|
||
type_id, 1.0, curr_seg_idx, filt_z])
|
||
|
||
points.extend([x, y, z, new_x, new_y, new_z])
|
||
colors.extend([*c, *c])
|
||
vertex_idx += 2
|
||
x, y, z, e = new_x, new_y, new_z, new_e
|
||
elif line.startswith('G92'):
|
||
parts = line.split(';')[0].split()
|
||
for p in parts[1:]:
|
||
try:
|
||
if p.startswith('E'): e = float(p[1:])
|
||
elif p.startswith('X'): x = float(p[1:])
|
||
elif p.startswith('Y'): y = float(p[1:])
|
||
elif p.startswith('Z'): z = float(p[1:])
|
||
except ValueError:
|
||
pass
|
||
|
||
if vertex_idx > segment_start:
|
||
# add_segment(current_segment_type, segment_start, vertex_idx - segment_start, z)
|
||
seg_len = vertex_idx - segment_start
|
||
add_segment(current_segment_type, segment_start, seg_len, z)
|
||
segment_visibility[(segment_start, seg_len)] = True
|
||
|
||
filters_np = np.array(filters, dtype=np.float32).reshape(-1, 4) if vertex_idx > 0 else np.zeros((0, 4), dtype=np.float32)
|
||
|
||
# 判断哪些segment在内部
|
||
for type_name, segments in type_segments.items():
|
||
if type_name in ('WALL-INNER', 'SUPPORT', 'FILL'):
|
||
for start, length in segments:
|
||
try:
|
||
px = points[start*3]
|
||
py = points[start*3+1]
|
||
pz = round(points[start*3+2], 2)
|
||
gx = int(px / 2.0)
|
||
gy = int(py / 2.0)
|
||
gird = layer_grids.get(pz, set())
|
||
if not gird:
|
||
continue
|
||
neighbors = 0
|
||
# for ox in range(-2,3):
|
||
# for oy in range(-2,3):
|
||
# if (gx + ox, gy + oy) in gird:
|
||
# neighbors += 1
|
||
for ox, oy in [(1,0), (-1,0), (0,1), (0,-1)]:
|
||
if (gx+ox, gy+oy) in gird:
|
||
neighbors += 1
|
||
if neighbors >= 4:
|
||
filters_np[start:start+length, 1] = 0.0
|
||
segment_visibility[(start, length)] = False
|
||
except Exception as e:
|
||
pass
|
||
|
||
cx = (min_x + max_x) / 2.0 if max_x >= min_x else 110.0
|
||
cy = (min_y + max_y) / 2.0 if max_y >= min_y else 110.0
|
||
cz = (min_z + max_z) / 2.0 if max_z >= min_z else 0.0
|
||
|
||
from collections import Counter
|
||
layer_height = 0.2
|
||
if z_deltas:
|
||
counter = Counter(z_deltas)
|
||
layer_height = counter.most_common(1)[0][0]
|
||
|
||
result = {
|
||
'vertices': np.array(points, dtype=np.float32) if vertex_idx > 0 else np.zeros((0,), dtype=np.float32),
|
||
'colors': np.array(colors, dtype=np.float32) if vertex_idx > 0 else np.zeros((0,), dtype=np.float32),
|
||
'filters': filters_np,
|
||
'vertex_count': vertex_idx,
|
||
'center_x': cx,
|
||
'center_y': cy,
|
||
'center_z': cz,
|
||
'type_segments': type_segments,
|
||
'type_visibility': type_visibility,
|
||
'layer_map': layer_map,
|
||
'segment_visibility': segment_visibility,
|
||
'segment_zs': segment_zs,
|
||
'layer_height': layer_height
|
||
}
|
||
self.finished.emit(result)
|
||
except Exception as e:
|
||
print("ParseGCode Error:", e)
|
||
self.finished.emit({})
|
||
|
||
class GCodeViewerWidget(QOpenGLWidget):
|
||
"""
|
||
3D G-code 预览控件（OpenGL ES / eglfs 兼容版）
|
||
使用可编程管线替代固定管线，适配树莓派 4B
|
||
"""
|
||
|
||
# PrusaSlicer 类型映射、颜色定义等保持不变
|
||
TYPE_MAP = {
|
||
'External perimeter': 'WALL-OUTER',
|
||
'Perimeter': 'WALL-INNER',
|
||
'Overhang perimeter': 'WALL-OUTER',
|
||
'Solid infill': 'SKIN',
|
||
'Top solid infill': 'SKIN',
|
||
'Bridge infill': 'SKIN',
|
||
'Internal infill': 'FILL',
|
||
'Support material': 'SUPPORT',
|
||
'Support material interface': 'SUPPORT-INTERFACE',
|
||
'Skirt': 'SKIRT',
|
||
'Brim': 'SKIRT',
|
||
'Custom': 'OTHER',
|
||
}
|
||
|
||
DEFAULT_COLORS = {
|
||
'WALL-OUTER': (0.92, 0.55, 0.22), # 0xeb8b38
|
||
'WALL-INNER': (0.25, 0.50, 0.81), # 0x4080cf
|
||
'FILL': (0.80, 0.75, 0.29), # 0xccc04b
|
||
'SKIN': (0.62, 0.38, 0.70), # 0x9e60b3
|
||
'SUPPORT': (0.34, 0.70, 0.34), # 0x57b357
|
||
'SUPPORT-INTERFACE': (0.17, 0.42, 0.17), # 0x2b6b2b
|
||
'SKIRT': (0.00, 1.00, 1.00), # 0x00ffff
|
||
'OTHER': (0.67, 0.67, 0.67), # 0xaaaaaa
|
||
'TRAVEL': (0.25, 0.31, 0.38), # 0x405060
|
||
}
|
||
|
||
TYPE_ID_MAP = {
|
||
'WALL-OUTER': 1,
|
||
'WALL-INNER': 2,
|
||
'SKIN': 3,
|
||
'FILL': 4,
|
||
'SUPPORT': 5,
|
||
'SUPPORT-INTERFACE': 6,
|
||
'SKIRT': 7,
|
||
'OTHER': 8,
|
||
'TRAVEL': 9,
|
||
}
|
||
|
||
# 顶点着色器（GLSL ES 1.00）
|
||
VERTEX_SHADER = """
|
||
attribute vec3 aPos;
|
||
attribute vec3 aColor;
|
||
attribute vec4 aFilter;
|
||
varying vec3 vColor;
|
||
uniform mat4 uMVP;
|
||
|
||
uniform float uZMin;
|
||
uniform float uZMax;
|
||
|
||
uniform float uVis1; // WALL-OUTER
|
||
uniform float uVis2; // WALL-INNER
|
||
uniform float uVis3; // SKIN
|
||
uniform float uVis4; // FILL
|
||
uniform float uVis5; // SUPPORT
|
||
uniform float uVis6; // SUPPORT-INTERFACE
|
||
uniform float uVis7; // SKIRT
|
||
uniform float uVis8; // OTHER
|
||
uniform float uVis9; // TRAVEL
|
||
|
||
uniform float uLodFactor;
|
||
uniform float uZoomMul;
|
||
|
||
void main() {
|
||
float doDraw = 1.0;
|
||
float type_id = aFilter.x;
|
||
float is_vis = aFilter.y;
|
||
float seg_idx = aFilter.z;
|
||
float seg_z = aFilter.w;
|
||
|
||
if (is_vis < 0.5) doDraw = 0.0;
|
||
|
||
int t = int(type_id + 0.1);
|
||
|
||
if (t == 2 || t == 4 || t == 5) {
|
||
if (seg_z < uZMin || seg_z > uZMax) doDraw = 0.0;
|
||
}
|
||
|
||
if (t == 1 && uVis1 < 0.5) doDraw = 0.0;
|
||
else if (t == 2 && uVis2 < 0.5) doDraw = 0.0;
|
||
else if (t == 3 && uVis3 < 0.5) doDraw = 0.0;
|
||
else if (t == 4 && uVis4 < 0.5) doDraw = 0.0;
|
||
else if (t == 5 && uVis5 < 0.5) doDraw = 0.0;
|
||
else if (t == 6 && uVis6 < 0.5) doDraw = 0.0;
|
||
else if (t == 7 && uVis7 < 0.5) doDraw = 0.0;
|
||
else if (t == 8 && uVis8 < 0.5) doDraw = 0.0;
|
||
else if (t == 9 && uVis9 < 0.5) doDraw = 0.0;
|
||
|
||
if (uLodFactor > 0.0) {
|
||
float simplify_mul = 1.0;
|
||
if (t == 4) simplify_mul = 3.0;
|
||
else if (t == 5) simplify_mul = 4.0;
|
||
else if (t == 9) simplify_mul = 8.0;
|
||
|
||
float lod_step_f = max(1.0, floor(uLodFactor * simplify_mul * uZoomMul));
|
||
if (lod_step_f > 1.0) {
|
||
if (mod(seg_idx, lod_step_f) != 0.0) doDraw = 0.0;
|
||
}
|
||
|
||
if (uZoomMul > 1.6 && (t == 4 || t == 5 || t == 2)) {
|
||
if (mod(floor(seg_idx / 2.0), 3.0) != 0.0) doDraw = 0.0;
|
||
}
|
||
if (uZoomMul > 2.8 && (t == 4 || t == 5 || t == 2)) {
|
||
if (mod(floor(seg_idx / 2.0), 6.0) != 0.0) doDraw = 0.0;
|
||
}
|
||
}
|
||
|
||
if (doDraw < 0.5) {
|
||
gl_Position = vec4(0.0, 0.0, 0.0, 0.0);
|
||
} else {
|
||
gl_Position = uMVP * vec4(aPos, 1.0);
|
||
}
|
||
vColor = aColor;
|
||
}
|
||
"""
|
||
|
||
# 片段着色器（添加可调节颜色深度的 uniform 以实现边界加深）
|
||
FRAGMENT_SHADER = """
|
||
precision mediump float;
|
||
varying vec3 vColor;
|
||
uniform float uDarken;
|
||
void main() {
|
||
gl_FragColor = vec4(vColor * uDarken, 1.0);
|
||
}
|
||
"""
|
||
|
||
def __init__(self, parent=None):
|
||
# 请求 OpenGL ES 2.0 上下文
|
||
fmt = QSurfaceFormat()
|
||
fmt.setRenderableType(QSurfaceFormat.RenderableType.OpenGLES)
|
||
fmt.setVersion(2, 0)
|
||
|
||
super().__init__(parent)
|
||
self.setMinimumSize(400, 300)
|
||
self.setAttribute(Qt.WidgetAttribute.WA_AcceptTouchEvents, True)
|
||
self.setFormat(fmt)
|
||
# 数据缓冲区
|
||
self.vertices = None
|
||
self.colors = None
|
||
self.filters = None
|
||
self.vertex_count = 0
|
||
self.vbo_vertices = None
|
||
self.vbo_colors = None
|
||
self.vbo_filters = None
|
||
self.vbo_ready = False
|
||
|
||
# 类型分段
|
||
self.type_segments = {}
|
||
self.type_visibility = {}
|
||
self.current_type = 'OTHER'
|
||
|
||
# 视角参数
|
||
self.view_rot_x = -60.0
|
||
self.view_rot_z = 45.0
|
||
self.view_zoom = -250.0 # 稍微退后一点以便看到整个打印平台
|
||
self.view_trans_x = 0.0
|
||
self.view_trans_y = 0.0
|
||
|
||
# ...
|
||
self.progress_ratio = 1.0
|
||
self.progress_vertices = 0
|
||
|
||
# 按需渲染：缓存当前的 filepos 对应的顶点数
|
||
self.layer_map = [(0, 0)] # (offset_bytes, vertex_idx)
|
||
self.last_reported_filepos = -1
|
||
|
||
# 模型中心点
|
||
self.center_x = 110.0
|
||
self.center_y = 110.0
|
||
self.center_z = 0.0
|
||
|
||
# 触摸状态
|
||
self.last_mouse_pos = None
|
||
self._touch_points = {}
|
||
self._pinch_start_dist = 0.0
|
||
self._pinch_start_zoom = 0.0
|
||
self._pinch_start_center = None
|
||
self._pinch_start_trans = (0.0, 0.0)
|
||
self._ignore_wheel = False
|
||
self._rot_sensitivity = 0.1
|
||
|
||
# 着色器程序
|
||
self.shader_program = None
|
||
self.aPos_location = None
|
||
self.aColor_location = None
|
||
self.uMVP_location = None
|
||
|
||
# 简化参数
|
||
self.enable_lod = False
|
||
self.lod_factor = 0.0
|
||
self.visible_top_layers = 0
|
||
self.visible_bottom_layers = 0
|
||
|
||
# ── 公开接口 ──
|
||
def load_gcode(self, filepath: str):
|
||
if hasattr(self, '_worker') and self._worker.isRunning():
|
||
self._worker.terminate()
|
||
self._worker.wait()
|
||
|
||
self._worker = GCodeParseWorker(filepath, self.TYPE_MAP, self.DEFAULT_COLORS, self.TYPE_ID_MAP)
|
||
self._worker.finished.connect(self._on_parse_finished)
|
||
self._worker.start()
|
||
|
||
def _on_parse_finished(self, result: dict):
|
||
if not result:
|
||
return
|
||
|
||
self.vertices = result['vertices']
|
||
self.colors = result['colors']
|
||
self.filters = result['filters']
|
||
self.vertex_count = result['vertex_count']
|
||
self.center_x = result['center_x']
|
||
self.center_y = result['center_y']
|
||
self.center_z = result['center_z']
|
||
self.type_segments = result['type_segments']
|
||
self.segment_zs = result['segment_zs']
|
||
self.type_visibility = result['type_visibility']
|
||
self.layer_map = result['layer_map']
|
||
self.segment_visibility = result['segment_visibility']
|
||
|
||
self.min_z = np.min(self.vertices[2::3]) if self.vertex_count > 0 else 0.0
|
||
self.max_z = np.max(self.vertices[2::3]) if self.vertex_count > 0 else 0.0
|
||
|
||
self.vbo_ready = False
|
||
# 初始时先不显示，让 update_by_filepos 决定，或者如果是0则自动更新
|
||
# 这里把 progress_vertices 赋予当前的 target
|
||
target = 0
|
||
if self.layer_map:
|
||
target = self.layer_map[-1][1] # 全显
|
||
self.layer_height = result.get('layer_height', 0.2)
|
||
|
||
self.progress_vertices = target
|
||
self.last_reported_filepos = -1
|
||
self.update()
|
||
|
||
def update_processes(self, progress: float):
|
||
pass
|
||
|
||
def update_by_filepos(self, filepos: int, is_printing: bool = True):
|
||
import bisect
|
||
if not hasattr(self, 'layer_map') or not self.layer_map:
|
||
return
|
||
|
||
if not is_printing:
|
||
# 不在打印途中时，渲染包含所有顶点（完整模型）
|
||
target_vertices = self.vertex_count
|
||
else:
|
||
# 使用二分查找快速定位当前 filepos 对应的最多展示顶点数
|
||
keys = [item[0] for item in self.layer_map]
|
||
idx = bisect.bisect_right(keys, filepos)
|
||
target_vertices = 0 if idx == 0 else self.layer_map[idx-1][1]
|
||
|
||
# 按需渲染：只有当层级（计算出的可见顶点数）真正发生跳变时才调用 update()
|
||
if target_vertices != getattr(self, 'progress_vertices', -1):
|
||
self.progress_vertices = target_vertices
|
||
self.update()
|
||
|
||
def update_switch(self, type_name: str, visible: bool):
|
||
if type_name in self.type_visibility:
|
||
self.type_visibility[type_name] = visible
|
||
self.update()
|
||
|
||
def set_view_angles(self, rot_x: float, rot_z: float, zoom: float = None):
|
||
self.view_rot_x = max(-90.0, min(0.0, rot_x))
|
||
self.view_rot_z = rot_z
|
||
if zoom is not None:
|
||
self.view_zoom = max(-500.0, min(-10.0, zoom))
|
||
self.update()
|
||
|
||
if length == 0:
|
||
return
|
||
self.type_segments.setdefault(type_name, []).append((start, length))
|
||
|
||
# ── OpenGL 可编程管线初始化 ──
|
||
def initializeGL(self):
|
||
import OpenGL.GL as gl
|
||
gl.glClearColor(0.15, 0.15, 0.15, 1.0)
|
||
gl.glEnable(gl.GL_DEPTH_TEST)
|
||
gl.glLineWidth(1.0)
|
||
|
||
# 编译着色器
|
||
self.shader_program = QOpenGLShaderProgram()
|
||
self.shader_program.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Vertex, self.VERTEX_SHADER)
|
||
self.shader_program.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Fragment, self.FRAGMENT_SHADER)
|
||
self.shader_program.link()
|
||
|
||
# 获取属性和 uniform 位置
|
||
self.aPos_location = self.shader_program.attributeLocation("aPos")
|
||
self.aColor_location = self.shader_program.attributeLocation("aColor")
|
||
self.aFilter_location = self.shader_program.attributeLocation("aFilter")
|
||
self.uMVP_location = self.shader_program.uniformLocation("uMVP")
|
||
self.uDarken_location = self.shader_program.uniformLocation("uDarken")
|
||
|
||
# 创建缓冲对象
|
||
self.vbo_vertices = QOpenGLBuffer(QOpenGLBuffer.Type.VertexBuffer)
|
||
self.vbo_colors = QOpenGLBuffer(QOpenGLBuffer.Type.VertexBuffer)
|
||
self.vbo_filters = QOpenGLBuffer(QOpenGLBuffer.Type.VertexBuffer)
|
||
|
||
def resizeGL(self, w, h):
|
||
import OpenGL.GL as gl
|
||
gl.glViewport(0, 0, w, h)
|
||
|
||
# ── 构建 MVP 矩阵（替代 glOrtho/glRotate） ──
|
||
def _build_mvp(self):
|
||
from PyQt6.QtGui import QMatrix4x4
|
||
mat = QMatrix4x4()
|
||
aspect = self.width() / self.height() if self.height() else 1
|
||
mat.perspective(45.0, aspect, 1.0, 1000.0)
|
||
|
||
mat.translate(self.view_trans_x, self.view_trans_y, self.view_zoom)
|
||
mat.rotate(self.view_rot_x, 1.0, 0.0, 0.0)
|
||
mat.rotate(self.view_rot_z, 0.0, 0.0, 1.0)
|
||
mat.translate(-self.center_x, -self.center_y, -self.center_z)
|
||
|
||
return mat
|
||
|
||
# ── 渲染 ──
|
||
def paintGL(self):
|
||
import OpenGL.GL as gl
|
||
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
|
||
|
||
if self.vertices is None or self.vertex_count == 0:
|
||
return
|
||
|
||
if not self.vbo_ready:
|
||
self._create_vbos()
|
||
self.vbo_ready = True
|
||
|
||
# 使用着色器程序
|
||
self.shader_program.bind()
|
||
|
||
# 设置 MVP 矩阵
|
||
import math
|
||
from PyQt6.QtGui import QMatrix4x4
|
||
mvp_mat = self._build_mvp()
|
||
self.shader_program.setUniformValue(self.uMVP_location, mvp_mat)
|
||
|
||
# 绑定 VBO
|
||
self.vbo_vertices.bind()
|
||
self.shader_program.setAttributeBuffer(self.aPos_location, gl.GL_FLOAT, 0, 3, 0)
|
||
self.shader_program.enableAttributeArray(self.aPos_location)
|
||
|
||
self.vbo_colors.bind()
|
||
self.shader_program.setAttributeBuffer(self.aColor_location, gl.GL_FLOAT, 0, 3, 0)
|
||
self.shader_program.enableAttributeArray(self.aColor_location)
|
||
|
||
# 允许 z-fighting 覆盖，用于同一位置多次渲染线条
|
||
gl.glDepthFunc(gl.GL_LEQUAL)
|
||
|
||
count = self.progress_vertices
|
||
|
||
# Set uniforms for shader logic
|
||
visible_toggles = {i: 1.0 for i in range(1, 10)}
|
||
for name, viz in self.type_visibility.items():
|
||
type_id = self.TYPE_ID_MAP.get(name, 8)
|
||
visible_toggles[type_id] = 1.0 if viz else 0.0
|
||
|
||
for i in range(1, 10):
|
||
loc = self.shader_program.uniformLocation(f"uVis{i}")
|
||
if loc >= 0:
|
||
self.shader_program.setUniformValue(loc, visible_toggles[i])
|
||
|
||
zoom_mul = max(1.0, abs(self.view_zoom) / 250.0)
|
||
lod_loc = self.shader_program.uniformLocation("uLodFactor")
|
||
self.shader_program.setUniformValue(lod_loc, float(self.lod_factor) if getattr(self, 'enable_lod', True) else 0.0)
|
||
zm_loc = self.shader_program.uniformLocation("uZoomMul")
|
||
self.shader_program.setUniformValue(zm_loc, float(zoom_mul))
|
||
|
||
top_limit = self.max_z - self.visible_top_layers * self.layer_height if getattr(self, 'visible_top_layers', 0) > 0 else 9999.0
|
||
bottom_limit = self.min_z + self.visible_bottom_layers * self.layer_height if getattr(self, 'visible_bottom_layers', 0) > 0 else -9999.0
|
||
uzmin_loc = self.shader_program.uniformLocation("uZMin")
|
||
uzmax_loc = self.shader_program.uniformLocation("uZMax")
|
||
self.shader_program.setUniformValue(uzmin_loc, float(bottom_limit))
|
||
self.shader_program.setUniformValue(uzmax_loc, float(top_limit))
|
||
|
||
self.vbo_filters.bind()
|
||
self.shader_program.setAttributeBuffer(self.aFilter_location, gl.GL_FLOAT, 0, 4, 0)
|
||
self.shader_program.enableAttributeArray(self.aFilter_location)
|
||
|
||
# 渲染两次：一次绘制加粗加深的边界底线，一次绘制正常宽度的原色骨架线
|
||
# （在树莓派等性能有限的平台上，使用真实的3D圆柱/方块代替线条会导致顶点数暴增十几倍直接卡顿，
|
||
# 因此通过动态加粗像素级线宽来性能无损地模拟出“体积感”）
|
||
for pass_idx in range(2):
|
||
if pass_idx == 0:
|
||
if getattr(self, 'enable_lod', True):
|
||
gl.glLineWidth(3.0) # 底线宽度（加大以模拟体积轮廓）
|
||
else:
|
||
gl.glLineWidth(6.0) # 底线宽度（加大以模拟体积轮廓）
|
||
self.shader_program.setUniformValue(self.uDarken_location, 0.8) # 加深颜色至 40% 亮度
|
||
else:
|
||
if getattr(self, 'enable_lod', True):
|
||
gl.glLineWidth(1.5) # 主体宽度（加大以模拟线条厚度）
|
||
else:
|
||
gl.glLineWidth(3.0) # 主体宽度（加大以模拟线条厚度）
|
||
self.shader_program.setUniformValue(self.uDarken_location, 1.0) # 保持原色
|
||
|
||
if count > 0:
|
||
gl.glDrawArrays(gl.GL_LINES, 0, count)
|
||
|
||
# 恢复默认深度测试模式
|
||
gl.glDepthFunc(gl.GL_LESS)
|
||
|
||
self.shader_program.disableAttributeArray(self.aPos_location)
|
||
self.shader_program.disableAttributeArray(self.aColor_location)
|
||
self.shader_program.disableAttributeArray(self.aFilter_location)
|
||
self.vbo_vertices.release()
|
||
self.vbo_colors.release()
|
||
self.vbo_filters.release()
|
||
self.shader_program.release()
|
||
|
||
def _create_vbos(self):
|
||
if self.vbo_vertices.isCreated():
|
||
self.vbo_vertices.destroy()
|
||
if self.vbo_colors.isCreated():
|
||
self.vbo_colors.destroy()
|
||
if self.vbo_filters.isCreated():
|
||
self.vbo_filters.destroy()
|
||
|
||
self.vbo_vertices.create()
|
||
self.vbo_vertices.bind()
|
||
self.vbo_vertices.allocate(self.vertices.tobytes(), self.vertices.nbytes)
|
||
self.vbo_vertices.release()
|
||
|
||
self.vbo_colors.create()
|
||
self.vbo_colors.bind()
|
||
self.vbo_colors.allocate(self.colors.tobytes(), self.colors.nbytes)
|
||
self.vbo_colors.release()
|
||
|
||
self.vbo_filters.create()
|
||
self.vbo_filters.bind()
|
||
self.vbo_filters.allocate(self.filters.tobytes(), self.filters.nbytes)
|
||
self.vbo_filters.release()
|
||
|
||
# ── 触摸/鼠标交互（完全不变） ──
|
||
def mousePressEvent(self, event):
|
||
self.last_mouse_pos = event.position()
|
||
|
||
def mouseMoveEvent(self, event):
|
||
if self.last_mouse_pos is None:
|
||
return
|
||
dx = event.position().x() - self.last_mouse_pos.x()
|
||
dy = event.position().y() - self.last_mouse_pos.y()
|
||
if event.buttons() & Qt.MouseButton.LeftButton:
|
||
self.view_rot_x += dy * self._rot_sensitivity
|
||
self.view_rot_x = max(-90.0, min(0.0, self.view_rot_x)) # 限制垂直视角的翻转
|
||
self.view_rot_z += dx * self._rot_sensitivity
|
||
self.last_mouse_pos = event.position()
|
||
self.update()
|
||
|
||
def wheelEvent(self, event):
|
||
delta = event.angleDelta().y() / 120
|
||
self.view_zoom += delta * 10
|
||
self.view_zoom = max(-500.0, min(-10.0, self.view_zoom))
|
||
self.update()
|
||
|
||
def event(self, e):
|
||
if e.type() in (QEvent.Type.TouchBegin, QEvent.Type.TouchUpdate, QEvent.Type.TouchEnd):
|
||
self._ignore_wheel = True
|
||
self.touchEvent(e)
|
||
return True
|
||
elif e.type() == QEvent.Type.Wheel:
|
||
if self._ignore_wheel:
|
||
self._ignore_wheel = False
|
||
return True
|
||
return super().event(e)
|
||
|
||
def touchEvent(self, event: QTouchEvent):
|
||
points = event.points()
|
||
if not points:
|
||
return
|
||
|
||
if event.type() == QEvent.Type.TouchEnd:
|
||
self._touch_points.clear()
|
||
self._pinch_start_center = None
|
||
self._pinch_start_dist = 0.0
|
||
event.accept()
|
||
return
|
||
|
||
if len(points) == 1:
|
||
p = points[0]
|
||
# 如果是刚检测到单指，或者从双指变回单指
|
||
if p.id() not in self._touch_points or self._pinch_start_center is not None:
|
||
self._touch_points.clear()
|
||
self._touch_points[p.id()] = p.position()
|
||
self._pinch_start_center = None
|
||
else:
|
||
last = self._touch_points[p.id()]
|
||
dx = p.position().x() - last.x()
|
||
dy = p.position().y() - last.y()
|
||
self.view_rot_x += dy * self._rot_sensitivity
|
||
self.view_rot_x = max(-90.0, min(0.0, self.view_rot_x)) # 限制垂直视角的翻转
|
||
self.view_rot_z += dx * self._rot_sensitivity
|
||
self._touch_points[p.id()] = p.position()
|
||
self.update()
|
||
|
||
elif len(points) == 2:
|
||
p1, p2 = points[0], points[1]
|
||
dx_p = p1.position().x() - p2.position().x()
|
||
dy_p = p1.position().y() - p2.position().y()
|
||
dist = (dx_p**2 + dy_p**2)**0.5
|
||
center_x = (p1.position().x() + p2.position().x()) / 2.0
|
||
center_y = (p1.position().y() + p2.position().y()) / 2.0
|
||
|
||
# 初始化双指状态
|
||
if self._pinch_start_center is None:
|
||
self._pinch_start_dist = dist
|
||
self._pinch_start_zoom = self.view_zoom
|
||
self._pinch_start_center = (center_x, center_y)
|
||
self._pinch_start_trans = (self.view_trans_x, self.view_trans_y)
|
||
self._touch_points.clear() # 清除单指记录
|
||
else:
|
||
# 缩放 (双指捏合)
|
||
if self._pinch_start_dist > 0:
|
||
scale = dist / self._pinch_start_dist
|
||
self.view_zoom = self._pinch_start_zoom * (1 / scale)
|
||
self.view_zoom = max(-500.0, min(-10.0, self.view_zoom))
|
||
|
||
# 平移 (双指并行移动)
|
||
dcx = center_x - self._pinch_start_center[0]
|
||
dcy = center_y - self._pinch_start_center[1]
|
||
pan_speed = abs(self.view_zoom) * 0.002
|
||
self.view_trans_x = self._pinch_start_trans[0] + dcx * pan_speed
|
||
self.view_trans_y = self._pinch_start_trans[1] - dcy * pan_speed
|
||
|
||
self.update()
|
||
event.accept() |