def get_color(self):
if self.name:
if self.name in HTML4_NAMES_TO_HEX:
r, g, b = hex_to_rgb(HTML4_NAMES_TO_HEX[self.name])
return [r / 255., g / 255., b / 255., 1.]
if self.color:
return self.color.rgba
return None
def draw_shader(self):
if not self.settings['faces.on']:
return
for node in self.nodes:
if not hasattr(node, 'vbo'):
continue
if not node.settings.get("faces.on", self.settings['faces.on']):
continue
shaders.glUseProgram(self.shader)
try:
# bind data into gpu
node.vbo.bind()
try:
# tells opengl to access vertex once
# we call a draw function
glDisable(GL_POLYGON_SMOOTH)
glEnableClientState(GL_VERTEX_ARRAY)
# point at our vbo data
glVertexPointerf(node.vbo)
# actually tell opengl to draw
# the stuff in the VBO as a series
# of triangles
if self.activate_selection and node.widget.isSelected():
glUniform3f(node.shader_uniforms['face_color'], 1, 1,
0)
else:
rgb = hex_to_rgb(node.settings.get("color", "#ffffff"))
glUniform3f(node.shader_uniforms['face_color'], *rgb)
glUniform1f(node.shader_uniforms['opacity'],
node.settings.get("opacity", 1))
glDrawArrays(GL_TRIANGLES, 0, node.vertex_buffer.shape[0])
finally:
# cleanup, unbind the our data from gpu ram
# and tell opengl that it should not
# expect vertex arrays anymore
node.vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
finally:
# stop using our shader
shaders.glUseProgram(0)
def get_color(self):
"""Get the RGBA color array of the material.
Returns
-------
:obj:`list` of :obj:`float`
List of 4 floats (``0.0-1.0``) indicating RGB colors and Alpha channel of the material.
Examples
--------
>>> material = Material('aqua')
>>> material.get_color()
[0.0, 1.0, 1.0, 1.0]
"""
if self.name:
if self.name in HTML4_NAMES_TO_HEX:
r, g, b = hex_to_rgb(HTML4_NAMES_TO_HEX[self.name])
return [r / 255., g / 255., b / 255., 1.]
if self.color:
return self.color.rgba
return None
polylines = []
for points in pointsets:
points = [Point(*point) for point in points]
polyline = Polyline(points)
polylines.append(polyline)
# ==============================================================================
# Visualize
# ==============================================================================
meshartist = MeshArtist(None)
meshartist.mesh = Mesh.from_vertices_and_faces(*A)
meshartist.layer = "CGAL::Intersections::A"
meshartist.clear_layer()
meshartist.draw_faces(join_faces=True, color=hex_to_rgb('#222222'))
meshartist.mesh = Mesh.from_vertices_and_faces(*B)
meshartist.layer = "CGAL::Intersections::B"
meshartist.clear_layer()
meshartist.draw_faces(join_faces=True, color=hex_to_rgb('#888888'))
polylineartist = PolylineArtist(None, layer="CGAL::Intersections::Polylines")
polylineartist.clear_layer()
pointartist = PointArtist(None, layer='CGAL::Intersections::Points')
pointartist.clear_layer()
for polyline in polylines:
polylineartist.primitive = polyline
polylineartist.color = hex_to_rgb('#ffffff')
polylineartist.draw()
def block_array_faces_color_back(self, block):
return flist(
hex_to_rgb(self.settings['faces.color:back']) for key in block.xyz)
def block_array_edges_color(self, block):
return flist(
hex_to_rgb(self.settings['edges.color']) for key in block.vertices)
def interface_array_faces_color_back(self, interface):
return flist(
hex_to_rgb(self.settings['interfaces.color:back'])
for key in interface.xyz)
def array_faces_color_back(self):
return flist(
hex_to_rgb(self.settings['faces.color:back'])
for key in self.mesh.xyz)
def array_edges_color(self):
return flist(
hex_to_rgb(self.settings['edges.color'])
for key in self.mesh.vertices)
def make_buffers(self):
# create instances map only at first time
if not hasattr(self, 'intances'):
self.intances = {}
for i, m in enumerate(self.nodes):
m.instance_color = self.random_hex()
self.intances[m.instance_color] = m
vertices = list(m.view.vertices)
m.vertices_instance_color = []
for v in vertices:
_hex = self.random_hex()
m.vertices_instance_color.append(_hex)
self.intances[_hex] = {'vertex': v, 'mesh': i}
edges = list(m.view.edges)
m.edge_instance = []
m.edges_instance_color = []
m.edge_xyz = []
for j, e in enumerate(edges):
v1, v2 = e
m.edge_xyz.extend(m.view.xyz[v1])
m.edge_xyz.extend(m.view.xyz[v2])
m.edge_instance.extend([j * 2, j * 2 + 1])
_hex = self.random_hex()
m.edges_instance_color.append(_hex)
m.edges_instance_color.append(_hex)
self.intances[_hex] = {'edge': e, 'mesh': i}
self.buffers = []
for node in self.nodes:
# print(node.settings)
xyz = flist(node.view.xyz)
vertices = list(node.view.vertices)
edges = flist(node.view.edges)
faces = flist(node.view.faces)
faces_back = flist(face[::-1] for face in node.view.faces)
vertices_instance_color = flist(
hex_to_rgb(vc) for vc in node.vertices_instance_color)
edges_instance_color = flist(
hex_to_rgb(c) for c in node.edges_instance_color)
instance_color = flist(
hex_to_rgb(node.instance_color) for key in node.view.xyz)
if hasattr(node.view, 'vertices_color'):
vertices_color = flist(vc for vc in node.view.vertices_color)
else:
vertices_color = node.settings.get("vertices.color", "#000000")
vertices_color = flist(
hex_to_rgb(vertices_color) for key in node.view.vertices)
edges_color = node.settings.get("edges.color", "#000000")
face_color = node.settings.get("color", "#cccccc")
edges_color = flist(hex_to_rgb(edges_color) for key in edges)
faces_color = flist(
hex_to_rgb(face_color) for key in node.view.xyz)
faces_color_back = flist(
hex_to_rgb(face_color) for key in node.view.xyz)
vertices_selected_color = flist(
hex_to_rgb('#999900') for key in node.view.vertices)
edges_selected_color = flist(
hex_to_rgb('#ffff00') for key in edges)
faces_selected_color = flist(
hex_to_rgb('#ffff00') for key in node.view.xyz)
faces_selected_color_back = flist(
hex_to_rgb('#ffff00') for key in node.view.xyz)
if self.activate_selection:
is_selected = node.widget.isSelected
else:
is_selected = lambda: False
buffer = {
'isSelected':
is_selected,
'xyz':
self.make_vertex_buffer(xyz),
'vertices':
self.make_index_buffer(vertices),
'edges':
self.make_index_buffer(edges),
'edges.instance':
self.make_index_buffer(node.edge_instance),
'faces':
self.make_index_buffer(faces),
'faces:back':
self.make_index_buffer(faces_back),
'vertices.color':
self.make_vertex_buffer(vertices_color, dynamic=True),
'vertices.instance.color':
self.make_vertex_buffer(vertices_instance_color, dynamic=True),
'vertices.selected.color':
self.make_vertex_buffer(vertices_selected_color, dynamic=True),
'edges.color':
self.make_vertex_buffer(edges_color, dynamic=True),
'edges.xyz':
self.make_vertex_buffer(node.edge_xyz),
'edges.instance.color':
self.make_vertex_buffer(edges_instance_color, dynamic=True),
'edges.selected.color':
self.make_vertex_buffer(edges_selected_color, dynamic=True),
'instance.color':
self.make_vertex_buffer(instance_color),
'edges.width':
node.settings.get("edges.width",
self.settings['edges.width:value']),
'vertices.size':
node.settings.get("vertices.size",
self.settings['vertices.size:value']),
'vertices.on':
node.settings.get("vertices.on", self.settings['vertices.on']),
'edges.on':
node.settings.get("edges.on", self.settings['edges.on']),
'faces.on':
node.settings.get("faces.on", self.settings['faces.on']),
'n':
len(xyz),
'v':
len(vertices),
'e':
len(edges),
'f':
len(faces)
}
if not self.use_shaders:
buffer.update({
'faces.color':
self.make_vertex_buffer(faces_color, dynamic=True),
'faces.color:back':
self.make_vertex_buffer(faces_color_back, dynamic=True),
'faces.selected.color':
self.make_vertex_buffer(faces_selected_color,
dynamic=True),
'faces.selected.color:back':
self.make_vertex_buffer(faces_selected_color_back,
dynamic=True),
})
self.buffers.append(buffer)
if self.use_shaders:
self.create_shader()
def make_buffers(self):
# create instances map only at first time
if not hasattr(self, 'intances'):
self.intances = {}
for i, m in enumerate(self.meshes):
m.instance_color = self.random_hex()
self.intances[m.instance_color] = m
vertices = list(m.view.vertices)
m.vertices_instance_color = []
for v in vertices:
_hex = self.random_hex()
m.vertices_instance_color.append(_hex)
self.intances[_hex] = {'vertex': v, 'mesh': i}
edges = list(m.view.edges)
m.edge_instance = []
m.edges_instance_color = []
m.edge_xyz = []
for j, e in enumerate(edges):
v1, v2 = e
m.edge_xyz.extend(m.view.xyz[v1])
m.edge_xyz.extend(m.view.xyz[v2])
m.edge_instance.extend([j * 2, j * 2 + 1])
_hex = self.random_hex()
m.edges_instance_color.append(_hex)
m.edges_instance_color.append(_hex)
self.intances[_hex] = {'edge': e, 'mesh': i}
self.buffers = []
for m in self.meshes:
xyz = flist(m.view.xyz)
vertices = list(m.view.vertices)
edges = flist(m.view.edges)
faces = flist(m.view.faces)
faces_back = flist(face[::-1] for face in m.view.faces)
vertices_color = flist(
hex_to_rgb('#000000') for key in m.view.vertices)
vertices_instance_color = flist(
hex_to_rgb(vc) for vc in m.vertices_instance_color)
edges_color = flist(hex_to_rgb('#333333') for key in m.view.edges)
edges_instance_color = flist(
hex_to_rgb(c) for c in m.edges_instance_color)
if m.widget.isSelected():
# default selection color
face_color = '#ffff00'
else:
face_color = m.color
faces_color = flist(hex_to_rgb(face_color) for key in m.view.xyz)
faces_color_back = flist(
hex_to_rgb(face_color) for key in m.view.xyz)
instance_color = flist(
hex_to_rgb(m.instance_color) for key in m.view.xyz)
self.buffers.append({
'xyz':
self.make_vertex_buffer(xyz),
'vertices':
self.make_index_buffer(vertices),
'edges':
self.make_index_buffer(edges),
'edges.instance':
self.make_index_buffer(m.edge_instance),
'faces':
self.make_index_buffer(faces),
'faces:back':
self.make_index_buffer(faces_back),
'vertices.color':
self.make_vertex_buffer(vertices_color, dynamic=True),
'vertices.instance.color':
self.make_vertex_buffer(vertices_instance_color, dynamic=True),
'edges.color':
self.make_vertex_buffer(edges_color, dynamic=True),
'edges.xyz':
self.make_vertex_buffer(m.edge_xyz),
'edges.instance.color':
self.make_vertex_buffer(edges_instance_color, dynamic=True),
'faces.color':
self.make_vertex_buffer(faces_color, dynamic=True),
'faces.color:back':
self.make_vertex_buffer(faces_color_back, dynamic=True),
'instance.color':
self.make_vertex_buffer(instance_color),
'n':
len(xyz),
'v':
len(vertices),
'e':
len(edges),
'f':
len(faces)
})
