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 _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 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 _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 __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 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 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 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 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 __init__(self, size, translation, rotation, color, text):
self._visible = False
wy, wx, wz = size[0], size[1], size[2]
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('cu_points', format, Geom.UHStatic)
vdata.setNumRows(8)
self._pos_writer = GeomVertexWriter(vdata, 'vertex')
self._color_writer = GeomVertexWriter(vdata, 'color')
self._pos_writer.set_row(0)
self._color_writer.set_row(0)
self._pos_writer.addData3f(-0.5 * wx, -0.5 * wy, 0.)
self._pos_writer.addData3f(-0.5 * wx, -0.5 * wy, wz)
self._pos_writer.addData3f(0.5 * wx, -0.5 * wy, wz)
self._pos_writer.addData3f(0.5 * wx, -0.5 * wy, 0.)
self._pos_writer.addData3f(-0.5 * wx, 0.5 * wy, 0.)
self._pos_writer.addData3f(-0.5 * wx, 0.5 * wy, wz)
self._pos_writer.addData3f(0.5 * wx, 0.5 * wy, wz)
self._pos_writer.addData3f(0.5 * wx, 0.5 * wy, 0.)
for i in range(8):
self._color_writer.addData4f(color[0], color[1], color[2],
color[3])
lines = GeomLines(Geom.UHStatic)
lines.addVertices(0, 1)
lines.addVertices(1, 2)
lines.addVertices(2, 3)
lines.addVertices(3, 0)
lines.addVertices(4, 5)
lines.addVertices(5, 6)
lines.addVertices(6, 7)
lines.addVertices(7, 4)
lines.addVertices(0, 4)
lines.addVertices(1, 5)
lines.addVertices(2, 6)
lines.addVertices(3, 7)
cuboid = Geom(vdata)
cuboid.addPrimitive(lines)
node = GeomNode('cuboid')
node.addGeom(cuboid)
self._node_path = NodePath(node)
# self.title = OnscreenText(text=text, style=1, fg=(1, 1, 1, 1), pos=(-0.1, 0.1), scale=.05,
# parent=self._node_path, align=TextNode.ARight)
self._txt_node = TextNode('id')
self._txt_node.setText(text)
self._txt_node.setTextScale(0.2)
self._txt_node.setCardColor(0, 0, 1, 1)
self._txt_node.setCardAsMargin(0, 0, 0, 0)
self._txt_node.setCardDecal(True)
self._txt_node.set_align(2)
text_geom = GeomNode('text')
text_geom.addChild(self._txt_node)
self._txt_np = NodePath(text_geom)
self._txt_np.reparentTo(self._node_path)
self.show()
self.update_values(size, translation, rotation, color, text)
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 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 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 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)
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 __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 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)
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(
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)
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 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)
