class cMinicolumn:
def __init__(self, nameOfLayer, nOfCellsPerColumn):
self.cells = []
self.nOfCellsPerColumn = nOfCellsPerColumn
for i in range(nOfCellsPerColumn):
n = cCell(self)
self.cells.append(n)
self.idx = -1
self.parentLayer = nameOfLayer
self.transparency = 1.0
self.gfxCreated = False
self.LodDistance1Stored = 100.0
self.LodDistance2Stored = 5000.0
self.bursting = False
self.active = False
self.oneOfCellPredictive = False
self.oneOfCellCorrectlyPredicted = False
self.oneOfCellFalselyPredicted = False
self.cntSegments = None # info about how many segments are on this cell
def CreateGfx(self, loader, idx):
# __node
# / \
# cellsNodePath columnBox
self.lod = LODNode("columnLOD") # Level of detail node for Column
self.__node = NodePath(
self.lod
) # NodePath(PandaNode('column'))# loader.loadModel("models/box")
self.__node.setPos(0, 0, 0)
self.__node.setScale(1, 1, 1)
self.idx = idx
# self.__node.setTag('clickable',str(idx))#to be able to click on it
self.__columnBox = loader.loadModel(
os.path.join(os.getcwd(), "models/cube"))
self.__columnBox.setPos(
0, 0, -0.5 + (0 if len(self.cells) == 0 else len(self.cells) *
(1 + CELL_OFFSET) / 2))
self.__columnBox.setScale(
0.5, 0.5, 0.5 * (1 if len(self.cells) == 0 else len(self.cells) *
(1 + CELL_OFFSET)))
self.__columnBox.setName("columnBox")
self.__cellsNodePath = NodePath(
PandaNode("cellsNode")) # to pack all cells into one node path
self.__cellsNodePath.setName("column")
self.__cellsNodePath.setTag(
"id",
str(idx)) # to be able to retrieve index of column for mouse click
self.lod.addSwitch(100.0, 0.0)
self.lod.addSwitch(5000.0, 100.0)
self.__cellsNodePath.reparentTo(self.__node)
self.__columnBox.reparentTo(self.__node)
z = 0
idx = 0
for n in self.cells:
n.CreateGfx(loader, idx)
idx += 1
n.getNode().setPos(0, 0, z)
z += 1 + CELL_OFFSET
n.getNode().reparentTo(self.__cellsNodePath)
self.gfxCreated = True
def LODUpdateSwitch(self, lodDistance, lodDistance2):
self.lodDistance1Stored = lodDistance
self.lodDistance2Stored = lodDistance2
self.lod.clearSwitches()
self.lod.addSwitch(lodDistance, 0.0)
self.lod.addSwitch(lodDistance2, lodDistance)
def LODUpdateSwitch_long(self):
self.lod.clearSwitches()
self.lod.addSwitch(self.lodDistance2Stored, 0.0)
self.lod.addSwitch(self.lodDistance2Stored, self.lodDistance2Stored)
def LODUpdateSwitch_normal(self):
self.LODUpdateSwitch(self.lodDistance1Stored, self.lodDistance2Stored)
def UpdateState(self, bursting, activeColumn, oneOfCellPredictive,
oneOfCellCorrectlyPredicted, oneOfCellFalselyPredicted):
self.bursting = bursting
self.active = activeColumn
self.oneOfCellPredictive = oneOfCellPredictive
self.oneOfCellCorrectlyPredicted = oneOfCellCorrectlyPredicted
self.oneOfCellFalselyPredicted = oneOfCellFalselyPredicted
# update column box color (for LOD in distance look)
if self.oneOfCellCorrectlyPredicted:
COL_COLUMN_ONEOFCELLCORRECTLY_PREDICTED.setW(self.transparency)
col = COL_COLUMN_ONEOFCELLCORRECTLY_PREDICTED
self.__columnBox.setColor(col)
elif self.oneOfCellFalselyPredicted:
COL_COLUMN_ONEOFCELLFALSELY_PREDICTED.setW(self.transparency)
col = COL_COLUMN_ONEOFCELLFALSELY_PREDICTED
self.__columnBox.setColor(col)
elif self.bursting:
COL_COLUMN_BURSTING.setW(self.transparency)
col = COL_COLUMN_BURSTING
self.__columnBox.setColor(col)
elif self.active and self.oneOfCellPredictive:
COL_COLUMN_ACTIVE_AND_ONEOFCELLPREDICTIVE.setW(self.transparency)
col = COL_COLUMN_ACTIVE_AND_ONEOFCELLPREDICTIVE
self.__columnBox.setColor(col)
elif self.oneOfCellPredictive:
COL_COLUMN_ONEOFCELLPREDICTIVE.setW(self.transparency)
col = COL_COLUMN_ONEOFCELLPREDICTIVE
self.__columnBox.setColor(col)
elif self.active:
COL_COLUMN_ACTIVE.setW(self.transparency)
col = COL_COLUMN_ACTIVE
self.__columnBox.setColor(col)
else:
COL_COLUMN_INACTIVE.setW(self.transparency)
col = COL_COLUMN_INACTIVE
self.__columnBox.setColor(col)
# for n in self.cells:
# n.active = active
# n.UpdateState()
def getNode(self):
return self.__node
def updateWireframe(self, value):
for cell in self.cells:
cell.updateWireframe(value)
if value:
self.__columnBox.setRenderModeFilledWireframe(LColor(0, 0, 0, 1.0))
else:
self.__columnBox.setRenderModeFilled()
def CreateSynapses(self, regionObjects, columnConnections, synapsesType,
sourceRegions, activeOnly):
printLog("Creating synapses", verbosityMedium)
ConnectionFactory.CreateSynapses(
callbackCreateSynapse=self._CreateOneSynapse,
synapsesType=synapsesType,
regionObjects=regionObjects,
connections=columnConnections,
idx=self.idx,
sourceRegions=sourceRegions,
activeOnly=activeOnly)
for arr in columnConnections:
if arr[0] == self.idx: # find this column
self.cntSegments = len(arr[1])
break
# creates synapse, that will go from presynCell to this cell
# presynCell - cell object
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 setTransparency(self, transparency):
self.transparency = transparency
for cell in self.cells:
cell.setTransparency(transparency)
self.UpdateState(self.bursting, self.active, self.oneOfCellPredictive,
self.oneOfCellCorrectlyPredicted,
self.oneOfCellFalselyPredicted)
def DestroySynapses(self, synapseType=None):
if synapseType is None:
synapseType = '*'
if not self.gfxCreated:
return
if synapseType == 'proximal':
for syn in self.__cellsNodePath.findAllMatches("Synapse_" +
str(synapseType)):
syn.removeNode()
for cell in self.cells:
cell.DestroySynapses(synapseType)
def getDescription(self):
txt = ""
txt += "ID:" + str(self.idx) + "\n"
txt += "Active:" + str(self.active) + "\n"
txt += "One of cell is predictive:" + str(
self.oneOfCellPredictive) + "\n"
txt += "One of cell correctly predicted:" + str(
self.oneOfCellCorrectlyPredicted) + "\n"
txt += "One of cell false predicted:" + str(
self.oneOfCellFalselyPredicted) + "\n"
txt += "Number of segments:" + str(self.cntSegments) + "\n"
return txt
class cMinicolumn:
def __init__(self, nameOfLayer, nOfCellsPerColumn):
self.cells = []
for i in range(nOfCellsPerColumn):
n = cCell(self)
self.cells.append(n)
self.parentLayer = nameOfLayer
self.transparency = 1.0
self.gfxCreated = False
self.LodDistance1Stored = 100.0
self.LodDistance2Stored = 5000.0
self.bursting = False
self.active = False
self.oneOfCellPredictive = False
self.oneOfCellCorrectlyPredicted = False
self.oneOfCellFalselyPredicted = False
def CreateGfx(self, loader, idx):
# __node
# / \
# cellsNodePath columnBox
self.lod = LODNode("columnLOD") # Level of detail node for Column
self.__node = NodePath(
self.lod
) # NodePath(PandaNode('column'))# loader.loadModel("models/box")
self.__node.setPos(0, 0, 0)
self.__node.setScale(1, 1, 1)
# self.__node.setTag('clickable',str(idx))#to be able to click on it
self.__columnBox = loader.loadModel("models/cube")
self.__columnBox.setPos(
0, 0, -0.5 + (0 if len(self.cells) == 0 else len(self.cells) *
(1 + CELL_OFFSET) / 2))
self.__columnBox.setScale(
0.5, 0.5, 0.5 * (1 if len(self.cells) == 0 else len(self.cells) *
(1 + CELL_OFFSET)))
self.__columnBox.setName("columnBox")
self.__cellsNodePath = NodePath(
PandaNode("cellsNode")) # to pack all cells into one node path
self.__cellsNodePath.setName("column")
self.__cellsNodePath.setTag(
"id",
str(idx)) # to be able to retrieve index of column for mouse click
self.lod.addSwitch(100.0, 0.0)
self.lod.addSwitch(5000.0, 100.0)
self.__cellsNodePath.reparentTo(self.__node)
self.__columnBox.reparentTo(self.__node)
z = 0
idx = 0
for n in self.cells:
n.CreateGfx(loader, idx)
idx += 1
n.getNode().setPos(0, 0, z)
z += 1 + CELL_OFFSET
n.getNode().reparentTo(self.__cellsNodePath)
self.gfxCreated = True
def LODUpdateSwitch(self, lodDistance, lodDistance2):
self.lodDistance1Stored = lodDistance
self.lodDistance2Stored = lodDistance2
self.lod.clearSwitches()
self.lod.addSwitch(lodDistance, 0.0)
self.lod.addSwitch(lodDistance2, lodDistance)
def LODUpdateSwitch_long(self):
self.lod.clearSwitches()
self.lod.addSwitch(self.lodDistance2Stored, 0.0)
self.lod.addSwitch(self.lodDistance2Stored, self.lodDistance2Stored)
def LODUpdateSwitch_normal(self):
self.LODUpdateSwitch(self.lodDistance1Stored, self.lodDistance2Stored)
def UpdateState(self, bursting, activeColumn, oneOfCellPredictive,
oneOfCellCorrectlyPredicted, oneOfCellFalselyPredicted):
self.bursting = bursting
self.active = activeColumn
self.oneOfCellPredictive = oneOfCellPredictive
self.oneOfCellCorrectlyPredicted = oneOfCellCorrectlyPredicted
self.oneOfCellFalselyPredicted = oneOfCellFalselyPredicted
# update column box color (for LOD in distance look)
if self.oneOfCellCorrectlyPredicted:
COL_COLUMN_ONEOFCELLCORRECTLY_PREDICTED.setW(self.transparency)
col = COL_COLUMN_ONEOFCELLCORRECTLY_PREDICTED
self.__columnBox.setColor(col)
elif self.oneOfCellFalselyPredicted:
COL_COLUMN_ONEOFCELLFALSELY_PREDICTED.setW(self.transparency)
col = COL_COLUMN_ONEOFCELLFALSELY_PREDICTED
self.__columnBox.setColor(col)
elif self.oneOfCellPredictive:
COL_COLUMN_ONEOFCELLPREDICTIVE.setW(self.transparency)
col = COL_COLUMN_ONEOFCELLPREDICTIVE
self.__columnBox.setColor(col)
elif self.active:
COL_COLUMN_ACTIVE.setW(self.transparency)
col = COL_COLUMN_ACTIVE
self.__columnBox.setColor(col)
else:
COL_COLUMN_INACTIVE.setW(self.transparency)
col = COL_COLUMN_INACTIVE
self.__columnBox.setColor(col)
# for n in self.cells:
# n.active = active
# n.UpdateState()
def getNode(self):
return self.__node
def updateWireframe(self, value):
for cell in self.cells:
cell.updateWireframe(value)
if value:
self.__columnBox.setRenderModeFilledWireframe(LColor(0, 0, 0, 1.0))
else:
self.__columnBox.setRenderModeFilled()
# -- Create proximal synapses
# inputObjects - list of names of inputs(areas)
# inputs - panda vis input object
# synapses - list of the second points of synapses (first point is this cortical column)
# NOTE: synapses are now DENSE
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 setTransparency(self, transparency):
self.transparency = transparency
for cell in self.cells:
cell.setTransparency(transparency)
self.UpdateState(self.bursting, self.active, self.oneOfCellPredictive,
self.oneOfCellCorrectlyPredicted,
self.oneOfCellFalselyPredicted)
def DestroyProximalSynapses(self):
for syn in self.__cellsNodePath.findAllMatches("ProximalSynapse"):
syn.removeNode()
def DestroyDistalSynapses(self):
for cell in self.cells:
cell.DestroyDistalSynapses()
cell.resetPresynapticFocus() # also reset distal focus
def getDescription(self):
txt = ""
txt += "Active:" + str(self.active) + "\n"
txt += "One of cell is predictive:" + str(
self.oneOfCellPredictive) + "\n"
txt += "One of cell correctly predicted:" + str(
self.oneOfCellCorrectlyPredicted) + "\n"
txt += "One of cell false predicted:" + str(
self.oneOfCellFalselyPredicted) + "\n"
return txt
class cGridCellModule:
def __init__(self, nOfCellsPerAxis):
self.cells = []
self.nOfCellsPerAxis = nOfCellsPerAxis
self.cellCount = nOfCellsPerAxis * nOfCellsPerAxis
self.CELL_OFFSET = 0.4 # space between cells
for i in range(self.cellCount):
self.cells.append(cCell(None))
self.idx = -1
self.transparency = 1.0
self.gfxCreated = False
self.LodDistance1Stored = 100.0
self.LodDistance2Stored = 5000.0
self.width = self.nOfCellsPerAxis * (1 + self.CELL_OFFSET
) # width of the module
def CreateGfx(self, loader, idx):
# __node
# / \
# cellsNodePath columnBox
self.lod = LODNode("columnLOD") # Level of detail node for Column
self.__node = NodePath(
self.lod
) # NodePath(PandaNode('column'))# loader.loadModel("models/box")
self.__node.setPos(0, 0, 0)
self.__node.setScale(1, 1, 1)
self.idx = idx
# self.__node.setTag('clickable',str(idx))#to be able to click on it
self.__rhombusEnvelope = loader.loadModel(
os.path.join(os.getcwd(), "models/rhombus"))
self.__rhombusEnvelope.setPos(self.width / 2, self.width / 2, 0.0)
self.__rhombusEnvelope.setScale(self.width / 2, self.width / 2, 0.5)
self.__rhombusEnvelope.setName("columnBox")
self.__cellsNodePath = NodePath(
PandaNode("cellsNode")) # to pack all cells into one node path
self.__cellsNodePath.setName("column")
self.__cellsNodePath.setTag(
"id",
str(idx)) # to be able to retrieve index of column for mouse click
self.lod.addSwitch(100.0, 0.0)
self.lod.addSwitch(5000.0, 100.0)
self.__cellsNodePath.reparentTo(self.__node)
self.__rhombusEnvelope.reparentTo(self.__node)
x = 0
y = 0
idx = 0
for n in self.cells:
n.CreateGfx(loader, idx)
idx += 1
pos = self._TransformRhombToGlob([x, y], 1 + self.CELL_OFFSET, 0.0)
n.getNode().setPos(pos[0], pos[1], 0)
x += 1
if x >= self.nOfCellsPerAxis:
y += 1
x = 0
n.getNode().reparentTo(self.__cellsNodePath)
self.gfxCreated = True
# transoforms coordinate system from rhombus to global
def _TransformRhombToGlob(self, position, scale, orientation):
t = np.radians(orientation) # theta
r = np.radians(60) # rhombus skew
s = scale
# create Rotation Matrix
R = np.array(((s * np.cos(t), s * np.cos(t + r)), (s * np.sin(t),
s * np.sin(t + r))))
return np.matmul(R, position) # multiply
# transforms coordinate system from global to rhombus
def _TransformGlobToRhomb(self, position, scale, orientation):
t = np.radians(orientation) # theta
r = np.radians(60) # rhombus skew
s = scale
# TODO add scale - use www.wolframalpha.com
# create Rotation Matrix - inverse of the one in _TransformRhombToGlob()
R = np.array(((np.sin(t + r) / np.sin(r), -np.cos(t + r) / np.sin(r)),
(-np.sin(t) / np.sin(r), np.cos(t) / np.sin(r))))
def LODUpdateSwitch(self, lodDistance, lodDistance2):
self.lodDistance1Stored = lodDistance
self.lodDistance2Stored = lodDistance2
self.lod.clearSwitches()
self.lod.addSwitch(lodDistance, 0.0)
self.lod.addSwitch(lodDistance2, lodDistance)
def LODUpdateSwitch_long(self):
self.lod.clearSwitches()
self.lod.addSwitch(self.lodDistance2Stored, 0.0)
self.lod.addSwitch(self.lodDistance2Stored, self.lodDistance2Stored)
def LODUpdateSwitch_normal(self):
self.LODUpdateSwitch(self.lodDistance1Stored, self.lodDistance2Stored)
def UpdateState(self, activeCells):
for cellID in range(len(self.cells)): # for each cell
isActive = activeCells[cellID]
self.cells[cellID].UpdateState(active=isActive,
predictive=False,
winner=False,
focused=False,
presynapticFocus=False,
showPredictionCorrectness=False,
prev_predictive=False)
def getNode(self):
return self.__node
def updateWireframe(self, value):
for cell in self.cells:
cell.updateWireframe(value)
if value:
self.__rhombusEnvelope.setRenderModeFilledWireframe(
LColor(0, 0, 0, 1.0))
else:
self.__rhombusEnvelope.setRenderModeFilled()
def setTransparency(self, transparency):
self.transparency = transparency
for cell in self.cells:
cell.setTransparency(transparency)
def DestroySynapses(self, synapseType):
if not self.gfxCreated:
return
for cell in self.cells:
cell.DestroySynapses(synapseType)
self.resetPresynapticFocus()
def resetPresynapticFocus(self):
if not self.gfxCreated:
return
for cell in self.cells:
cell.resetPresynapticFocus() # also reset distal focus
def getDescription(self):
txt = ""
txt += "TODO GridCellModule desc ID:" + str(self.idx) + "\n"
return txt
