Mercurial > hg-public > lasercut-scripts / file revision
printrun-src/printrun/gl/libtatlin/actors.py@cce0af6351f0
printrun-src/printrun/gl/libtatlin/actors.py
Wed, 20 Jan 2021 10:15:13 +0100
- author
- mdd
- date
- Wed, 20 Jan 2021 10:15:13 +0100
- changeset 46
- cce0af6351f0
- parent 15
- 0bbb006204fc
- permissions
- -rw-r--r--
updated and added new files for printrun
# -*- coding: utf-8 -*- # Copyright (C) 2013 Guillaume Seguin # Copyright (C) 2011 Denis Kobozev # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import time import numpy import array import math import logging import threading from ctypes import sizeof from pyglet.gl import glPushMatrix, glPopMatrix, glTranslatef, \ glGenLists, glNewList, GL_COMPILE, glEndList, glCallList, \ GL_ELEMENT_ARRAY_BUFFER, GL_UNSIGNED_INT, GL_TRIANGLES, GL_LINE_LOOP, \ GL_ARRAY_BUFFER, GL_STATIC_DRAW, glColor4f, glVertex3f, \ glBegin, glEnd, GL_LINES, glEnable, glDisable, glGetFloatv, \ GL_LINE_SMOOTH, glLineWidth, GL_LINE_WIDTH, GLfloat, GL_FLOAT, GLuint, \ glVertexPointer, glColorPointer, glDrawArrays, glDrawRangeElements, \ glEnableClientState, glDisableClientState, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, \ GL_FRONT_AND_BACK, GL_FRONT, glMaterialfv, GL_SPECULAR, GL_EMISSION, \ glColorMaterial, GL_AMBIENT_AND_DIFFUSE, glMaterialf, GL_SHININESS, \ GL_NORMAL_ARRAY, glNormalPointer, GL_LIGHTING, glColor3f from pyglet.graphics.vertexbuffer import create_buffer, VertexBufferObject from printrun.utils import install_locale install_locale('pronterface') def vec(*args): return (GLfloat * len(args))(*args) def compile_display_list(func, *options): display_list = glGenLists(1) glNewList(display_list, GL_COMPILE) func(*options) glEndList() return display_list def numpy2vbo(nparray, target = GL_ARRAY_BUFFER, usage = GL_STATIC_DRAW, use_vbos = True): vbo = create_buffer(nparray.nbytes, target = target, usage = usage, vbo = use_vbos) vbo.bind() vbo.set_data(nparray.ctypes.data) return vbo def triangulate_rectangle(i1, i2, i3, i4): return [i1, i4, i3, i3, i2, i1] def triangulate_box(i1, i2, i3, i4, j1, j2, j3, j4): return [i1, i2, j2, j2, j1, i1, i2, i3, j3, j3, j2, i2, i3, i4, j4, j4, j3, i3, i4, i1, j1, j1, j4, i4] class BoundingBox: """ A rectangular box (cuboid) enclosing a 3D model, defined by lower and upper corners. """ def __init__(self, upper_corner, lower_corner): self.upper_corner = upper_corner self.lower_corner = lower_corner @property def width(self): width = abs(self.upper_corner[0] - self.lower_corner[0]) return round(width, 2) @property def depth(self): depth = abs(self.upper_corner[1] - self.lower_corner[1]) return round(depth, 2) @property def height(self): height = abs(self.upper_corner[2] - self.lower_corner[2]) return round(height, 2) class Platform: """ Platform on which models are placed. """ def __init__(self, build_dimensions, light = False, circular = False, grid = (1, 10)): self.light = light self.circular = circular self.width = build_dimensions[0] self.depth = build_dimensions[1] self.height = build_dimensions[2] self.xoffset = build_dimensions[3] self.yoffset = build_dimensions[4] self.zoffset = build_dimensions[5] self.grid = grid self.color_grads_minor = (0xaf / 255, 0xdf / 255, 0x5f / 255, 0.1) self.color_grads_interm = (0xaf / 255, 0xdf / 255, 0x5f / 255, 0.2) self.color_grads_major = (0xaf / 255, 0xdf / 255, 0x5f / 255, 0.33) self.initialized = False self.loaded = True def init(self): self.display_list = compile_display_list(self.draw) self.initialized = True def draw(self): glPushMatrix() glTranslatef(self.xoffset, self.yoffset, self.zoffset) def color(i): if i % self.grid[1] == 0: glColor4f(*self.color_grads_major) elif i % (self.grid[1] // 2) == 0: glColor4f(*self.color_grads_interm) else: if self.light: return False glColor4f(*self.color_grads_minor) return True # draw the grid glBegin(GL_LINES) if self.circular: # Draw a circular grid for i in numpy.arange(0, int(math.ceil(self.width + 1)), self.grid[0]): angle = math.asin(2 * float(i) / self.width - 1) x = (math.cos(angle) + 1) * self.depth / 2 if color(i): glVertex3f(float(i), self.depth - x, 0.0) glVertex3f(float(i), x, 0.0) for i in numpy.arange(0, int(math.ceil(self.depth + 1)), self.grid[0]): angle = math.acos(2 * float(i) / self.depth - 1) x = (math.sin(angle) + 1) * self.width / 2 if color(i): glVertex3f(self.width - x, float(i), 0.0) glVertex3f(x, float(i), 0.0) else: # Draw a rectangular grid for i in numpy.arange(0, int(math.ceil(self.width + 1)), self.grid[0]): if color(i): glVertex3f(float(i), 0.0, 0.0) glVertex3f(float(i), self.depth, 0.0) for i in numpy.arange(0, int(math.ceil(self.depth + 1)), self.grid[0]): if color(i): glVertex3f(0, float(i), 0.0) glVertex3f(self.width, float(i), 0.0) glEnd() if self.circular: glBegin(GL_LINE_LOOP) for i in range(0, 360): angle = math.radians(i) glVertex3f((math.cos(angle) + 1) * self.width / 2, (math.sin(angle) + 1) * self.depth / 2, 0.0) glEnd() glPopMatrix() def display(self, mode_2d=False): # FIXME: using the list sometimes results in graphical corruptions # glCallList(self.display_list) self.draw() class PrintHead: def __init__(self): self.color = (43. / 255, 0., 175. / 255, 1.0) self.scale = 5 self.height = 5 self.initialized = False self.loaded = True def init(self): self.display_list = compile_display_list(self.draw) self.initialized = True def draw(self): glPushMatrix() glBegin(GL_LINES) glColor4f(*self.color) for di in [-1, 1]: for dj in [-1, 1]: glVertex3f(0, 0, 0) glVertex3f(self.scale * di, self.scale * dj, self.height) glEnd() glPopMatrix() def display(self, mode_2d=False): glEnable(GL_LINE_SMOOTH) orig_linewidth = (GLfloat)() glGetFloatv(GL_LINE_WIDTH, orig_linewidth) glLineWidth(3.0) glCallList(self.display_list) glLineWidth(orig_linewidth) glDisable(GL_LINE_SMOOTH) class Model: """ Parent class for models that provides common functionality. """ AXIS_X = (1, 0, 0) AXIS_Y = (0, 1, 0) AXIS_Z = (0, 0, 1) letter_axis_map = { 'x': AXIS_X, 'y': AXIS_Y, 'z': AXIS_Z, } axis_letter_map = dict([(v, k) for k, v in letter_axis_map.items()]) lock = None def __init__(self, offset_x=0, offset_y=0): self.offset_x = offset_x self.offset_y = offset_y self.lock = threading.Lock() self.init_model_attributes() def init_model_attributes(self): """ Set/reset saved properties. """ self.invalidate_bounding_box() self.modified = False def invalidate_bounding_box(self): self._bounding_box = None @property def bounding_box(self): """ Get a bounding box for the model. """ if self._bounding_box is None: self._bounding_box = self._calculate_bounding_box() return self._bounding_box def _calculate_bounding_box(self): """ Calculate an axis-aligned box enclosing the model. """ # swap rows and columns in our vertex arrays so that we can do max and # min on axis 1 xyz_rows = self.vertices.reshape(-1, order='F').reshape(3, -1) lower_corner = xyz_rows.min(1) upper_corner = xyz_rows.max(1) box = BoundingBox(upper_corner, lower_corner) return box @property def width(self): return self.bounding_box.width @property def depth(self): return self.bounding_box.depth @property def height(self): return self.bounding_box.height def movement_color(self, move): """ Return the color to use for particular type of movement. """ if move.extruding: if move.current_tool == 0: return self.color_tool0 elif move.current_tool == 1: return self.color_tool1 elif move.current_tool == 2: return self.color_tool2 elif move.current_tool == 3: return self.color_tool3 else: return self.color_tool4 return self.color_travel def movement_angle(src, dst, precision=0): x = dst[0] - src[0] y = dst[1] - src[1] angle = math.degrees(math.atan2(y, -x)) # negate x for clockwise rotation angle return round(angle, precision) def get_next_move(gcode, layer_idx, gline_idx): gline_idx += 1 while layer_idx < len(gcode.all_layers): layer = gcode.all_layers[layer_idx] while gline_idx < len(layer): gline = layer[gline_idx] if gline.is_move: return gline gline_idx += 1 layer_idx += 1 gline_idx = 0 return None def interpolate_arcs(gline, prev_gline): if gline.command == "G2" or gline.command == "G3": rx = gline.i if gline.i is not None else 0 ry = gline.j if gline.j is not None else 0 r = math.sqrt(rx*rx + ry*ry) cx = prev_gline.current_x + rx cy = prev_gline.current_y + ry a_start = math.atan2(-ry, -rx) dx = gline.current_x - cx dy = gline.current_y - cy a_end = math.atan2(dy, dx) a_delta = a_end - a_start if gline.command == "G3" and a_delta <= 0: a_delta += math.pi * 2 elif gline.command == "G2" and a_delta >= 0: a_delta -= math.pi * 2 z0 = prev_gline.current_z dz = gline.current_z - z0 # max segment size: 0.5mm, max num of segments: 100 segments = math.ceil(abs(a_delta) * r * 2 / 0.5) if segments > 100: segments = 100 for t in range(segments): a = t / segments * a_delta + a_start mid = ( cx + math.cos(a) * r, cy + math.sin(a) * r, z0 + t / segments * dz ) yield mid yield (gline.current_x, gline.current_y, gline.current_z) class GcodeModel(Model): """ Model for displaying Gcode data. """ color_travel = (0.6, 0.6, 0.6, 0.6) color_tool0 = (1.0, 0.0, 0.0, 1.0) color_tool1 = (0.67, 0.05, 0.9, 1.0) color_tool2 = (1.0, 0.8, 0., 1.0) color_tool3 = (1.0, 0., 0.62, 1.0) color_tool4 = (0., 1.0, 0.58, 1.0) color_printed = (0.2, 0.75, 0, 1.0) color_current = (0, 0.9, 1.0, 1.0) color_current_printed = (0.1, 0.4, 0, 1.0) display_travels = True buffers_created = False use_vbos = True loaded = False fully_loaded = False gcode = None path_halfwidth = 0.2 path_halfheight = 0.2 def set_path_size(self, path_halfwidth, path_halfheight): with self.lock: self.path_halfwidth = path_halfwidth self.path_halfheight = path_halfheight def load_data(self, model_data, callback=None): t_start = time.time() self.gcode = model_data self.count_travel_indices = count_travel_indices = [0] self.count_print_indices = count_print_indices = [0] self.count_print_vertices = count_print_vertices = [0] # Some trivial computations, but that's mostly for documentation :) # Not like 10 multiplications are going to cost much time vs what's # about to happen :) # Max number of values which can be generated per gline # to store coordinates/colors/normals. # Nicely enough we have 3 per kind of thing for all kinds. coordspervertex = 3 buffered_color_len = 3 # 4th color component (alpha) is ignored verticesperline = 8 coordsperline = coordspervertex * verticesperline coords_count = lambda nlines: nlines * coordsperline travelverticesperline = 2 travelcoordsperline = coordspervertex * travelverticesperline travel_coords_count = lambda nlines: nlines * travelcoordsperline trianglesperface = 2 facesperbox = 4 trianglesperbox = trianglesperface * facesperbox verticespertriangle = 3 indicesperbox = verticespertriangle * trianglesperbox boxperline = 2 indicesperline = indicesperbox * boxperline indices_count = lambda nlines: nlines * indicesperline nlines = len(model_data) ntravelcoords = travel_coords_count(nlines) ncoords = coords_count(nlines) nindices = indices_count(nlines) travel_vertices = self.travels = numpy.zeros(ntravelcoords, dtype = GLfloat) travel_vertex_k = 0 vertices = self.vertices = numpy.zeros(ncoords, dtype = GLfloat) vertex_k = 0 colors = self.colors = numpy.zeros(ncoords, dtype = GLfloat) color_k = 0 normals = self.normals = numpy.zeros(ncoords, dtype = GLfloat) indices = self.indices = numpy.zeros(nindices, dtype = GLuint) index_k = 0 self.layer_idxs_map = {} self.layer_stops = [0] prev_move_normal_x = None prev_move_normal_y = None prev_move_angle = None prev_pos = (0, 0, 0) prev_gline = None layer_idx = 0 self.printed_until = 0 self.only_current = False twopi = 2 * math.pi processed_lines = 0 while layer_idx < len(model_data.all_layers): with self.lock: nlines = len(model_data) remaining_lines = nlines - processed_lines # Only reallocate memory which might be needed, not memory # for everything ntravelcoords = coords_count(remaining_lines) + travel_vertex_k ncoords = coords_count(remaining_lines) + vertex_k nindices = indices_count(remaining_lines) + index_k if ncoords > vertices.size: self.travels.resize(ntravelcoords, refcheck = False) self.vertices.resize(ncoords, refcheck = False) self.colors.resize(ncoords, refcheck = False) self.normals.resize(ncoords, refcheck = False) self.indices.resize(nindices, refcheck = False) layer = model_data.all_layers[layer_idx] has_movement = False for gline_idx, gline in enumerate(layer): if not gline.is_move: continue if gline.x is None and gline.y is None and gline.z is None: continue has_movement = True for current_pos in interpolate_arcs(gline, prev_gline): if not gline.extruding: if self.travels.size < (travel_vertex_k + 100 * 6): # arc interpolation extra points allocation # if not enough room for another 100 points now, # allocate enough and 50% extra to minimize separate allocations ratio = (travel_vertex_k + 100 * 6) / self.travels.size * 1.5 # print(f"gl realloc travel {self.travels.size} -> {int(self.travels.size * ratio)}") self.travels.resize(int(self.travels.size * ratio), refcheck = False) travel_vertices[travel_vertex_k:travel_vertex_k+3] = prev_pos travel_vertices[travel_vertex_k + 3:travel_vertex_k + 6] = current_pos travel_vertex_k += 6 else: delta_x = current_pos[0] - prev_pos[0] delta_y = current_pos[1] - prev_pos[1] norm = delta_x * delta_x + delta_y * delta_y if norm == 0: # Don't draw anything if this move is Z+E only continue norm = math.sqrt(norm) move_normal_x = - delta_y / norm move_normal_y = delta_x / norm move_angle = math.atan2(delta_y, delta_x) # FIXME: compute these dynamically path_halfwidth = self.path_halfwidth * 1.2 path_halfheight = self.path_halfheight * 1.2 new_indices = [] new_vertices = [] new_normals = [] if prev_gline and prev_gline.extruding: # Store previous vertices indices prev_id = vertex_k // 3 - 4 avg_move_normal_x = (prev_move_normal_x + move_normal_x) / 2 avg_move_normal_y = (prev_move_normal_y + move_normal_y) / 2 norm = avg_move_normal_x * avg_move_normal_x + avg_move_normal_y * avg_move_normal_y if norm == 0: avg_move_normal_x = move_normal_x avg_move_normal_y = move_normal_y else: norm = math.sqrt(norm) avg_move_normal_x /= norm avg_move_normal_y /= norm delta_angle = move_angle - prev_move_angle delta_angle = (delta_angle + twopi) % twopi fact = abs(math.cos(delta_angle / 2)) # If move is turning too much, avoid creating a big peak # by adding an intermediate box if fact < 0.5: # FIXME: It looks like there's some heavy code duplication here... hw = path_halfwidth p1x = prev_pos[0] - hw * prev_move_normal_x p2x = prev_pos[0] + hw * prev_move_normal_x p1y = prev_pos[1] - hw * prev_move_normal_y p2y = prev_pos[1] + hw * prev_move_normal_y new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) new_vertices.extend((p1x, p1y, prev_pos[2])) new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) new_vertices.extend((p2x, p2y, prev_pos[2])) new_normals.extend((0, 0, 1)) new_normals.extend((-prev_move_normal_x, -prev_move_normal_y, 0)) new_normals.extend((0, 0, -1)) new_normals.extend((prev_move_normal_x, prev_move_normal_y, 0)) first = vertex_k // 3 # Link to previous new_indices += triangulate_box(prev_id, prev_id + 1, prev_id + 2, prev_id + 3, first, first + 1, first + 2, first + 3) p1x = prev_pos[0] - hw * move_normal_x p2x = prev_pos[0] + hw * move_normal_x p1y = prev_pos[1] - hw * move_normal_y p2y = prev_pos[1] + hw * move_normal_y new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) new_vertices.extend((p1x, p1y, prev_pos[2])) new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) new_vertices.extend((p2x, p2y, prev_pos[2])) new_normals.extend((0, 0, 1)) new_normals.extend((-move_normal_x, -move_normal_y, 0)) new_normals.extend((0, 0, -1)) new_normals.extend((move_normal_x, move_normal_y, 0)) prev_id += 4 first += 4 # Link to previous new_indices += triangulate_box(prev_id, prev_id + 1, prev_id + 2, prev_id + 3, first, first + 1, first + 2, first + 3) else: hw = path_halfwidth / fact # Compute vertices p1x = prev_pos[0] - hw * avg_move_normal_x p2x = prev_pos[0] + hw * avg_move_normal_x p1y = prev_pos[1] - hw * avg_move_normal_y p2y = prev_pos[1] + hw * avg_move_normal_y new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) new_vertices.extend((p1x, p1y, prev_pos[2])) new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) new_vertices.extend((p2x, p2y, prev_pos[2])) new_normals.extend((0, 0, 1)) new_normals.extend((-avg_move_normal_x, -avg_move_normal_y, 0)) new_normals.extend((0, 0, -1)) new_normals.extend((avg_move_normal_x, avg_move_normal_y, 0)) first = vertex_k // 3 # Link to previous new_indices += triangulate_box(prev_id, prev_id + 1, prev_id + 2, prev_id + 3, first, first + 1, first + 2, first + 3) else: # Compute vertices normal to the current move and cap it p1x = prev_pos[0] - path_halfwidth * move_normal_x p2x = prev_pos[0] + path_halfwidth * move_normal_x p1y = prev_pos[1] - path_halfwidth * move_normal_y p2y = prev_pos[1] + path_halfwidth * move_normal_y new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) new_vertices.extend((p1x, p1y, prev_pos[2])) new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) new_vertices.extend((p2x, p2y, prev_pos[2])) new_normals.extend((0, 0, 1)) new_normals.extend((-move_normal_x, -move_normal_y, 0)) new_normals.extend((0, 0, -1)) new_normals.extend((move_normal_x, move_normal_y, 0)) first = vertex_k // 3 new_indices = triangulate_rectangle(first, first + 1, first + 2, first + 3) next_move = get_next_move(model_data, layer_idx, gline_idx) next_is_extruding = next_move and next_move.extruding if not next_is_extruding: # Compute caps and link everything p1x = current_pos[0] - path_halfwidth * move_normal_x p2x = current_pos[0] + path_halfwidth * move_normal_x p1y = current_pos[1] - path_halfwidth * move_normal_y p2y = current_pos[1] + path_halfwidth * move_normal_y new_vertices.extend((current_pos[0], current_pos[1], current_pos[2] + path_halfheight)) new_vertices.extend((p1x, p1y, current_pos[2])) new_vertices.extend((current_pos[0], current_pos[1], current_pos[2] - path_halfheight)) new_vertices.extend((p2x, p2y, current_pos[2])) new_normals.extend((0, 0, 1)) new_normals.extend((-move_normal_x, -move_normal_y, 0)) new_normals.extend((0, 0, -1)) new_normals.extend((move_normal_x, move_normal_y, 0)) end_first = vertex_k // 3 + len(new_vertices) // 3 - 4 new_indices += triangulate_rectangle(end_first + 3, end_first + 2, end_first + 1, end_first) new_indices += triangulate_box(first, first + 1, first + 2, first + 3, end_first, end_first + 1, end_first + 2, end_first + 3) if self.indices.size < (index_k + len(new_indices) + 100 * indicesperline): # arc interpolation extra points allocation ratio = (index_k + len(new_indices) + 100 * indicesperline) / self.indices.size * 1.5 # print(f"gl realloc print {self.vertices.size} -> {int(self.vertices.size * ratio)}") self.vertices.resize(int(self.vertices.size * ratio), refcheck = False) self.colors.resize(int(self.colors.size * ratio), refcheck = False) self.normals.resize(int(self.normals.size * ratio), refcheck = False) self.indices.resize(int(self.indices.size * ratio), refcheck = False) for new_i, item in enumerate(new_indices): indices[index_k + new_i] = item index_k += len(new_indices) new_vertices_len = len(new_vertices) vertices[vertex_k:vertex_k+new_vertices_len] = new_vertices normals[vertex_k:vertex_k+new_vertices_len] = new_normals vertex_k += new_vertices_len new_vertices_count = new_vertices_len//coordspervertex # settings support alpha (transperancy), but it is ignored here gline_color = self.movement_color(gline)[:buffered_color_len] for vi in range(new_vertices_count): colors[color_k:color_k+buffered_color_len] = gline_color color_k += buffered_color_len prev_move_normal_x = move_normal_x prev_move_normal_y = move_normal_y prev_move_angle = move_angle prev_pos = current_pos prev_gline = gline count_travel_indices.append(travel_vertex_k // 3) count_print_indices.append(index_k) count_print_vertices.append(vertex_k // 3) gline.gcview_end_vertex = len(count_print_indices) - 1 if has_movement: self.layer_stops.append(len(count_print_indices) - 1) self.layer_idxs_map[layer_idx] = len(self.layer_stops) - 1 self.max_layers = len(self.layer_stops) - 1 self.num_layers_to_draw = self.max_layers + 1 self.initialized = False self.loaded = True processed_lines += len(layer) if callback: callback(layer_idx + 1) yield layer_idx layer_idx += 1 with self.lock: self.dims = ((model_data.xmin, model_data.xmax, model_data.width), (model_data.ymin, model_data.ymax, model_data.depth), (model_data.zmin, model_data.zmax, model_data.height)) self.travels.resize(travel_vertex_k, refcheck = False) self.vertices.resize(vertex_k, refcheck = False) self.colors.resize(color_k, refcheck = False) self.normals.resize(vertex_k, refcheck = False) self.indices.resize(index_k, refcheck = False) self.layer_stops = array.array('L', self.layer_stops) self.count_travel_indices = array.array('L', count_travel_indices) self.count_print_indices = array.array('L', count_print_indices) self.count_print_vertices = array.array('L', count_print_vertices) self.max_layers = len(self.layer_stops) - 1 self.num_layers_to_draw = self.max_layers + 1 self.loaded = True self.initialized = False self.loaded = True self.fully_loaded = True t_end = time.time() logging.debug(_('Initialized 3D visualization in %.2f seconds') % (t_end - t_start)) logging.debug(_('Vertex count: %d') % ((len(self.vertices) + len(self.travels)) // 3)) yield None def copy(self): copy = GcodeModel() for var in ["vertices", "colors", "travels", "indices", "normals", "max_layers", "num_layers_to_draw", "printed_until", "layer_stops", "dims", "only_current", "layer_idxs_map", "count_travel_indices", "count_print_indices", "count_print_vertices", "path_halfwidth", "path_halfheight", "gcode"]: setattr(copy, var, getattr(self, var)) copy.loaded = True copy.fully_loaded = True copy.initialized = False return copy def update_colors(self): """Rebuild gl color buffer without loading. Used after color settings edit""" ncoords = self.count_print_vertices[-1] colors = numpy.empty(ncoords*3, dtype = GLfloat) cur_vertex = 0 gline_i = 1 for gline in self.gcode.lines: if gline.gcview_end_vertex: gline_color = self.movement_color(gline)[:3] last_vertex = self.count_print_vertices[gline_i] gline_i += 1 while cur_vertex < last_vertex: colors[cur_vertex*3:cur_vertex*3+3] = gline_color cur_vertex += 1 if self.vertex_color_buffer: self.vertex_color_buffer.delete() self.vertex_color_buffer = numpy2vbo(colors, use_vbos = self.use_vbos) # ------------------------------------------------------------------------ # DRAWING # ------------------------------------------------------------------------ def init(self): with self.lock: self.layers_loaded = self.max_layers self.initialized = True if self.buffers_created: self.travel_buffer.delete() self.index_buffer.delete() self.vertex_buffer.delete() self.vertex_color_buffer.delete() self.vertex_normal_buffer.delete() self.travel_buffer = numpy2vbo(self.travels, use_vbos = self.use_vbos) self.index_buffer = numpy2vbo(self.indices, use_vbos = self.use_vbos, target = GL_ELEMENT_ARRAY_BUFFER) self.vertex_buffer = numpy2vbo(self.vertices, use_vbos = self.use_vbos) self.vertex_color_buffer = numpy2vbo(self.colors, use_vbos = self.use_vbos) self.vertex_normal_buffer = numpy2vbo(self.normals, use_vbos = self.use_vbos) if self.fully_loaded: # Delete numpy arrays after creating VBOs after full load self.travels = None self.indices = None self.vertices = None self.colors = None self.normals = None self.buffers_created = True def display(self, mode_2d=False): with self.lock: glPushMatrix() glTranslatef(self.offset_x, self.offset_y, 0) glEnableClientState(GL_VERTEX_ARRAY) has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) if self.display_travels: self._display_travels(has_vbo) glEnable(GL_LIGHTING) glEnableClientState(GL_NORMAL_ARRAY) glEnableClientState(GL_COLOR_ARRAY) glMaterialfv(GL_FRONT, GL_SPECULAR, vec(1, 1, 1, 1)) glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, vec(0, 0, 0, 0)) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50) glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE) self._display_movements(has_vbo) glDisable(GL_LIGHTING) glDisableClientState(GL_COLOR_ARRAY) glDisableClientState(GL_VERTEX_ARRAY) glDisableClientState(GL_NORMAL_ARRAY) glPopMatrix() def _display_travels(self, has_vbo): self.travel_buffer.bind() glVertexPointer(3, GL_FLOAT, 0, self.travel_buffer.ptr) # Prevent race condition by using the number of currently loaded layers max_layers = self.layers_loaded # TODO: show current layer travels in a different color end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] end_index = self.count_travel_indices[end] glColor4f(*self.color_travel) if self.only_current: if self.num_layers_to_draw < max_layers: end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] start_index = self.count_travel_indices[end_prev_layer + 1] glDrawArrays(GL_LINES, start_index, end_index - start_index + 1) else: glDrawArrays(GL_LINES, 0, end_index) self.travel_buffer.unbind() def _draw_elements(self, start, end, draw_type = GL_TRIANGLES): # Don't attempt printing empty layer if self.count_print_indices[end] == self.count_print_indices[start - 1]: return glDrawRangeElements(draw_type, self.count_print_vertices[start - 1], self.count_print_vertices[end] - 1, self.count_print_indices[end] - self.count_print_indices[start - 1], GL_UNSIGNED_INT, sizeof(GLuint) * self.count_print_indices[start - 1]) def _display_movements(self, has_vbo): self.vertex_buffer.bind() glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) self.vertex_color_buffer.bind() glColorPointer(3, GL_FLOAT, 0, self.vertex_color_buffer.ptr) self.vertex_normal_buffer.bind() glNormalPointer(GL_FLOAT, 0, self.vertex_normal_buffer.ptr) self.index_buffer.bind() # Prevent race condition by using the number of currently loaded layers max_layers = self.layers_loaded start = 1 layer_selected = self.num_layers_to_draw <= max_layers if layer_selected: end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] else: end_prev_layer = 0 end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] glDisableClientState(GL_COLOR_ARRAY) glColor3f(*self.color_printed[:-1]) # Draw printed stuff until end or end_prev_layer cur_end = min(self.printed_until, end) if not self.only_current: if 1 <= end_prev_layer <= cur_end: self._draw_elements(1, end_prev_layer) elif cur_end >= 1: self._draw_elements(1, cur_end) glEnableClientState(GL_COLOR_ARRAY) # Draw nonprinted stuff until end_prev_layer start = max(cur_end, 1) if end_prev_layer >= start: if not self.only_current: self._draw_elements(start, end_prev_layer) cur_end = end_prev_layer # Draw current layer if layer_selected: glDisableClientState(GL_COLOR_ARRAY) glColor3f(*self.color_current_printed[:-1]) if cur_end > end_prev_layer: self._draw_elements(end_prev_layer + 1, cur_end) glColor3f(*self.color_current[:-1]) if end > cur_end: self._draw_elements(cur_end + 1, end) glEnableClientState(GL_COLOR_ARRAY) # Draw non printed stuff until end (if not ending at a given layer) start = max(self.printed_until, 1) if not layer_selected and end >= start: self._draw_elements(start, end) self.index_buffer.unbind() self.vertex_buffer.unbind() self.vertex_color_buffer.unbind() self.vertex_normal_buffer.unbind() class GcodeModelLight(Model): """ Model for displaying Gcode data. """ color_travel = (0.6, 0.6, 0.6, 0.6) color_tool0 = (1.0, 0.0, 0.0, 0.6) color_tool1 = (0.67, 0.05, 0.9, 0.6) color_tool2 = (1.0, 0.8, 0., 0.6) color_tool3 = (1.0, 0., 0.62, 0.6) color_tool4 = (0., 1.0, 0.58, 0.6) color_printed = (0.2, 0.75, 0, 0.6) color_current = (0, 0.9, 1.0, 0.8) color_current_printed = (0.1, 0.4, 0, 0.8) buffers_created = False use_vbos = True loaded = False fully_loaded = False gcode = None def load_data(self, model_data, callback=None): t_start = time.time() self.gcode = model_data self.layer_idxs_map = {} self.layer_stops = [0] prev_pos = (0, 0, 0) layer_idx = 0 nlines = len(model_data) vertices = self.vertices = numpy.zeros(nlines * 6, dtype = GLfloat) vertex_k = 0 colors = self.colors = numpy.zeros(nlines * 8, dtype = GLfloat) color_k = 0 self.printed_until = -1 self.only_current = False prev_gline = None while layer_idx < len(model_data.all_layers): with self.lock: nlines = len(model_data) if nlines * 6 > vertices.size: self.vertices.resize(nlines * 6, refcheck = False) self.colors.resize(nlines * 8, refcheck = False) layer = model_data.all_layers[layer_idx] has_movement = False for gline in layer: if not gline.is_move: continue if gline.x is None and gline.y is None and gline.z is None: continue has_movement = True for current_pos in interpolate_arcs(gline, prev_gline): if self.vertices.size < (vertex_k + 100 * 6): # arc interpolation extra points allocation ratio = (vertex_k + 100 * 6) / self.vertices.size * 1.5 # print(f"gl realloc lite {self.vertices.size} -> {int(self.vertices.size * ratio)}") self.vertices.resize(int(self.vertices.size * ratio), refcheck = False) self.colors.resize(int(self.colors.size * ratio), refcheck = False) vertices[vertex_k] = prev_pos[0] vertices[vertex_k + 1] = prev_pos[1] vertices[vertex_k + 2] = prev_pos[2] vertices[vertex_k + 3] = current_pos[0] vertices[vertex_k + 4] = current_pos[1] vertices[vertex_k + 5] = current_pos[2] vertex_k += 6 vertex_color = self.movement_color(gline) colors[color_k] = vertex_color[0] colors[color_k + 1] = vertex_color[1] colors[color_k + 2] = vertex_color[2] colors[color_k + 3] = vertex_color[3] colors[color_k + 4] = vertex_color[0] colors[color_k + 5] = vertex_color[1] colors[color_k + 6] = vertex_color[2] colors[color_k + 7] = vertex_color[3] color_k += 8 prev_pos = current_pos prev_gline = gline gline.gcview_end_vertex = vertex_k // 3 if has_movement: self.layer_stops.append(vertex_k // 3) self.layer_idxs_map[layer_idx] = len(self.layer_stops) - 1 self.max_layers = len(self.layer_stops) - 1 self.num_layers_to_draw = self.max_layers + 1 self.initialized = False self.loaded = True if callback: callback(layer_idx + 1) yield layer_idx layer_idx += 1 with self.lock: self.dims = ((model_data.xmin, model_data.xmax, model_data.width), (model_data.ymin, model_data.ymax, model_data.depth), (model_data.zmin, model_data.zmax, model_data.height)) self.vertices.resize(vertex_k, refcheck = False) self.colors.resize(color_k, refcheck = False) self.max_layers = len(self.layer_stops) - 1 self.num_layers_to_draw = self.max_layers + 1 self.initialized = False self.loaded = True self.fully_loaded = True t_end = time.time() logging.debug(_('Initialized 3D visualization in %.2f seconds') % (t_end - t_start)) logging.debug(_('Vertex count: %d') % (len(self.vertices) // 3)) yield None def copy(self): copy = GcodeModelLight() for var in ["vertices", "colors", "max_layers", "num_layers_to_draw", "printed_until", "layer_stops", "dims", "only_current", "layer_idxs_map", "gcode"]: setattr(copy, var, getattr(self, var)) copy.loaded = True copy.fully_loaded = True copy.initialized = False return copy # ------------------------------------------------------------------------ # DRAWING # ------------------------------------------------------------------------ def init(self): with self.lock: self.layers_loaded = self.max_layers self.initialized = True if self.buffers_created: self.vertex_buffer.delete() self.vertex_color_buffer.delete() self.vertex_buffer = numpy2vbo(self.vertices, use_vbos = self.use_vbos) self.vertex_color_buffer = numpy2vbo(self.colors, use_vbos = self.use_vbos) # each pair of vertices shares the color if self.fully_loaded: # Delete numpy arrays after creating VBOs after full load self.vertices = None self.colors = None self.buffers_created = True def display(self, mode_2d=False): with self.lock: glPushMatrix() glTranslatef(self.offset_x, self.offset_y, 0) glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_COLOR_ARRAY) self._display_movements(mode_2d) glDisableClientState(GL_COLOR_ARRAY) glDisableClientState(GL_VERTEX_ARRAY) glPopMatrix() def _display_movements(self, mode_2d=False): self.vertex_buffer.bind() has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) if has_vbo: glVertexPointer(3, GL_FLOAT, 0, None) else: glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) self.vertex_color_buffer.bind() if has_vbo: glColorPointer(4, GL_FLOAT, 0, None) else: glColorPointer(4, GL_FLOAT, 0, self.vertex_color_buffer.ptr) # Prevent race condition by using the number of currently loaded layers max_layers = self.layers_loaded start = 0 if self.num_layers_to_draw <= max_layers: end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] else: end_prev_layer = -1 end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] glDisableClientState(GL_COLOR_ARRAY) glColor4f(*self.color_printed) # Draw printed stuff until end or end_prev_layer cur_end = min(self.printed_until, end) if not self.only_current: if 0 <= end_prev_layer <= cur_end: glDrawArrays(GL_LINES, start, end_prev_layer) elif cur_end >= 0: glDrawArrays(GL_LINES, start, cur_end) glEnableClientState(GL_COLOR_ARRAY) # Draw nonprinted stuff until end_prev_layer start = max(cur_end, 0) if end_prev_layer >= start: if not self.only_current: glDrawArrays(GL_LINES, start, end_prev_layer - start) cur_end = end_prev_layer # Draw current layer if end_prev_layer >= 0: glDisableClientState(GL_COLOR_ARRAY) # Backup & increase line width orig_linewidth = (GLfloat)() glGetFloatv(GL_LINE_WIDTH, orig_linewidth) glLineWidth(2.0) glColor4f(*self.color_current_printed) if cur_end > end_prev_layer: glDrawArrays(GL_LINES, end_prev_layer, cur_end - end_prev_layer) glColor4f(*self.color_current) if end > cur_end: glDrawArrays(GL_LINES, cur_end, end - cur_end) # Restore line width glLineWidth(orig_linewidth) glEnableClientState(GL_COLOR_ARRAY) # Draw non printed stuff until end (if not ending at a given layer) start = max(self.printed_until, 0) end = end - start if end_prev_layer < 0 and end > 0 and not self.only_current: glDrawArrays(GL_LINES, start, end) self.vertex_buffer.unbind() self.vertex_color_buffer.unbind()
