def add_data(self, lines):
assert lines.shape[1] == 4
x_coord = np.mgrid[0.0:1.0:lines.shape[0] * 1j].astype("f4")
x_coord = x_coord.reshape((-1, 1))
self.n_vertices = lines.shape[0]
self.vertex_array.attributes.append(
VertexAttribute(name="rgba_values", data=lines))
self.vertex_array.attributes.append(
VertexAttribute(name="x_coord", data=x_coord))
def add_data(self, field):
v, d, i = self.get_mesh_data(self.data_source, field)
v.shape = (v.size // 3, 3)
v = np.concatenate([v, np.ones((v.shape[0], 1))], axis=-1).astype("f4")
d.shape = (d.size, 1)
i.shape = (i.size, 1)
i = i.astype("uint32")
# d[:] = np.mgrid[0.0:1.0:1j*d.size].astype("f4")[:,None]
self.vertex_array.attributes.append(
VertexAttribute(name="model_vertex", data=v)
)
self.vertex_array.attributes.append(
VertexAttribute(name="vertex_data", data=d.astype("f4"))
)
self.vertex_array.indices = i
self.size = i.size
def _default_vertex_array(self):
va = VertexArray(name="box_outline", each=36)
data = compute_box_geometry(self.left_edge, self.right_edge).copy()
va.attributes.append(
VertexAttribute(name="model_vertex", data=data.astype("f4")))
N = data.size // 4
le = np.concatenate([[self.left_edge.copy()] for _ in range(N)])
re = np.concatenate([[self.right_edge.copy()] for _ in range(N)])
dds = self.right_edge - self.left_edge
dds = np.concatenate([[dds.copy()] for _ in range(N)])
va.attributes.append(
VertexAttribute(name="in_left_edge", data=le.astype("f4")))
va.attributes.append(
VertexAttribute(name="in_right_edge", data=re.astype("f4")))
va.attributes.append(
VertexAttribute(name="in_dx", data=dds.astype("f4")))
return va
def _default_base_quad(self):
bq = SceneData(
name="fullscreen_quad",
vertex_array=VertexArray(name="tri", each=6),
)
fq = FULLSCREEN_QUAD.reshape((6, 3), order="C")
bq.vertex_array.attributes.append(
VertexAttribute(name="vertexPosition_modelspace", data=fq))
return bq
def add_data(self):
self.n_vertices = self.data.shape[0]
self.vertex_array.attributes.append(
VertexAttribute(name="model_vertex", data=self.data.astype("f4")))
self.vertex_array.indices = np.arange(0,
self.n_vertices).astype("uint32")
self.size = self.n_vertices
def _default_vertex_array(self):
va = VertexArray(name="grid_bounds")
positions = []
dx = []
le = []
re = []
for g in self.grid_list:
dx.append(g.dds.tolist())
le.append(g.LeftEdge.tolist())
re.append(g.RightEdge.tolist())
positions = np.ones((len(self.grid_list), 4), dtype="f4")
dx = np.array(dx).astype("f4")
le = np.array(le).astype("f4")
re = np.array(re).astype("f4")
va.attributes.append(
VertexAttribute(name="model_vertex", data=positions))
va.attributes.append(VertexAttribute(name="in_left_edge", data=le))
va.attributes.append(VertexAttribute(name="in_dx", data=dx))
va.attributes.append(VertexAttribute(name="in_right_edge", data=re))
return va
def _default_vertex_array(self):
model_vertex = np.array([[-1, 1], [-1, -1], [1, 1], [1, -1]],
order="F",
dtype="f4")
va = VertexArray(name="particle_positions")
va.attributes.append(
VertexAttribute(name="model_vertex", data=model_vertex, divisor=0))
for attr in ("position_field", "radius_field", "color_field"):
if getattr(self, attr) is None:
continue
field = self.data_source[self.particle_type, getattr(self, attr)]
if field.units.dimensions is length:
field.convert_to_units("unitary")
field = field.astype("f4").d
if field.ndim == 1:
field.shape = (field.size, 1)
else:
self.size = field.shape[0] # for positions
print(f"Setting {attr} to a field of shape {field.shape}")
va.attributes.append(
VertexAttribute(name=attr, data=field, divisor=1))
print(f"Size is now: {self.size}")
return va
def add_data(self, curve):
# curve is a collection of ndarray of points
assert curve.shape[0] > 1 # a curve needs at least 2 points
assert curve.shape[1] == 3 # a curve needs at least 3 dimensions
# add the singleton 4th dim
data = np.ones((curve.shape[0], 4))
data[:, 0:3] = curve
self.n_vertices = curve.shape[0]
self.data = data
self.vertex_array.attributes.append(
VertexAttribute(name="model_vertex", data=data.astype("f4")))
self.vertex_array.indices = np.arange(0,
self.n_vertices).astype("uint32")
self.size = self.n_vertices
def build_textures(self):
# This doesn't check if the textures have already been built
self.font.set_size(self.font_size, 200)
chars = [ord(_) for _ in string.printable]
tex_ids = GL.glGenTextures(len(chars))
vert = []
for i, (tex_id, char_code) in enumerate(zip(tex_ids, chars)):
self.font.clear()
self.font.set_text(chr(char_code), flags=LOAD_FORCE_AUTOHINT)
self.font.draw_glyphs_to_bitmap(antialiased=True)
glyph = self.font.load_char(char_code)
x0, y0, x1, y1 = glyph.bbox
bitmap = self.font.get_image().astype(">f4") / 255.0
dx = 1.0 / bitmap.shape[0]
dy = 1.0 / bitmap.shape[1]
triangles = np.array(
[
[x0, y1, 0.0 + dx / 2.0, 0.0 + dy / 2.0],
[x0, y0, 0.0 + dx / 2.0, 1.0 - dy / 2.0],
[x1, y0, 1.0 - dx / 2.0, 1.0 - dy / 2.0],
[x0, y1, 0.0 + dx / 2.0, 0.0 + dy / 2.0],
[x1, y0, 1.0 - dx / 2.0, 1.0 - dy / 2.0],
[x1, y1, 1.0 - dx / 2.0, 0.0 + dy / 2.0],
],
dtype="<f4",
)
vert.append(triangles)
texture = Texture2D(texture_name=tex_id,
data=bitmap,
boundary_x="clamp",
boundary_y="clamp")
# I can't find information as to why horiAdvance is a
# factor of 8 larger than the other factors. I assume it
# is referenced somewhere, but I cannot find it.
self.characters[chr(char_code)] = Character(
texture, i, glyph.horiAdvance / 8.0, glyph.vertAdvance)
vert = np.concatenate(vert)
self.vertex_array.attributes.append(
VertexAttribute(name="quad_vertex", data=vert.astype("<f4")))
def _default_vertex_array(self):
va = VertexArray(name="tri", each=6)
fq = FULLSCREEN_QUAD.reshape((6, 3), order="C")
va.attributes.append(
VertexAttribute(name="vertexPosition_modelspace", data=fq))
return va
def add_data(self, field, no_ghost=False):
r"""Adds a source of data for the block collection.
Given a `data_source` and a `field` to populate from, adds the data
to the block collection so that is able to be rendered.
Parameters
----------
data_source : YTRegion
A YTRegion object to use as a data source.
field : string
A field to populate from.
no_ghost : bool (False)
Should we speed things up by skipping ghost zone generation?
"""
self.data_source.tiles.set_fields([field], [False], no_ghost=no_ghost)
# Every time we change our data source, we wipe all existing ones.
# We now set up our vertices into our current data source.
vert, dx, le, re = [], [], [], []
self.min_val = +np.inf
self.max_val = -np.inf
if self.scale:
left_min = np.ones(3, "f8") * np.inf
right_max = np.ones(3, "f8") * -np.inf
for block in self.data_source.tiles.traverse():
np.minimum(left_min, block.LeftEdge, left_min)
np.maximum(right_max, block.LeftEdge, right_max)
scale = right_max.max() - left_min.min()
for block in self.data_source.tiles.traverse():
block.LeftEdge -= left_min
block.LeftEdge /= scale
block.RightEdge -= left_min
block.RightEdge /= scale
for i, block in enumerate(self.data_source.tiles.traverse()):
self.min_val = min(self.min_val, np.nanmin(np.abs(block.my_data[0])).min())
self.max_val = max(self.max_val, np.nanmax(np.abs(block.my_data[0])).max())
self.blocks[id(block)] = (i, block)
vert.append([1.0, 1.0, 1.0, 1.0])
dds = (block.RightEdge - block.LeftEdge) / block.source_mask.shape
dx.append(dds.tolist())
le.append(block.LeftEdge.tolist())
re.append(block.RightEdge.tolist())
for (g, node, (sl, _dims, _gi)) in self.data_source.tiles.slice_traverse():
block = node.data
self.blocks_by_grid[g.id - g._id_offset].append((id(block), i))
self.grids_by_block[id(node.data)] = (g.id - g._id_offset, sl)
if hasattr(self.min_val, "in_units"):
self.min_val = self.min_val.d
if hasattr(self.max_val, "in_units"):
self.max_val = self.max_val.d
LE = np.array([b.LeftEdge for i, b in self.blocks.values()]).min(axis=0)
RE = np.array([b.RightEdge for i, b in self.blocks.values()]).max(axis=0)
self.diagonal = np.sqrt(((RE - LE) ** 2).sum())
# Now we set up our buffer
vert = np.array(vert, dtype="f4")
dx = np.array(dx, dtype="f4")
le = np.array(le, dtype="f4")
re = np.array(re, dtype="f4")
self.vertex_array.attributes.append(
VertexAttribute(name="model_vertex", data=vert)
)
self.vertex_array.attributes.append(VertexAttribute(name="in_dx", data=dx))
self.vertex_array.attributes.append(
VertexAttribute(name="in_left_edge", data=le)
)
self.vertex_array.attributes.append(
VertexAttribute(name="in_right_edge", data=re)
)
# Now we set up our textures
self._load_textures()
def add_data(self, field):
r"""Adds a source of data for the block collection.
Given a `data_source` and a `field` to populate from, adds the data
to the block collection so that is able to be rendered.
Parameters
----------
data_source : YTRegion
A YTRegion object to use as a data source.
field : string
A field to populate from.
no_ghost : bool (False)
Should we speed things up by skipping ghost zone generation?
"""
ds = self.data_source.ds
ds.index._identify_base_chunk(self.data_source)
left_edges = []
right_edges = []
dx = []
data = []
for obj in self.data_source._current_chunk.objs:
bs = OctreeSubsetBlockSlice(obj, ds)
LE = bs._fcoords[0, 0,
0, :, :].d - bs._fwidth[0, 0, 0, :, :].d * 0.5
RE = bs._fcoords[-1, -1,
-1, :, :].d + bs._fwidth[-1, -1, -1, :, :].d * 0.5
dx.append(bs._fwidth[-1, -1, -1, :, :].d)
left_edges.append(LE)
right_edges.append(RE)
d = bs.get_vertex_centered_data([field])[field]
data.append(
np.concatenate([d[:, :, :, i] for i in range(d.shape[-1])],
axis=2).copy(order="C"))
# Let's reshape ...
left_edges = np.concatenate(left_edges, axis=0).astype("f4")
right_edges = np.concatenate(right_edges, axis=0).astype("f4")
dx = np.concatenate(dx, axis=0).astype("f4")
data = np.concatenate(data, axis=-1).astype("f4")
data = data.reshape((3, 3, -1))
self.min_val = np.nanmin(data)
self.max_val = np.nanmax(data)
if hasattr(self.min_val, "in_units"):
self.min_val = self.min_val.d
if hasattr(self.max_val, "in_units"):
self.max_val = self.max_val.d
if self.max_val != self.min_val:
data = (data - self.min_val) / (
(self.max_val - self.min_val)) # * self.diagonal)
self.vertex_array.attributes.append(
VertexAttribute(name="model_vertex",
data=aabb_triangle_strip,
divisor=0))
self.vertex_array.attributes.append(
VertexAttribute(name="in_dx", data=dx, divisor=1))
self.vertex_array.attributes.append(
VertexAttribute(name="in_left_edge", data=left_edges, divisor=1))
self.vertex_array.attributes.append(
VertexAttribute(name="in_right_edge", data=right_edges, divisor=1))
# Now we set up our textures; we need to break our texture up into
# groups of MAX_3D_TEXTURE_SIZE
tex_size = GL.glGetInteger(GL.GL_MAX_3D_TEXTURE_SIZE)
# for now, use one texture for all the bitmaps
bt = Texture3D(data=np.ones((3, 3, tex_size), dtype="u1") * 255)
for start_index in np.mgrid[0:data.shape[-1]:tex_size]:
d = data[:, :, start_index:start_index + tex_size]
self.data_textures.append(Texture3D(data=d))
self.bitmap_textures.append(bt)
self.shapes.append(d.shape[-1])