|
import pyglet.gl as pgl |
|
from pyglet import font |
|
|
|
from sympy.core import S |
|
from sympy.plotting.pygletplot.plot_object import PlotObject |
|
from sympy.plotting.pygletplot.util import billboard_matrix, dot_product, \ |
|
get_direction_vectors, strided_range, vec_mag, vec_sub |
|
from sympy.utilities.iterables import is_sequence |
|
|
|
|
|
class PlotAxes(PlotObject): |
|
|
|
def __init__(self, *args, |
|
style='', none=None, frame=None, box=None, ordinate=None, |
|
stride=0.25, |
|
visible='', overlay='', colored='', label_axes='', label_ticks='', |
|
tick_length=0.1, |
|
font_face='Arial', font_size=28, |
|
**kwargs): |
|
|
|
style = style.lower() |
|
|
|
|
|
if none is not None: |
|
style = 'none' |
|
if frame is not None: |
|
style = 'frame' |
|
if box is not None: |
|
style = 'box' |
|
if ordinate is not None: |
|
style = 'ordinate' |
|
|
|
if style in ['', 'ordinate']: |
|
self._render_object = PlotAxesOrdinate(self) |
|
elif style in ['frame', 'box']: |
|
self._render_object = PlotAxesFrame(self) |
|
elif style in ['none']: |
|
self._render_object = None |
|
else: |
|
raise ValueError(("Unrecognized axes style %s.") % (style)) |
|
|
|
|
|
try: |
|
stride = eval(stride) |
|
except TypeError: |
|
pass |
|
if is_sequence(stride): |
|
if len(stride) != 3: |
|
raise ValueError("length should be equal to 3") |
|
self._stride = stride |
|
else: |
|
self._stride = [stride, stride, stride] |
|
self._tick_length = float(tick_length) |
|
|
|
|
|
self._origin = [0, 0, 0] |
|
self.reset_bounding_box() |
|
|
|
def flexible_boolean(input, default): |
|
if input in [True, False]: |
|
return input |
|
if input in ('f', 'F', 'false', 'False'): |
|
return False |
|
if input in ('t', 'T', 'true', 'True'): |
|
return True |
|
return default |
|
|
|
|
|
self.visible = flexible_boolean(kwargs, True) |
|
self._overlay = flexible_boolean(overlay, True) |
|
self._colored = flexible_boolean(colored, False) |
|
self._label_axes = flexible_boolean(label_axes, False) |
|
self._label_ticks = flexible_boolean(label_ticks, True) |
|
|
|
|
|
self.font_face = font_face |
|
self.font_size = font_size |
|
|
|
|
|
|
|
self.reset_resources() |
|
|
|
def reset_resources(self): |
|
self.label_font = None |
|
|
|
def reset_bounding_box(self): |
|
self._bounding_box = [[None, None], [None, None], [None, None]] |
|
self._axis_ticks = [[], [], []] |
|
|
|
def draw(self): |
|
if self._render_object: |
|
pgl.glPushAttrib(pgl.GL_ENABLE_BIT | pgl.GL_POLYGON_BIT | pgl.GL_DEPTH_BUFFER_BIT) |
|
if self._overlay: |
|
pgl.glDisable(pgl.GL_DEPTH_TEST) |
|
self._render_object.draw() |
|
pgl.glPopAttrib() |
|
|
|
def adjust_bounds(self, child_bounds): |
|
b = self._bounding_box |
|
c = child_bounds |
|
for i in range(3): |
|
if abs(c[i][0]) is S.Infinity or abs(c[i][1]) is S.Infinity: |
|
continue |
|
b[i][0] = c[i][0] if b[i][0] is None else min([b[i][0], c[i][0]]) |
|
b[i][1] = c[i][1] if b[i][1] is None else max([b[i][1], c[i][1]]) |
|
self._bounding_box = b |
|
self._recalculate_axis_ticks(i) |
|
|
|
def _recalculate_axis_ticks(self, axis): |
|
b = self._bounding_box |
|
if b[axis][0] is None or b[axis][1] is None: |
|
self._axis_ticks[axis] = [] |
|
else: |
|
self._axis_ticks[axis] = strided_range(b[axis][0], b[axis][1], |
|
self._stride[axis]) |
|
|
|
def toggle_visible(self): |
|
self.visible = not self.visible |
|
|
|
def toggle_colors(self): |
|
self._colored = not self._colored |
|
|
|
|
|
class PlotAxesBase(PlotObject): |
|
|
|
def __init__(self, parent_axes): |
|
self._p = parent_axes |
|
|
|
def draw(self): |
|
color = [([0.2, 0.1, 0.3], [0.2, 0.1, 0.3], [0.2, 0.1, 0.3]), |
|
([0.9, 0.3, 0.5], [0.5, 1.0, 0.5], [0.3, 0.3, 0.9])][self._p._colored] |
|
self.draw_background(color) |
|
self.draw_axis(2, color[2]) |
|
self.draw_axis(1, color[1]) |
|
self.draw_axis(0, color[0]) |
|
|
|
def draw_background(self, color): |
|
pass |
|
|
|
def draw_axis(self, axis, color): |
|
raise NotImplementedError() |
|
|
|
def draw_text(self, text, position, color, scale=1.0): |
|
if len(color) == 3: |
|
color = (color[0], color[1], color[2], 1.0) |
|
|
|
if self._p.label_font is None: |
|
self._p.label_font = font.load(self._p.font_face, |
|
self._p.font_size, |
|
bold=True, italic=False) |
|
|
|
label = font.Text(self._p.label_font, text, |
|
color=color, |
|
valign=font.Text.BASELINE, |
|
halign=font.Text.CENTER) |
|
|
|
pgl.glPushMatrix() |
|
pgl.glTranslatef(*position) |
|
billboard_matrix() |
|
scale_factor = 0.005 * scale |
|
pgl.glScalef(scale_factor, scale_factor, scale_factor) |
|
pgl.glColor4f(0, 0, 0, 0) |
|
label.draw() |
|
pgl.glPopMatrix() |
|
|
|
def draw_line(self, v, color): |
|
o = self._p._origin |
|
pgl.glBegin(pgl.GL_LINES) |
|
pgl.glColor3f(*color) |
|
pgl.glVertex3f(v[0][0] + o[0], v[0][1] + o[1], v[0][2] + o[2]) |
|
pgl.glVertex3f(v[1][0] + o[0], v[1][1] + o[1], v[1][2] + o[2]) |
|
pgl.glEnd() |
|
|
|
|
|
class PlotAxesOrdinate(PlotAxesBase): |
|
|
|
def __init__(self, parent_axes): |
|
super().__init__(parent_axes) |
|
|
|
def draw_axis(self, axis, color): |
|
ticks = self._p._axis_ticks[axis] |
|
radius = self._p._tick_length / 2.0 |
|
if len(ticks) < 2: |
|
return |
|
|
|
|
|
axis_lines = [[0, 0, 0], [0, 0, 0]] |
|
axis_lines[0][axis], axis_lines[1][axis] = ticks[0], ticks[-1] |
|
axis_vector = vec_sub(axis_lines[1], axis_lines[0]) |
|
|
|
|
|
pos_z = get_direction_vectors()[2] |
|
d = abs(dot_product(axis_vector, pos_z)) |
|
d = d / vec_mag(axis_vector) |
|
|
|
|
|
labels_visible = abs(d - 1.0) > 0.02 |
|
|
|
|
|
for tick in ticks: |
|
self.draw_tick_line(axis, color, radius, tick, labels_visible) |
|
|
|
|
|
self.draw_axis_line(axis, color, ticks[0], ticks[-1], labels_visible) |
|
|
|
def draw_axis_line(self, axis, color, a_min, a_max, labels_visible): |
|
axis_line = [[0, 0, 0], [0, 0, 0]] |
|
axis_line[0][axis], axis_line[1][axis] = a_min, a_max |
|
self.draw_line(axis_line, color) |
|
if labels_visible: |
|
self.draw_axis_line_labels(axis, color, axis_line) |
|
|
|
def draw_axis_line_labels(self, axis, color, axis_line): |
|
if not self._p._label_axes: |
|
return |
|
axis_labels = [axis_line[0][::], axis_line[1][::]] |
|
axis_labels[0][axis] -= 0.3 |
|
axis_labels[1][axis] += 0.3 |
|
a_str = ['X', 'Y', 'Z'][axis] |
|
self.draw_text("-" + a_str, axis_labels[0], color) |
|
self.draw_text("+" + a_str, axis_labels[1], color) |
|
|
|
def draw_tick_line(self, axis, color, radius, tick, labels_visible): |
|
tick_axis = {0: 1, 1: 0, 2: 1}[axis] |
|
tick_line = [[0, 0, 0], [0, 0, 0]] |
|
tick_line[0][axis] = tick_line[1][axis] = tick |
|
tick_line[0][tick_axis], tick_line[1][tick_axis] = -radius, radius |
|
self.draw_line(tick_line, color) |
|
if labels_visible: |
|
self.draw_tick_line_label(axis, color, radius, tick) |
|
|
|
def draw_tick_line_label(self, axis, color, radius, tick): |
|
if not self._p._label_axes: |
|
return |
|
tick_label_vector = [0, 0, 0] |
|
tick_label_vector[axis] = tick |
|
tick_label_vector[{0: 1, 1: 0, 2: 1}[axis]] = [-1, 1, 1][ |
|
axis] * radius * 3.5 |
|
self.draw_text(str(tick), tick_label_vector, color, scale=0.5) |
|
|
|
|
|
class PlotAxesFrame(PlotAxesBase): |
|
|
|
def __init__(self, parent_axes): |
|
super().__init__(parent_axes) |
|
|
|
def draw_background(self, color): |
|
pass |
|
|
|
def draw_axis(self, axis, color): |
|
raise NotImplementedError() |
|
|