def _make_ribbon_mesh(self, x, y, w, h): signal_power = np.square(self.data) frames_per_pixel = int(self.frames_per_beat / HORIZ_SCALE) scale_factor = frames_per_pixel * 2 pad_size = math.ceil(float(signal_power.size)/scale_factor)*scale_factor - signal_power.size signal_power = np.append(signal_power, np.zeros(pad_size)*np.NaN) print signal_power.shape signal_power = signal_power.reshape(-1, scale_factor) print signal_power.shape signal_power = scipy.nanmean(signal_power, axis=1) print signal_power.shape signal_power /= np.max(signal_power) print 'signal power', len(signal_power) print signal_power[100:200] print np.max(signal_power) segments = self.blah_width mesh = Mesh() # create indices mesh.indices = range(segments * 2 + 2) # create vertices with evenly spaced texture coordinates span = np.linspace(0.0, 1.0, segments + 1) verts = [] mid_y = y + h/2 y_scale = h/2 idx = 0 for s in span: height = y_scale * signal_power[idx] verts += [x + s * w, mid_y - height, s, 0, x + s * w, mid_y + height, s, 1] idx += 1 mesh.vertices = verts # # animate a sine wave by setting the vert positions every frame: # theta = 3.0 * self.time # y = 300 + 50 * np.sin(np.linspace(theta, theta + 2 * np.pi, self.segments + 1)) # self.mesh.vertices[5::8] = y # seems that you have to reassign the entire verts list in order for the change # to take effect. mesh.vertices = mesh.vertices # # assign texture # if tex_file: # mesh.texture = Image(tex_file).texture # standard triangle strip mode mesh.mode = 'triangle_strip' return mesh
def DrawTris(vertices, triangles, DrawCallback): #Arrange data in kivy internal mesh format vertMod = [] for i in range(len(vertices)/2): vertMod.extend((vertices[i*2], vertices[(i*2)+1], 0., 0.)) ind = [] for tri in triangles: ind.extend(tri) mesh = Mesh() mesh.vertices = vertMod mesh.indices = ind mesh.mode = "triangles" DrawCallback(mesh)
def _set_ticks(self, *args): mesh = self._mesh s_max = self.max s_min = self.min if self.ticks_major and s_max > s_min: if not mesh: mesh = Mesh(mode='lines', group=str('TickMarker%d' % id(self))) self._mesh = mesh self.canvas.add(mesh) indices = mesh.indices vertices = mesh.vertices compute_ticks(indices, vertices, self.ticks_minor, self.ticks_major, self.padding, self.max, self.min, self.log, self.orientation == 'horizontal', tuple(self.size), tuple(self.pos)) mesh.vertices = vertices mesh.indices = indices else: if mesh: self.canvas.remove_group(str('TickMarker%d' % id(self))) self._mesh = None
def _set_ticks(self, *args): mesh = self._mesh s_max = self.max s_min = self.min if self.ticks_major and s_max > s_min: if not mesh: mesh = Mesh(mode='lines', group=str('TickMarker%d' % id(self))) self._mesh = mesh self.canvas.add(mesh) indices = mesh.indices vertices = mesh.vertices ticks_minor = self.ticks_minor ticks_major = self.ticks_major padding = self.padding log = self.log if log: # count the decades in min - max. This is in actual decades, # not logs. n_decades = floor(s_max - s_min) # for the fractional part of the last decade, we need to # convert the log value, x, to 10**x but need to handle # differently if the last incomplete decade has a decade # boundary in it if floor(s_min + n_decades) != floor(s_max): n_decades += 1 - (10 ** (s_min + n_decades + 1) - 10 ** s_max) / 10 ** floor(s_max + 1) else: n_decades += ((10 ** s_max - 10 ** (s_min + n_decades)) / 10 ** floor(s_max + 1)) # this might be larger than what is needed, but we delete # excess later n_ticks = n_decades / float(ticks_major) n_ticks = int(floor(n_ticks * (ticks_minor if ticks_minor >= 1. else 1.0))) + 2 # in decade multiples, e.g. 0.1 of the decade, the distance # between ticks decade_dist = ticks_major / float(ticks_minor if ticks_minor else 1.0) points = [0] * n_ticks points[0] = (0., True) # first element is always a major tick k = 1 # position in points # because each decade is missing 0.1 of the decade, if a tick # falls in < min_pos skip it min_pos = 0.1 - 0.00001 * decade_dist s_min_low = floor(s_min) # first real tick location. value is in fractions of decades # from the start we have to use decimals here, otherwise # floating point inaccuracies results in bad values start_dec = ceil((10 ** Decimal(s_min - s_min_low - 1)) / Decimal(decade_dist)) * decade_dist count_min = (0 if not ticks_minor else floor(start_dec / decade_dist) % ticks_minor) start_dec += s_min_low count = 0 # number of ticks we currently have passed start while True: # this is the current position in decade that we are. # e.g. -0.9 means that we're at 0.1 of the 10**ceil(-0.9) # decade pos_dec = start_dec + decade_dist * count pos_dec_low = floor(pos_dec) diff = pos_dec - pos_dec_low zero = abs(diff) < 0.001 * decade_dist if zero: # the same value as pos_dec but in log scale pos_log = pos_dec_low else: pos_log = log10((pos_dec - pos_dec_low ) * 10 ** ceil(pos_dec)) if pos_log > s_max: break count += 1 if zero or diff >= min_pos: points[k] = (pos_log - s_min, ticks_minor and not count_min % ticks_minor) k += 1 count_min += 1 del points[k:] n_ticks = len(points) else: # distance between each tick tick_dist = ticks_major / float(ticks_minor if ticks_minor else 1.0) n_ticks = int(floor((s_max - s_min) / tick_dist) + 1) count = len(indices) // 2 # adjust mesh size if count > n_ticks: del vertices[n_ticks * 8:] del indices[n_ticks * 2:] elif count < n_ticks: vertices.extend([0] * (8 * (n_ticks - count))) indices.extend(range(2 * count, 2 * n_ticks)) if self.orientation == 'horizontal': center = self.center_y axis_dist = self.width start = self.x + padding above, below, dist1, dist2 = 1, 5, 0, 4 else: center = self.center_x axis_dist = self.height start = self.y + padding above, below, dist1, dist2 = 0, 4, 1, 5 # now, the physical distance between ticks tick_dist = (axis_dist - 2 * padding ) / float(s_max - s_min) * (tick_dist if not log else 1.0) # amounts that ticks extend above/below axis maj_plus = center + metrics.dp(12) maj_minus = center - metrics.dp(12) min_plus = center + metrics.dp(6) min_minus = center - metrics.dp(6) if log: for k in range(0, n_ticks): m = k * 8 vertices[m + dist1] = start + points[k][0] * tick_dist vertices[m + dist2] = vertices[m + dist1] if not points[k][1]: vertices[m + above] = min_plus vertices[m + below] = min_minus else: vertices[m + above] = maj_plus vertices[m + below] = maj_minus else: for k in range(0, n_ticks): m = k * 8 vertices[m + dist1] = start + k * tick_dist vertices[m + dist2] = vertices[m + dist1] if ticks_minor and k % ticks_minor: vertices[m + above] = min_plus vertices[m + below] = min_minus else: vertices[m + above] = maj_plus vertices[m + below] = maj_minus mesh.vertices = vertices mesh.indices = indices else: if mesh: self.canvas.remove_group(str('TickMarker%d' % id(self))) self._mesh = None