def make_grid(num_ticks=10, step=1.0): """Make a grid geometry. Keyword Arguments: step {float} -- step in meters (default: {1.0}) num_ticks {int} -- ticks number per axis (default: {5}) Returns: Geom -- p3d geometry """ ticks = np.arange(-num_ticks // 2, num_ticks // 2 + 1) * step vformat = GeomVertexFormat.get_v3() vdata = GeomVertexData('vdata', vformat, Geom.UHStatic) vdata.uncleanSetNumRows(len(ticks) * 4) vertex = GeomVertexWriter(vdata, 'vertex') for t in ticks: vertex.addData3(t, ticks[0], 0) vertex.addData3(t, ticks[-1], 0) vertex.addData3(ticks[0], t, 0) vertex.addData3(ticks[-1], t, 0) prim = GeomLines(Geom.UHStatic) prim.addNextVertices(len(ticks) * 4) geom = Geom(vdata) geom.addPrimitive(prim) return geom
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') radius = 1.0 top = LPoint3d(0, 0, radius * 1.25) north_pole = LPoint3d(0, 0, radius) south_pole = LPoint3d(0, 0, -radius) bottom = LPoint3d(0, 0, -radius * 1.25) self.vertexWriter.addData3f(*top) self.vertexWriter.addData3f(*north_pole) self.vertexWriter.addData3f(*south_pole) self.vertexWriter.addData3f(*bottom) self.lines = GeomLines(Geom.UHStatic) self.lines.addVertex(0) self.lines.addVertex(1) self.lines.addVertex(2) self.lines.addVertex(3) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-axis') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.axis_thickness) self.instance.setColor(self.parent.get_orbit_color()) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.instance.reparentTo(self.context.annotation)
def line(self): # Create and populate the Moon orbit model using Vertices and Lines self.planetOrbitVertexData = GeomVertexData(self.description+'OrbitVertexData', GeomVertexFormat.getV3(), Geom.UHDynamic) self.planetOrbitVertexWriter = GeomVertexWriter(self.planetOrbitVertexData, 'vertex') self.planetOrbitNumberPoints = 360 for i in range(self.planetOrbitNumberPoints): angleDegrees = i * 360 / self.planetOrbitNumberPoints angleRadians = angleDegrees * (pi / 180.0) x = -self.distance * sin(angleRadians) y = self.distance * cos(angleRadians) self.planetOrbitVertexWriter.addData3f(x, y, 0.0) self.planetOrbitLines = GeomLines(Geom.UHStatic) for i in range(self.planetOrbitNumberPoints-1): self.planetOrbitLines.addVertex(i) self.planetOrbitLines.addVertex(i+1) self.planetOrbitLines.closePrimitive() self.planetOrbitLines.addVertex(self.planetOrbitNumberPoints-1) self.planetOrbitLines.addVertex(0) self.planetOrbitLines.closePrimitive() self.planetOrbitGeom = Geom(self.planetOrbitVertexData) self.planetOrbitGeom.addPrimitive(self.planetOrbitLines) self.planetOrbitNode = GeomNode(self.description+'OrbitNode') self.planetOrbitNode.addGeom(self.planetOrbitGeom) self.planetOrbitNnodePath = render.attachNewNode(self.planetOrbitNode) self.planetOrbitNnodePath.reparentTo(self.worldOrigin) return self.planetOrbitVertexWriter
def __init__(self, length=1., tickness=3.): GeomNode.__init__(self, "Basis") self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertex = GeomVertexWriter(self.vertexData, 'vertex') self.color = GeomVertexWriter(self.vertexData, 'color') self.mesh = Geom(self.vertexData) self.lines = GeomLines(Geom.UHStatic) self.vertex.addData3f(0.0, 0.0, 0.0) self.color.addData4f(1.0, 0.0, 0.0, 1.0) self.vertex.addData3f(length, 0.0, 0.0) self.color.addData4f(1.0, 0.0, 0.0, 1.0) self.lines.add_vertices(0, 1) self.vertex.addData3f(0.0, 0.0, 0.0) self.color.addData4f(0.0, 1.0, 0.0, 1.0) self.vertex.addData3f(0.0, length, 0.0) self.color.addData4f(0.0, 1.0, 0.0, 1.0) self.lines.add_vertices(2, 3) self.vertex.addData3f(0.0, 0.0, 0.0) self.color.addData4f(0.0, 0.0, 1.0, 1.0) self.vertex.addData3f(0.0, 0.0, length) self.color.addData4f(0.0, 0.0, 1.0, 1.0) self.lines.add_vertices(4, 5) self.lines.closePrimitive() self.mesh.addPrimitive(self.lines) self.addGeom(self.mesh) NodePath(self).setRenderModeThickness(tickness) NodePath(self).setLightOff() NodePath(self).setColorOff() NodePath(self).set_bin('fixed', 9)
def _CreateOneSynapse(self, presynCell, synapsesType): form = GeomVertexFormat.getV3() vdata = GeomVertexData("SynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(presynCell.getNode().getPos(self.__node)) vertex.addData3f(0, 0, 0) # vertex.addData3f(self.__node.getPos()) # printLog("inputObj:"+str(i)+"bits:"+str(y)) # printLog(inputObj[i].inputBits[y].getNode().getPos(self.__node)) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("Synapse_" + str(synapsesType)) node.addGeom(geom) nodePath = self.__cellsNodePath.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if presynCell.active: nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') for point in self.points: position = point.project(0, self.context.observer.camera_global_pos, self.context.observer.infinity) self.vertexWriter.addData3f(*position) self.colorwriter.addData4f(*self.color) self.lines = GeomLines(Geom.UHStatic) index = 0 for i in range(len(self.points) - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("boundary") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.boundary_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setBin('background', settings.boundaries_depth) self.instance.set_depth_write(False)
def make_axes(): """Make an axes geometry. Returns: Geom -- p3d geometry """ vformat = GeomVertexFormat.get_v3c4() vdata = GeomVertexData('vdata', vformat, Geom.UHStatic) vdata.uncleanSetNumRows(6) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') for x, y, z in np.eye(3): vertex.addData3(0, 0, 0) color.addData4(x, y, z, 1) vertex.addData3(x, y, z) color.addData4(x, y, z, 1) prim = GeomLines(Geom.UHStatic) prim.addNextVertices(6) geom = Geom(vdata) geom.addPrimitive(prim) return geom
def _CreateOneSynapse(self, presynCell, synapsesType): presynCell.setPresynapticFocus() # highlight presynaptic cells form = GeomVertexFormat.getV3() vdata = GeomVertexData("SynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(presynCell.getNode().getPos(self._node)) vertex.addData3f(0, 0, 0) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("Synapse_" + str(synapsesType)) node.addGeom(geom) nodePath = self._node.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if presynCell.active: nodePath.setColor(COL_DISTAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_DISTAL_SYNAPSES_INACTIVE)
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') for r in range(1, self.nbOfRings + 1): for i in range(self.nbOfPoints): angle = 2 * pi / self.nbOfPoints * i x = cos(angle) * sin( pi * r / (self.nbOfRings + 1) ) y = sin(angle) * sin( pi * r / (self.nbOfRings + 1) ) z = sin( -pi / 2 + pi * r / (self.nbOfRings + 1) ) self.vertexWriter.addData3f((self.context.observer.infinity * x, self.context.observer.infinity * y, self.context.observer.infinity * z)) if r == self.nbOfRings / 2 + 1: self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1) else: self.colorwriter.addData4f(*self.color) for s in range(self.nbOfSectors): for i in range(self.points_to_remove, self.nbOfPoints // 2 - self.points_to_remove + 1): angle = 2 * pi / self.nbOfPoints * i x = cos(2*pi * s / self.nbOfSectors) * sin(angle) y = sin(2*pi * s / self.nbOfSectors) * sin(angle) z = cos(angle) self.vertexWriter.addData3f((self.context.observer.infinity * x , self.context.observer.infinity * y, self.context.observer.infinity * z)) if s == 0: self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1) else: self.colorwriter.addData4f(*self.color) self.lines = GeomLines(Geom.UHStatic) index = 0 for r in range(self.nbOfRings): for i in range(self.nbOfPoints-1): self.lines.addVertex(index) self.lines.addVertex(index+1) self.lines.closePrimitive() index += 1 self.lines.addVertex(index) self.lines.addVertex(index - self.nbOfPoints + 1) self.lines.closePrimitive() index += 1 for r in range(self.nbOfSectors): for i in range(self.nbOfPoints // 2 - self.points_to_remove * 2): self.lines.addVertex(index) self.lines.addVertex(index+1) self.lines.closePrimitive() index += 1 index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("grid") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.grid_thickness) #myMaterial = Material() #myMaterial.setEmission((1.0, 1.0, 1.0, 1)) #self.instance.setMaterial(myMaterial) self.instance.reparentTo(self.context.annotation) self.instance.setQuat(LQuaternion(*self.orientation))
def update_geometry(self): # The geosphere itself vertex = GeomVertexWriter(self.sphere_vdata, 'vertex') normal = GeomVertexWriter(self.sphere_vdata, 'normal') # u_map and v_map are in [-pi, pi] u_map_list = [(float(u) / float(self.res[0]) - 0.5) * 2.0 * pi for u in range(0, self.res[0] + 1)] v_map_list = [(float(v) / float(self.res[1]) - 0.5) * 2.0 * pi for v in range(0, self.res[1] + 1)] if self.unwrap_state == 0.0: # Flat map for v_map in v_map_list: for u_map in u_map_list: vertex.addData3f(u_map, 0.0, v_map / 2.0) normal.addData3f(0.0, -1.0, 0.0) else: # Non-flat map sphere_radius = 1.0 / self.unwrap_state sphere_offset = sphere_radius - self.unwrap_state for v_map in v_map_list: for u_map in u_map_list: u_sphere = u_map / sphere_radius v_sphere = v_map / sphere_radius # And this, kids, is why you should pay attention in trigonometry. v_x, v_y, v_z = sin(u_sphere) * cos(v_sphere/2.0) * sphere_radius, \ -cos(u_sphere) * cos(v_sphere/2.0) * sphere_radius + sphere_offset, \ sin(v_sphere / 2.0) * sphere_radius n_x_un, n_y_un, n_z_un = v_x, sphere_offset - v_y, v_z # FIXME: This is a lie. length = sqrt(n_x_un**2 + n_y_un**2 + n_z_un**2) n_x, n_y, n_z = n_x_un / length, n_y_un / length, n_z_un / length vertex.addData3f(v_x, v_y, v_z) normal.addData3f(n_x, n_y, n_z) # The connections between bases segs_per_connection = 30 vertex = GeomVertexWriter(self.connections_vdata, 'vertex') color = GeomVertexWriter(self.connections_vdata, 'color') for c_1_uv, c_2_uv in self.connections: # s will be [0.0, 1.0] for s in [float(c)/float(segs_per_connection+1) for c in range(0, segs_per_connection+2)]: u = (c_1_uv[0] * s) + (c_2_uv[0] * (1.0 - s)) v = (c_1_uv[1] * s) + (c_2_uv[1] * (1.0 - s)) (v_x, v_y, v_z), (n_x, n_y, n_z) = self.uv_to_xyz(u, v) min_height = 0.0001 * (1.0 - self.unwrap_state) max_height = (0.2 - min_height) * self.unwrap_state seg_height = (1.0 - (abs(s-0.5) * 2.0)**2.0) * max_height + min_height vertex.addData3f(v_x + n_x*seg_height, v_y + n_y*seg_height, v_z + n_z*seg_height) color.addData4f(1, 1, 1, 1) for c in range(0, len(self.connections)): for s in range(0, segs_per_connection+1): seg = GeomLines(Geom.UHDynamic) seg.addVertices(c*(segs_per_connection+2) + s, c*(segs_per_connection+2) + s + 1) seg.closePrimitive() self.connections_geom.addPrimitive(seg)
def makeGeomNode(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 gapLen = 0.2 coneLen = 0.18 coneRad = 0.06 circRes = 10 v.addData3f(0, 0, -length/2.0) # back cone butt v.addData3f(0, 0, -length/2.0 + coneLen) # back cone point v.addData3f(0, 0, -gapLen/2.0) v.addData3f(0, 0, gapLen/2.0) v.addData3f(0, 0, length/2.0 - coneLen) # front cone butt v.addData3f(0, 0, length/2.0) # font cone point # Add vertices for the cone's circles. for z in [-length/2.0, length/2.0 - coneLen]: for i in xrange(circRes): theta = i*(2*pi/circRes) v.addData3f(coneRad*sin(theta), coneRad*cos(theta), z) lines = Geom(vdata) # Make prims for the two lines. for vertices in [(0, 2), (3, 5)]: line = GeomLines(Geom.UHStatic) line.addVertices(*vertices) line.closePrimitive() lines.addPrimitive(line) cones = Geom(vdata) # Make prims for the cones. for back, circ in [(0, 6), (4, 6 + circRes)]: point = back + 1 cone = GeomTriangles(Geom.UHStatic) for i in xrange(circRes): if i + 1 == circRes: cone.addVertices(back, circ, circ + i) cone.addVertices(point, circ + i, circ) else: cone.addVertices(back, circ + i + 1, circ + i) cone.addVertices(point, circ + i, circ + i + 1) cone.closePrimitive() cones.addPrimitive(cone) node = GeomNode('geomnode') node.addGeom(lines) node.addGeom(cones) return node
def create_instance(self): if not self.orbit: return self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() for i in range(self.nbOfPoints): time = self.orbit.period / self.nbOfPoints * i pos = self.orbit.get_position_at(time) rot = self.orbit.get_rotation_at(time) pos = self.orbit.frame.get_local_position(rot.xform(pos)) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints - 1): self.lines.addVertex(i) self.lines.addVertex(i + 1) self.lines.closePrimitive() self.lines.addVertex(self.nbOfPoints - 1) self.lines.addVertex(0) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation_shader) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(self.color * self.fade) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.appearance = ModelAppearance(attribute_color=True) if settings.use_inv_scaling: vertex_control = LargeObjectVertexControl() else: vertex_control = None self.instance_ready = True self.shader = BasicShader(lighting_model=FlatLightingModel(), vertex_control=vertex_control) self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance)
def CreateTestScene(self): form = GeomVertexFormat.getV3() vdata = GeomVertexData("myLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(0, 0, 0) vertex.addData3f(60, 0, 50) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("gnode") node.addGeom(geom) nodePath = self.render.attachNewNode(node)
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') #TODO: Ugly hack to calculate star position from the sun... old_cam_pos = self.context.observer.camera_global_pos self.context.observer.camera_global_pos = LPoint3d() center = LPoint3d() for segment in self.segments: if len(segment) < 2: continue for star in segment: #TODO: Temporary workaround to have star pos star.update(0) star.update_obs(self.context.observer) position, distance, scale_factor = self.get_real_pos_rel( star.rel_position, star.distance_to_obs, star.vector_to_obs) self.vertexWriter.addData3f(*position) self.colorwriter.addData4f(*self.color) self.context.observer.camera_global_pos = old_cam_pos self.lines = GeomLines(Geom.UHStatic) index = 0 for segment in self.segments: if len(segment) < 2: continue for i in range(len(segment) - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("asterism") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.asterism_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setBin('background', settings.asterisms_depth) self.instance.set_depth_write(False)
def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() if self.orbit.is_periodic(): epoch = self.context.time.time_full - self.orbit.period / 2 step = self.orbit.period / (self.nbOfPoints - 1) else: #TODO: Properly calculate orbit start and end time epoch = self.orbit.get_time_of_perihelion() - self.orbit.period * 5.0 step = self.orbit.period * 10.0 / (self.nbOfPoints - 1) for i in range(self.nbOfPoints): time = epoch + step * i pos = self.orbit.get_position_at(time) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints-1): self.lines.addVertex(i) self.lines.addVertex(i+1) if self.orbit.is_periodic() and self.orbit.is_closed(): self.lines.addVertex(self.nbOfPoints-1) self.lines.addVertex(0) self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(srgb_to_linear(self.color * self.fade)) self.instance_ready = True if self.shader is None: self.create_shader() self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance)
class RotationAxis(VisibleObject): default_shown = False ignore_light = True def __init__(self, body): VisibleObject.__init__(self, body.get_ascii_name() + '-axis') self.body = body def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') radius = 1.0 top = LPoint3d(0, 0, radius * 1.25) north_pole = LPoint3d(0, 0, radius) south_pole = LPoint3d(0, 0, -radius) bottom = LPoint3d(0, 0, -radius * 1.25) self.vertexWriter.addData3f(*top) self.vertexWriter.addData3f(*north_pole) self.vertexWriter.addData3f(*south_pole) self.vertexWriter.addData3f(*bottom) self.lines = GeomLines(Geom.UHStatic) self.lines.addVertex(0) self.lines.addVertex(1) self.lines.addVertex(2) self.lines.addVertex(3) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-axis') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.axis_thickness) self.instance.setColor(self.parent.get_orbit_color()) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.instance.reparentTo(self.context.annotation) def check_settings(self): self.set_shown(settings.show_rotation_axis) def check_visibility(self, pixel_size): if self.parent.shown: distance_to_obs = self.parent.distance_to_obs if distance_to_obs > 0.0: size = self.parent.get_apparent_radius() / (distance_to_obs * pixel_size) else: size = 0.0 self.visible = size > settings.axis_fade else: self.visible = False def update_instance(self, camera_pos, orientation): if self.instance: self.place_instance(self.instance, self.parent) def get_scale(self): return self.body.get_scale()
def __init__(self, max_r): self.max_r = max_r format = GeomVertexFormat.getV3c4() vdata = GeomVertexData('point', format, Geom.UHDynamic) self._pos_writer = GeomVertexWriter(vdata, 'vertex') self._color_writer = GeomVertexWriter(vdata, 'color') line_num = 60 vdata.setNumRows(line_num) angles = np.linspace(0, np.pi * 2 - np.pi * 2 / line_num, line_num) other_rgba = (0., 0., 0.3, 0.1) other2_rgba = (0.1, 0.1, 0.4, 0.4) axis_rgba = (0.2, 0.2, 0.5, 1.0) max_r = 250 for indx, angle in enumerate(angles): if indx % 5 == 0: rgba = axis_rgba else: rgba = other_rgba self._pos_writer.addData3d(0, 0, 0.) self._color_writer.addData4f(rgba[0], rgba[1], rgba[2], rgba[3]) self._pos_writer.addData3d(max_r * np.sin(angle), max_r * np.cos(angle), 0.) self._color_writer.addData4f(rgba[0], rgba[1], rgba[2], rgba[3]) grnd_prmtv = GeomLines(Geom.UHStatic) grnd_prmtv.addConsecutiveVertices(0, 2 * line_num) grnd_prmtv.closePrimitive() ground_geom = Geom(vdata) ground_geom.addPrimitive(grnd_prmtv) snode = GeomNode('ground_lines') snode.addGeom(ground_geom) self.points_node = base.render.attachNewNode(snode) self.points_node.setTwoSided(True) for rad in range(int(max_r)): color = axis_rgba pp = makeArc(angleDegrees=360, numSteps=160, scale=rad, color=color) tn = TextNode('dd') tn.setText(str(rad)) tn.setTextScale(0.2) tn.setTextColor(color) text_geom = GeomNode('text') text_geom.addChild(tn) tp = NodePath(text_geom) tp.setPos((0, rad - 0.2, 0)) tp.setHpr((0, -90, 0)) tp.reparentTo(self.points_node) pp.reparentTo(self.points_node)
def getGeomFromPrim(prim, matstate): if type(prim) is collada.triangleset.TriangleSet: (vdata, gprim) = getPrimAndDataFromTri(prim, matstate) elif type(prim) is collada.polylist.Polylist or type(prim) is collada.polygons.Polygons: triset = prim.triangleset() (vdata, gprim) = getPrimAndDataFromTri(triset, matstate) elif type(prim) is collada.lineset.LineSet: vdata, indexdata = getVertexData(prim.vertex, prim.vertex_index) gprim = GeomLines(Geom.UHStatic) gprim.setIndexType(Geom.NTUint32) gprim.setVertices(indexdata) gprim.closePrimitive() else: raise Exception("Error: Unsupported primitive type. Exiting.") pgeom = Geom(vdata) pgeom.addPrimitive(gprim) return pgeom
def makeGeomNode(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 gapLen = 0.2 coneLen = 0.18 coneRad = 0.06 circRes = 10 v.addData3f(0, 0, -length / 2.0) # back cone butt v.addData3f(0, 0, -length / 2.0 + coneLen) # back cone point v.addData3f(0, 0, -gapLen / 2.0) v.addData3f(0, 0, gapLen / 2.0) v.addData3f(0, 0, length / 2.0 - coneLen) # front cone butt v.addData3f(0, 0, length / 2.0) # font cone point # Add vertices for the cone's circles. for z in [-length / 2.0, length / 2.0 - coneLen]: for i in xrange(circRes): theta = i * (2 * pi / circRes) v.addData3f(coneRad * sin(theta), coneRad * cos(theta), z) lines = Geom(vdata) # Make prims for the two lines. for vertices in [(0, 2), (3, 5)]: line = GeomLines(Geom.UHStatic) line.addVertices(*vertices) line.closePrimitive() lines.addPrimitive(line) cones = Geom(vdata) # Make prims for the cones. for back, circ in [(0, 6), (4, 6 + circRes)]: point = back + 1 cone = GeomTriangles(Geom.UHStatic) for i in xrange(circRes): if i + 1 == circRes: cone.addVertices(back, circ, circ + i) cone.addVertices(point, circ + i, circ) else: cone.addVertices(back, circ + i + 1, circ + i) cone.addVertices(point, circ + i, circ + i + 1) cone.closePrimitive() cones.addPrimitive(cone) node = GeomNode('geomnode') node.addGeom(lines) node.addGeom(cones) return node
class Boundary(VisibleObject): ignore_light = True default_shown = True def __init__(self, name, points=[], color=None): VisibleObject.__init__(self, name) self.visible = True if color is None: color = bodyClasses.get_orbit_color('boundary') self.color = color self.points = points def check_settings(self): self.set_shown(settings.show_boundaries) def set_points_list(self, points): self.points = points def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') for point in self.points: position = point.project(0, self.context.observer.camera_global_pos, self.context.observer.infinity) self.vertexWriter.addData3f(*position) self.colorwriter.addData4f(*self.color) self.lines = GeomLines(Geom.UHStatic) index = 0 for i in range(len(self.points) - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("boundary") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.boundary_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setBin('background', settings.boundaries_depth) self.instance.set_depth_write(False)
def draw_shape(angles, width, radius): res = 10 if radius == 0: point = GeomNode('gnode') vdata = GeomVertexData('occ', GeomVertexFormat.getV3(), Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, 'vertex') vertex.addData3f(0, 0, 0) geom = Geom(vdata) g = GeomPoints(Geom.UHStatic) g.addVertex(0) geom.addPrimitive(g) point.addGeom(geom) return point, point #first, sort angles in ascending order #if negative is given, translate to range of 2pi for i in range(len(angles)): if angles[i] < 0: angles[i] = 360 + angles[i] angles.sort() angles = [math.radians(a) for a in angles] angles.append(angles[0]) #read first angle to account for wrapping around #function = 'w/sin(theta)' vdata = GeomVertexData('occ', GeomVertexFormat.getV3(), Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, 'vertex') numverts = [3] * (len(angles) - 1 ) #center, and two points on function lines for i in range(len(angles) - 1): #find center point #L = [None,None] #sign = [-1,1] #for p in range(2): # theta1 = angles[i+p] - sign[p]*math.pi/2 # theta2 = angles[i+p] + sign[p]*math.pi/4 # x1 = width*math.cos(theta1) # y1 = width*math.sin(theta1) # r = math.sqrt(2*width**2) # x2 = r*math.cos(theta2) # y2 = r*math.sin(theta2) # L[p] = line([x1,y1], [x2,y2]) #R = intersection(L[0],L[1]) #if R is False: # R = [x1,y1] #if parallel, shift both lines down by y_width #vertex.addData3f(R[0],R[1],1) difang = (angles[i + 1] - angles[i]) / 2 l = width / math.sin(difang) avgang = (angles[i] + angles[i + 1]) / 2 x0 = l * math.cos(avgang) y0 = l * math.sin(avgang) vertex.addData3f(x0, y0, 1) newang1 = angles[i] + (math.pi / 2 - math.acos(width / radius)) x = radius * math.cos(newang1) y = radius * math.sin(newang1) vertex.addData3f(x, y, 1) newang2 = angles[i + 1] - (math.pi / 2 - math.acos(width / radius)) for angle in arc(newang1, newang2, res): vertex.addData3f(radius * math.cos(math.radians(angle)), radius * math.sin(math.radians(angle)), 1) numverts[i] = numverts[i] + 1 x = radius * math.cos(newang2) y = radius * math.sin(newang2) vertex.addData3f(x, y, 1) #copy all data to the bottom, moving it down to z = -1 vertread = GeomVertexReader(vdata, 'vertex') while not vertread.isAtEnd(): v = vertread.getData3f() vertex.addData3f(v[0], v[1], -1) #draw geom = Geom(vdata) #draw top for i in range(len(angles) - 1): for j in range(numverts[i] - 2): ind = sum(numverts[0:i]) + j g = GeomTriangles(Geom.UHStatic) g.add_vertices(ind - j, ind + 1, ind + 2) geom.addPrimitive(g) #draw bottom for i in range(len(angles) - 1): for j in range(numverts[i] - 2): ind = sum(numverts) + sum(numverts[0:i]) + j g = GeomTriangles(Geom.UHStatic) g.add_vertices(ind - j, ind + 2, ind + 1) geom.addPrimitive(g) #draw edges for i in range(len(angles) - 1): for j in range(numverts[i] - 1): ind = sum(numverts[0:i]) + j g = GeomTriangles(Geom.UHStatic) g.add_vertices(ind, ind + sum(numverts), ind + 1) g.add_vertices(ind + sum(numverts), ind + 1 + sum(numverts), ind + 1) geom.addPrimitive(g) g = GeomTriangles(Geom.UHStatic) ind = sum(numverts[0:i]) indx = sum(numverts[0:i + 1]) g.add_vertices(indx - 1, indx + sum(numverts) - 1, ind) g.add_vertices(indx + sum(numverts) - 1, sum(numverts) + ind, ind) geom.addPrimitive(g) #outline object lines = Geom(vdata) l = GeomLines(Geom.UHStatic) for i in range(len(angles) - 1): for j in range(numverts[i] - 1): ind = sum(numverts[0:i]) + j l.add_vertices(ind, ind + 1) l.add_vertices(sum(numverts) + ind, sum(numverts) + ind + 1) ind = sum(numverts[0:i]) indx = sum(numverts[0:i + 1]) l.add_vertices(ind, indx - 1) l.add_vertices(sum(numverts) + ind, sum(numverts) + indx - 1) l.add_vertices(ind + 1, sum(numverts) + ind + 1) l.add_vertices(indx - 1, sum(numverts) + indx - 1) lines.addPrimitive(l) node = GeomNode('gnode') node.addGeom(geom) nodeL = GeomNode('gnode') nodeL.addGeom(lines) return node, nodeL
def generate( self ): # call this after setting some of the variables to update it if not self.vertices: return if hasattr(self, 'geomNode'): self.geomNode.removeAllGeoms() static_mode = Geom.UHStatic if self.static else Geom.UHDynamic formats = { (0, 0, 0): GeomVertexFormat.getV3(), (1, 0, 0): GeomVertexFormat.getV3c4(), (0, 1, 0): GeomVertexFormat.getV3t2(), (0, 0, 1): GeomVertexFormat.getV3n3(), (1, 0, 1): GeomVertexFormat.getV3n3c4(), (1, 1, 0): GeomVertexFormat.getV3c4t2(), (0, 1, 1): GeomVertexFormat.getV3n3t2(), (1, 1, 1): GeomVertexFormat.getV3n3c4t2(), } vertex_format = formats[(bool(self.colors), bool(self.uvs), bool(self.normals))] vdata = GeomVertexData('name', vertex_format, static_mode) vdata.setNumRows(len(self.vertices)) # for speed vertexwriter = GeomVertexWriter(vdata, 'vertex') for v in self.vertices: vertexwriter.addData3f((v[0], v[2], v[1])) # swap y and z if self.colors: colorwriter = GeomVertexWriter(vdata, 'color') for c in self.colors: colorwriter.addData4f(c) if self.uvs: uvwriter = GeomVertexWriter(vdata, 'texcoord') for uv in self.uvs: uvwriter.addData2f(uv[0], uv[1]) if self.normals != None: normalwriter = GeomVertexWriter(vdata, 'normal') for norm in self.normals: normalwriter.addData3f((norm[0], norm[2], norm[1])) modes = { 'triangle': GeomTriangles(static_mode), 'tristrip': GeomTristrips(static_mode), 'ngon': GeomTrifans(static_mode), 'line': GeomLines(static_mode), 'lines': GeomLinestrips(static_mode), 'point': GeomPoints(static_mode), } if self.mode == 'line' and len(self.vertices) % 2 > 0: if len(self.vertices) == 1: self.mode = point print( 'warning: number of vertices must be even for line mode, ignoring last vert' ) self.vertices = self.vertices[:len(self.vertices) - 1] prim = modes[self.mode] if self._triangles: if isinstance(self._triangles[0], int): for t in self._triangles: prim.addVertex(t) elif len( self._triangles[0] ) >= 3: # if tris are tuples like this: ((0,1,2), (1,2,3)) for t in self._triangles: if len(t) == 3: for e in t: prim.addVertex(e) elif len(t) == 4: # turn quad into tris prim.addVertex(t[0]) prim.addVertex(t[1]) prim.addVertex(t[2]) prim.addVertex(t[2]) prim.addVertex(t[3]) prim.addVertex(t[0]) else: prim.addConsecutiveVertices(0, len(self.vertices)) prim.close_primitive() geom = Geom(vdata) geom.addPrimitive(prim) self.geomNode = GeomNode('mesh') self.geomNode.addGeom(geom) self.attachNewNode(self.geomNode) # print('finished') self.recipe = f'''Mesh(
class Orbit(VisibleObject): ignore_light = True default_shown = False selected_color = LColor(1.0, 0.0, 0.0, 1.0) def __init__(self, body): VisibleObject.__init__(self, body.get_ascii_name() + '-orbit') self.body = body self.nbOfPoints = 360 self.orbit = self.find_orbit(self.body) self.color = None self.fade = 0.0 if not self.orbit: print("No orbit for", self.get_name()) self.visible = False self.check_settings() def check_settings(self): if self.body.body_class is None: print("No class for", self.body.get_name()) return self.set_shown(settings.show_orbits and bodyClasses.get_show_orbit(self.body.body_class)) def find_orbit(self, body): if body != None: if not isinstance(body.orbit, FixedOrbit): return body.orbit else: return None, None else: return None, None def set_selected(self, selected): if selected: self.color = self.selected_color else: self.color = self.parent.get_orbit_color() if self.instance: self.instance.setColor(self.color * self.fade) def create_instance(self): if not self.orbit: return self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() for i in range(self.nbOfPoints): time = self.orbit.period / self.nbOfPoints * i pos = self.orbit.get_position_at(time) rot = self.orbit.get_rotation_at(time) pos = self.orbit.frame.get_local_position(rot.xform(pos)) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints - 1): self.lines.addVertex(i) self.lines.addVertex(i + 1) self.lines.closePrimitive() self.lines.addVertex(self.nbOfPoints - 1) self.lines.addVertex(0) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation_shader) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(self.color * self.fade) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.appearance = ModelAppearance(attribute_color=True) if settings.use_inv_scaling: vertex_control = LargeObjectVertexControl() else: vertex_control = None self.instance_ready = True self.shader = BasicShader(lighting_model=FlatLightingModel(), vertex_control=vertex_control) self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance) def check_visibility(self, pixel_size): if self.parent.shown and self.orbit: distance_to_obs = self.parent.distance_to_obs if distance_to_obs > 0.0: size = self.orbit.get_apparent_radius() / (distance_to_obs * pixel_size) else: size = 0.0 self.visible = size > settings.orbit_fade self.fade = min( 1.0, max(0.0, (size - settings.orbit_fade) / settings.orbit_fade)) if self.color is not None and self.instance is not None: self.instance.setColor(self.color * self.fade) else: self.visible = False def update_instance(self, camera_pos, orientation): if self.instance: self.place_instance_params(self.instance, self.body.parent.scene_position, self.body.parent.scene_scale_factor, LQuaternion()) self.shader.update(self, self.appearance)
class Asterism(VisibleObject): def __init__(self, name): VisibleObject.__init__(self, name) self.visible = True self.color = bodyClasses.get_orbit_color('constellation') self.position = LPoint3d(0, 0, 0) self.segments = [] self.position = None def check_settings(self): self.set_shown(settings.show_asterisms) def set_segments_list(self, segments): self.segments = segments ra_sin = 0 ra_cos = 0 decl = 0 if len(self.segments) > 0 and len(self.segments[0]) > 0: for star in self.segments[0]: asc = star.orbit.get_right_asc() ra_sin += sin(asc) ra_cos += cos(asc) decl += star.orbit.get_declination() ra = atan2(ra_sin, ra_cos) decl /= len(self.segments[0]) self.position = InfinitePosition(right_asc=ra, right_asc_unit=units.Rad, declination=decl, declination_unit=units.Rad) def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') #TODO: Ugly hack to calculate star position from the sun... old_cam_pos = self.context.observer.camera_global_pos self.context.observer.camera_global_pos = LPoint3d() center = LPoint3d() for segment in self.segments: if len(segment) < 2: continue for star in segment: #TODO: Temporary workaround to have star pos star.update(0) star.update_obs(self.context.observer) position, distance, scale_factor = self.get_real_pos_rel( star.rel_position, star.distance_to_obs, star.vector_to_obs) self.vertexWriter.addData3f(*position) self.colorwriter.addData4f(*self.color) self.context.observer.camera_global_pos = old_cam_pos self.lines = GeomLines(Geom.UHStatic) index = 0 for segment in self.segments: if len(segment) < 2: continue for i in range(len(segment) - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("asterism") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.asterism_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setBin('background', settings.asterisms_depth) self.instance.set_depth_write(False)
class Grid(VisibleObject): ignore_light = True default_shown = False def __init__(self, name, orientation, color): VisibleObject.__init__(self, name) self.visible = True self.nbOfPoints = 360 self.nbOfRings = 17 self.nbOfSectors = 24 self.points_to_remove = (self.nbOfPoints // (self.nbOfRings + 1)) // 2 self.orientation = orientation self.color = color self.settings_attr = 'show_' + name.lower() + '_grid' def check_settings(self): show = getattr(settings, self.settings_attr) if show is not None: self.set_shown(show) def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') for r in range(1, self.nbOfRings + 1): for i in range(self.nbOfPoints): angle = 2 * pi / self.nbOfPoints * i x = cos(angle) * sin( pi * r / (self.nbOfRings + 1) ) y = sin(angle) * sin( pi * r / (self.nbOfRings + 1) ) z = sin( -pi / 2 + pi * r / (self.nbOfRings + 1) ) self.vertexWriter.addData3f((self.context.observer.infinity * x, self.context.observer.infinity * y, self.context.observer.infinity * z)) if r == self.nbOfRings / 2 + 1: self.colorwriter.addData4(srgb_to_linear((self.color.x * 1.5, 0, 0, 1))) else: self.colorwriter.addData4(srgb_to_linear(self.color)) for s in range(self.nbOfSectors): for i in range(self.points_to_remove, self.nbOfPoints // 2 - self.points_to_remove + 1): angle = 2 * pi / self.nbOfPoints * i x = cos(2*pi * s / self.nbOfSectors) * sin(angle) y = sin(2*pi * s / self.nbOfSectors) * sin(angle) z = cos(angle) self.vertexWriter.addData3f((self.context.observer.infinity * x , self.context.observer.infinity * y, self.context.observer.infinity * z)) if s == 0: self.colorwriter.addData4(srgb_to_linear((self.color.x * 1.5, 0, 0, 1))) else: self.colorwriter.addData4(srgb_to_linear(self.color)) self.lines = GeomLines(Geom.UHStatic) index = 0 for r in range(self.nbOfRings): for i in range(self.nbOfPoints-1): self.lines.addVertex(index) self.lines.addVertex(index+1) self.lines.closePrimitive() index += 1 self.lines.addVertex(index) self.lines.addVertex(index - self.nbOfPoints + 1) self.lines.closePrimitive() index += 1 for r in range(self.nbOfSectors): for i in range(self.nbOfPoints // 2 - self.points_to_remove * 2): self.lines.addVertex(index) self.lines.addVertex(index+1) self.lines.closePrimitive() index += 1 index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("grid") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.grid_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setQuat(LQuaternion(*self.orientation)) def set_orientation(self, orientation): self.orientation = orientation if self.instance: self.instance.setQuat(LQuaternion(*self.orientation))
def CreateDistalSynapses(self, HTMObject, layer, data, inputObjects): for child in self.__node.getChildren(): if child.getName() == "DistalSynapseLine": child.removeNode() printLog("Creating distal synapses", verbosityMedium) printLog("EXTERNAL DISTAL:" + str(inputObjects)) printLog("HTM inputs:" + str(HTMObject.inputs)) printLog("HTM layers:" + str(HTMObject.layers)) for segment in data: for presynCellID in segment: cellID = presynCellID % layer.nOfCellsPerColumn colID = (int)(presynCellID / layer.nOfCellsPerColumn) if colID < len(layer.minicolumns): presynCell = layer.minicolumns[colID].cells[ cellID] # it is within current layer else: # it is for external distal input cellID = presynCellID - len( layer.minicolumns) * layer.nOfCellsPerColumn for inputObj in inputObjects: if inputObj in HTMObject.inputs: if cellID < HTMObject.inputs[inputObj].count: presynCell = HTMObject.inputs[ inputObj].inputBits[cellID] break else: # not this one cellID -= HTMObject.inputs[inputObj].count elif inputObj in HTMObject.layers: if cellID < HTMObject.layers[ inputObj].nOfCellsPerColumn * len( HTMObject.layers[inputObj].minicolumns ): presynCell = HTMObject.layers[ inputObj].minicolumns[(int)( cellID / HTMObject.layers[inputObj]. nOfCellsPerColumn)].cells[ cellID % HTMObject. layers[inputObj].nOfCellsPerColumn] break else: # not this one cellID -= HTMObject.layers[ inputObj].nOfCellsPerColumn * len( HTMObject.layers[inputObj].minicolumns) presynCell.setPresynapticFocus( ) # highlight presynapctic cells form = GeomVertexFormat.getV3() vdata = GeomVertexData("DistalSynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f(presynCell.getNode().getPos(self.__node)) vertex.addData3f(0, 0, 0) prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("DistalSynapse") node.addGeom(geom) nodePath = self.__node.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if presynCell.active: nodePath.setColor(COL_DISTAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_DISTAL_SYNAPSES_INACTIVE)
class Orbit(VisibleObject): ignore_light = True default_shown = False selected_color = LColor(1.0, 0.0, 0.0, 1.0) appearance = None shader = None def __init__(self, body): VisibleObject.__init__(self, body.get_ascii_name() + '-orbit') self.body = body self.owner = body self.nbOfPoints = 360 self.orbit = self.find_orbit(self.body) self.color = None self.fade = 0.0 if not self.orbit: print("No orbit for", self.get_name()) self.visible = False def get_oid_color(self): if self.body is not None: return self.body.oid_color else: return LColor() @classmethod def create_shader(cls): cls.appearance = ModelAppearance(attribute_color=True) if settings.use_inv_scaling: vertex_control = LargeObjectVertexControl() else: vertex_control = None cls.shader = BasicShader(lighting_model=FlatLightingModel(), vertex_control=vertex_control) def check_settings(self): if self.body.body_class is None: print("No class for", self.body.get_name()) return self.set_shown(settings.show_orbits and bodyClasses.get_show_orbit(self.body.body_class)) def find_orbit(self, body): if body != None: if not isinstance(body.orbit, FixedOrbit): return body.orbit else: return None, None else: return None, None def set_selected(self, selected): if selected: self.color = self.selected_color else: self.color = self.parent.get_orbit_color() if self.instance: self.instance.setColor(srgb_to_linear(self.color * self.fade)) def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() if self.orbit.is_periodic(): epoch = self.context.time.time_full - self.orbit.period / 2 step = self.orbit.period / (self.nbOfPoints - 1) else: #TODO: Properly calculate orbit start and end time epoch = self.orbit.get_time_of_perihelion() - self.orbit.period * 5.0 step = self.orbit.period * 10.0 / (self.nbOfPoints - 1) for i in range(self.nbOfPoints): time = epoch + step * i pos = self.orbit.get_position_at(time) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints-1): self.lines.addVertex(i) self.lines.addVertex(i+1) if self.orbit.is_periodic() and self.orbit.is_closed(): self.lines.addVertex(self.nbOfPoints-1) self.lines.addVertex(0) self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(srgb_to_linear(self.color * self.fade)) self.instance_ready = True if self.shader is None: self.create_shader() self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance) def update_geom(self): geom = self.node.modify_geom(0) vdata = geom.modify_vertex_data() vwriter = GeomVertexRewriter(vdata, InternalName.get_vertex()) #TODO: refactor with above code !!! delta = self.body.parent.get_local_position() if self.orbit.is_periodic(): epoch = self.context.time.time_full - self.orbit.period step = self.orbit.period / (self.nbOfPoints - 1) else: #TODO: Properly calculate orbit start and end time epoch = self.orbit.get_time_of_perihelion() - self.orbit.period * 5.0 step = self.orbit.period * 10.0 / (self.nbOfPoints - 1) for i in range(self.nbOfPoints): time = epoch + step * i pos = self.orbit.get_position_at(time) - delta vwriter.setData3f(*pos) def check_visibility(self, pixel_size): if self.parent.parent.visible and self.parent.shown and self.orbit: distance_to_obs = self.parent.distance_to_obs if distance_to_obs > 0.0: size = self.orbit.get_apparent_radius() / (distance_to_obs * pixel_size) else: size = 0.0 self.visible = size > settings.orbit_fade self.fade = min(1.0, max(0.0, (size - settings.orbit_fade) / settings.orbit_fade)) if self.color is not None and self.instance is not None: self.instance.setColor(srgb_to_linear(self.color * self.fade)) else: self.visible = False def update_instance(self, camera_pos, camera_rot): if self.instance: self.place_instance_params(self.instance, self.body.parent.scene_position, self.body.parent.scene_scale_factor, LQuaternion()) self.shader.update(self, self.appearance) def update_user_parameters(self): if self.instance is not None: self.update_geom()
class Planetimpl(): def __init__(self, world, size, distance, ratio, description, rotation, translation): self.worldOrigin = world self.size = size self.distance = distance self.renderRatio = ratio self.description = description self.rotation = rotation self.translation = translation def impl(self): # Load the Moon model self.planet = loader.loadModel("models/planet_sphere") self.chooseTexture("models/"+self.description+"_1k_tex.jpg") self.planet.reparentTo(self.worldOrigin) self.planet.setScale(self.size * self.renderRatio) self.planet.setPos(self.distance * self.renderRatio, 0.0, 0.0) self.planet.setTag('targetSize', str(self.size)) self.planet.setTag('isPickable', '2') self.startstop = True return self.planet def chooseTexture(self, name): """ Methode zum Setzen der Ursprungstextur """ self.planet.setTexture(loader.loadTexture(name), 1) def line(self): # Create and populate the Moon orbit model using Vertices and Lines self.planetOrbitVertexData = GeomVertexData(self.description+'OrbitVertexData', GeomVertexFormat.getV3(), Geom.UHDynamic) self.planetOrbitVertexWriter = GeomVertexWriter(self.planetOrbitVertexData, 'vertex') self.planetOrbitNumberPoints = 360 for i in range(self.planetOrbitNumberPoints): angleDegrees = i * 360 / self.planetOrbitNumberPoints angleRadians = angleDegrees * (pi / 180.0) x = -self.distance * sin(angleRadians) y = self.distance * cos(angleRadians) self.planetOrbitVertexWriter.addData3f(x, y, 0.0) self.planetOrbitLines = GeomLines(Geom.UHStatic) for i in range(self.planetOrbitNumberPoints-1): self.planetOrbitLines.addVertex(i) self.planetOrbitLines.addVertex(i+1) self.planetOrbitLines.closePrimitive() self.planetOrbitLines.addVertex(self.planetOrbitNumberPoints-1) self.planetOrbitLines.addVertex(0) self.planetOrbitLines.closePrimitive() self.planetOrbitGeom = Geom(self.planetOrbitVertexData) self.planetOrbitGeom.addPrimitive(self.planetOrbitLines) self.planetOrbitNode = GeomNode(self.description+'OrbitNode') self.planetOrbitNode.addGeom(self.planetOrbitGeom) self.planetOrbitNnodePath = render.attachNewNode(self.planetOrbitNode) self.planetOrbitNnodePath.reparentTo(self.worldOrigin) return self.planetOrbitVertexWriter def setstartstop(self): self.startstop = not self.startstop return self.startstop def rotatePlanet(self, task): # Compute earth rotation frameTime = globalClock.getFrameTime() angleDegrees = frameTime * self.rotation self.planet.setHpr(angleDegrees, 0, 0) # End task if self.startstop: return Task.cont else: return Task.done def translatePlanet(self, task): # Compute Moon position relative to Earth with circular orbit frameTime = globalClock.getFrameTime() angleDegrees = frameTime * self.translation angleRadians = angleDegrees * (pi / 180.0) # Compute the Moon's position with respect to the Earth x = -self.distance * self.renderRatio * sin(angleRadians) y = self.distance * self.renderRatio * cos(angleRadians) # Set the position on the model self.planet.setPos(x, y, 0.0) # Also rotate the orbit to follow the Moon and eliminate jitter effect self.planetOrbitVertexWriter.setRow(0) for i in range(self.planetOrbitNumberPoints): angleDegrees = angleDegrees + 360.0 / self.planetOrbitNumberPoints angleRadians = angleDegrees * (pi / 180.0) x = -self.distance * self.renderRatio * sin(angleRadians) y = self.distance * self.renderRatio * cos(angleRadians) self.planetOrbitVertexWriter.setData3f(x, y, 0.0) # End task if self.startstop: return Task.cont else: return Task.done
def CreateProximalSynapses(self, inputNames, inputObj, permanences, thresholdConnected, createOnlyActive=False): self.DestroyProximalSynapses() printLog("Creating proximal permanences", verbosityMedium) printLog("To inputObj called:" + str(inputNames), verbosityMedium) printLog("permanences count:" + str(len(permanences)), verbosityMedium) printLog("active:" + str(sum([i for i in permanences])), verbosityHigh) # inputObj are divided into separate items in list - [input1,input2,input3] # permanences are one united array [1,0,0,1,0,1,0...] # length is the same # synapses can be connected to one input or to several inputObj # if to more than one - split synapses array synapsesDiv = [] offset = 0 for inputName in inputNames: synapsesDiv.append(permanences[offset : offset + inputObj[inputName].count]) offset += inputObj[inputName].count for i in range(len(synapsesDiv)): # for each input object inputObj[inputNames[i]].resetProximalFocus() # clear color highlight for y in range( len(synapsesDiv[i]) ): # go through every synapse and check if its connected (we are comparing permanences) if synapsesDiv[i][y] >= thresholdConnected: if createOnlyActive and not inputObj[inputNames[i]].inputBits[y].active:# we want to show only active synapses continue form = GeomVertexFormat.getV3() vdata = GeomVertexData("ProximalSynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f( inputObj[inputNames[i]] .inputBits[y] .getNode() .getPos(self.__node) ) vertex.addData3f(0, 0, 0) # vertex.addData3f(self.__node.getPos()) # printLog("inputObj:"+str(i)+"bits:"+str(y)) # printLog(inputObj[i].inputBits[y].getNode().getPos(self.__node)) # highlight inputObj[inputNames[i]].inputBits[ y ].setProximalFocus() # highlight connected bits prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("ProximalSynapse") node.addGeom(geom) nodePath = self.__cellsNodePath.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if inputObj[inputNames[i]].inputBits[y].active: nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)
def __init__(self, x_extend=None, y_extend=None, x_size=1, y_size=1, z=-0.01, tickness=1., name='Grid', x_color=None, y_color=None): GeomNode.__init__(self, name) if x_color is None: x_color = LVector4f(1.0, 1.0, 1.0, 1.0) if y_color is None: y_color = LVector4f(1.0, 1.0, 1.0, 1.0) if x_extend is None: x_extend = [0, 10] if y_extend is None: y_extend = [0, 10] self.vertexData = GeomVertexData("Chunk", GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertex = GeomVertexWriter(self.vertexData, 'vertex') self.color = GeomVertexWriter(self.vertexData, 'color') self.mesh = Geom(self.vertexData) self.lines = GeomLines(Geom.UHStatic) nb_lines_x = int((x_extend[1] - x_extend[0]) / x_size) nb_lines_y = int((y_extend[1] - y_extend[0]) / y_size) vertex_nb = 0 for ix in range(nb_lines_x): for iy in range(nb_lines_y): x = x_extend[0] + ix * x_size y = y_extend[0] + iy * y_size self.vertex.addData3f(x, y, z) self.color.addData4f(x_color) self.vertex.addData3f(x + x_size, y, z) self.color.addData4f(x_color) self.vertex.addData3f(x, y, z) self.color.addData4f(y_color) self.vertex.addData3f(x, y + y_size, z) self.color.addData4f(y_color) self.lines.add_vertices(vertex_nb, vertex_nb + 1, vertex_nb + 2, vertex_nb + 3) vertex_nb += 4 self.lines.closePrimitive() self.mesh.addPrimitive(self.lines) self.addGeom(self.mesh) NodePath(self).setRenderModeThickness(tickness) NodePath(self).setLightOff() NodePath(self).setColorOff() NodePath(self).set_bin('fixed', 8)
def _build_grid(self): color = getattr(self.parameters, "color", (0, 0, 0, 0)) node = NodePath(self.identifier) sx = self.grid.maxx - self.grid.minx + 1 sy = self.grid.maxy - self.grid.miny + 1 # 1. the squares squares = {} card = CardMaker('') cardgeom = NodePath(card.generate()) for n in range(sx): for nn in range(sy): square = NodePath(self.identifier + '-square-%d-%d' % (n + 1, nn + 1)) cardgeom.instanceTo(square) square.setPos(float(n) / sx, 0, -float(nn + 1) / sy) square.setScale(1.0 / sx, 1, 1.0 / sy) square.setColor(0, 0, 0, 1) square.reparentTo(node) squares[n, nn] = square #2: the lines gnode = GeomNode(self.identifier + "-lines") vformat = GeomVertexFormat.getV3cp() vdata = GeomVertexData(self.identifier + '-lines', vformat, Geom.UHStatic) v_vertex = GeomVertexWriter(vdata, 'vertex') v_colors = GeomVertexWriter(vdata, 'color') for n in range(sx + 1): px = float(n) / sx v_vertex.addData3f(px, 0.0, 0.0) v_colors.addData4f(*color) v_vertex.addData3f(px, 0, -1) v_colors.addData4f(*color) for n in range(sy + 1): py = float(n) / sy v_vertex.addData3f(0.0, 0.0, -py) v_colors.addData4f(*color) v_vertex.addData3f(1.0, 0, -py) v_colors.addData4f(*color) geom = Geom(vdata) prim = GeomLines(Geom.UHStatic) for n in range(sx + 1): prim.addVertex(2 * n) prim.addVertex(2 * n + 1) for n in range(sy + 1): prim.addVertex(2 * (sx + n + 1)) prim.addVertex(2 * (sx + n + 1) + 1) prim.closePrimitive() geom.addPrimitive(prim) gnode.addGeom(geom) node1 = NodePath(gnode) node1.reparentTo(node) self.node, self.squares, self.sx, self.sy = node, squares, sx, sy self.node.reparentTo(self.parentnode)
def CreateProximalSynapses(self, inputObjects, inputs, synapses): for child in self.__cellsNodePath.getChildren(): if child.getName() == "ProximalSynapseLine": child.removeNode() printLog("Creating proximal synapses", verbosityMedium) printLog("To inputs called:" + str(inputObjects), verbosityMedium) printLog("Synapses count:" + str(len(synapses)), verbosityMedium) printLog("active:" + str(sum([i for i in synapses])), verbosityHigh) # inputs are divided into separate items in list - [input1,input2,input3] # synapses are one united array [1,0,0,1,0,1,0...] # length is the same # synapses can be connected to one input or to several inputs # if to more than one - split synapses array synapsesDiv = [] offset = 0 for inputObj in inputObjects: synapsesDiv.append(synapses[offset:offset + inputs[inputObj].count]) offset += inputs[inputObj].count for i in range(len(synapsesDiv)): # for each input object inputs[ inputObjects[i]].resetProximalFocus() # clear color highlight for y in range(len(synapsesDiv[i]) ): # go through every synapse and check activity if synapsesDiv[i][y] == 1: form = GeomVertexFormat.getV3() vdata = GeomVertexData("ProximalSynapseLine", form, Geom.UHStatic) vdata.setNumRows(1) vertex = GeomVertexWriter(vdata, "vertex") vertex.addData3f( inputs[inputObjects[i]].inputBits[y].getNode().getPos( self.__node)) vertex.addData3f(0, 0, 0) # vertex.addData3f(self.__node.getPos()) # printLog("Inputs:"+str(i)+"bits:"+str(y)) # printLog(inputs[i].inputBits[y].getNode().getPos(self.__node)) # highlight inputs[inputObjects[i]].inputBits[y].setProximalFocus( ) # highlight connected bits prim = GeomLines(Geom.UHStatic) prim.addVertices(0, 1) geom = Geom(vdata) geom.addPrimitive(prim) node = GeomNode("ProximalSynapse") node.addGeom(geom) nodePath = self.__cellsNodePath.attachNewNode(node) nodePath.setRenderModeThickness(2) # color of the line if inputs[inputObjects[i]].inputBits[y].active: nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE) else: nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)