Beispiel #1
0
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
Beispiel #2
0
 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
Beispiel #4
0
    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)
Beispiel #5
0
    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)
Beispiel #6
0
 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)
Beispiel #7
0
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
Beispiel #8
0
    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)
Beispiel #9
0
    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)
Beispiel #11
0
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
Beispiel #12
0
 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)
Beispiel #14
0
 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)
Beispiel #15
0
 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)
Beispiel #16
0
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()
Beispiel #17
0
    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)
Beispiel #18
0
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
Beispiel #19
0
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
Beispiel #20
0
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
Beispiel #21
0
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)
Beispiel #22
0
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
Beispiel #23
0
    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(
Beispiel #24
0
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)
Beispiel #25
0
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)
Beispiel #26
0
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))
Beispiel #27
0
    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)
Beispiel #28
0
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
Beispiel #30
0
    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)
Beispiel #31
0
    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)
Beispiel #32
0
    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)
Beispiel #33
0
    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)