diff -r 51bf56ba3c10 -r 0bbb006204fc printrun-src/printrun/gl/libtatlin/actors.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/printrun-src/printrun/gl/libtatlin/actors.py Fri Jun 03 09:16:07 2016 +0200 @@ -0,0 +1,1062 @@ +# -*- 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(object): + """ + 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(object): + """ + Platform on which models are placed. + """ + graduations_major = 10 + + def __init__(self, build_dimensions, light = False, circular = False): + 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.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.graduations_major == 0: + glColor4f(*self.color_grads_major) + elif i % (self.graduations_major / 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 range(0, int(math.ceil(self.width + 1))): + 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 range(0, int(math.ceil(self.depth + 1))): + 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 range(0, int(math.ceil(self.width + 1))): + if color(i): + glVertex3f(float(i), 0.0, 0.0) + glVertex3f(float(i), self.depth, 0.0) + + for i in range(0, int(math.ceil(self.depth + 1))): + 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(object): + 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(object): + """ + 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 + +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 + 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) + normal_k = 0 + indices = self.indices = numpy.zeros(nindices, dtype = GLuint) + index_k = 0 + self.layer_idxs_map = {} + self.layer_stops = [0] + + prev_is_extruding = False + prev_move_normal_x = None + prev_move_normal_y = None + prev_move_angle = None + + prev_pos = (0, 0, 0) + 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 + current_pos = (gline.current_x, gline.current_y, gline.current_z) + if not gline.extruding: + travel_vertices[travel_vertex_k] = prev_pos[0] + travel_vertices[travel_vertex_k + 1] = prev_pos[1] + travel_vertices[travel_vertex_k + 2] = prev_pos[2] + travel_vertices[travel_vertex_k + 3] = current_pos[0] + travel_vertices[travel_vertex_k + 4] = current_pos[1] + travel_vertices[travel_vertex_k + 5] = current_pos[2] + travel_vertex_k += 6 + prev_is_extruding = False + else: + gline_color = self.movement_color(gline) + + next_move = get_next_move(model_data, layer_idx, gline_idx) + next_is_extruding = (next_move.extruding + if next_move is not None else False) + + 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_is_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) + + 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) + + for new_i, item in enumerate(new_indices): + indices[index_k + new_i] = item + index_k += len(new_indices) + for new_i, item in enumerate(new_vertices): + vertices[vertex_k + new_i] = item + vertex_k += len(new_vertices) + for new_i, item in enumerate(new_normals): + normals[normal_k + new_i] = item + normal_k += len(new_normals) + new_colors = list(gline_color)[:-1] * (len(new_vertices) / 3) + for new_i, item in enumerate(new_colors): + colors[color_k + new_i] = item + color_k += len(new_colors) + + prev_is_extruding = True + prev_move_normal_x = move_normal_x + prev_move_normal_y = move_normal_y + prev_move_angle = move_angle + + prev_pos = current_pos + 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(normal_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 + + # ------------------------------------------------------------------------ + # 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 + 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 + vertices[vertex_k] = prev_pos[0] + vertices[vertex_k + 1] = prev_pos[1] + vertices[vertex_k + 2] = prev_pos[2] + current_pos = (gline.current_x, gline.current_y, gline.current_z) + 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 + 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()