def create_3dcube(self, pos, size): x, y, z = pos w, h, p = size fmt = [('vPosition', 3, 'float'), ('vColor', 4, 'float')] vertices = [ x, y, z, 1, 0, 0, 1, x + w, y, z, .5, .5, 0, 1, x + w, y + h, z, 0, 1, 0, 1, x, y + h, z, 0, .5, .5, 1, x, y, z + p, 0, 0, 1, 1, x + w, y, z + p, .5, 0, .5, 1, x + w, y + h, z + p, 0, 0, 0, 1, x, y + h, z + p, 1, 1, 1, 1 ] indices = [ 0, 2, 1, 0, 3, 2, 5, 0, 1, 5, 4, 0, 5, 2, 6, 5, 1, 2, 4, 3, 0, 4, 7, 3, 2, 7, 6, 2, 3, 7, 5, 6, 4, 4, 6, 7 ] Color(1, 1, 1) Mesh(vertices=vertices, indices=indices, fmt=fmt, mode='triangles') vertices = [ x, y, z, 1, 1, 1, 1, x + w, y, z, 1, 1, 1, 1, x + w, y + h, z, 1, 1, 1, 1, x, y + h, z, 1, 1, 1, 1, x, y, z + p, 1, 1, 1, 1, x + w, y, z + p, 1, 1, 1, 1, x + w, y + h, z + p, 1, 1, 1, 1, x, y + h, z + p, 1, 1, 1, 1 ] indices = [ 0, 2, 2, 1, 1, 0, 0, 3, 3, 2, 1, 5, 2, 5, 2, 6, 6, 5, 0, 4, 4, 3, 3, 7, 7, 4, 7, 2, 0, 5, 4, 5, 7, 6, 4, 6 ] Color(1, 1, 1) Mesh(vertices=vertices, indices=indices, fmt=fmt, mode='lines')
def render(self): ff_vertices, ff_indices = self.render_font_file(color=(1, 0.5, 1)) msg_vertices, msg_indices = self.render_text( 'Awesome font rendering from a sprite sheet! ;)', pos=(5, 200), color=(0.5, 1.0, 1.0)) msg2_vertices, msg2_indices = self.render_text( 'Demonstration of background clipping for transparency.', pos=(5, 150), color=(0.5, 1.0, 1.0)) with self.canvas: Mesh(fmt=self.vfmt, mode=str('triangles'), indices=ff_indices, vertices=ff_vertices, texture=self.texture) Mesh(fmt=self.vfmt, mode=str('triangles'), indices=msg_indices, vertices=msg_vertices, texture=self.texture) Mesh(fmt=self.vfmt, mode=str('triangles'), indices=msg2_indices, vertices=msg2_vertices, texture=self.texture)
def _regenerate_mesh(self): '''(re)generates mesh(map visualisation) according to the surface points''' vertices = [] indices = [] scene = self.scene for i in range(MapWidget.map_segments_count): x, y = self.surface[i] # surface point vertices.extend([int(x), int(y), 0, 0]) # map bottom point vertices.extend([int(x), int(0), 0, 0]) min_x = scene.float_x_to_pixels(0) min_y = scene.float_y_to_pixels(0) max_x = scene.float_x_to_pixels(1) max_y = scene.float_y_to_pixels(1) # corners to make it polygonal fill of widget under surface vertices.extend([max_x, scene.float_y_to_pixels(random()), 0, 0]) vertices.extend([max_x, min_y, 0, 0]) vertices.extend([max_x, min_y, 0, 0]) vertices.extend([min_x, min_y, 0, 0]) indices = list(range(MapWidget.map_segments_count*2 + 4)) self.canvas.clear() with self.canvas.before: # blue sky Color(0.4, 0.9, 1) self.mesh = Mesh(vertices=[min_x,min_y,0,0 ,min_x,max_y,0,0 ,max_x,max_y,0,0 , max_x,min_y,0,0], indices=[0,1,2,3], mode='triangle_fan') with self.canvas: # green terrain Color(0.2, 0.85, 0.3) self.mesh = Mesh(vertices=vertices, indices=indices, mode='triangle_strip')
def _draw_element(m, texture='', texture1=''): #bind the texture BEFORE the draw (Mesh) if texture1: # here, we are binding a custom texture at index 1 # this will be used as texture1 in shader. tex1 = Image(texture1).texture tex1.wrap = 'repeat' #enable of uv support >1 or <0 BindTexture(texture=tex1, index=1) #clear the texture if none else: BindTexture(source="", index=1) mesh = Mesh( vertices=m.vertices, indices=m.indices, fmt=m.vertex_format, mode='triangles', group='truc', ) if texture: try: texture = Image(texture).texture texture.wrap = 'repeat' #enable of uv support >1 or <0 mesh.texture = texture except: #no texture if not found or not supported pass
def loadShaders(self): ## generate the glsl code #self.shader_substitutions.update(args) # print('scalar tracker subs') # print(self.shader_substitutions) self.shaders = glsl_utils.loadShaders('graph_renderer.glsl', self.shader_substitutions) # # ## set the meshes shaders to the generated glsl code self.render_context.shader.vs = self.shaders['vs'] self.render_context.shader.fs = self.shaders['fs'] ## replace any previous mesh with the new mesh if hasattr(self, 'curve_mesh'): self.render_context.remove(self.curve_mesh) fmt = [(b'v_pos', 2, 'float')] self.curve_mesh = Mesh(mode='line_strip', fmt=fmt) self.render_context['color'] = [1.0, 0.1, 0.0, 1.0] self.render_context.add(self.curve_mesh) if hasattr(self, 'fill_mesh'): self.render_context.remove(self.fill_mesh) fmt = [(b'v_pos', 2, 'float')] self.fill_mesh = Mesh(mode='triangles', fmt=fmt) self.render_context.add(self.fill_mesh)
def __init__(self, **kwargs): super(Graph, self).__init__(**kwargs) self._mesh = Mesh(mode='lines') self._mesh_rect = Mesh(mode='line_strip') val = 0.25 self.canvas.add(Color(1 * val, 1 * val, 1 * val)) self.canvas.add(self._mesh) self.canvas.add(Color(1, 1, 1)) self.canvas.add(self._mesh_rect) mesh = self._mesh_rect mesh.vertices = [0] * (5 * 4) mesh.indices = [k for k in xrange(5)] self._plot_area = StencilView() self.add_widget(self._plot_area) self._trigger = Clock.create_trigger(self._redraw_all) self._trigger_size = Clock.create_trigger(self._redraw_size) self.bind(center=self._trigger_size, padding=self._trigger_size, font_size=self._trigger_size, plots=self._trigger_size, x_grid=self._trigger_size, y_grid=self._trigger_size, draw_border=self._trigger_size) self.bind(xmin=self._trigger, xmax=self._trigger, xlog=self._trigger, x_ticks_major=self._trigger, x_ticks_minor=self._trigger, xlabel=self._trigger, x_grid_label=self._trigger, ymin=self._trigger, ymax=self._trigger, ylog=self._trigger, y_ticks_major=self._trigger, y_ticks_minor=self._trigger, ylabel=self._trigger, y_grid_label=self._trigger) self._trigger()
def build_mesh(self): #switch between original and alteration code # switch = False #original switch = True #alteration """ returns a Mesh of a rough circle. """ vertices = [] indices = [] step = 10 istep = (pi * 2) / float(step) # my alteration # mask for mapping list of vertices # where is problem with format? vertex_format = [(b'v_pos', 2, "float")] for i in range(step): x = 300 + cos(istep * i) * 100 y = 300 + sin(istep * i) * 100 if switch == False: # originall code vertices.extend([x, y, 0, 0]) else: # my alteration vertices.extend([x, y]) indices.append(i) if switch == False: # originall code return Mesh(vertices=vertices, indices=indices) else: # my alteration return Mesh(vertices=vertices, indices=indices, fmt=vertex_format)
def __init__(self, **kwargs): super(FooBar, self).__init__(**kwargs) with self.canvas: self.mesh = Mesh(mode='triangles', source='img/bar.png') self.face = Mesh(mode='triangles', source='img/foo.png') self.build_mesh() self.build_face(self.vertices)
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 __init__(self, **kwargs): super(Graph, self).__init__(**kwargs) with self.canvas: self._fbo = Fbo(size=self.size, with_stencilbuffer=self._with_stencilbuffer) with self._fbo: self._background_color = Color(*self.background_color) self._background_rect = Rectangle(size=self.size) self._mesh_ticks_color = Color(*self.tick_color) self._mesh_ticks = Mesh(mode='lines') self._mesh_rect_color = Color(*self.border_color) self._mesh_rect = Mesh(mode='line_strip') with self.canvas: Color(1, 1, 1) self._fbo_rect = Rectangle(size=self.size, texture=self._fbo.texture) mesh = self._mesh_rect mesh.vertices = [0] * (5 * 4) mesh.indices = range(5) self._plot_area = StencilView() self.add_widget(self._plot_area) t = self._trigger = Clock.create_trigger(self._redraw_all) ts = self._trigger_size = Clock.create_trigger(self._redraw_size) tc = self._trigger_color = Clock.create_trigger(self._update_colors) self.bind(center=ts, padding=ts, precision=ts, plots=ts, x_grid=ts, y_grid=ts, draw_border=ts) self.bind(xmin=t, xmax=t, xlog=t, x_ticks_major=t, x_ticks_minor=t, xlabel=t, x_grid_label=t, ymin=t, ymax=t, ylog=t, y_ticks_major=t, y_ticks_minor=t, ylabel=t, y_grid_label=t, font_size=t, label_options=t, x_ticks_angle=t) self.bind(tick_color=tc, background_color=tc, border_color=tc) self._trigger()
def _draw_element(m, texture=''): mesh = Mesh( vertices=m.vertices, indices=m.indices, fmt=m.vertex_format, mode='triangles', ) if texture: texture = Image(texture).texture mesh.texture = texture
def _create_arrow(self, start_point: np.array, dir_vec: np.array): """Renders an arrow starting from `start_point` and pointing towards `dir_vec`. Parameters ---------- start_point : `numpy.array`, (3 x 1) The coordinates of the origin of the arrow. dir_vec : `numpy.array`, (3 x 1) The direction vector of the arrow. Returns ------- arrow_shaft : `kivy.graphics.Mesh` The mesh data of the arrow's shaft. arrw_head : `kivy.graphics.Mesh` The mesh data of the arrow's head. """ dir_vec /= 2 end_point = start_point + dir_vec shaft_data = GLMeshData( np.concatenate((start_point, end_point), axis=0), normals=-np.ones((2, 3)), indices=[0, 1], ) arrow_shaft = Mesh( vertices=shaft_data.verts_gl, indices=shaft_data.indices, fmt=shaft_data.vertex_format, mode="lines", ) # Create the points of the arrow head's base circle bases = self._get_base_vecs(dir_vec) npoints = 20 step = 2 * math.pi / npoints points = [] for j in range(npoints): points.append(0.03 * (bases[0] * math.sin(step * j) + bases[1] * math.cos(step * j))) points = np.array(points) points += start_point + dir_vec * 0.8 # Add to the points of the circle the tip of the arrow and set up the faces to create the mesh points = np.append(points, end_point, axis=0) faces = [] for j in range(npoints): faces.append([j, npoints, (j + 1) % npoints]) head_data = GLMeshData(points, faces=faces) arrow_head = Mesh( vertices=head_data.verts_gl, indices=head_data.indices, fmt=head_data.vertex_format, mode="triangles", ) return (arrow_shaft, arrow_head)
def show_axis(self): Color(1, 1, 0, 1) #Yellow Mesh( vertices=[ -1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0.8, 0.1, 0, 1, 1, 0, 0, 0, 0.8, -0.1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0.8, 0, -0.1, 1, 1, 0, 0, 0, 0.8, 0, 0.1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, ], indices=[0, 1, 2, 3, 4, 5, 6, 7], fmt=self.mesh_data.vertex_format, mode='line_strip', ) Color(1, 0, 1, 1) # purple Mesh( vertices=[ 0, 0, -1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0.1, 0, 0.8, 0, 1, 1, 0, 0, -0.1, 0, 0.8, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, -0.1, 0.8, 0, 1, 1, 0, 0, 0, 0.1, 0.8, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, ], indices=[0, 1, 2, 3, 4, 5, 6, 7], fmt=self.mesh_data.vertex_format, mode='line_strip', ) Color(0, 1, 1, 1) # Baby Blue Mesh( vertices=[ 0, -1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0.1, 0.8, 0, 1, 1, 0, 0, 0, -0.1, 0.8, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0.8, -0.1, 1, 1, 0, 0, 0, 0, 0.8, 0.1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, ], indices=[0, 1, 2, 3, 4, 5, 6, 7], fmt=self.mesh_data.vertex_format, mode='line_strip', )
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 draw_object(self, obj_id): m = self._scene.objects[obj_id] self.obj_rot_z = Rotate(self.obj_rotation[2], 0, 0, 1) self.obj_rot_y = Rotate(self.obj_rotation[1], 0, 1, 0) self.obj_rot_x = Rotate(self.obj_rotation[0], 1, 0, 0) self.obj_translate = Translate(xyz=self.obj_translation) if len(m.indices) > 2**16: print '%s too big! %s indices' % (obj_id, len(m.indices)) if m.texture: print "loading texture %s " % m.texture img = Image( source=resource_find(join(dirname(self.scene), m.texture))) texture = img.texture if texture: texture.wrap = 'repeat' else: texture = None vertex_lenght = sum(x[1] for x in m.vertex_format) if len(m.vertices) % vertex_lenght: print(('warning: vertices lenght (%s)' 'is not a multiple of vertex_format lenght(%s)') % (len(m.vertices), vertex_lenght)) Mesh(vertices=m.vertices, indices=m.indices, fmt=m.vertex_format, texture=texture, mode=self.mode)
def drawTriangles(self, lastPos, newPos, lastHeight, newHeight): trianglePts = [] baseWhite = lastHeight >= 0.5 * self.height and newHeight >= 0.5 * self.height \ and (lastHeight > 0.5 * self.height or newHeight > 0.5 * self.height) baseBlack = lastHeight <= 0.5 * self.height and newHeight <= 0.5 * self.height \ and (lastHeight < 0.5 * self.height or newHeight < 0.5 * self.height) if baseWhite or baseBlack: refHeight = min(lastHeight, newHeight) if baseWhite else max( lastHeight, newHeight) biggestHeight = max(lastHeight, newHeight) if baseWhite else min( lastHeight, newHeight) refPos = lastPos if refHeight == lastHeight else newPos biggestPos = lastPos if biggestHeight == lastHeight else newPos trianglePts += [ self.x + self.width * lastPos, self.y + 0.5 * self.height, 0, 0, self.x + self.width * lastPos, self.y + refHeight, 0, 0, self.x + self.width * newPos, self.y + 0.5 * self.height, 0, 0, self.x + self.width * lastPos, self.y + refHeight, 0, 0, self.x + self.width * newPos, self.y + 0.5 * self.height, 0, 0, self.x + self.width * newPos, self.y + refHeight, 0, 0, self.x + self.width * refPos, self.y + refHeight, 0, 0, self.x + self.width * biggestPos, self.y + refHeight, 0, 0, self.x + self.width * biggestPos, self.y + biggestHeight, 0, 0 ] baseColor = 0.65 if baseWhite else 0.35 with self.canvas: Color(baseColor, baseColor, baseColor) if len(trianglePts) > 0: Mesh(vertices=trianglePts, mode="triangles", indices=range(int(len(trianglePts) / 4)))
def draw_mesh(self, star_list): star_tex = Image('star1.png').texture vertex_format = [ (b'vPosition', 2, 'float'), (b'vSize', 1, 'float'), (b'vRotation', 1, 'float'), ] indices = [] ia = indices.append for star_number in range(len(star_list)): ia(star_number) vertices = [] e = vertices.extend for star in star_list: e([star[0], star[1], star[2], star[3]]) if self.mesh == None: with self.canvas: PushMatrix() self.mesh = Mesh(indices=indices, vertices=vertices, fmt=vertex_format, mode='points', texture=star_tex) PopMatrix() else: self.mesh.indices = indices self.mesh.vertices = vertices
def __init__(self, pos, texture, size_x=1.0, size_y=1.0, intensity=1.0, Tr=1.0): super(BillboardDisplay, self).__init__() self.intensity = intensity self.Tr = Tr self.translate = Translate() self.rotate_azi = Rotate(origin=(0,0,0), axis=(0,1,0)) self.rotate_ele = Rotate(origin=(0,0,0), axis=(1,0,0)) self.scale = Scale() self.color_instruction = InstructionGroup() self.mesh = Mesh( texture=texture, vertices=rectangle_nurb.vertices, indices=rectangle_nurb.indices, fmt=rectangle_nurb.vertex_format, mode='triangles' ) self.add(PushMatrix()) self.add(self.translate) self.add(self.rotate_azi) self.add(self.rotate_ele) self.add(self.scale) self.add(self.color_instruction) self.add(self.mesh) self.add(PopMatrix()) self.set_color(intensity=intensity, Tr=Tr) self.set_size(size_x, size_y) self.set_pos(pos) self.set_texture(texture)
def draw_mesh(self, this_star_list): if self.this_op is None: self.this_op = PointRendererOp() star_tex = Image('star1.png').texture self.this_op.indices = [] ia = self.this_op.indices.append for star_number in range(len(this_star_list)): ia(star_number) self.this_op.vertices = [] e = self.this_op.vertices.extend for star in this_star_list: this_star = [ star[0], star[1], star[2], star[3], \ star[4], star[5], star[6], star[7] ] if len(this_star) != self.vertex_depth: print("FATAL ERROR: array size does not match " + \ "vertex depth (offset)") exit(1) e(this_star) if self.mesh == None: with self.canvas: PushMatrix() self.mesh = Mesh(indices=self.this_op.indices, vertices=self.this_op.vertices, fmt=self.vertex_format, mode='points', texture=star_tex) PopMatrix() else: # self.mesh.indices = self.this_op.indices self.mesh.vertices = self.this_op.vertices pass
def _geojson_part_geometry(self, geometry, properties): tp = geometry["type"] graphics = [] if tp == "Polygon": tess = Tesselator() for c in geometry["coordinates"]: xy = list(self._lonlat_to_xy(c)) xy = flatten(xy) tess.add_contour(xy) tess.tesselate(WINDING_ODD, TYPE_POLYGONS) color = self._get_color_from(properties.get("style").get("stroke", "FF000088")) graphics.append(Color(*color)) for vertices, indices in tess.meshes: graphics.append( Mesh( vertices=vertices, indices=indices, mode="triangle_fan")) elif tp == "LineString": stroke = get_color_from_hex(properties.get("style").get("stroke", "#ffffff")) print "stroke: " + `stroke` #storke = [0.0, 0.0, 0.0, 1] print 'properties.get("width") :' + `properties.get("style").get("width")` stroke_width = dp(properties.get("style").get("width")) print "stroke_width: " + `stroke_width` xy = list(self._lonlat_to_xy(geometry["coordinates"])) xy = flatten(xy) graphics.append(Color(*stroke)) graphics.append(Line(points=xy, width=stroke_width)) return graphics
def draw_mesh(self, star_list): address = 'assets/particles/' tex_choice = choice([ 'particle.png', 'smokeparticle.png', 'VFX-0-Circle.png', 'VFX-0-Star.png', 'VFX-1-Star.png' ]) tex = Image(address + tex_choice).texture vertex_format = [(b'vPosition', 2, 'float'), (b'vSize', 1, 'float'), (b'vRotation', 1, 'float'), (b'vColor', 4, 'float')] indices = [] ia = indices.append for star_number in range(len(star_list)): ia(star_number) vertices = [] e = vertices.extend for star in star_list: color = star[4] e([ star[0], star[1], star[2], star[3], color[0], color[1], color[2], color[3] ]) if self.mesh == None: with self.canvas: PushMatrix() self.mesh = Mesh(indices=indices, vertices=vertices, fmt=vertex_format, mode='points', texture=tex) PopMatrix() else: self.mesh.indices = indices self.mesh.vertices = vertices self.mesh.texture = tex
def show_lines(self): indices = [] grid = self.grid cols = grid.cols rows = grid.rows for col in range(grid.cols + 1): indices.extend(( col * (rows + 1), col * (rows + 1) + rows, )) for row in range(grid.rows + 1): indices.extend(( row, row + (cols * (rows + 1)), )) with self.canvas: self.g_canvas = Canvas() with self.g_canvas: Color(1, 0, 0, 0.5) PushMatrix() Scale(self.width, self.height, 1.) self.g_mesh = Mesh(vertices=self.grid.line_vertices, indices=self.grid.line_indices, mode="lines", source="projectionmapping/data/white.png") PopMatrix() self.rebuild_informations()
def __init__(self, edges=3, color=None, **kwargs): super(RegularShape, self).__init__(**kwargs) if edges < 3: raise Exception('Not enough edges! (3+ only)') color = color or [random() for i in range(3)] rad_edge = (pi * 2) / float(edges) r_x = self.width / 2.0 r_y = self.height / 2.0 poly = [] vertices = [] for i in range(edges): # get points within a circle with radius of [r_x, r_y] x = cos(rad_edge * i) * r_x + self.center_x y = sin(rad_edge * i) * r_y + self.center_y poly.extend([x, y]) # add UV layout zeros for Mesh, see Mesh docs vertices.extend([x, y, 0, 0]) # draw Mesh shape from generated poly points with self.canvas: Color(rgba=(color[0], color[1], color[2], 0.6)) self.shape = Mesh(pos=self.pos, vertices=vertices, indices=list(range(edges)), mode='triangle_fan') self.poly = poly
def __init__(self, **kw): super(Background, self).__init__(**kw) # self.frames = -1 with self.canvas: self.clr = Color(0, .2, .2, mode='hsv') self.mesh = Mesh(mode='triangles', source='img/background.png') self.build_mesh()
def __init__(self, **kwargs): self._color = Color(1, 1, 1, group='LinePlot%d' % id(self)) self._mesh = Mesh(mode='line_strip', group='LinePlot%d' % id(self)) super(MeshLinePlot, self).__init__(**kwargs) self._trigger = Clock.create_trigger(self._redraw) self.bind(_params=self._trigger, points=self._trigger)
def generateMesh(self): hgt = self.generateHeightData(200, 200, 0.1) norm = self.calcNormals(hgt) idcs = self.generateTriangleCounterClockWiseIndices(hgt) print(hgt.shape) vtx = [] idx = [] i = 0 for x in range(hgt.shape[0]): for y in range(hgt.shape[1]): vtx.extend([ float(x) / 10.0 - 5, hgt[x, y], float(y) / 10.0 - 5, norm[x, y, 0] / 10.0, norm[x, y, 1], norm[x, y, 2] / 10.0, 0.0, 0.0, ]) idx.append(i) i += 1 m = Mesh(vertices=vtx, indices=idcs, mode='triangles', fmt=[('v_pos', 3, 'float'), ('v_normal', 3, 'float'), ('v_tc0', 2, 'float') ]) #[(b'v_pos', 2, b'float'), (b'tc', 2, b'float')]) return m
def get_mesh(self): v = [] # first calculate the distance between endpoints of the inner # arc, so we know how many steps to use when calculating # vertices end_point_inner = polar_to_rect(self.origin, self.r_min, self.theta_max) d_inner = d_outer = 3. theta_step_inner = (self.theta_max - self.theta_min) / d_inner end_point_outer = polar_to_rect(self.origin, self.r_max, self.theta_max) if self.r_min == 0: theta_step_outer = (self.theta_max - self.theta_min) / d_outer for x in range(int(d_outer)): v += (polar_to_rect(self.origin, 0, 0) * 2) v += (polar_to_rect(self.origin, self.r_max, self.theta_min + x * theta_step_outer) * 2) else: for x in range(int(d_inner + 2)): v += (polar_to_rect(self.origin, self.r_min - 1, self.theta_min + x * theta_step_inner) * 2) v += (polar_to_rect(self.origin, self.r_max + 1, self.theta_min + x * theta_step_inner) * 2) v += (end_point_inner * 2) v += (end_point_outer * 2) return Mesh(vertices=v, indices=range(int(len(v) / 4)), mode='triangle_strip')
def make_pretty_dots(self): points_per_side = 50 points = [] for idx in range(points_per_side): v = -1.0 + ((2.0 / points_per_side) * float(idx)) tex = idx / float(points_per_side) print("TEX: {}".format(str(tex))) points.append([[v, -1.0, -1.0, v, -1.0, -1.0, tex, 0.0], [v, -1.0, 1.0, v, -1.0, 1.0, tex, 0.0], [v, 1.0, -1.0, v, 1.0, -1.0, tex, 1.0], [v, 1.0, 1.0, v, 1.0, 1.0, tex, 1.0], [-1.0, v, -1.0, -1.0, v, -1.0, 0.0, tex], [-1.0, v, 1.0, -1.0, v, 1.0, 0.0, tex], [1.0, v, -1.0, 1.0, v, -1.0, 1.0, tex], [1.0, v, 1.0, 1.0, v, 1.0, 1.0, tex], [-1.0, -1.0, v, -1.0, -1.0, v, tex, tex], [-1.0, 1.0, v, -1.0, 1.0, v, tex, tex], [1.0, -1.0, v, 1.0, -1.0, v, tex, tex], [1.0, 1.0, v, 1.0, 1.0, v, tex, tex]], ) points = np.array(points).flatten() Color(1, 1, 1, 1) Mesh( vertices=points, indices=[i for i in range(len(points) / 8)], fmt=self.mesh_data.vertex_format, mode='points', )
def _geojson_part_geometry(self, geometry, properties): from kivy.graphics import Mesh, Line, Color from kivy.graphics.tesselator import Tesselator, WINDING_ODD, TYPE_POLYGONS from kivy.utils import get_color_from_hex from kivy.metrics import dp tp = geometry["type"] graphics = [] if tp == "Polygon": tess = Tesselator() for c in geometry["coordinates"]: xy = list(self._lonlat_to_xy(c)) xy = flatten(xy) tess.add_contour(xy) tess.tesselate(WINDING_ODD, TYPE_POLYGONS) color = self._get_color_from(properties.get("color", "FF000088")) graphics.append(Color(*color)) for vertices, indices in tess.meshes: graphics.append( Mesh(vertices=vertices, indices=indices, mode="triangle_fan")) elif tp == "LineString": stroke = get_color_from_hex(properties.get("stroke", "#ffffff")) stroke_width = dp(properties.get("stroke-width")) xy = list(self._lonlat_to_xy(geometry["coordinates"])) xy = flatten(xy) graphics.append(Color(*stroke)) graphics.append(Line(points=xy, width=stroke_width)) return graphics
def get_mesh(self): v = [] # first calculate the distance between endpoints of the outer # arc, so we know how many steps to use when calculating # vertices theta_step_outer = 0.1 theta = self.theta_max - self.theta_min d_outer = int(theta / theta_step_outer) theta_step_outer = theta / d_outer if self.r_min == 0: for x in range(0, d_outer, 2): v += (polar_to_rect(self.origin, self.r_max, self.theta_min + x * theta_step_outer) * 2) v += polar_to_rect(self.origin, 0, 0) * 2 v += ( polar_to_rect(self.origin, self.r_max, self.theta_min + (x + 1) * theta_step_outer) * 2) if not d_outer & 1: # add a last point if d_outer is even v += ( polar_to_rect(self.origin, self.r_max, self.theta_min + d_outer * theta_step_outer) * 2) else: for x in range(d_outer + 1): v += (polar_to_rect(self.origin, self.r_min, self.theta_min + x * theta_step_outer) * 2) v += (polar_to_rect(self.origin, self.r_max, self.theta_min + x * theta_step_outer) * 2) return Mesh(vertices=v, indices=range(int(len(v) / 4)), mode='triangle_strip')
def make_editable(self, editable = True, player_won_color = None, size_hint = None): self.editable = editable scores_holder = self.ids.scores_holder scores_holder.clear_widgets() if player_won_color != None: with self.canvas: # green terrain Color(player_won_color.r, player_won_color.g, player_won_color.b) self.mesh = Mesh(vertices=[0,0,0,0 ,0,size_hint.y,0,0 ,size_hint.x,size_hint.y,0,0 , size_hint.x,0,0,0], indices=[0,1,2,3], mode='triangle_fan') scores = [] Path("./scores/").mkdir(parents=True, exist_ok=True) if not os.path.isfile('./scores/scores.txt'): with open('./scores/scores.txt', 'a'): pass if os.path.isfile('./scores/scores.txt') and os.stat('./scores/scores.txt').st_size > 0: with open('./scores/scores.txt', 'r') as f: content = f.readlines() scores = [line.strip('\n') for line in content] scores = scores + ["-Not filled yet-"] * (5-len(scores)) if(editable): scores_holder.add_widget(TextInput(hint_text='Write your name..', id='score_input')) scores = scores[:-1] for score in scores: scores_holder.add_widget(Label(text=score, font_size = 15))
def __init__(self): super(Sprite, self).__init__() with self: self.color = Color() self.mesh = Mesh(vertices=[0.0] * 16, indices=range(4), mode=MODE_TRIANGLE_FAN)
def get_graphics(self, gc, polygons, points_line, rgbFace, closed=False): '''Return an instruction group which contains the necessary graphics instructions to draw the respective graphics. ''' instruction_group = InstructionGroup() if isinstance(gc.line['dash_list'], tuple): gc.line['dash_list'] = list(gc.line['dash_list']) if rgbFace is not None: if len(polygons.meshes) != 0: instruction_group.add(Color(*rgbFace)) for vertices, indices in polygons.meshes: instruction_group.add( Mesh(vertices=vertices, indices=indices, mode=str("triangle_fan"))) instruction_group.add(Color(*gc.get_rgb())) if _mpl_1_5 and closed: points_poly_line = points_line[:-2] else: points_poly_line = points_line if gc.line['width'] > 0: instruction_group.add( Line(points=points_poly_line, width=int(gc.line['width'] / 2), dash_length=gc.line['dash_length'], dash_offset=gc.line['dash_offset'], dash_joint=gc.line['joint_style'], dash_list=gc.line['dash_list'])) return instruction_group
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