Skip to content
Snippets Groups Projects
Commit 186c022b authored by Stuart Layton's avatar Stuart Layton
Browse files

updated spike plotting to show points in the projection plots, points don't... 

updated spike plotting to show points in the projection plots, points don't persists and I haven't been able to disable anti-aliasing on the mac so those things still need to be done
parent 753adc99
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 124 additions and 407 deletions
Source/Processors/Visualization/SpikePlotting/ProjectionAxes.cpp
+ 74
− 344
View file @ 186c022b
// #include "ProjectionAxes.h" #include "ProjectionAxes.h"
// ProjectionAxes::ProjectionAxes(): ProjectionAxes::ProjectionAxes():
// BaseUIElement(), GenericAxes(),
// type(1), drawGrid(false),
// drawWaveformLine(true), overlay(false),
// drawWaveformPoints(false), convertLabelUnits(true)
// drawGrid(true), {
// gotFirstSpike(false), GenericAxes::gotFirstSpike = false;
// overlay(false), GenericAxes::resizedFlag = false;
// convertLabelUnits(true),
// resizedFlag(false)
// {
// ylims[0] = 0;
// ylims[1] = 1;
// setWaveformColor(1.0,1.0,0.6);
// setThresholdColor(1.0, 0.1, 0.1);
// setPointColor(1.0, 1.0, 1.0);
// setGridColor(0.4, 0.2, 0.2);
// BaseUIElement::elementName = (char*) "ProjectionAxes";
// }
// ProjectionAxes::ProjectionAxes(int x, int y, double w, double h, int t): ylims[0] = 0;
// BaseUIElement(x,y,w,h), ylims[1] = 1;
// drawWaveformLine(true), setPointColor(1.0,1.0,1.0);
// drawWaveformPoints(false),
// drawGrid(true),
// gotFirstSpike(false),
// overlay(false),
// convertLabelUnits(true),
// resizedFlag(false)
// {
// // if (t<WAVE1 || t>PROJ3x4)
// //("Invalid Axes type specified");
// type = t;
// setWaveformColor(1.0,1.0,0.6);
// setThresholdColor(1.0, 0.1, 0.1);
// setPointColor(1.0, 1.0, 1.0);
// setGridColor(0.2, 0.2, 0.2);
// BaseUIElement::elementName = (char*) "ProjectionAxes";
// } BaseUIElement::elementName = (char*) "ProjectionAxes";
// void ProjectionAxes::updateSpikeData(SpikeObject newSpike){ }
// if (!gotFirstSpike){
// gotFirstSpike = true;
// printf("ProjectionAxes::updateSpikeData() got first spike\n");
// }
// s = newSpike;
// }
// void ProjectionAxes::redraw(){
// BaseUIElement::redraw();
// if (BaseUIElement::enabled)
// plotData();
// BaseUIElement::drawElementEdges(); ProjectionAxes::ProjectionAxes(int x, int y, double w, double h, int t):
// } GenericAxes(x,y,w,h,t),
// void ProjectionAxes::plotData(){ drawGrid(true),
overlay(false),
convertLabelUnits(true)
{
GenericAxes::gotFirstSpike = false;
GenericAxes::resizedFlag = false;
// if (!gotFirstSpike) setPointColor(1.0,1.0,1.0);
// {
// std::cout<<"\tWaiting for the first spike"<<std::endl;
// return;
// }
// switch(type){
// case WAVE1:
// case WAVE2:
// case WAVE3:
// case WAVE4:
// plotWaveform(type);
// break;
// case PROJ1x2:
// case PROJ1x3:
// case PROJ1x4:
// case PROJ2x3:
// case PROJ2x4:
// case PROJ3x4:
// plotProjection(type);
// break;
// default:
// std::cout<<"ProjectionAxes::plotData(), Invalid type specified, cannot plot"<<std::endl;
// exit(1);
// }
// }
// void ProjectionAxes::setYLims(double ymin, double ymax){
// ylims[0] = ymin;
// ylims[1] = ymax;
// }
// void ProjectionAxes::getYLims(double *min, double *max){
// *min = ylims[0];
// *max = ylims[1];
// }
// void ProjectionAxes::setXLims(double xmin, double xmax){
// xlims[0] = xmin;
// xlims[1] = xmax;
// }
// void ProjectionAxes::getXLims(double *min, double *max){
// *min = xlims[0];
// *max = xlims[1];
// }
// void ProjectionAxes::setType(int t){
// if (t<WAVE1 || t>PROJ3x4){
// std::cout<<"Invalid Axes type specified";
// return;
// }
// type = t; BaseUIElement::elementName = (char*) "ProjectionAxes";
// }
// int ProjectionAxes::getType(){
// return type;
// }
// void ProjectionAxes::plotWaveform(int chan){ }
// if (chan>WAVE4 || chan<WAVE1) void ProjectionAxes::updateSpikeData(SpikeObject newSpike){
// { //std::cout<<"ProjectionAxes::updateSpikeData()"<<std::endl;
// std::cout<<"ProjectionAxes::plotWaveform() invalid channel, must be between 0 and 4"<<std::endl; GenericAxes::updateSpikeData(newSpike);
// return;
// }
// if (s.n_samps_per_chan>1024)
// return;
// // Set the plotting range for the current axes }
// // the xlims member is ignored as the
// // xdims are 0->number of samples per waveform minus one
// // so the line goes all the way to the edges
// // ydims are specified by the ylims vector
// setViewportRange(0, ylims[0], s.n_samps_per_chan-1, ylims[1]);
// if(!overlay){
// glColor3f(0.0,0.0,0.0);
// glRectd(0, ylims[0], s.n_samps_per_chan, ylims[1]);
// }
// if(drawGrid)
// drawWaveformGrid(s.thresh[chan], s.gains[chan]);
// //compute the spatial width for each wawveform sample
// float dx = 1;
// float x = 0;
// int sampIdx = chan;
// //Draw the individual waveform points connected with a line void ProjectionAxes::redraw(){
// // if drawWaveformPoints is set to false then force the drawing of the line, _SOMETHING_ must be drawn
// glColor3fv(waveColor);
// //if drawWaveformLine and drawWaveformPoints are both set BaseUIElement::redraw();
// if(drawWaveformLine){
// glLineWidth(1);
// glBegin( GL_LINE_STRIP );
// for (int i=0; i<s.n_samps_per_chan; i++)
// {
// glVertex2f(x, s.data[sampIdx]);
// sampIdx +=4;
// x +=dx;
// }
// glEnd();
// }
plot();
// //if drawWaveformLine and drawWaveformPoints are both set false then draw the points
// //this ensures that something is always drawn
// if(drawWaveformPoints || !drawWaveformLine){
// x = 0;
// sampIdx = chan;
// glColor3fv(pointColor);
// glPointSize(1);
// glBegin( GL_POINTS );
// for (int i=0; i<s.n_samps_per_chan; i++)
// {
// glVertex2f(x, s.data[sampIdx]);
// sampIdx +=4;
// x +=dx;
// }
// glEnd();
// }
// // Draw the threshold line and label
// glColor3fv(thresholdColor); BaseUIElement::drawElementEdges();
// glLineWidth(1); }
// glLineStipple(4, 0xAAAA); // make a dashed line
// glEnable(GL_LINE_STIPPLE);
// glBegin( GL_LINE_STRIP );
// glVertex2f(0, s.thresh[chan]);
// glVertex2f(s.n_samps_per_chan, s.thresh[chan]);
// glEnd();
// glDisable(GL_LINE_STIPPLE);
// char str[500] = {0};
// /*if(convertLabelUnits)
// sprintf(str, "%duV", ad16ToUv(s.thresh[chan], s.gains[chan]));
// else
// sprintf(str, "%d", (int) s.thresh[chan]);*/
// makeLabel(s.thresh[chan], s.gains[chan], convertLabelUnits, str);
// // printf(str);
// float yOffset = (ylims[1] - ylims[0])/BaseUIElement::height * 2;
// drawString(1 ,s.thresh[chan] + yOffset, GLUT_BITMAP_8_BY_13, str);
// }
void ProjectionAxes::plot(){
// void ProjectionAxes::plotProjection(int proj){ setViewportRange(xlims[0], ylims[0], xlims[1], ylims[1]);
// // std::cout<<"ProjectionAxes::plotProjection():"<<proj<<" not yet implemented"<<std::endl;
// // if (proj<PROJ1x2 || proj>PROJ3x4)
// // error("ProjectionAxes:plotProjection() invalid projection specified");
// setViewportRange(xlims[0], ylims[0], xlims[1], ylims[1]);
// int d1, d2; int d1, d2;
// n2ProjIdx(proj, &d1, &d2); n2ProjIdx(type, &d1, &d2);
// int idx1, idx2; int idx1, idx2;
// calcWaveformPeakIdx(d1,d2,&idx1, &idx2); calcWaveformPeakIdx(d1,d2,&idx1, &idx2);
// if (drawGrid)
// drawProjectionGrid(s.gains[d1], s.gains[d2]);
// glColor3fv(pointColor); //if (drawGrid)
// glPointSize(1); // drawProjectionGrid(s.gain[d1], s.gain[d2]);
// glBegin(GL_POINTS); glColor3fv(pointColor);
// glVertex2f(s.data[idx1], s.data[idx2]); glPointSize(1);
// glEnd();
// }
// void ProjectionAxes::calcWaveformPeakIdx(int d1, int d2, int *idx1, int *idx2){ glBegin(GL_POINTS);
glVertex2f(s.data[idx1], s.data[idx2]);
glEnd();
}
// int max1 = -1*pow(2,15); void ProjectionAxes::calcWaveformPeakIdx(int d1, int d2, int *idx1, int *idx2){
// int max2 = max1;
// for (int i=0; i<s.n_samps_per_chan ; i++){
// if (s.data[i*s.n_chans + d1] > max1)
// {
// *idx1 = i*s.n_chans + d1;
// max1 = s.data[*idx1];
// }
// if (s.data[i*s.n_chans + d2] > max2)
// {
// *idx2 = i*s.n_chans + d2;
// max2 = s.data[*idx2];
// }
// }
// }
// void ProjectionAxes::drawWaveformGrid(int thold, int gain){
// double voltRange = ylims[1] - ylims[0];
// double pixelRange = BaseUIElement::height;
// //This is a totally arbitrary value that i'll mess around with and set as a macro when I figure out a value I like
// int minPixelsPerTick = 25;
// int MAX_N_TICKS = 10;
// int nTicks = pixelRange / minPixelsPerTick;
// while(nTicks>MAX_N_TICKS){
// minPixelsPerTick += 5;
// nTicks = pixelRange / minPixelsPerTick;
// }
// int voltPerTick = (voltRange / nTicks);
// // Round to the nearest 200
int max1 = -1*pow(2,15);
int max2 = max1;
// double meanRange = voltRange/2; for (int i=0; i<s.nSamples ; i++){
// glColor3fv(gridColor); if (s.data[d1*s.nSamples + i] > max1)
{
*idx1 = d1*s.nSamples+i;
max1 = s.data[*idx1];
}
if (s.data[d2*s.nSamples+i] > max2)
{
*idx2 = d2*s.nSamples+i;
max2 = s.data[*idx2];
}
}
}
// glLineWidth(1); void ProjectionAxes::setPointColor(GLfloat r, GLfloat g, GLfloat b){
// char str[200] = {0}; pointColor[0] = r;
pointColor[1] = g;
// double tickVoltage = thold; pointColor[2] = b;
// while(tickVoltage < ylims[1] - voltPerTick/2) // Draw the ticks above the thold line }
// { void ProjectionAxes::setGridColor(GLfloat r, GLfloat g, GLfloat b){
// tickVoltage = roundUp(tickVoltage + voltPerTick, 100); gridColor[0] = r;
gridColor[1] = g;
// glBegin(GL_LINE_STRIP); gridColor[2] = b;
// glVertex2i(0, tickVoltage); }
// glVertex2i(s.n_samps_per_chan, tickVoltage);
// glEnd();
// makeLabel(tickVoltage, gain, convertLabelUnits, str);
// drawString(1, tickVoltage+voltPerTick/10, GLUT_BITMAP_8_BY_13, str);
// }
// tickVoltage = thold;
// while(tickVoltage > ylims[0] + voltPerTick) // draw the ticks below the thold line
// {
// tickVoltage = roundUp(tickVoltage - voltPerTick, 100);
// glBegin(GL_LINE_STRIP);
// glVertex2i(0, tickVoltage);
// glVertex2i(s.n_samps_per_chan, tickVoltage);
// glEnd();
// makeLabel(tickVoltage, gain, convertLabelUnits, str);
// drawString(1, tickVoltage+voltPerTick/10, GLUT_BITMAP_8_BY_13, str);
// }
// }
// void ProjectionAxes::drawProjectionGrid(int gain1, int gain2){
// return; // Disabled method, figure out how you want to implement this in the future
// double voltRange = ylims[1] - ylims[0];
// double threeQuarters = voltRange * 3.0f / 4.0f;
// double pixelRange = BaseUIElement::height;
// //This is a totally arbitrary value that i'll mess around with and set as a macro when I figure out a value I like
// int minPixelsPerTick = 50;
// int nTicks = pixelRange / minPixelsPerTick;
// int voltPerTick = (voltRange / nTicks);
// // Round to the nearest 200
// double meanRange = voltRange/2;
// glColor3fv(gridColor);
// glLineWidth(1);
// char str[100] = {0};
// makeLabel(threeQuarters, gain1, convertLabelUnits, str);
// drawString(threeQuarters, (ylims[1] - ylims[0]) / 100, GLUT_BITMAP_8_BY_13, str );
// glBegin(GL_LINE_STRIP);
// glVertex2f(threeQuarters, ylims[0]);
// glVertex2f(threeQuarters, ylims[1]);
// glEnd();
// glBegin(GL_LINE_STRIP);
// glVertex2f(ylims[0], threeQuarters);
// glVertex2f(ylims[1], threeQuarters);
// glEnd();
// makeLabel(threeQuarters, gain2, convertLabelUnits, str);
// drawString( ylims[0] + (ylims[1] - ylims[0])/25, threeQuarters, GLUT_BITMAP_8_BY_13, str );
// }
// void ProjectionAxes::setWaveformColor(GLfloat r, GLfloat g, GLfloat b){
// waveColor[0] = r;
// waveColor[1] = g;
// waveColor[2] = b;
// }
// void ProjectionAxes::setThresholdColor(GLfloat r, GLfloat g, GLfloat b){
// thresholdColor[0] = r;
// thresholdColor[1] = g;
// thresholdColor[2] = b;
// }
// void ProjectionAxes::setPointColor(GLfloat r, GLfloat g, GLfloat b){
// pointColor[0] = r;
// pointColor[1] = g;
// pointColor[2] = b;
// }
// void ProjectionAxes::setGridColor(GLfloat r, GLfloat g, GLfloat b){
// gridColor[0] = r;
// gridColor[1] = g;
// gridColor[2] = b;
// }
// void ProjectionAxes::setPosition(int x, int y, double w, double h){
// BaseUIElement::setPosition(x,y,w,h);
// resizedFlag = true;
// }
// void ProjectionAxes::clearOnNextDraw(bool b){
// BaseUIElement::clearOnNextDraw(b);
// }
\ No newline at end of file
Source/Processors/Visualization/SpikePlotting/ProjectionAxes.h
+ 40
− 54
View file @ 186c022b
// #ifndef PROJECTION_AXES_H_ #ifndef PROJECTION_AXES_H_
// #define PROJECTION_AXES_H_ #define PROJECTION_AXES_H_
// #if defined(__linux__) #if defined(__linux__)
// #include <GL/glut.h> #include <GL/glut.h>
// #else #else
// #include <GLUT/glut.h> #include <GLUT/glut.h>
// #endif #endif
// #include <stdlib.h> #include <stdlib.h>
#include "BaseUIElement.h"
// #include "../SpikeObject.h" #include "../SpikeObject.h"
// #include "BaseUIElement.h" #include "PlotUtils.h"
// #include "PlotUtils.h" #include "GenericAxes.h"
// class ProjectionAxes: public BaseUIElement{ class ProjectionAxes: public GenericAxes{
// int type;
// void plotWaveform(int c);
// void plotProjection(int p);
// double xlims[2];
// double ylims[2];
// SpikeObject s;
// GLfloat waveColor[3];
// GLfloat thresholdColor[3];
// GLfloat pointColor[3];
// GLfloat gridColor[3];
// void calcWaveformPeakIdx(int,int,int*,int*);
// bool gotFirstSpike; GLfloat pointColor[3];
// bool resizedFlag; GLfloat gridColor[3];
// void drawWaveformGrid(int thold, int gain); void drawProjectionGrid(int thold, int gain);
// void drawProjectionGrid(int gain1, int gain2); void calcWaveformPeakIdx(int, int, int*, int*);
protected:
void plot();
// public: public:
// ProjectionAxes(); ProjectionAxes();
// ProjectionAxes(int x, int y, double w, double h, int t); ProjectionAxes(int x, int y, double w, double h, int t);
// void plotData();
// void updateSpikeData(SpikeObject s);
// void setXLims(double xmin, double xmax);
// void getXLims(double *xmin, double *xmax);
// void setYLims(double ymin, double ymax);
// void getYLims(double *ymin, double *ymax);
// void setType(int type);
// int getType();
// void redraw(); void updateSpikeData(SpikeObject s);
void setPointColor(GLfloat r, GLfloat g, GLfloat b);
void setGridColor(GLfloat, GLfloat, GLfloat);
void redraw();
// void setWaveformColor(GLfloat r, GLfloat g, GLfloat b);
// void setThresholdColor(GLfloat r, GLfloat g, GLfloat b);
// void setPointColor(GLfloat r, GLfloat g, GLfloat b);
// void setGridColor(GLfloat, GLfloat, GLfloat);
// void setPosition(int,int,double,double);
// bool drawWaveformLine; bool overlay;
// bool drawWaveformPoints; bool drawGrid;
// bool overlay; bool convertLabelUnits;
// bool drawGrid;
// bool convertLabelUnits;
// void clearOnNextDraw(bool c); };
// };
#endif // PROJECTION_AXES_H_
......
Source/Processors/Visualization/SpikePlotting/StereotrodePlot.cpp
+ 8
− 7
View file @ 186c022b
...@@ -34,6 +34,7 @@ void StereotrodePlot::redraw(){ ...@@ -34,6 +34,7 @@ void StereotrodePlot::redraw(){
wAxes[0].redraw(); wAxes[0].redraw();
wAxes[1].redraw(); wAxes[1].redraw();
pAxes.redraw();
} }
// This would normally happen for collection of axes but an electrode plot doesn't have a collection instead its a single axes // This would normally happen for collection of axes but an electrode plot doesn't have a collection instead its a single axes
...@@ -41,7 +42,7 @@ void StereotrodePlot::processSpikeObject(SpikeObject s){ ...@@ -41,7 +42,7 @@ void StereotrodePlot::processSpikeObject(SpikeObject s){
//std::cout<<"ElectrdePlot::processSpikeObject()"<<std::endl; //std::cout<<"ElectrdePlot::processSpikeObject()"<<std::endl;
wAxes[0].updateSpikeData(s); wAxes[0].updateSpikeData(s);
wAxes[1].updateSpikeData(s); wAxes[1].updateSpikeData(s);
//pAxesStereotrode.updateSpikeData(s); pAxes.updateSpikeData(s);
} }
void StereotrodePlot::setTitle(char *n){ void StereotrodePlot::setTitle(char *n){
plotTitle = n; plotTitle = n;
...@@ -52,7 +53,7 @@ void StereotrodePlot::setEnabled(bool e){ ...@@ -52,7 +53,7 @@ void StereotrodePlot::setEnabled(bool e){
wAxes[0].setEnabled(e); wAxes[0].setEnabled(e);
wAxes[1].setEnabled(e); wAxes[1].setEnabled(e);
//pAxesStereotrode.setEnabled(e); pAxes.setEnabled(e);
} }
bool StereotrodePlot::getEnabled(){ bool StereotrodePlot::getEnabled(){
...@@ -72,17 +73,17 @@ void StereotrodePlot::initAxes(){ ...@@ -72,17 +73,17 @@ void StereotrodePlot::initAxes(){
wAxes[0] = WaveAxes(minX, minY, axesWidth/2, axesHeight, WAVE1); wAxes[0] = WaveAxes(minX, minY, axesWidth/2, axesHeight, WAVE1);
wAxes[1] = WaveAxes(minX + axesWidth/2, minY, axesWidth/2, axesHeight, WAVE2); wAxes[1] = WaveAxes(minX + axesWidth/2, minY, axesWidth/2, axesHeight, WAVE2);
//pAxesStereotrode = ProjectionAxes(minX + axesWidth, minY, axesWidth, axesHeight, PROJ1x2) pAxes = ProjectionAxes(minX + axesWidth, minY, axesWidth, axesHeight, PROJ1x2);
//axes.setEnabled(false); //axes.setEnabled(false);
wAxes[0].setYLims(-1*pow(2,11), pow(2,14)*1.6); wAxes[0].setYLims(-1*pow(2,11), pow(2,14)*1.6);
wAxes[1].setYLims(-1*pow(2,11), pow(2,14)*1.6); wAxes[1].setYLims(-1*pow(2,11), pow(2,14)*1.6);
////pAxesStereotrodeStereotrode.setYLims(-1*pow(2,11), pow(2,14)*1.6); pAxes.setYLims(-1*pow(2,11), pow(2,14)*1.6);
//pAxesStereotrode.setXLims(-1*pow(2,11), pow(2,14)*1.6); pAxes.setXLims(-1*pow(2,11), pow(2,14)*1.6);
wAxes[0].setWaveformColor(1.0, 1.0, 1.0); wAxes[0].setWaveformColor(1.0, 1.0, 1.0);
wAxes[1].setWaveformColor(1.0, 1.0, 1.0); wAxes[1].setWaveformColor(1.0, 1.0, 1.0);
//pAxesStereotrode.setWaveformColor(1.0, 1.0, 1.0); pAxes.setPointColor(1.0, 1.0, 1.0);
} }
...@@ -96,7 +97,7 @@ void StereotrodePlot::setPosition(int x, int y, double w, double h){ ...@@ -96,7 +97,7 @@ void StereotrodePlot::setPosition(int x, int y, double w, double h){
wAxes[0] = WaveAxes(minX, minY, axesWidth/2, axesHeight, WAVE1); wAxes[0] = WaveAxes(minX, minY, axesWidth/2, axesHeight, WAVE1);
wAxes[1] = WaveAxes(minX + axesWidth/2, minY, axesWidth/2, axesHeight, WAVE2); wAxes[1] = WaveAxes(minX + axesWidth/2, minY, axesWidth/2, axesHeight, WAVE2);
//pAxesStereotrode = ProjectionAxes(minX + axesWidth, minY, axesWidth, axesHeight, PROJ1x2) pAxes = ProjectionAxes(minX + axesWidth, minY, axesWidth, axesHeight, PROJ1x2);
titleBox.setPosition(x, y+h-titleHeight-3, w, titleHeight+3); titleBox.setPosition(x, y+h-titleHeight-3, w, titleHeight+3);
} }
......
Source/Processors/Visualization/SpikePlotting/StereotrodePlot.h
+ 1
− 1
View file @ 186c022b
...@@ -34,7 +34,7 @@ class StereotrodePlot : public BaseUIElement{ ...@@ -34,7 +34,7 @@ class StereotrodePlot : public BaseUIElement{
double limits[1][2]; double limits[1][2];
WaveAxes wAxes[2]; WaveAxes wAxes[2];
//ProjectionAxes pAxes; ProjectionAxes pAxes;
......
Source/Processors/Visualization/SpikePlotting/WaveAxes.cpp
+ 1
− 1
View file @ 186c022b
...@@ -80,7 +80,7 @@ void WaveAxes::plot(){ ...@@ -80,7 +80,7 @@ void WaveAxes::plot(){
// sample based upon which channel is getting plotted // sample based upon which channel is getting plotted
// type values are defined in PlotUtils.h // type values are defined in PlotUtils.h
int sampIdx = s.nSamples * type; // int sampIdx = s.nSamples * type; //
std::cout<<"Starting with idx:"<<sampIdx<<std::endl; //std::cout<<"Starting with idx:"<<sampIdx<<std::endl;
//Draw the individual waveform points connected with a line //Draw the individual waveform points connected with a line
glColor3fv(waveColor); glColor3fv(waveColor);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment