Thu, 30 May 2019 18:10:01 +0200
dont know what i have done
15 | 1 | # -*- coding: utf-8 -*- |
2 | # Copyright (C) 2013 Guillaume Seguin | |
3 | # Copyright (C) 2011 Denis Kobozev | |
4 | # | |
5 | # This program is free software; you can redistribute it and/or modify | |
6 | # it under the terms of the GNU General Public License as published by | |
7 | # the Free Software Foundation; either version 2 of the License, or | |
8 | # (at your option) any later version. | |
9 | # | |
10 | # This program is distributed in the hope that it will be useful, | |
11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | # GNU General Public License for more details. | |
14 | # | |
15 | # You should have received a copy of the GNU General Public License | |
16 | # along with this program; if not, write to the Free Software Foundation, | |
17 | # Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 | ||
19 | import time | |
20 | import numpy | |
21 | import array | |
22 | import math | |
23 | import logging | |
24 | import threading | |
25 | ||
26 | from ctypes import sizeof | |
27 | ||
28 | from pyglet.gl import glPushMatrix, glPopMatrix, glTranslatef, \ | |
29 | glGenLists, glNewList, GL_COMPILE, glEndList, glCallList, \ | |
30 | GL_ELEMENT_ARRAY_BUFFER, GL_UNSIGNED_INT, GL_TRIANGLES, GL_LINE_LOOP, \ | |
31 | GL_ARRAY_BUFFER, GL_STATIC_DRAW, glColor4f, glVertex3f, \ | |
32 | glBegin, glEnd, GL_LINES, glEnable, glDisable, glGetFloatv, \ | |
33 | GL_LINE_SMOOTH, glLineWidth, GL_LINE_WIDTH, GLfloat, GL_FLOAT, GLuint, \ | |
34 | glVertexPointer, glColorPointer, glDrawArrays, glDrawRangeElements, \ | |
35 | glEnableClientState, glDisableClientState, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, \ | |
36 | GL_FRONT_AND_BACK, GL_FRONT, glMaterialfv, GL_SPECULAR, GL_EMISSION, \ | |
37 | glColorMaterial, GL_AMBIENT_AND_DIFFUSE, glMaterialf, GL_SHININESS, \ | |
38 | GL_NORMAL_ARRAY, glNormalPointer, GL_LIGHTING, glColor3f | |
39 | from pyglet.graphics.vertexbuffer import create_buffer, VertexBufferObject | |
40 | ||
41 | from printrun.utils import install_locale | |
42 | install_locale('pronterface') | |
43 | ||
44 | def vec(*args): | |
45 | return (GLfloat * len(args))(*args) | |
46 | ||
47 | def compile_display_list(func, *options): | |
48 | display_list = glGenLists(1) | |
49 | glNewList(display_list, GL_COMPILE) | |
50 | func(*options) | |
51 | glEndList() | |
52 | return display_list | |
53 | ||
54 | def numpy2vbo(nparray, target = GL_ARRAY_BUFFER, usage = GL_STATIC_DRAW, use_vbos = True): | |
55 | vbo = create_buffer(nparray.nbytes, target = target, usage = usage, vbo = use_vbos) | |
56 | vbo.bind() | |
57 | vbo.set_data(nparray.ctypes.data) | |
58 | return vbo | |
59 | ||
60 | def triangulate_rectangle(i1, i2, i3, i4): | |
61 | return [i1, i4, i3, i3, i2, i1] | |
62 | ||
63 | def triangulate_box(i1, i2, i3, i4, | |
64 | j1, j2, j3, j4): | |
65 | return [i1, i2, j2, j2, j1, i1, i2, i3, j3, j3, j2, i2, | |
66 | i3, i4, j4, j4, j3, i3, i4, i1, j1, j1, j4, i4] | |
67 | ||
68 | class BoundingBox(object): | |
69 | """ | |
70 | A rectangular box (cuboid) enclosing a 3D model, defined by lower and upper corners. | |
71 | """ | |
72 | def __init__(self, upper_corner, lower_corner): | |
73 | self.upper_corner = upper_corner | |
74 | self.lower_corner = lower_corner | |
75 | ||
76 | @property | |
77 | def width(self): | |
78 | width = abs(self.upper_corner[0] - self.lower_corner[0]) | |
79 | return round(width, 2) | |
80 | ||
81 | @property | |
82 | def depth(self): | |
83 | depth = abs(self.upper_corner[1] - self.lower_corner[1]) | |
84 | return round(depth, 2) | |
85 | ||
86 | @property | |
87 | def height(self): | |
88 | height = abs(self.upper_corner[2] - self.lower_corner[2]) | |
89 | return round(height, 2) | |
90 | ||
91 | ||
92 | class Platform(object): | |
93 | """ | |
94 | Platform on which models are placed. | |
95 | """ | |
96 | graduations_major = 10 | |
97 | ||
98 | def __init__(self, build_dimensions, light = False, circular = False): | |
99 | self.light = light | |
100 | self.circular = circular | |
101 | self.width = build_dimensions[0] | |
102 | self.depth = build_dimensions[1] | |
103 | self.height = build_dimensions[2] | |
104 | self.xoffset = build_dimensions[3] | |
105 | self.yoffset = build_dimensions[4] | |
106 | self.zoffset = build_dimensions[5] | |
107 | ||
108 | self.color_grads_minor = (0xaf / 255, 0xdf / 255, 0x5f / 255, 0.1) | |
109 | self.color_grads_interm = (0xaf / 255, 0xdf / 255, 0x5f / 255, 0.2) | |
110 | self.color_grads_major = (0xaf / 255, 0xdf / 255, 0x5f / 255, 0.33) | |
111 | ||
112 | self.initialized = False | |
113 | self.loaded = True | |
114 | ||
115 | def init(self): | |
116 | self.display_list = compile_display_list(self.draw) | |
117 | self.initialized = True | |
118 | ||
119 | def draw(self): | |
120 | glPushMatrix() | |
121 | ||
122 | glTranslatef(self.xoffset, self.yoffset, self.zoffset) | |
123 | ||
124 | def color(i): | |
125 | if i % self.graduations_major == 0: | |
126 | glColor4f(*self.color_grads_major) | |
127 | elif i % (self.graduations_major / 2) == 0: | |
128 | glColor4f(*self.color_grads_interm) | |
129 | else: | |
130 | if self.light: return False | |
131 | glColor4f(*self.color_grads_minor) | |
132 | return True | |
133 | ||
134 | # draw the grid | |
135 | glBegin(GL_LINES) | |
136 | if self.circular: # Draw a circular grid | |
137 | for i in range(0, int(math.ceil(self.width + 1))): | |
138 | angle = math.asin(2 * float(i) / self.width - 1) | |
139 | x = (math.cos(angle) + 1) * self.depth / 2 | |
140 | if color(i): | |
141 | glVertex3f(float(i), self.depth - x, 0.0) | |
142 | glVertex3f(float(i), x, 0.0) | |
143 | ||
144 | for i in range(0, int(math.ceil(self.depth + 1))): | |
145 | angle = math.acos(2 * float(i) / self.depth - 1) | |
146 | x = (math.sin(angle) + 1) * self.width / 2 | |
147 | if color(i): | |
148 | glVertex3f(self.width - x, float(i), 0.0) | |
149 | glVertex3f(x, float(i), 0.0) | |
150 | else: # Draw a rectangular grid | |
151 | for i in range(0, int(math.ceil(self.width + 1))): | |
152 | if color(i): | |
153 | glVertex3f(float(i), 0.0, 0.0) | |
154 | glVertex3f(float(i), self.depth, 0.0) | |
155 | ||
156 | for i in range(0, int(math.ceil(self.depth + 1))): | |
157 | if color(i): | |
158 | glVertex3f(0, float(i), 0.0) | |
159 | glVertex3f(self.width, float(i), 0.0) | |
160 | glEnd() | |
161 | ||
162 | if self.circular: | |
163 | glBegin(GL_LINE_LOOP) | |
164 | for i in range(0, 360): | |
165 | angle = math.radians(i) | |
166 | glVertex3f((math.cos(angle) + 1) * self.width / 2, | |
167 | (math.sin(angle) + 1) * self.depth / 2, 0.0) | |
168 | glEnd() | |
169 | ||
170 | glPopMatrix() | |
171 | ||
172 | def display(self, mode_2d=False): | |
173 | # FIXME: using the list sometimes results in graphical corruptions | |
174 | # glCallList(self.display_list) | |
175 | self.draw() | |
176 | ||
177 | class PrintHead(object): | |
178 | def __init__(self): | |
179 | self.color = (43. / 255, 0., 175. / 255, 1.0) | |
180 | self.scale = 5 | |
181 | self.height = 5 | |
182 | ||
183 | self.initialized = False | |
184 | self.loaded = True | |
185 | ||
186 | def init(self): | |
187 | self.display_list = compile_display_list(self.draw) | |
188 | self.initialized = True | |
189 | ||
190 | def draw(self): | |
191 | glPushMatrix() | |
192 | ||
193 | glBegin(GL_LINES) | |
194 | glColor4f(*self.color) | |
195 | for di in [-1, 1]: | |
196 | for dj in [-1, 1]: | |
197 | glVertex3f(0, 0, 0) | |
198 | glVertex3f(self.scale * di, self.scale * dj, self.height) | |
199 | glEnd() | |
200 | ||
201 | glPopMatrix() | |
202 | ||
203 | def display(self, mode_2d=False): | |
204 | glEnable(GL_LINE_SMOOTH) | |
205 | orig_linewidth = (GLfloat)() | |
206 | glGetFloatv(GL_LINE_WIDTH, orig_linewidth) | |
207 | glLineWidth(3.0) | |
208 | glCallList(self.display_list) | |
209 | glLineWidth(orig_linewidth) | |
210 | glDisable(GL_LINE_SMOOTH) | |
211 | ||
212 | class Model(object): | |
213 | """ | |
214 | Parent class for models that provides common functionality. | |
215 | """ | |
216 | AXIS_X = (1, 0, 0) | |
217 | AXIS_Y = (0, 1, 0) | |
218 | AXIS_Z = (0, 0, 1) | |
219 | ||
220 | letter_axis_map = { | |
221 | 'x': AXIS_X, | |
222 | 'y': AXIS_Y, | |
223 | 'z': AXIS_Z, | |
224 | } | |
225 | ||
226 | axis_letter_map = dict([(v, k) for k, v in letter_axis_map.items()]) | |
227 | ||
228 | lock = None | |
229 | ||
230 | def __init__(self, offset_x=0, offset_y=0): | |
231 | self.offset_x = offset_x | |
232 | self.offset_y = offset_y | |
233 | ||
234 | self.lock = threading.Lock() | |
235 | ||
236 | self.init_model_attributes() | |
237 | ||
238 | def init_model_attributes(self): | |
239 | """ | |
240 | Set/reset saved properties. | |
241 | """ | |
242 | self.invalidate_bounding_box() | |
243 | self.modified = False | |
244 | ||
245 | def invalidate_bounding_box(self): | |
246 | self._bounding_box = None | |
247 | ||
248 | @property | |
249 | def bounding_box(self): | |
250 | """ | |
251 | Get a bounding box for the model. | |
252 | """ | |
253 | if self._bounding_box is None: | |
254 | self._bounding_box = self._calculate_bounding_box() | |
255 | return self._bounding_box | |
256 | ||
257 | def _calculate_bounding_box(self): | |
258 | """ | |
259 | Calculate an axis-aligned box enclosing the model. | |
260 | """ | |
261 | # swap rows and columns in our vertex arrays so that we can do max and | |
262 | # min on axis 1 | |
263 | xyz_rows = self.vertices.reshape(-1, order='F').reshape(3, -1) | |
264 | lower_corner = xyz_rows.min(1) | |
265 | upper_corner = xyz_rows.max(1) | |
266 | box = BoundingBox(upper_corner, lower_corner) | |
267 | return box | |
268 | ||
269 | @property | |
270 | def width(self): | |
271 | return self.bounding_box.width | |
272 | ||
273 | @property | |
274 | def depth(self): | |
275 | return self.bounding_box.depth | |
276 | ||
277 | @property | |
278 | def height(self): | |
279 | return self.bounding_box.height | |
280 | ||
281 | def movement_color(self, move): | |
282 | """ | |
283 | Return the color to use for particular type of movement. | |
284 | """ | |
285 | if move.extruding: | |
286 | if move.current_tool == 0: | |
287 | return self.color_tool0 | |
288 | elif move.current_tool == 1: | |
289 | return self.color_tool1 | |
290 | elif move.current_tool == 2: | |
291 | return self.color_tool2 | |
292 | elif move.current_tool == 3: | |
293 | return self.color_tool3 | |
294 | else: | |
295 | return self.color_tool4 | |
296 | ||
297 | return self.color_travel | |
298 | ||
299 | def movement_angle(src, dst, precision=0): | |
300 | x = dst[0] - src[0] | |
301 | y = dst[1] - src[1] | |
302 | angle = math.degrees(math.atan2(y, -x)) # negate x for clockwise rotation angle | |
303 | return round(angle, precision) | |
304 | ||
305 | def get_next_move(gcode, layer_idx, gline_idx): | |
306 | gline_idx += 1 | |
307 | while layer_idx < len(gcode.all_layers): | |
308 | layer = gcode.all_layers[layer_idx] | |
309 | while gline_idx < len(layer): | |
310 | gline = layer[gline_idx] | |
311 | if gline.is_move: | |
312 | return gline | |
313 | gline_idx += 1 | |
314 | layer_idx += 1 | |
315 | gline_idx = 0 | |
316 | return None | |
317 | ||
318 | class GcodeModel(Model): | |
319 | """ | |
320 | Model for displaying Gcode data. | |
321 | """ | |
322 | ||
323 | color_travel = (0.6, 0.6, 0.6, 0.6) | |
324 | color_tool0 = (1.0, 0.0, 0.0, 1.0) | |
325 | color_tool1 = (0.67, 0.05, 0.9, 1.0) | |
326 | color_tool2 = (1.0, 0.8, 0., 1.0) | |
327 | color_tool3 = (1.0, 0., 0.62, 1.0) | |
328 | color_tool4 = (0., 1.0, 0.58, 1.0) | |
329 | color_printed = (0.2, 0.75, 0, 1.0) | |
330 | color_current = (0, 0.9, 1.0, 1.0) | |
331 | color_current_printed = (0.1, 0.4, 0, 1.0) | |
332 | ||
333 | display_travels = True | |
334 | ||
335 | buffers_created = False | |
336 | use_vbos = True | |
337 | loaded = False | |
338 | fully_loaded = False | |
339 | ||
340 | gcode = None | |
341 | ||
342 | path_halfwidth = 0.2 | |
343 | path_halfheight = 0.2 | |
344 | ||
345 | def set_path_size(self, path_halfwidth, path_halfheight): | |
346 | with self.lock: | |
347 | self.path_halfwidth = path_halfwidth | |
348 | self.path_halfheight = path_halfheight | |
349 | ||
350 | def load_data(self, model_data, callback=None): | |
351 | t_start = time.time() | |
352 | self.gcode = model_data | |
353 | ||
354 | self.count_travel_indices = count_travel_indices = [0] | |
355 | self.count_print_indices = count_print_indices = [0] | |
356 | self.count_print_vertices = count_print_vertices = [0] | |
357 | ||
358 | # Some trivial computations, but that's mostly for documentation :) | |
359 | # Not like 10 multiplications are going to cost much time vs what's | |
360 | # about to happen :) | |
361 | ||
362 | # Max number of values which can be generated per gline | |
363 | # to store coordinates/colors/normals. | |
364 | # Nicely enough we have 3 per kind of thing for all kinds. | |
365 | coordspervertex = 3 | |
366 | verticesperline = 8 | |
367 | coordsperline = coordspervertex * verticesperline | |
368 | coords_count = lambda nlines: nlines * coordsperline | |
369 | ||
370 | travelverticesperline = 2 | |
371 | travelcoordsperline = coordspervertex * travelverticesperline | |
372 | travel_coords_count = lambda nlines: nlines * travelcoordsperline | |
373 | ||
374 | trianglesperface = 2 | |
375 | facesperbox = 4 | |
376 | trianglesperbox = trianglesperface * facesperbox | |
377 | verticespertriangle = 3 | |
378 | indicesperbox = verticespertriangle * trianglesperbox | |
379 | boxperline = 2 | |
380 | indicesperline = indicesperbox * boxperline | |
381 | indices_count = lambda nlines: nlines * indicesperline | |
382 | ||
383 | nlines = len(model_data) | |
384 | ntravelcoords = travel_coords_count(nlines) | |
385 | ncoords = coords_count(nlines) | |
386 | nindices = indices_count(nlines) | |
387 | travel_vertices = self.travels = numpy.zeros(ntravelcoords, dtype = GLfloat) | |
388 | travel_vertex_k = 0 | |
389 | vertices = self.vertices = numpy.zeros(ncoords, dtype = GLfloat) | |
390 | vertex_k = 0 | |
391 | colors = self.colors = numpy.zeros(ncoords, dtype = GLfloat) | |
392 | color_k = 0 | |
393 | normals = self.normals = numpy.zeros(ncoords, dtype = GLfloat) | |
394 | normal_k = 0 | |
395 | indices = self.indices = numpy.zeros(nindices, dtype = GLuint) | |
396 | index_k = 0 | |
397 | self.layer_idxs_map = {} | |
398 | self.layer_stops = [0] | |
399 | ||
400 | prev_is_extruding = False | |
401 | prev_move_normal_x = None | |
402 | prev_move_normal_y = None | |
403 | prev_move_angle = None | |
404 | ||
405 | prev_pos = (0, 0, 0) | |
406 | layer_idx = 0 | |
407 | ||
408 | self.printed_until = 0 | |
409 | self.only_current = False | |
410 | ||
411 | twopi = 2 * math.pi | |
412 | ||
413 | processed_lines = 0 | |
414 | ||
415 | while layer_idx < len(model_data.all_layers): | |
416 | with self.lock: | |
417 | nlines = len(model_data) | |
418 | remaining_lines = nlines - processed_lines | |
419 | # Only reallocate memory which might be needed, not memory | |
420 | # for everything | |
421 | ntravelcoords = coords_count(remaining_lines) + travel_vertex_k | |
422 | ncoords = coords_count(remaining_lines) + vertex_k | |
423 | nindices = indices_count(remaining_lines) + index_k | |
424 | if ncoords > vertices.size: | |
425 | self.travels.resize(ntravelcoords, refcheck = False) | |
426 | self.vertices.resize(ncoords, refcheck = False) | |
427 | self.colors.resize(ncoords, refcheck = False) | |
428 | self.normals.resize(ncoords, refcheck = False) | |
429 | self.indices.resize(nindices, refcheck = False) | |
430 | layer = model_data.all_layers[layer_idx] | |
431 | has_movement = False | |
432 | for gline_idx, gline in enumerate(layer): | |
433 | if not gline.is_move: | |
434 | continue | |
435 | if gline.x is None and gline.y is None and gline.z is None: | |
436 | continue | |
437 | has_movement = True | |
438 | current_pos = (gline.current_x, gline.current_y, gline.current_z) | |
439 | if not gline.extruding: | |
440 | travel_vertices[travel_vertex_k] = prev_pos[0] | |
441 | travel_vertices[travel_vertex_k + 1] = prev_pos[1] | |
442 | travel_vertices[travel_vertex_k + 2] = prev_pos[2] | |
443 | travel_vertices[travel_vertex_k + 3] = current_pos[0] | |
444 | travel_vertices[travel_vertex_k + 4] = current_pos[1] | |
445 | travel_vertices[travel_vertex_k + 5] = current_pos[2] | |
446 | travel_vertex_k += 6 | |
447 | prev_is_extruding = False | |
448 | else: | |
449 | gline_color = self.movement_color(gline) | |
450 | ||
451 | next_move = get_next_move(model_data, layer_idx, gline_idx) | |
452 | next_is_extruding = (next_move.extruding | |
453 | if next_move is not None else False) | |
454 | ||
455 | delta_x = current_pos[0] - prev_pos[0] | |
456 | delta_y = current_pos[1] - prev_pos[1] | |
457 | norm = delta_x * delta_x + delta_y * delta_y | |
458 | if norm == 0: # Don't draw anything if this move is Z+E only | |
459 | continue | |
460 | norm = math.sqrt(norm) | |
461 | move_normal_x = - delta_y / norm | |
462 | move_normal_y = delta_x / norm | |
463 | move_angle = math.atan2(delta_y, delta_x) | |
464 | ||
465 | # FIXME: compute these dynamically | |
466 | path_halfwidth = self.path_halfwidth * 1.2 | |
467 | path_halfheight = self.path_halfheight * 1.2 | |
468 | ||
469 | new_indices = [] | |
470 | new_vertices = [] | |
471 | new_normals = [] | |
472 | if prev_is_extruding: | |
473 | # Store previous vertices indices | |
474 | prev_id = vertex_k / 3 - 4 | |
475 | avg_move_normal_x = (prev_move_normal_x + move_normal_x) / 2 | |
476 | avg_move_normal_y = (prev_move_normal_y + move_normal_y) / 2 | |
477 | norm = avg_move_normal_x * avg_move_normal_x + avg_move_normal_y * avg_move_normal_y | |
478 | if norm == 0: | |
479 | avg_move_normal_x = move_normal_x | |
480 | avg_move_normal_y = move_normal_y | |
481 | else: | |
482 | norm = math.sqrt(norm) | |
483 | avg_move_normal_x /= norm | |
484 | avg_move_normal_y /= norm | |
485 | delta_angle = move_angle - prev_move_angle | |
486 | delta_angle = (delta_angle + twopi) % twopi | |
487 | fact = abs(math.cos(delta_angle / 2)) | |
488 | # If move is turning too much, avoid creating a big peak | |
489 | # by adding an intermediate box | |
490 | if fact < 0.5: | |
491 | # FIXME: It looks like there's some heavy code duplication here... | |
492 | hw = path_halfwidth | |
493 | p1x = prev_pos[0] - hw * prev_move_normal_x | |
494 | p2x = prev_pos[0] + hw * prev_move_normal_x | |
495 | p1y = prev_pos[1] - hw * prev_move_normal_y | |
496 | p2y = prev_pos[1] + hw * prev_move_normal_y | |
497 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) | |
498 | new_vertices.extend((p1x, p1y, prev_pos[2])) | |
499 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) | |
500 | new_vertices.extend((p2x, p2y, prev_pos[2])) | |
501 | new_normals.extend((0, 0, 1)) | |
502 | new_normals.extend((-prev_move_normal_x, -prev_move_normal_y, 0)) | |
503 | new_normals.extend((0, 0, -1)) | |
504 | new_normals.extend((prev_move_normal_x, prev_move_normal_y, 0)) | |
505 | first = vertex_k / 3 | |
506 | # Link to previous | |
507 | new_indices += triangulate_box(prev_id, prev_id + 1, | |
508 | prev_id + 2, prev_id + 3, | |
509 | first, first + 1, | |
510 | first + 2, first + 3) | |
511 | p1x = prev_pos[0] - hw * move_normal_x | |
512 | p2x = prev_pos[0] + hw * move_normal_x | |
513 | p1y = prev_pos[1] - hw * move_normal_y | |
514 | p2y = prev_pos[1] + hw * move_normal_y | |
515 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) | |
516 | new_vertices.extend((p1x, p1y, prev_pos[2])) | |
517 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) | |
518 | new_vertices.extend((p2x, p2y, prev_pos[2])) | |
519 | new_normals.extend((0, 0, 1)) | |
520 | new_normals.extend((-move_normal_x, -move_normal_y, 0)) | |
521 | new_normals.extend((0, 0, -1)) | |
522 | new_normals.extend((move_normal_x, move_normal_y, 0)) | |
523 | prev_id += 4 | |
524 | first += 4 | |
525 | # Link to previous | |
526 | new_indices += triangulate_box(prev_id, prev_id + 1, | |
527 | prev_id + 2, prev_id + 3, | |
528 | first, first + 1, | |
529 | first + 2, first + 3) | |
530 | else: | |
531 | hw = path_halfwidth / fact | |
532 | # Compute vertices | |
533 | p1x = prev_pos[0] - hw * avg_move_normal_x | |
534 | p2x = prev_pos[0] + hw * avg_move_normal_x | |
535 | p1y = prev_pos[1] - hw * avg_move_normal_y | |
536 | p2y = prev_pos[1] + hw * avg_move_normal_y | |
537 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) | |
538 | new_vertices.extend((p1x, p1y, prev_pos[2])) | |
539 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) | |
540 | new_vertices.extend((p2x, p2y, prev_pos[2])) | |
541 | new_normals.extend((0, 0, 1)) | |
542 | new_normals.extend((-avg_move_normal_x, -avg_move_normal_y, 0)) | |
543 | new_normals.extend((0, 0, -1)) | |
544 | new_normals.extend((avg_move_normal_x, avg_move_normal_y, 0)) | |
545 | first = vertex_k / 3 | |
546 | # Link to previous | |
547 | new_indices += triangulate_box(prev_id, prev_id + 1, | |
548 | prev_id + 2, prev_id + 3, | |
549 | first, first + 1, | |
550 | first + 2, first + 3) | |
551 | else: | |
552 | # Compute vertices normal to the current move and cap it | |
553 | p1x = prev_pos[0] - path_halfwidth * move_normal_x | |
554 | p2x = prev_pos[0] + path_halfwidth * move_normal_x | |
555 | p1y = prev_pos[1] - path_halfwidth * move_normal_y | |
556 | p2y = prev_pos[1] + path_halfwidth * move_normal_y | |
557 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] + path_halfheight)) | |
558 | new_vertices.extend((p1x, p1y, prev_pos[2])) | |
559 | new_vertices.extend((prev_pos[0], prev_pos[1], prev_pos[2] - path_halfheight)) | |
560 | new_vertices.extend((p2x, p2y, prev_pos[2])) | |
561 | new_normals.extend((0, 0, 1)) | |
562 | new_normals.extend((-move_normal_x, -move_normal_y, 0)) | |
563 | new_normals.extend((0, 0, -1)) | |
564 | new_normals.extend((move_normal_x, move_normal_y, 0)) | |
565 | first = vertex_k / 3 | |
566 | new_indices = triangulate_rectangle(first, first + 1, | |
567 | first + 2, first + 3) | |
568 | ||
569 | if not next_is_extruding: | |
570 | # Compute caps and link everything | |
571 | p1x = current_pos[0] - path_halfwidth * move_normal_x | |
572 | p2x = current_pos[0] + path_halfwidth * move_normal_x | |
573 | p1y = current_pos[1] - path_halfwidth * move_normal_y | |
574 | p2y = current_pos[1] + path_halfwidth * move_normal_y | |
575 | new_vertices.extend((current_pos[0], current_pos[1], current_pos[2] + path_halfheight)) | |
576 | new_vertices.extend((p1x, p1y, current_pos[2])) | |
577 | new_vertices.extend((current_pos[0], current_pos[1], current_pos[2] - path_halfheight)) | |
578 | new_vertices.extend((p2x, p2y, current_pos[2])) | |
579 | new_normals.extend((0, 0, 1)) | |
580 | new_normals.extend((-move_normal_x, -move_normal_y, 0)) | |
581 | new_normals.extend((0, 0, -1)) | |
582 | new_normals.extend((move_normal_x, move_normal_y, 0)) | |
583 | end_first = vertex_k / 3 + len(new_vertices) / 3 - 4 | |
584 | new_indices += triangulate_rectangle(end_first + 3, end_first + 2, | |
585 | end_first + 1, end_first) | |
586 | new_indices += triangulate_box(first, first + 1, | |
587 | first + 2, first + 3, | |
588 | end_first, end_first + 1, | |
589 | end_first + 2, end_first + 3) | |
590 | ||
591 | for new_i, item in enumerate(new_indices): | |
592 | indices[index_k + new_i] = item | |
593 | index_k += len(new_indices) | |
594 | for new_i, item in enumerate(new_vertices): | |
595 | vertices[vertex_k + new_i] = item | |
596 | vertex_k += len(new_vertices) | |
597 | for new_i, item in enumerate(new_normals): | |
598 | normals[normal_k + new_i] = item | |
599 | normal_k += len(new_normals) | |
600 | new_colors = list(gline_color)[:-1] * (len(new_vertices) / 3) | |
601 | for new_i, item in enumerate(new_colors): | |
602 | colors[color_k + new_i] = item | |
603 | color_k += len(new_colors) | |
604 | ||
605 | prev_is_extruding = True | |
606 | prev_move_normal_x = move_normal_x | |
607 | prev_move_normal_y = move_normal_y | |
608 | prev_move_angle = move_angle | |
609 | ||
610 | prev_pos = current_pos | |
611 | count_travel_indices.append(travel_vertex_k / 3) | |
612 | count_print_indices.append(index_k) | |
613 | count_print_vertices.append(vertex_k / 3) | |
614 | gline.gcview_end_vertex = len(count_print_indices) - 1 | |
615 | ||
616 | if has_movement: | |
617 | self.layer_stops.append(len(count_print_indices) - 1) | |
618 | self.layer_idxs_map[layer_idx] = len(self.layer_stops) - 1 | |
619 | self.max_layers = len(self.layer_stops) - 1 | |
620 | self.num_layers_to_draw = self.max_layers + 1 | |
621 | self.initialized = False | |
622 | self.loaded = True | |
623 | ||
624 | processed_lines += len(layer) | |
625 | ||
626 | if callback: | |
627 | callback(layer_idx + 1) | |
628 | ||
629 | yield layer_idx | |
630 | layer_idx += 1 | |
631 | ||
632 | with self.lock: | |
633 | self.dims = ((model_data.xmin, model_data.xmax, model_data.width), | |
634 | (model_data.ymin, model_data.ymax, model_data.depth), | |
635 | (model_data.zmin, model_data.zmax, model_data.height)) | |
636 | ||
637 | self.travels.resize(travel_vertex_k, refcheck = False) | |
638 | self.vertices.resize(vertex_k, refcheck = False) | |
639 | self.colors.resize(color_k, refcheck = False) | |
640 | self.normals.resize(normal_k, refcheck = False) | |
641 | self.indices.resize(index_k, refcheck = False) | |
642 | ||
643 | self.layer_stops = array.array('L', self.layer_stops) | |
644 | self.count_travel_indices = array.array('L', count_travel_indices) | |
645 | self.count_print_indices = array.array('L', count_print_indices) | |
646 | self.count_print_vertices = array.array('L', count_print_vertices) | |
647 | ||
648 | self.max_layers = len(self.layer_stops) - 1 | |
649 | self.num_layers_to_draw = self.max_layers + 1 | |
650 | self.loaded = True | |
651 | self.initialized = False | |
652 | self.loaded = True | |
653 | self.fully_loaded = True | |
654 | ||
655 | t_end = time.time() | |
656 | ||
657 | logging.debug(_('Initialized 3D visualization in %.2f seconds') % (t_end - t_start)) | |
658 | logging.debug(_('Vertex count: %d') % ((len(self.vertices) + len(self.travels)) / 3)) | |
659 | yield None | |
660 | ||
661 | def copy(self): | |
662 | copy = GcodeModel() | |
663 | for var in ["vertices", "colors", "travels", "indices", "normals", | |
664 | "max_layers", "num_layers_to_draw", "printed_until", | |
665 | "layer_stops", "dims", "only_current", | |
666 | "layer_idxs_map", "count_travel_indices", | |
667 | "count_print_indices", "count_print_vertices", | |
668 | "path_halfwidth", "path_halfheight", | |
669 | "gcode"]: | |
670 | setattr(copy, var, getattr(self, var)) | |
671 | copy.loaded = True | |
672 | copy.fully_loaded = True | |
673 | copy.initialized = False | |
674 | return copy | |
675 | ||
676 | # ------------------------------------------------------------------------ | |
677 | # DRAWING | |
678 | # ------------------------------------------------------------------------ | |
679 | ||
680 | def init(self): | |
681 | with self.lock: | |
682 | self.layers_loaded = self.max_layers | |
683 | self.initialized = True | |
684 | if self.buffers_created: | |
685 | self.travel_buffer.delete() | |
686 | self.index_buffer.delete() | |
687 | self.vertex_buffer.delete() | |
688 | self.vertex_color_buffer.delete() | |
689 | self.vertex_normal_buffer.delete() | |
690 | self.travel_buffer = numpy2vbo(self.travels, use_vbos = self.use_vbos) | |
691 | self.index_buffer = numpy2vbo(self.indices, use_vbos = self.use_vbos, | |
692 | target = GL_ELEMENT_ARRAY_BUFFER) | |
693 | self.vertex_buffer = numpy2vbo(self.vertices, use_vbos = self.use_vbos) | |
694 | self.vertex_color_buffer = numpy2vbo(self.colors, use_vbos = self.use_vbos) | |
695 | self.vertex_normal_buffer = numpy2vbo(self.normals, use_vbos = self.use_vbos) | |
696 | if self.fully_loaded: | |
697 | # Delete numpy arrays after creating VBOs after full load | |
698 | self.travels = None | |
699 | self.indices = None | |
700 | self.vertices = None | |
701 | self.colors = None | |
702 | self.normals = None | |
703 | self.buffers_created = True | |
704 | ||
705 | def display(self, mode_2d=False): | |
706 | with self.lock: | |
707 | glPushMatrix() | |
708 | glTranslatef(self.offset_x, self.offset_y, 0) | |
709 | glEnableClientState(GL_VERTEX_ARRAY) | |
710 | ||
711 | has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) | |
712 | if self.display_travels: | |
713 | self._display_travels(has_vbo) | |
714 | ||
715 | glEnable(GL_LIGHTING) | |
716 | glEnableClientState(GL_NORMAL_ARRAY) | |
717 | glEnableClientState(GL_COLOR_ARRAY) | |
718 | glMaterialfv(GL_FRONT, GL_SPECULAR, vec(1, 1, 1, 1)) | |
719 | glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, vec(0, 0, 0, 0)) | |
720 | glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50) | |
721 | ||
722 | glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE) | |
723 | self._display_movements(has_vbo) | |
724 | ||
725 | glDisable(GL_LIGHTING) | |
726 | ||
727 | glDisableClientState(GL_COLOR_ARRAY) | |
728 | glDisableClientState(GL_VERTEX_ARRAY) | |
729 | glDisableClientState(GL_NORMAL_ARRAY) | |
730 | ||
731 | glPopMatrix() | |
732 | ||
733 | def _display_travels(self, has_vbo): | |
734 | self.travel_buffer.bind() | |
735 | glVertexPointer(3, GL_FLOAT, 0, self.travel_buffer.ptr) | |
736 | ||
737 | # Prevent race condition by using the number of currently loaded layers | |
738 | max_layers = self.layers_loaded | |
739 | # TODO: show current layer travels in a different color | |
740 | end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] | |
741 | end_index = self.count_travel_indices[end] | |
742 | glColor4f(*self.color_travel) | |
743 | if self.only_current: | |
744 | if self.num_layers_to_draw < max_layers: | |
745 | end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] | |
746 | start_index = self.count_travel_indices[end_prev_layer + 1] | |
747 | glDrawArrays(GL_LINES, start_index, end_index - start_index + 1) | |
748 | else: | |
749 | glDrawArrays(GL_LINES, 0, end_index) | |
750 | ||
751 | self.travel_buffer.unbind() | |
752 | ||
753 | def _draw_elements(self, start, end, draw_type = GL_TRIANGLES): | |
754 | # Don't attempt printing empty layer | |
755 | if self.count_print_indices[end] == self.count_print_indices[start - 1]: | |
756 | return | |
757 | glDrawRangeElements(draw_type, | |
758 | self.count_print_vertices[start - 1], | |
759 | self.count_print_vertices[end] - 1, | |
760 | self.count_print_indices[end] - self.count_print_indices[start - 1], | |
761 | GL_UNSIGNED_INT, | |
762 | sizeof(GLuint) * self.count_print_indices[start - 1]) | |
763 | ||
764 | def _display_movements(self, has_vbo): | |
765 | self.vertex_buffer.bind() | |
766 | glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) | |
767 | ||
768 | self.vertex_color_buffer.bind() | |
769 | glColorPointer(3, GL_FLOAT, 0, self.vertex_color_buffer.ptr) | |
770 | ||
771 | self.vertex_normal_buffer.bind() | |
772 | glNormalPointer(GL_FLOAT, 0, self.vertex_normal_buffer.ptr) | |
773 | ||
774 | self.index_buffer.bind() | |
775 | ||
776 | # Prevent race condition by using the number of currently loaded layers | |
777 | max_layers = self.layers_loaded | |
778 | ||
779 | start = 1 | |
780 | layer_selected = self.num_layers_to_draw <= max_layers | |
781 | if layer_selected: | |
782 | end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] | |
783 | else: | |
784 | end_prev_layer = 0 | |
785 | end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] | |
786 | ||
787 | glDisableClientState(GL_COLOR_ARRAY) | |
788 | ||
789 | glColor3f(*self.color_printed[:-1]) | |
790 | ||
791 | # Draw printed stuff until end or end_prev_layer | |
792 | cur_end = min(self.printed_until, end) | |
793 | if not self.only_current: | |
794 | if 1 <= end_prev_layer <= cur_end: | |
795 | self._draw_elements(1, end_prev_layer) | |
796 | elif cur_end >= 1: | |
797 | self._draw_elements(1, cur_end) | |
798 | ||
799 | glEnableClientState(GL_COLOR_ARRAY) | |
800 | ||
801 | # Draw nonprinted stuff until end_prev_layer | |
802 | start = max(cur_end, 1) | |
803 | if end_prev_layer >= start: | |
804 | if not self.only_current: | |
805 | self._draw_elements(start, end_prev_layer) | |
806 | cur_end = end_prev_layer | |
807 | ||
808 | # Draw current layer | |
809 | if layer_selected: | |
810 | glDisableClientState(GL_COLOR_ARRAY) | |
811 | ||
812 | glColor3f(*self.color_current_printed[:-1]) | |
813 | ||
814 | if cur_end > end_prev_layer: | |
815 | self._draw_elements(end_prev_layer + 1, cur_end) | |
816 | ||
817 | glColor3f(*self.color_current[:-1]) | |
818 | ||
819 | if end > cur_end: | |
820 | self._draw_elements(cur_end + 1, end) | |
821 | ||
822 | glEnableClientState(GL_COLOR_ARRAY) | |
823 | ||
824 | # Draw non printed stuff until end (if not ending at a given layer) | |
825 | start = max(self.printed_until, 1) | |
826 | if not layer_selected and end >= start: | |
827 | self._draw_elements(start, end) | |
828 | ||
829 | self.index_buffer.unbind() | |
830 | self.vertex_buffer.unbind() | |
831 | self.vertex_color_buffer.unbind() | |
832 | self.vertex_normal_buffer.unbind() | |
833 | ||
834 | class GcodeModelLight(Model): | |
835 | """ | |
836 | Model for displaying Gcode data. | |
837 | """ | |
838 | ||
839 | color_travel = (0.6, 0.6, 0.6, 0.6) | |
840 | color_tool0 = (1.0, 0.0, 0.0, 0.6) | |
841 | color_tool1 = (0.67, 0.05, 0.9, 0.6) | |
842 | color_tool2 = (1.0, 0.8, 0., 0.6) | |
843 | color_tool3 = (1.0, 0., 0.62, 0.6) | |
844 | color_tool4 = (0., 1.0, 0.58, 0.6) | |
845 | color_printed = (0.2, 0.75, 0, 0.6) | |
846 | color_current = (0, 0.9, 1.0, 0.8) | |
847 | color_current_printed = (0.1, 0.4, 0, 0.8) | |
848 | ||
849 | buffers_created = False | |
850 | use_vbos = True | |
851 | loaded = False | |
852 | fully_loaded = False | |
853 | ||
854 | gcode = None | |
855 | ||
856 | def load_data(self, model_data, callback=None): | |
857 | t_start = time.time() | |
858 | self.gcode = model_data | |
859 | ||
860 | self.layer_idxs_map = {} | |
861 | self.layer_stops = [0] | |
862 | ||
863 | prev_pos = (0, 0, 0) | |
864 | layer_idx = 0 | |
865 | nlines = len(model_data) | |
866 | vertices = self.vertices = numpy.zeros(nlines * 6, dtype = GLfloat) | |
867 | vertex_k = 0 | |
868 | colors = self.colors = numpy.zeros(nlines * 8, dtype = GLfloat) | |
869 | color_k = 0 | |
870 | self.printed_until = -1 | |
871 | self.only_current = False | |
872 | while layer_idx < len(model_data.all_layers): | |
873 | with self.lock: | |
874 | nlines = len(model_data) | |
875 | if nlines * 6 != vertices.size: | |
876 | self.vertices.resize(nlines * 6, refcheck = False) | |
877 | self.colors.resize(nlines * 8, refcheck = False) | |
878 | layer = model_data.all_layers[layer_idx] | |
879 | has_movement = False | |
880 | for gline in layer: | |
881 | if not gline.is_move: | |
882 | continue | |
883 | if gline.x is None and gline.y is None and gline.z is None: | |
884 | continue | |
885 | has_movement = True | |
886 | vertices[vertex_k] = prev_pos[0] | |
887 | vertices[vertex_k + 1] = prev_pos[1] | |
888 | vertices[vertex_k + 2] = prev_pos[2] | |
889 | current_pos = (gline.current_x, gline.current_y, gline.current_z) | |
890 | vertices[vertex_k + 3] = current_pos[0] | |
891 | vertices[vertex_k + 4] = current_pos[1] | |
892 | vertices[vertex_k + 5] = current_pos[2] | |
893 | vertex_k += 6 | |
894 | ||
895 | vertex_color = self.movement_color(gline) | |
896 | colors[color_k] = vertex_color[0] | |
897 | colors[color_k + 1] = vertex_color[1] | |
898 | colors[color_k + 2] = vertex_color[2] | |
899 | colors[color_k + 3] = vertex_color[3] | |
900 | colors[color_k + 4] = vertex_color[0] | |
901 | colors[color_k + 5] = vertex_color[1] | |
902 | colors[color_k + 6] = vertex_color[2] | |
903 | colors[color_k + 7] = vertex_color[3] | |
904 | color_k += 8 | |
905 | ||
906 | prev_pos = current_pos | |
907 | gline.gcview_end_vertex = vertex_k / 3 | |
908 | ||
909 | if has_movement: | |
910 | self.layer_stops.append(vertex_k / 3) | |
911 | self.layer_idxs_map[layer_idx] = len(self.layer_stops) - 1 | |
912 | self.max_layers = len(self.layer_stops) - 1 | |
913 | self.num_layers_to_draw = self.max_layers + 1 | |
914 | self.initialized = False | |
915 | self.loaded = True | |
916 | ||
917 | if callback: | |
918 | callback(layer_idx + 1) | |
919 | ||
920 | yield layer_idx | |
921 | layer_idx += 1 | |
922 | ||
923 | with self.lock: | |
924 | self.dims = ((model_data.xmin, model_data.xmax, model_data.width), | |
925 | (model_data.ymin, model_data.ymax, model_data.depth), | |
926 | (model_data.zmin, model_data.zmax, model_data.height)) | |
927 | ||
928 | self.vertices.resize(vertex_k, refcheck = False) | |
929 | self.colors.resize(color_k, refcheck = False) | |
930 | self.max_layers = len(self.layer_stops) - 1 | |
931 | self.num_layers_to_draw = self.max_layers + 1 | |
932 | self.initialized = False | |
933 | self.loaded = True | |
934 | self.fully_loaded = True | |
935 | ||
936 | t_end = time.time() | |
937 | ||
938 | logging.debug(_('Initialized 3D visualization in %.2f seconds') % (t_end - t_start)) | |
939 | logging.debug(_('Vertex count: %d') % (len(self.vertices) / 3)) | |
940 | yield None | |
941 | ||
942 | def copy(self): | |
943 | copy = GcodeModelLight() | |
944 | for var in ["vertices", "colors", "max_layers", | |
945 | "num_layers_to_draw", "printed_until", | |
946 | "layer_stops", "dims", "only_current", | |
947 | "layer_idxs_map", "gcode"]: | |
948 | setattr(copy, var, getattr(self, var)) | |
949 | copy.loaded = True | |
950 | copy.fully_loaded = True | |
951 | copy.initialized = False | |
952 | return copy | |
953 | ||
954 | # ------------------------------------------------------------------------ | |
955 | # DRAWING | |
956 | # ------------------------------------------------------------------------ | |
957 | ||
958 | def init(self): | |
959 | with self.lock: | |
960 | self.layers_loaded = self.max_layers | |
961 | self.initialized = True | |
962 | if self.buffers_created: | |
963 | self.vertex_buffer.delete() | |
964 | self.vertex_color_buffer.delete() | |
965 | self.vertex_buffer = numpy2vbo(self.vertices, use_vbos = self.use_vbos) | |
966 | self.vertex_color_buffer = numpy2vbo(self.colors, use_vbos = self.use_vbos) # each pair of vertices shares the color | |
967 | if self.fully_loaded: | |
968 | # Delete numpy arrays after creating VBOs after full load | |
969 | self.vertices = None | |
970 | self.colors = None | |
971 | self.buffers_created = True | |
972 | ||
973 | def display(self, mode_2d=False): | |
974 | with self.lock: | |
975 | glPushMatrix() | |
976 | glTranslatef(self.offset_x, self.offset_y, 0) | |
977 | glEnableClientState(GL_VERTEX_ARRAY) | |
978 | glEnableClientState(GL_COLOR_ARRAY) | |
979 | ||
980 | self._display_movements(mode_2d) | |
981 | ||
982 | glDisableClientState(GL_COLOR_ARRAY) | |
983 | glDisableClientState(GL_VERTEX_ARRAY) | |
984 | glPopMatrix() | |
985 | ||
986 | def _display_movements(self, mode_2d=False): | |
987 | self.vertex_buffer.bind() | |
988 | has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) | |
989 | if has_vbo: | |
990 | glVertexPointer(3, GL_FLOAT, 0, None) | |
991 | else: | |
992 | glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) | |
993 | ||
994 | self.vertex_color_buffer.bind() | |
995 | if has_vbo: | |
996 | glColorPointer(4, GL_FLOAT, 0, None) | |
997 | else: | |
998 | glColorPointer(4, GL_FLOAT, 0, self.vertex_color_buffer.ptr) | |
999 | ||
1000 | # Prevent race condition by using the number of currently loaded layers | |
1001 | max_layers = self.layers_loaded | |
1002 | ||
1003 | start = 0 | |
1004 | if self.num_layers_to_draw <= max_layers: | |
1005 | end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] | |
1006 | else: | |
1007 | end_prev_layer = -1 | |
1008 | end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] | |
1009 | ||
1010 | glDisableClientState(GL_COLOR_ARRAY) | |
1011 | ||
1012 | glColor4f(*self.color_printed) | |
1013 | ||
1014 | # Draw printed stuff until end or end_prev_layer | |
1015 | cur_end = min(self.printed_until, end) | |
1016 | if not self.only_current: | |
1017 | if 0 <= end_prev_layer <= cur_end: | |
1018 | glDrawArrays(GL_LINES, start, end_prev_layer) | |
1019 | elif cur_end >= 0: | |
1020 | glDrawArrays(GL_LINES, start, cur_end) | |
1021 | ||
1022 | glEnableClientState(GL_COLOR_ARRAY) | |
1023 | ||
1024 | # Draw nonprinted stuff until end_prev_layer | |
1025 | start = max(cur_end, 0) | |
1026 | if end_prev_layer >= start: | |
1027 | if not self.only_current: | |
1028 | glDrawArrays(GL_LINES, start, end_prev_layer - start) | |
1029 | cur_end = end_prev_layer | |
1030 | ||
1031 | # Draw current layer | |
1032 | if end_prev_layer >= 0: | |
1033 | glDisableClientState(GL_COLOR_ARRAY) | |
1034 | ||
1035 | # Backup & increase line width | |
1036 | orig_linewidth = (GLfloat)() | |
1037 | glGetFloatv(GL_LINE_WIDTH, orig_linewidth) | |
1038 | glLineWidth(2.0) | |
1039 | ||
1040 | glColor4f(*self.color_current_printed) | |
1041 | ||
1042 | if cur_end > end_prev_layer: | |
1043 | glDrawArrays(GL_LINES, end_prev_layer, cur_end - end_prev_layer) | |
1044 | ||
1045 | glColor4f(*self.color_current) | |
1046 | ||
1047 | if end > cur_end: | |
1048 | glDrawArrays(GL_LINES, cur_end, end - cur_end) | |
1049 | ||
1050 | # Restore line width | |
1051 | glLineWidth(orig_linewidth) | |
1052 | ||
1053 | glEnableClientState(GL_COLOR_ARRAY) | |
1054 | ||
1055 | # Draw non printed stuff until end (if not ending at a given layer) | |
1056 | start = max(self.printed_until, 0) | |
1057 | end = end - start | |
1058 | if end_prev_layer < 0 and end > 0 and not self.only_current: | |
1059 | glDrawArrays(GL_LINES, start, end) | |
1060 | ||
1061 | self.vertex_buffer.unbind() | |
1062 | self.vertex_color_buffer.unbind() |