Search is not available for this dataset
text stringlengths 75 104k |
|---|
def sim_timetrace(emission, max_rate, t_step):
"""Draw random emitted photons from Poisson(emission_rates).
"""
emission_rates = emission * max_rate * t_step
return np.random.poisson(lam=emission_rates).astype(np.uint8) |
def sim_timetrace_bg(emission, max_rate, bg_rate, t_step, rs=None):
"""Draw random emitted photons from r.v. ~ Poisson(emission_rates).
Arguments:
emission (2D array): array of normalized emission rates. One row per
particle (axis = 0). Columns are the different time steps.
max_rate... |
def sim_timetrace_bg2(emission, max_rate, bg_rate, t_step, rs=None):
"""Draw random emitted photons from r.v. ~ Poisson(emission_rates).
This is an alternative implementation of :func:`sim_timetrace_bg`.
"""
if rs is None:
rs = np.random.RandomState()
emiss_bin_rate = np.zeros((emission.sha... |
def volume(self):
"""Box volume in m^3."""
return (self.x2 - self.x1) * (self.y2 - self.y1) * (self.z2 - self.z1) |
def _generate(num_particles, D, box, rs):
"""Generate a list of `Particle` objects."""
X0 = rs.rand(num_particles) * (box.x2 - box.x1) + box.x1
Y0 = rs.rand(num_particles) * (box.y2 - box.y1) + box.y1
Z0 = rs.rand(num_particles) * (box.z2 - box.z1) + box.z1
return [Particle(D=D, ... |
def add(self, num_particles, D):
"""Add particles with diffusion coefficient `D` at random positions.
"""
self._plist += self._generate(num_particles, D, box=self.box,
rs=self.rs) |
def positions(self):
"""Initial position for each particle. Shape (N, 3, 1)."""
return np.vstack([p.r0 for p in self]).reshape(len(self), 3, 1) |
def diffusion_coeff_counts(self):
"""List of tuples of (diffusion coefficient, counts) pairs.
The order of the diffusion coefficients is as in self.diffusion_coeff.
"""
return [(key, len(list(group)))
for key, group in itertools.groupby(self.diffusion_coeff)] |
def datafile_from_hash(hash_, prefix, path):
"""Return pathlib.Path for a data-file with given hash and prefix.
"""
pattern = '%s_%s*.h*' % (prefix, hash_)
datafiles = list(path.glob(pattern))
if len(datafiles) == 0:
raise NoMatchError('No matches for "%s"' % pattern)... |
def from_datafile(hash_, path='./', ignore_timestamps=False, mode='r'):
"""Load simulation from disk trajectories and (when present) timestamps.
"""
path = Path(path)
assert path.exists()
file_traj = ParticlesSimulation.datafile_from_hash(
hash_, prefix=ParticlesSimu... |
def _get_group_randomstate(rs, seed, group):
"""Return a RandomState, equal to the input unless rs is None.
When rs is None, try to get the random state from the
'last_random_state' attribute in `group`. When not available,
use `seed` to generate a random state. When seed is None the re... |
def hash(self):
"""Return an hash for the simulation parameters (excluding ID and EID)
This can be used to generate unique file names for simulations
that have the same parameters and just different ID or EID.
"""
hash_numeric = 't_step=%.3e, t_max=%.2f, np=%d, conc=%.2e' % \
... |
def compact_name_core(self, hashsize=6, t_max=False):
"""Compact representation of simulation params (no ID, EID and t_max)
"""
Moles = self.concentration()
name = "%s_%dpM_step%.1fus" % (
self.particles.short_repr(), Moles * 1e12, self.t_step * 1e6)
if hashsize > 0:
... |
def compact_name(self, hashsize=6):
"""Compact representation of all simulation parameters
"""
# this can be made more robust for ID > 9 (double digit)
s = self.compact_name_core(hashsize, t_max=True)
s += "_ID%d-%d" % (self.ID, self.EID)
return s |
def numeric_params(self):
"""A dict containing all the simulation numeric-parameters.
The values are 2-element tuples: first element is the value and
second element is a string describing the parameter (metadata).
"""
nparams = dict(
D = (self.diffusion_coeff.mean(),... |
def print_sizes(self):
"""Print on-disk array sizes required for current set of parameters."""
float_size = 4
MB = 1024 * 1024
size_ = self.n_samples * float_size
em_size = size_ * self.num_particles / MB
pos_size = 3 * size_ * self.num_particles / MB
print(" Num... |
def concentration(self, pM=False):
"""Return the concentration (in Moles) of the particles in the box.
"""
concentr = (self.num_particles / NA) / self.box.volume_L
if pM:
concentr *= 1e12
return concentr |
def _sim_trajectories(self, time_size, start_pos, rs,
total_emission=False, save_pos=False, radial=False,
wrap_func=wrap_periodic):
"""Simulate (in-memory) `time_size` steps of trajectories.
Simulate Brownian motion diffusion and emission of all the p... |
def simulate_diffusion(self, save_pos=False, total_emission=True,
radial=False, rs=None, seed=1, path='./',
wrap_func=wrap_periodic,
chunksize=2**19, chunkslice='times', verbose=True):
"""Simulate Brownian motion trajectories and e... |
def get_timestamps_part(self, name):
"""Return matching (timestamps, particles) pytables arrays.
"""
par_name = name + '_par'
timestamps = self.ts_store.h5file.get_node('/timestamps', name)
particles = self.ts_store.h5file.get_node('/timestamps', par_name)
return timestam... |
def _sim_timestamps(self, max_rate, bg_rate, emission, i_start, rs,
ip_start=0, scale=10, sort=True):
"""Simulate timestamps from emission trajectories.
Uses attributes: `.t_step`.
Returns:
A tuple of two arrays: timestamps and particles.
"""
... |
def simulate_timestamps_mix(self, max_rates, populations, bg_rate,
rs=None, seed=1, chunksize=2**16,
comp_filter=None, overwrite=False,
skip_existing=False, scale=10,
path=None, t_chunksize=No... |
def simulate_timestamps_mix_da(self, max_rates_d, max_rates_a,
populations, bg_rate_d, bg_rate_a,
rs=None, seed=1, chunksize=2**16,
comp_filter=None, overwrite=False,
skip_existing... |
def merge_da(ts_d, ts_par_d, ts_a, ts_par_a):
"""Merge donor and acceptor timestamps and particle arrays.
Parameters:
ts_d (array): donor timestamp array
ts_par_d (array): donor particles array
ts_a (array): acceptor timestamp array
ts_par_a (array): acceptor particles array
... |
def em_rates_from_E_DA(em_rate_tot, E_values):
"""Donor and Acceptor emission rates from total emission rate and E (FRET).
"""
E_values = np.asarray(E_values)
em_rates_a = E_values * em_rate_tot
em_rates_d = em_rate_tot - em_rates_a
return em_rates_d, em_rates_a |
def em_rates_from_E_unique(em_rate_tot, E_values):
"""Array of unique emission rates for given total emission and E (FRET).
"""
em_rates_d, em_rates_a = em_rates_from_E_DA(em_rate_tot, E_values)
return np.unique(np.hstack([em_rates_d, em_rates_a])) |
def em_rates_from_E_DA_mix(em_rates_tot, E_values):
"""D and A emission rates for two populations.
"""
em_rates_d, em_rates_a = [], []
for em_rate_tot, E_value in zip(em_rates_tot, E_values):
em_rate_di, em_rate_ai = em_rates_from_E_DA(em_rate_tot, E_value)
em_rates_d.append(em_rate_di)
... |
def populations_diff_coeff(particles, populations):
"""Diffusion coefficients of the two specified populations.
"""
D_counts = particles.diffusion_coeff_counts
if len(D_counts) == 1:
pop_sizes = [pop.stop - pop.start for pop in populations]
assert D_counts[0][1] >= sum(pop_sizes)
... |
def populations_slices(particles, num_pop_list):
"""2-tuple of slices for selection of two populations.
"""
slices = []
i_prev = 0
for num_pop in num_pop_list:
slices.append(slice(i_prev, i_prev + num_pop))
i_prev += num_pop
return slices |
def _calc_hash_da(self, rs):
"""Compute hash of D and A timestamps for single-step D+A case.
"""
self.hash_d = hash_(rs.get_state())[:6]
self.hash_a = self.hash_d |
def run(self, rs, overwrite=True, skip_existing=False, path=None,
chunksize=None):
"""Compute timestamps for current populations."""
if path is None:
path = str(self.S.store.filepath.parent)
kwargs = dict(rs=rs, overwrite=overwrite, path=path,
timesl... |
def run_da(self, rs, overwrite=True, skip_existing=False, path=None,
chunksize=None):
"""Compute timestamps for current populations."""
if path is None:
path = str(self.S.store.filepath.parent)
kwargs = dict(rs=rs, overwrite=overwrite, path=path,
... |
def merge_da(self):
"""Merge donor and acceptor timestamps, computes `ts`, `a_ch`, `part`.
"""
print(' - Merging D and A timestamps', flush=True)
ts_d, ts_par_d = self.S.get_timestamps_part(self.name_timestamps_d)
ts_a, ts_par_a = self.S.get_timestamps_part(self.name_timestamps_a... |
def save_photon_hdf5(self, identity=None, overwrite=True, path=None):
"""Create a smFRET Photon-HDF5 file with current timestamps."""
filepath = self.filepath
if path is not None:
filepath = Path(path, filepath.name)
self.merge_da()
data = self._make_photon_hdf5(ident... |
def print_attrs(data_file, node_name='/', which='user', compress=False):
"""Print the HDF5 attributes for `node_name`.
Parameters:
data_file (pytables HDF5 file object): the data file to print
node_name (string): name of the path inside the file to be printed.
Can be either a group ... |
def print_children(data_file, group='/'):
"""Print all the sub-groups in `group` and leaf-nodes children of `group`.
Parameters:
data_file (pytables HDF5 file object): the data file to print
group (string): path name of the group to be printed.
Default: '/', the root node.
"""
... |
def fit(self, trX, trY, batch_size=64, n_epochs=1, len_filter=LenFilter(), snapshot_freq=1, path=None):
"""Train model on given training examples and return the list of costs after each minibatch is processed.
Args:
trX (list) -- Inputs
trY (list) -- Outputs
batch_size (in... |
def plane_xz(size=(10, 10), resolution=(10, 10)) -> VAO:
"""
Generates a plane on the xz axis of a specific size and resolution.
Normals and texture coordinates are also included.
Args:
size: (x, y) tuple
resolution: (x, y) tuple
Returns:
A :py:class:`demosys.opengl.vao.VAO... |
def load(self):
"""
Deferred loading of the scene
:param scene: The scene object
:param file: Resolved path if changed by finder
"""
self.path = self.find_scene(self.meta.path)
if not self.path:
raise ValueError("Scene '{}' not found".format(self.meta... |
def load_gltf(self):
"""Loads a gltf json file"""
with open(self.path) as fd:
self.meta = GLTFMeta(self.path, json.load(fd)) |
def load_glb(self):
"""Loads a binary gltf file"""
with open(self.path, 'rb') as fd:
# Check header
magic = fd.read(4)
if magic != GLTF_MAGIC_HEADER:
raise ValueError("{} has incorrect header {} != {}".format(self.path, magic, GLTF_MAGIC_HEADER))
... |
def _link_data(self):
"""Add references"""
# accessors -> buffer_views -> buffers
for acc in self.accessors:
acc.bufferView = self.buffer_views[acc.bufferViewId]
for buffer_view in self.buffer_views:
buffer_view.buffer = self.buffers[buffer_view.bufferId]
... |
def check_extensions(self, supported):
"""
"extensionsRequired": ["KHR_draco_mesh_compression"],
"extensionsUsed": ["KHR_draco_mesh_compression"]
"""
if self.data.get('extensionsRequired'):
for ext in self.data.get('extensionsRequired'):
if ext not in ... |
def buffers_exist(self):
"""Checks if the bin files referenced exist"""
for buff in self.buffers:
if not buff.is_separate_file:
continue
path = self.path.parent / buff.uri
if not os.path.exists(path):
raise FileNotFoundError("Buffer {}... |
def load_indices(self, primitive):
"""Loads the index buffer / polygon list for a primitive"""
if getattr(primitive, "indices") is None:
return None, None
_, component_type, buffer = primitive.indices.read()
return component_type, buffer |
def prepare_attrib_mapping(self, primitive):
"""Pre-parse buffer mappings for each VBO to detect interleaved data for a primitive"""
buffer_info = []
for name, accessor in primitive.attributes.items():
info = VBOInfo(*accessor.info())
info.attributes.append((name, info.co... |
def get_bbox(self, primitive):
"""Get the bounding box for the mesh"""
accessor = primitive.attributes.get('POSITION')
return accessor.min, accessor.max |
def interleaves(self, info):
"""Does the buffer interleave with this one?"""
return info.byte_offset == self.component_type.size * self.components |
def create(self):
"""Create the VBO"""
dtype = NP_COMPONENT_DTYPE[self.component_type.value]
data = numpy.frombuffer(
self.buffer.read(byte_length=self.byte_length, byte_offset=self.byte_offset),
count=self.count * self.components,
dtype=dtype,
)
... |
def read(self):
"""
Reads buffer data
:return: component count, component type, data
"""
# ComponentType helps us determine the datatype
dtype = NP_COMPONENT_DTYPE[self.componentType.value]
return ACCESSOR_TYPE[self.type], self.componentType, self.bufferView.read(... |
def info(self):
"""
Get underlying buffer info for this accessor
:return: buffer, byte_length, byte_offset, component_type, count
"""
buffer, byte_length, byte_offset = self.bufferView.info(byte_offset=self.byteOffset)
return buffer, self.bufferView, \
byte_le... |
def info(self, byte_offset=0):
"""
Get the underlying buffer info
:param byte_offset: byte offset from accessor
:return: buffer, byte_length, byte_offset
"""
return self.buffer, self.byteLength, byte_offset + self.byteOffset |
def set_position(self, x, y, z):
"""
Set the 3D position of the camera
:param x: float
:param y: float
:param z: float
"""
self.position = Vector3([x, y, z]) |
def view_matrix(self):
"""
:return: The current view matrix for the camera
"""
self._update_yaw_and_pitch()
return self._gl_look_at(self.position, self.position + self.dir, self._up) |
def _update_yaw_and_pitch(self):
"""
Updates the camera vectors based on the current yaw and pitch
"""
front = Vector3([0.0, 0.0, 0.0])
front.x = cos(radians(self.yaw)) * cos(radians(self.pitch))
front.y = sin(radians(self.pitch))
front.z = sin(radians(self.yaw)) ... |
def look_at(self, vec=None, pos=None):
"""
Look at a specific point
:param vec: Vector3 position
:param pos: python list [x, y, x]
:return: Camera matrix
"""
if pos is None:
vec = Vector3(pos)
if vec is None:
raise ValueError("vec... |
def _gl_look_at(self, pos, target, up):
"""
The standard lookAt method
:param pos: current position
:param target: target position to look at
:param up: direction up
"""
z = vector.normalise(pos - target)
x = vector.normalise(vector3.cross(vector.normalis... |
def move_state(self, direction, activate):
"""
Set the camera position move state
:param direction: What direction to update
:param activate: Start or stop moving in the direction
"""
if direction == RIGHT:
self._xdir = POSITIVE if activate else STILL
... |
def rot_state(self, x, y):
"""
Set the rotation state of the camera
:param x: viewport x pos
:param y: viewport y pos
"""
if self.last_x is None:
self.last_x = x
if self.last_y is None:
self.last_y = y
x_offset = self.last_x - x
... |
def view_matrix(self):
"""
:return: The current view matrix for the camera
"""
# Use separate time in camera so we can move it when the demo is paused
now = time.time()
# If the camera has been inactive for a while, a large time delta
# can suddenly move the camer... |
def _translate_string(self, data, length):
"""Translate string into character texture positions"""
for index, char in enumerate(data):
if index == length:
break
yield self._meta.characters - 1 - self._ct[char] |
def _generate_character_map(self):
"""Generate character translation map (latin1 pos to texture pos)"""
self._ct = [-1] * 256
index = 0
for crange in self._meta.character_ranges:
for cpos in range(crange['min'], crange['max'] + 1):
self._ct[cpos] = index... |
def buffer_format(frmt: str) -> BufferFormat:
"""
Look up info about a buffer format
:param frmt: format string such as 'f', 'i' and 'u'
:return: BufferFormat instance
"""
try:
return BUFFER_FORMATS[frmt]
except KeyError:
raise ValueError("Buffer format '{}' unknown. Valid fo... |
def attribute_format(frmt: str) -> BufferFormat:
"""
Look up info about an attribute format
:param frmt: Format of an
:return: BufferFormat instance
"""
try:
return ATTRIBUTE_FORMATS[frmt]
except KeyError:
raise ValueError("Buffer format '{}' unknown. Valid formats: {}".forma... |
def init(window=None, project=None, timeline=None):
"""
Initialize, load and run
:param manager: The effect manager to use
"""
from demosys.effects.registry import Effect
from demosys.scene import camera
window.timeline = timeline
# Inject attributes into the base Effect class
set... |
def draw(self, projection_matrix=None, camera_matrix=None, time=0):
"""
Draw all the nodes in the scene
:param projection_matrix: projection matrix (bytes)
:param camera_matrix: camera_matrix (bytes)
:param time: The current time
"""
projection_matrix = projectio... |
def draw_bbox(self, projection_matrix=None, camera_matrix=None, all=True):
"""Draw scene and mesh bounding boxes"""
projection_matrix = projection_matrix.astype('f4').tobytes()
camera_matrix = camera_matrix.astype('f4').tobytes()
# Scene bounding box
self.bbox_program["m_proj"].... |
def apply_mesh_programs(self, mesh_programs=None):
"""Applies mesh programs to meshes"""
if not mesh_programs:
mesh_programs = [ColorProgram(), TextureProgram(), FallbackProgram()]
for mesh in self.meshes:
for mp in mesh_programs:
instance = mp.apply(mesh... |
def calc_scene_bbox(self):
"""Calculate scene bbox"""
bbox_min, bbox_max = None, None
for node in self.root_nodes:
bbox_min, bbox_max = node.calc_global_bbox(
matrix44.create_identity(),
bbox_min,
bbox_max
)
self.bb... |
def points_random_3d(count, range_x=(-10.0, 10.0), range_y=(-10.0, 10.0), range_z=(-10.0, 10.0), seed=None) -> VAO:
"""
Generates random positions inside a confied box.
Args:
count (int): Number of points to generate
Keyword Args:
range_x (tuple): min-max range for x axis: Example (-10... |
def start(self):
"""Play the music"""
if self.initialized:
mixer.music.unpause()
else:
mixer.music.play()
# FIXME: Calling play twice to ensure the music is actually playing
mixer.music.play()
self.initialized = True
self.paused... |
def pause(self):
"""Pause the music"""
mixer.music.pause()
self.pause_time = self.get_time()
self.paused = True |
def get_time(self) -> float:
"""
Get the current position in the music in seconds
"""
if self.paused:
return self.pause_time
return mixer.music.get_pos() / 1000.0 |
def set_time(self, value: float):
"""
Set the current time in the music in seconds causing the player
to seek to this location in the file.
"""
if value < 0:
value = 0
# mixer.music.play(start=value)
mixer.music.set_pos(value) |
def draw_buffers(self, near, far):
"""
Draw framebuffers for debug purposes.
We need to supply near and far plane so the depth buffer can be linearized when visualizing.
:param near: Projection near value
:param far: Projection far value
"""
self.ctx.disable(mode... |
def add_point_light(self, position, radius):
"""Add point light"""
self.point_lights.append(PointLight(position, radius)) |
def render_lights(self, camera_matrix, projection):
"""Render light volumes"""
# Draw light volumes from the inside
self.ctx.front_face = 'cw'
self.ctx.blend_func = moderngl.ONE, moderngl.ONE
helper._depth_sampler.use(location=1)
with self.lightbuffer_scope:
... |
def render_lights_debug(self, camera_matrix, projection):
"""Render outlines of light volumes"""
self.ctx.enable(moderngl.BLEND)
self.ctx.blend_func = moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA
for light in self.point_lights:
m_mv = matrix44.multiply(light.matrix, came... |
def combine(self):
"""Combine diffuse and light buffer"""
self.gbuffer.color_attachments[0].use(location=0)
self.combine_shader["diffuse_buffer"].value = 0
self.lightbuffer.color_attachments[0].use(location=1)
self.combine_shader["light_buffer"].value = 1
self.quad.render... |
def load_shader(self, shader_type: str, path: str):
"""Load a single shader"""
if path:
resolved_path = self.find_program(path)
if not resolved_path:
raise ValueError("Cannot find {} shader '{}'".format(shader_type, path))
print("Loading:", pat... |
def load(self):
"""Load a texture array"""
self._open_image()
width, height, depth = self.image.size[0], self.image.size[1] // self.layers, self.layers
components, data = image_data(self.image)
texture = self.ctx.texture_array(
(width, height, depth),
... |
def draw(self, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0):
"""
Draw the mesh using the assigned mesh program
:param projection_matrix: projection_matrix (bytes)
:param view_matrix: view_matrix (bytes)
:param camera_matrix: camera_matrix (bytes)
... |
def add_attribute(self, attr_type, name, components):
"""
Add metadata about the mesh
:param attr_type: POSITION, NORMAL etc
:param name: The attribute name used in the program
:param components: Number of floats
"""
self.attributes[attr_type] = {"name": name, "co... |
def set_time(self, value: float):
"""
Set the current time jumping in the timeline.
Args:
value (float): The new time
"""
if value < 0:
value = 0
self.controller.row = self.rps * value |
def draw(self, time: float, frametime: float, target: moderngl.Framebuffer):
"""
Draw function called by the system every frame when the effect is active.
This method raises ``NotImplementedError`` unless implemented.
Args:
time (float): The current time in seconds.
... |
def get_program(self, label: str) -> moderngl.Program:
"""
Get a program by its label
Args:
label (str): The label for the program
Returns: py:class:`moderngl.Program` instance
"""
return self._project.get_program(label) |
def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray,
moderngl.Texture3D, moderngl.TextureCube]:
"""
Get a texture by its label
Args:
label (str): The Label for the texture
Returns:
The... |
def get_effect_class(self, effect_name: str, package_name: str = None) -> Type['Effect']:
"""
Get an effect class by the class name
Args:
effect_name (str): Name of the effect class
Keyword Args:
package_name (str): The package the effect belongs to. This is opt... |
def create_projection(self, fov: float = 75.0, near: float = 1.0, far: float = 100.0, aspect_ratio: float = None):
"""
Create a projection matrix with the following parameters.
When ``aspect_ratio`` is not provided the configured aspect
ratio for the window will be used.
Args:
... |
def create_transformation(self, rotation=None, translation=None):
"""
Creates a transformation matrix woth rotations and translation.
Args:
rotation: 3 component vector as a list, tuple, or :py:class:`pyrr.Vector3`
translation: 3 component vector as a list, tuple, or :py... |
def create_normal_matrix(self, modelview):
"""
Creates a normal matrix from modelview matrix
Args:
modelview: The modelview matrix
Returns:
A 3x3 Normal matrix as a :py:class:`numpy.array`
"""
normal_m = Matrix33.from_matrix44(modelview)
... |
def available_templates(value):
"""Scan for available templates in effect_templates"""
templates = list_templates()
if value not in templates:
raise ArgumentTypeError("Effect template '{}' does not exist.\n Available templates: {} ".format(
value, ", ".join(templates)))
return valu... |
def root_path():
"""Get the absolute path to the root of the demosys package"""
module_dir = os.path.dirname(globals()['__file__'])
return os.path.dirname(os.path.dirname(module_dir)) |
def load(self):
"""Load a file in text mode"""
self.meta.resolved_path = self.find_data(self.meta.path)
if not self.meta.resolved_path:
raise ImproperlyConfigured("Data file '{}' not found".format(self.meta.path))
print("Loading:", self.meta.path)
with ope... |
def get_finder(import_path):
"""
Get a finder class from an import path.
Raises ``demosys.core.exceptions.ImproperlyConfigured`` if the finder is not found.
This function uses an lru cache.
:param import_path: string representing an import path
:return: An instance of the finder
"""
Fin... |
def find(self, path: Path):
"""
Find a file in the path. The file may exist in multiple
paths. The last found file will be returned.
:param path: The path to find
:return: The absolute path to the file or None if not found
"""
# Update paths from settings to make... |
def update(self, aspect_ratio=None, fov=None, near=None, far=None):
"""
Update the internal projection matrix based on current values
or values passed in if specified.
:param aspect_ratio: New aspect ratio
:param fov: New field of view
:param near: New near value
... |
def projection_constants(self):
"""
Returns the (x, y) projection constants for the current projection.
:return: x, y tuple projection constants
"""
return self.far / (self.far - self.near), (self.far * self.near) / (self.near - self.far) |
def draw(self, projection_matrix=None, camera_matrix=None, time=0):
"""
Draw node and children
:param projection_matrix: projection matrix (bytes)
:param camera_matrix: camera_matrix (bytes)
:param time: The current time
"""
if self.mesh:
self.mesh.dr... |
def calc_global_bbox(self, view_matrix, bbox_min, bbox_max):
"""Recursive calculation of scene bbox"""
if self.matrix is not None:
view_matrix = matrix44.multiply(self.matrix, view_matrix)
if self.mesh:
bbox_min, bbox_max = self.mesh.calc_global_bbox(view_matrix, bbox_mi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.