/*
Version: $Id: wxmodel.cpp 134 2013-11-22 14:30:58Z gk $
Implementation of GUI interface
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "constructs.h"
#include "wxglmodel.h"
#include "wx/sizer.h"
#include "wx/glcanvas.h"
#include <GL/glu.h>
#include <GL/gl.h>
#include <GL/glut.h>
// The next global variable controls the animation's state and speed.
float RotateAngle = 0.0f; // Angle in degrees of rotation around y-axis
float Azimuth = 20.0; // Rotated up or down by this amount
float AngleStepSize = 3.0f; // Step three degrees at a time
const float AngleStepMax = 10.0f;
const float AngleStepMin = 0.1f;
int WireFrameOn = 1; // == 1 for wire frame mode
GLfloat light_position2[] = { 0, 1,1,0};
enum {
MENU_RUN=1,
MENU_1Hour,
MENU_REFRESH,
MENU_QUIT,
MENU_CS = 100,
MENU_CSUS = 300,
MENU_STRONGTRAIN = 400,
MENU_INTERSTIM = 500,
MENU_PROTO = 600,
};
/*
wxDECLARE_EVENT(wxEVT_COMMAND_MYTHREAD_COMPLETED, wxThreadEvent);
wxDECLARE_EVENT(wxEVT_COMMAND_MYTHREAD_UPDATE, wxThreadEvent);
*/
GLuint raw_texture_load(const char *filename, int width, int height)
{
GLuint texture =0;
unsigned char *data;
FILE *file;
// open texture data
file = fopen(filename, "rb");
if (file == NULL) return 0;
// allocate buffer
int sq;
data = (unsigned char*) malloc(sq = width * height *4 );
cout << "sq=" << sq<<endl;
// read texture data
sq = fread(data,1, width * height *3 , file);
cout << "read "<<sq << endl;
fclose(file);
// allocate a texture name
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &texture);
// select our current texture
glBindTexture(GL_TEXTURE_2D, texture);
// select modulate to mix texture with color for shading
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
// when texture area is small, bilinear filter the closest mipmap
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
// when texture area is large, bilinear filter the first mipmap
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// texture should tile
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// build our texture mipmaps
//float pixels[] = { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f };
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_FLOAT, pixels);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
// gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
glDisable(GL_TEXTURE_2D);
free(data);
return texture;
}
class MyThread : public wxThread
{
public:
LANetwork* m_network;
MyThread(LAWindow *handler) : wxThread(wxTHREAD_JOINABLE)
{
m_pHandler = handler ;
m_network = handler->network;
}
~MyThread() {}
protected:
virtual ExitCode Entry();
LAWindow *m_pHandler;
};
wxThread::ExitCode MyThread::Entry()
{
this->m_network->RunStore2(3, 1, 180, 0);
exit(0);
return (wxThread::ExitCode)0; // success
}
LAWindow::LAWindow(const wxString& title, LANetwork* netw)
:wxFrame(NULL, wxID_ANY, title, wxDefaultPosition,wxSize(1024, 768))
{
Centre();
timersRun =0;
int args[] = {WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 16, 0};
this->network = netw;
this->network_glpanel = new LAGLPane(this, this->network, args);
//this->network_panel->network = this->network;
//this->network->wx_window = this;
//this->network_panel->SetFocus();
wxMenu* m = new wxMenu;
m->Append(MENU_RUN, _("&Run"));
m->Append(MENU_REFRESH, _("Re&fresh"));
m->Append(MENU_QUIT, _("&Quit"));
wxMenuBar* mb = new wxMenuBar;
mb->Append(m, _("&Simulation"));
m = new wxMenu;
for (int i =0; i < network->n_inputs; i++)
m->Append(MENU_CS+i, wxString::Format(wxT("CS %d"), i));
mb->Append(m, _("Run CS"));
m = new wxMenu;
for (int i =0; i < network->n_inputs; i++)
m->Append(MENU_CSUS+i, wxString::Format(wxT("CS+US %d"), i));
mb->Append(m, _("Train"));
m = new wxMenu;
for (int i =1; i < 5; i++)
m->Append(MENU_INTERSTIM+i, wxString::Format(wxT("Interstim %d hours"), i));
mb->Append(m, _("Interstim"));
wxString mprotos[] = {
wxT("Coallocation Protocol"),
wxT("Capacity Protocol"),
};
m = new wxMenu;
for (size_t i =0; i < 2; i++)
{
m->Append(MENU_PROTO+i, mprotos[i]);
}
mb->Append(m, _("Protocols"));
//SetMenuBar(mb);
//
Connect(wxEVT_TIMER, wxCommandEventHandler(LAWindow::OnTimer));
}
void LAWindow::OnQuit(wxCommandEvent& ev)
{
printf("cleaning up... \n");
this->network->Cleanup();
Close(true);
printf("Done\n");
}
void LAWindow::OnTimer(wxCommandEvent& ev)
{
//printf("Window Timer!\n");
timersRun++;
float angle = this->network_glpanel->angle;
angle += 0.2;
if (angle>360.0) angle =0.;
this->network_glpanel->angle =angle;
this->network_glpanel->Refresh(false);
}
/* Menu handlers */
void LAWindow::OnRun(wxCommandEvent& ev)
{
int id = ev.GetId();
printf("Running %d!\n", id);
SetStatusText(wxString::Format(wxT("Wait, running %d..."), id));
if (id >= MENU_PROTO) // Protocols
{
int n = id - MENU_PROTO;
switch (n)
{
case 0:
{
this->network->CreateFearNet(30, 100, 10, 4);
for (int i =0; i < network->n_inputs; i++)
{
SetStatusText(wxString::Format(wxT("Training # %d..."), i));
//network->Stimulate(i, 2);
int mins = 50;
SetStatusText(wxString::Format(wxT("Waiting %d minutes ..."), mins) );
network->Interstim(mins*60);
}
SetStatusText(wxString::Format(wxT("Waiting 8 Hours...")));
network->Interstim((60*8)*60);
FILE* f = fopen("./data/0/memorytest.dat", "w");
network->enablePlasticity = false;
network->ResetCrebLevels();
for (int i =0; i < network->n_inputs; i++)
{
SetStatusText(wxString::Format(wxT("Testing # %d..."), i));
//network->Stimulate(i, 1);
for (nrn_iter ni = network->pyr_list.begin(); ni != network->pyr_list.end(); ++ni)
{
fprintf(f , "%d ", (*ni)->total_spikes);
}
fprintf(f, "\n");
}
network->enablePlasticity = true;
fclose(f);
f = fopen("./data/0/synweights.txt", "w") ;
for (syn_iter si = network->synapses.begin(); si != network->synapses.end(); ++si)
{
LASynapse* syn = *si;
if (syn->isPlastic != -1)
fprintf(f, "%d %d %d %d %f\n", syn->sid, syn->target_branch->bid, syn->target_nrn->nid, syn->source_nrn->input_id, syn->weight);
}
fclose(f);
}
break;
case 2:
break;
case 3:
break;
case 4:
break;
}
}
else if (id >= MENU_INTERSTIM)
network->Interstim((id - MENU_INTERSTIM)*3600);
SetStatusText(wxT("Done!"));
printf("Done running\n");
}
inline static void colormap1(wxBrush& pen, float value )
{
pen.SetColour(250, 250-value*200, value*200);
}
inline static void colormap1(wxPen& pen, float value )
{
pen.SetColour(value*240.0, 0, 250 - value*200.0);
}
static int palette[][3] = {
{200, 50,50},
{50, 200,50},
{250 , 250,100},
{200, 190,3},
{255,0,255 },
{4, 3,200},
{255,0,0 },
{128,0,0 },
{250, 3,3},
{0,255,0},
{128,128,0},
{200, 190,3},
{0,128,0},
{128,0,128},
{0,255,255},
{0,128,128},
{ 50,50,255 },
{4, 200,3},
};
static wxPoint somap[7] = {
wxPoint(30, 10),
wxPoint(30, 10),
wxPoint(40, 10),
wxPoint(40, 10),
wxPoint(40, 10),
wxPoint(35, 1),
wxPoint(30, 10)
};
static wxColour pyrcolor(150, 200, 150);
static wxColour incolor(200, 100, 100);
static wxColour syncolor(30, 200, 20);
static wxColour eltpcolor(200, 30, 20);
static wxColour calccolor(20, 30, 200);
static wxColour firecolor(255, 30,30);
static wxColour branchfirecolor(250, 100,30);
static wxPen pen;
bool LAApp::OnInit()
{
this->network = new LANetwork();
LANetwork::SetRandomSeed(1980);
this->network->CreateFearNet(20, 20, 10, 6);
LAWindow* window = new LAWindow(wxT("LA Model"), this->network);
window->network = network;
window->timer = new wxTimer(window, 13);
window->timer->Start(30);
MyThread* m_pThread = new MyThread(window);
cout << "Starting thread!!\n"<<endl;
int err;
err = m_pThread->Create();
if (err != wxTHREAD_NO_ERROR)
{
perror("TA");
cout << ("Can't create the thread!") << endl;
printf("Error %d\n", err);
delete m_pThread;
m_pThread = NULL;
}
else
{
err = m_pThread->Run() ;
if ( err != wxTHREAD_NO_ERROR )
{
perror("TA");
cout << ("Can't create the thread!") << endl;
printf("Error %d\n", err);
delete m_pThread;
m_pThread = NULL;
}
}
window->Show(true);
return true;
}
IMPLEMENT_APP(LAApp)
BEGIN_EVENT_TABLE(LAWindow, wxFrame)
EVT_MENU(MENU_RUN, LAWindow::OnRun)
EVT_MENU_RANGE(MENU_CS, MENU_CS+20, LAWindow::OnRun)
//EVT_MENU_RANGE(MENU_CSUS, MENU_CSUS+20, LAWindow::OnRun)
EVT_MENU_RANGE(MENU_INTERSTIM, MENU_INTERSTIM+5, LAWindow::OnRun)
//EVT_MENU_RANGE(MENU_STRONGTRAIN, MENU_STRONGTRAIN, LAWindow::OnRun)
EVT_MENU_RANGE(MENU_PROTO, MENU_PROTO+4, LAWindow::OnRun)
EVT_MENU(MENU_QUIT, LAWindow::OnQuit)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(LAGLPane, wxGLCanvas)
//EVT_MOTION(BasicGLPane::mouseMoved)
//EVT_LEFT_DOWN(BasicGLPane::mouseDown)
//EVT_LEFT_UP(BasicGLPane::mouseReleased)
//EVT_RIGHT_DOWN(BasicGLPane::rightClick)
//EVT_LEAVE_WINDOW(BasicGLPane::mouseLeftWindow)
//EVT_SIZE(BasicGLPane::resized)
//EVT_KEY_DOWN(BasicGLPane::keyPressed)
//EVT_KEY_UP(BasicGLPane::keyReleased)
//EVT_MOUSEWHEEL(BasicGLPane::mouseWheelMoved)
EVT_PAINT(LAGLPane::render)
END_EVENT_TABLE()
// Vertices and faces of a simple cube to demonstrate 3D render
// source: http://www.opengl.org/resources/code/samples/glut_examples/examples/cube.c
GLfloat v[8][3];
GLint faces[6][4] = { /* Vertex indices for the 6 faces of a cube. */
{0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4},
{4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3} };
GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 2.0}; /* Red diffuse light. */
LAGLPane::LAGLPane(wxFrame* parent, LANetwork* net, int* args) :
wxGLCanvas(parent, wxID_ANY, args, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE)
{
this->m_context = new wxGLContext(this);
SetBackgroundStyle(wxBG_STYLE_CUSTOM);
m_sphereTexture = 0;
//glClearColor (0.0, 0.0, 0.0, 0.0);
this->m_quadric = gluNewQuadric();
m_network = net;
angle =0;
// To avoid flashing on MSW
this->m_sphereq = gluNewQuadric();
}
LAGLPane::~LAGLPane()
{
delete m_context;
}
void LAGLPane::resized(wxSizeEvent& evt)
{
// wxGLCanvas::OnSize(evt);
Refresh();
}
GLfloat light_position[] = { 2, 2,2,0};
GLfloat light_amb[] = { 0.4,0.4, 0.4 } ;
GLfloat myglfog[] = {0.8, 0.8,1.0 , 1.};
/** Inits the OpenGL viewport for drawing in 3D. */
void LAGLPane::prepare3DViewport(int topleft_x, int topleft_y, int bottomrigth_x, int bottomrigth_y)
{
//glClearColor(0.0, 0.0f, 0.0f, 1.0f); // Black Background
}
/** Inits the OpenGL viewport for drawing in 2D. */
void LAGLPane::prepare2DViewport(int topleft_x, int topleft_y, int bottomrigth_x, int bottomrigth_y)
{
}
int LAGLPane::getWidth()
{
return GetSize().x;
}
int LAGLPane::getHeight()
{
return GetSize().y;
}
void LAdrawNeuron()
{
}
GLUquadricObj* myReusableQuadric = 0;
void LAGLPane::drawPyrNeuron( LANeuron* n)
{
glPushMatrix();
glRotatef(-90, 1,0,0);
float b =n->V/90;
if (b < -0.1) b = -0.1;
if (n->isSpiking)
glColor3f(1.0, 1.0, 1.0);
else
glColor3f(0.5, 0.5+b, 0.5-b);
gluCylinder(this->m_quadric, 0.7, 0.02, 0.9, 16, 16);
gluCylinder(this->m_quadric, 0.05, 0.01, 8.2, 8, 8);
glRotatef(90, 1,0,0);
glTranslatef(0, 1.0, 0);
float ang = 0.;
pthread_mutex_lock(&n->network->synapses_mutex);
for (branch_iter bi = n->branches.begin(); bi != n->branches.end(); ++bi)
{
LABranch* b = *bi;
glTranslatef(0, 0.3, 0);
glPushMatrix();
glRotatef(ang, 0,1,0);
ang+= 55;
glColor3f(0.6, 0.6, 0.6);
glBegin(GL_LINES);
glVertex3f(0, 0, 0);
glVertex3f(0, 0, 2);
glEnd();
for (syn_iter si=b->synapses.begin(); si != b->synapses.end(); ++si)
{
LASynapse* s = *si;
if (s->source_nrn->input_id >=0 && s->source_nrn->input_id < 3 )
{
int iid = s->source_nrn->input_id;
if (s->source_nrn->isSpiking)
glColor3f(255, 255, 255);
else if (s->source_nrn->input_id <0)
{
glColor3f(50, 50, 50);
}
else
{
int* p = palette[iid];
if (s->source_nrn->nid%2)
glColor3f(p[0]/500., p[1]/500., p[2]/500.);
else
glColor3f(p[0]/300., p[1]/300., p[2]/300.);
}
glTranslatef(0.0, 0.0, 0.2);
//glRotatef(-90, 1,0,0);
float height = 0.05 + (0.12*(s->weight/3.0));
gluDisk(this->m_quadric, 0, height, 9, 9);
//gluCylinder(this->m_quadric, 0.03, 0.03, height, 8, 8);
//glRotatef(90, 1,0,0);
}
}
glTranslatef(0, -0.08, 0);
glPopMatrix();
}
pthread_mutex_unlock(&n->network->synapses_mutex);
glPopMatrix();
glFlush();
}
void LAGLPane::render( wxPaintEvent& evt)
{
if(!IsShown()) return;
cout<< "Rendering" <<endl;
if (m_sphereTexture ==0)
{
glEnable(GL_TEXTURE_2D);
m_sphereTexture = raw_texture_load("./texture.raw", 256, 256 );
printf("Loaded texture id %d \n", m_sphereTexture);
}
wxGLCanvas::SetCurrent(*m_context);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//prepare3DViewport(0 ,0,getWidth(), getHeight());
int topleft_x= 0, topleft_y =0;
int bottomrigth_x= getWidth(), bottomrigth_y = getHeight();
glClearColor(0.0, 0.0, 0.0, 1.0f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_TEXTURE_2D);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_BLEND);
glViewport(topleft_x, topleft_y, bottomrigth_x-topleft_x, bottomrigth_y-topleft_y);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float ratio_w_h = (float)(bottomrigth_x-topleft_x)/(float)(bottomrigth_y-topleft_y);
gluPerspective(35 /*view angle*/, ratio_w_h, 0.05 /*clip close*/, 200 /*clip far*/);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_diffuse);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable( GL_POLYGON_SMOOTH );
glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glLineWidth(2.0);
//glLightfv(GL_LIGHT0, GL_SPECULAR, light_amb);
glTranslatef(1, -4, -18);
glRotatef( this->angle, 0.0, 1, .05);
glPushMatrix();
glRotatef( 90, 1, 0, 0);
gluQuadricDrawStyle(m_sphereq, GLU_LINE);
glColor3f(0.3, 0.4, 0.5);
gluSphere(m_sphereq, 20.2, 32, 16);
glPopMatrix();
/*
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_sphereTexture);
gluSphere(m_sphereq, 1.2, 32, 32);
glDisable(GL_TEXTURE_2D);
*/
if (this->m_network && this->m_network->pyr_list.size())
{
int tot =0;
for (nrn_iter ni = this->m_network->pyr_list.begin(); ni != this->m_network->pyr_list.end(); ++ni)
{
LANeuron* n= *ni;
glPushMatrix();
glTranslatef((tot%4)*6.0 - 9., 0., (tot/4)*6.0 - 9.);
drawPyrNeuron(n);
glPopMatrix();
if (tot++>10) break;
}
}
//glFlush();
SwapBuffers();
}
