MNE-CPP  0.1.9
A Framework for Electrophysiology
network.cpp
Go to the documentation of this file.
1 //=============================================================================================================
36 //=============================================================================================================
37 // INCLUDES
38 //=============================================================================================================
39 
40 #include "network.h"
41 
42 #include "networkedge.h"
43 #include "networknode.h"
44 
45 #include <utils/spectral.h>
46 
47 #include <limits>
48 
49 //=============================================================================================================
50 // QT INCLUDES
51 //=============================================================================================================
52 
53 #include <QDebug>
54 
55 //=============================================================================================================
56 // EIGEN INCLUDES
57 //=============================================================================================================
58 
59 //=============================================================================================================
60 // USED NAMESPACES
61 //=============================================================================================================
62 
63 using namespace CONNECTIVITYLIB;
64 using namespace Eigen;
65 using namespace UTILSLIB;
66 
67 //=============================================================================================================
68 // DEFINE GLOBAL METHODS
69 //=============================================================================================================
70 
71 //=============================================================================================================
72 // DEFINE MEMBER METHODS
73 //=============================================================================================================
74 
75 Network::Network(const QString& sConnectivityMethod,
76  double dThreshold)
77 : m_sConnectivityMethod(sConnectivityMethod)
78 , m_minMaxFullWeights(QPair<double,double>(std::numeric_limits<double>::max(),0.0))
79 , m_minMaxThresholdedWeights(QPair<double,double>(std::numeric_limits<double>::max(),0.0))
80 , m_dThreshold(dThreshold)
81 , m_fSFreq(0.0f)
82 , m_iFFTSize(128)
83 , m_iNumberFreqBins(0)
84 {
85  qRegisterMetaType<CONNECTIVITYLIB::Network>("CONNECTIVITYLIB::Network");
86  qRegisterMetaType<CONNECTIVITYLIB::Network::SPtr>("CONNECTIVITYLIB::Network::SPtr");
87  qRegisterMetaType<QList<CONNECTIVITYLIB::Network> >("QList<CONNECTIVITYLIB::Network>");
88  qRegisterMetaType<QList<CONNECTIVITYLIB::Network::SPtr> >("QList<CONNECTIVITYLIB::Network::SPtr>");
89 }
90 
91 //=============================================================================================================
92 
93 MatrixXd Network::getFullConnectivityMatrix(bool bGetMirroredVersion) const
94 {
95  MatrixXd matDist(m_lNodes.size(), m_lNodes.size());
96  matDist.setZero();
97 
98  for(int i = 0; i < m_lFullEdges.size(); ++i) {
99  int row = m_lFullEdges.at(i)->getStartNodeID();
100  int col = m_lFullEdges.at(i)->getEndNodeID();
101 
102  if(row < matDist.rows() && col < matDist.cols()) {
103  matDist(row,col) = m_lFullEdges.at(i)->getWeight();
104 
105  if(bGetMirroredVersion) {
106  matDist(col,row) = m_lFullEdges.at(i)->getWeight();
107  }
108  }
109  }
110 
111  //IOUtils::write_eigen_matrix(matDist,"eigen.txt");
112  return matDist;
113 }
114 
115 //=============================================================================================================
116 
117 MatrixXd Network::getThresholdedConnectivityMatrix(bool bGetMirroredVersion) const
118 {
119  MatrixXd matDist(m_lNodes.size(), m_lNodes.size());
120  matDist.setZero();
121 
122  for(int i = 0; i < m_lThresholdedEdges.size(); ++i) {
123  int row = m_lThresholdedEdges.at(i)->getStartNodeID();
124  int col = m_lThresholdedEdges.at(i)->getEndNodeID();
125 
126  if(row < matDist.rows() && col < matDist.cols()) {
127  matDist(row,col) = m_lThresholdedEdges.at(i)->getWeight();
128 
129  if(bGetMirroredVersion) {
130  matDist(col,row) = m_lThresholdedEdges.at(i)->getWeight();
131  }
132  }
133  }
134 
135  //IOUtils::write_eigen_matrix(matDist,"eigen.txt");
136  return matDist;
137 }
138 
139 //=============================================================================================================
140 
141 const QList<NetworkEdge::SPtr>& Network::getFullEdges() const
142 {
143  return m_lFullEdges;
144 }
145 
146 //=============================================================================================================
147 
148 const QList<NetworkEdge::SPtr>& Network::getThresholdedEdges() const
149 {
150  return m_lThresholdedEdges;
151 }
152 
153 //=============================================================================================================
154 
155 const QList<NetworkNode::SPtr>& Network::getNodes() const
156 {
157  return m_lNodes;
158 }
159 
160 //=============================================================================================================
161 
163 {
164  return m_lNodes.at(i);
165 }
166 
167 //=============================================================================================================
168 
170 {
171  qint16 distribution = 0;
172 
173  for(int i = 0; i < m_lNodes.size(); ++i) {
174  distribution += m_lNodes.at(i)->getFullDegree();
175  }
176 
177  return distribution;
178 }
179 
180 //=============================================================================================================
181 
183 {
184  qint16 distribution = 0;
185 
186  for(int i = 0; i < m_lNodes.size(); ++i) {
187  distribution += m_lNodes.at(i)->getThresholdedDegree();
188  }
189 
190  return distribution;
191 }
192 
193 //=============================================================================================================
194 
195 void Network::setConnectivityMethod(const QString& sConnectivityMethod)
196 {
197  m_sConnectivityMethod = sConnectivityMethod;
198 }
199 
200 //=============================================================================================================
201 
203 {
204  return m_sConnectivityMethod;
205 }
206 
207 //=============================================================================================================
208 
209 QPair<double, double> Network::getMinMaxFullWeights() const
210 {
211  return m_minMaxFullWeights;
212 }
213 
214 //=============================================================================================================
215 
216 QPair<double, double> Network::getMinMaxThresholdedWeights() const
217 {
219 }
220 
221 //=============================================================================================================
222 
223 QPair<int,int> Network::getMinMaxFullDegrees() const
224 {
225  int maxDegree = 0;
226  int minDegree = 1000000;
227 
228  for(int i = 0; i < m_lNodes.size(); ++i) {
229  if(m_lNodes.at(i)->getFullDegree() > maxDegree){
230  maxDegree = m_lNodes.at(i)->getFullDegree();
231  } else if (m_lNodes.at(i)->getFullDegree() < minDegree){
232  minDegree = m_lNodes.at(i)->getFullDegree();
233  }
234  }
235 
236  return QPair<int,int>(minDegree,maxDegree);
237 }
238 
239 //=============================================================================================================
240 
242 {
243  int maxDegree = 0;
244  int minDegree = 1000000;
245 
246  for(int i = 0; i < m_lNodes.size(); ++i) {
247  if(m_lNodes.at(i)->getThresholdedDegree() > maxDegree){
248  maxDegree = m_lNodes.at(i)->getThresholdedDegree();
249  } else if (m_lNodes.at(i)->getThresholdedDegree() < minDegree){
250  minDegree = m_lNodes.at(i)->getThresholdedDegree();
251  }
252  }
253 
254  return QPair<int,int>(minDegree,maxDegree);
255 }
256 
257 //=============================================================================================================
258 
259 QPair<int,int> Network::getMinMaxFullIndegrees() const
260 {
261  int maxDegree = 0;
262  int minDegree = 1000000;
263 
264  for(int i = 0; i < m_lNodes.size(); ++i) {
265  if(m_lNodes.at(i)->getFullIndegree() > maxDegree){
266  maxDegree = m_lNodes.at(i)->getFullIndegree();
267  } else if (m_lNodes.at(i)->getFullIndegree() < minDegree){
268  minDegree = m_lNodes.at(i)->getFullIndegree();
269  }
270  }
271 
272  return QPair<int,int>(minDegree,maxDegree);
273 }
274 
275 //=============================================================================================================
276 
278 {
279  int maxDegree = 0;
280  int minDegree = 1000000;
281 
282  for(int i = 0; i < m_lNodes.size(); ++i) {
283  if(m_lNodes.at(i)->getThresholdedIndegree() > maxDegree){
284  maxDegree = m_lNodes.at(i)->getThresholdedIndegree();
285  } else if (m_lNodes.at(i)->getThresholdedIndegree() < minDegree){
286  minDegree = m_lNodes.at(i)->getThresholdedIndegree();
287  }
288  }
289 
290  return QPair<int,int>(minDegree,maxDegree);
291 }
292 
293 //=============================================================================================================
294 
295 QPair<int,int> Network::getMinMaxFullOutdegrees() const
296 {
297  int maxDegree = 0;
298  int minDegree = 1000000;
299 
300  for(int i = 0; i < m_lNodes.size(); ++i) {
301  if(m_lNodes.at(i)->getFullOutdegree() > maxDegree){
302  maxDegree = m_lNodes.at(i)->getFullOutdegree();
303  } else if (m_lNodes.at(i)->getFullOutdegree() < minDegree){
304  minDegree = m_lNodes.at(i)->getFullOutdegree();
305  }
306  }
307 
308  return QPair<int,int>(minDegree,maxDegree);
309 }
310 
311 //=============================================================================================================
312 
314 {
315  int maxDegree = 0;
316  int minDegree = 1000000;
317 
318  for(int i = 0; i < m_lNodes.size(); ++i) {
319  if(m_lNodes.at(i)->getThresholdedOutdegree() > maxDegree){
320  maxDegree = m_lNodes.at(i)->getThresholdedOutdegree();
321  } else if (m_lNodes.at(i)->getThresholdedOutdegree() < minDegree){
322  minDegree = m_lNodes.at(i)->getThresholdedOutdegree();
323  }
324  }
325 
326  return QPair<int,int>(minDegree,maxDegree);
327 }
328 
329 //=============================================================================================================
330 
331 void Network::setThreshold(double dThreshold)
332 {
333  m_dThreshold = dThreshold;
334  m_lThresholdedEdges.clear();
335 
336  for(int i = 0; i < m_lFullEdges.size(); ++i) {
337  if(fabs(m_lFullEdges.at(i)->getWeight()) >= m_dThreshold) {
338  m_lFullEdges.at(i)->setActive(true);
339  m_lThresholdedEdges.append(m_lFullEdges.at(i));
340  } else {
341  m_lFullEdges.at(i)->setActive(false);
342  }
343  }
344 
347 }
348 
349 //=============================================================================================================
350 
352 {
353  return m_dThreshold;
354 }
355 
356 //=============================================================================================================
357 
358 void Network::setFrequencyRange(float fLowerFreq, float fUpperFreq)
359 {
360  if(fLowerFreq > fUpperFreq || fUpperFreq < fLowerFreq) {
361  qDebug() << "Network::setFrequencyRange - Upper and lower frequency are out of range from each other. Weights will not be recalculated. Returning.";
362  return;
363  }
364 
365  if(m_fSFreq <= 0.0f) {
366  qDebug() << "Network::setFrequencyRange - Sampling frequency has not been set. Returning.";
367  return;
368  }
369 
370  if(fUpperFreq > m_fSFreq/2.0f) {
371  qDebug() << "Network::setFrequencyRange - Upper frequency is bigger than nyquist frequency. Returning.";
372  return;
373  }
374 
375  if(m_iNumberFreqBins <= 0) {
376  qDebug() << "Network::setFrequencyRange - Number of samples has not been set. Returning.";
377  return;
378  }
379 
380  double dScaleFactor = m_iFFTSize/(m_fSFreq/2);
381 
382  m_minMaxFrequency.first = fLowerFreq;
383  m_minMaxFrequency.second = fUpperFreq;
384 
385  int iLowerBin = fLowerFreq * dScaleFactor;
386  int iUpperBin = fUpperFreq * dScaleFactor;
387 
388  // Update the min max values
389  m_minMaxFullWeights = QPair<double,double>(std::numeric_limits<double>::max(),0.0);
390 
391  for(int i = 0; i < m_lFullEdges.size(); ++i) {
392  m_lFullEdges.at(i)->setFrequencyBins(QPair<int,int>(iLowerBin,iUpperBin));
393 
394  if(fabs(m_lFullEdges.at(i)->getWeight()) < m_minMaxFullWeights.first) {
395  m_minMaxFullWeights.first = fabs(m_lFullEdges.at(i)->getWeight());
396  } else if(fabs(m_lFullEdges.at(i)->getWeight()) > m_minMaxFullWeights.second) {
397  m_minMaxFullWeights.second = fabs(m_lFullEdges.at(i)->getWeight());
398  }
399  }
400 }
401 
402 //=============================================================================================================
403 
404 const QPair<float,float>& Network::getFrequencyRange() const
405 {
406  return m_minMaxFrequency;
407 }
408 
409 //=============================================================================================================
410 
412 {
413  if(newEdge->getEndNodeID() != newEdge->getStartNodeID()) {
414  double dEdgeWeight = newEdge->getWeight();
415  if(dEdgeWeight < m_minMaxFullWeights.first) {
416  m_minMaxFullWeights.first = dEdgeWeight;
417  } else if(dEdgeWeight >= m_minMaxFullWeights.second) {
418  m_minMaxFullWeights.second = dEdgeWeight;
419  }
420 
421  m_lFullEdges << newEdge;
422 
423  if(fabs(newEdge->getWeight()) >= m_dThreshold) {
424  m_lThresholdedEdges << newEdge;
425  }
426  }
427 }
428 
429 //=============================================================================================================
430 
432 {
433  m_lNodes << newNode;
434 }
435 
436 //=============================================================================================================
437 
438 bool Network::isEmpty() const
439 {
440  if(m_lFullEdges.isEmpty() || m_lNodes.isEmpty()) {
441  return true;
442  }
443 
444  return false;
445 }
446 
447 //=============================================================================================================
448 
450 {
451  // Normalize full network
452  if(m_minMaxFullWeights.second == 0.0) {
453  qDebug() << "Network::normalize() - Max weight is 0. Returning.";
454  return;
455  }
456 
457  for(int i = 0; i < m_lFullEdges.size(); ++i) {
458  m_lFullEdges.at(i)->setWeight(m_lFullEdges.at(i)->getWeight()/m_minMaxFullWeights.second);
459  }
460 
462  m_minMaxFullWeights.second = 1.0;
463 
465  m_minMaxThresholdedWeights.second = 1.0;
466 }
467 
468 //=============================================================================================================
469 
471 {
472  return m_visualizationInfo;
473 }
474 
475 //=============================================================================================================
476 
477 void Network::setVisualizationInfo(const VisualizationInfo& visualizationInfo)
478 {
479  m_visualizationInfo = visualizationInfo;
480 }
481 
482 //=============================================================================================================
483 
485 {
486  return m_fSFreq;
487 }
488 
489 //=============================================================================================================
490 
492 {
493  m_fSFreq = fSFreq;
494 }
495 
496 //=============================================================================================================
497 
499 {
500  return m_iNumberFreqBins;
501 }
502 
503 //=============================================================================================================
504 
505 void Network::setUsedFreqBins(int iNumberFreqBins)
506 {
507  m_iNumberFreqBins = iNumberFreqBins;
508 }
509 
510 //=============================================================================================================
511 
512 void Network::setFFTSize(int iFFTSize)
513 {
514  m_iFFTSize = iFFTSize;
515 }
516 
517 //=============================================================================================================
518 
520 {
521  return m_iFFTSize;
522 }
523 
void setFrequencyRange(float fLowerFreq, float fUpperFreq)
Definition: network.cpp:358
QPair< int, int > getMinMaxFullDegrees() const
Definition: network.cpp:223
void setConnectivityMethod(const QString &sConnectivityMethod)
Definition: network.cpp:195
Eigen::MatrixXd getThresholdedConnectivityMatrix(bool bGetMirroredVersion=true) const
Definition: network.cpp:117
QList< QSharedPointer< NetworkEdge > > m_lFullEdges
Definition: network.h:396
void append(QSharedPointer< NetworkEdge > newEdge)
Definition: network.cpp:411
QPair< double, double > getMinMaxFullWeights() const
Definition: network.cpp:209
const QList< QSharedPointer< NetworkNode > > & getNodes() const
Definition: network.cpp:155
QPair< double, double > getMinMaxThresholdedWeights() const
Definition: network.cpp:216
void setSamplingFrequency(float fSFreq)
Definition: network.cpp:491
void setThreshold(double dThreshold=0.0)
Definition: network.cpp:331
Eigen::MatrixXd getFullConnectivityMatrix(bool bGetMirroredVersion=true) const
Definition: network.cpp:93
QList< QSharedPointer< NetworkNode > > m_lNodes
Definition: network.h:399
NetworkEdge class declaration.
VisualizationInfo m_visualizationInfo
Definition: network.h:414
QSharedPointer< NetworkNode > SPtr
Definition: networknode.h:85
qint16 getFullDistribution() const
Definition: network.cpp:169
Network(const QString &sConnectivityMethod="Unknown", double dThreshold=0.0)
Definition: network.cpp:75
const QList< QSharedPointer< NetworkEdge > > & getFullEdges() const
Definition: network.cpp:141
float getSamplingFrequency() const
Definition: network.cpp:484
void setUsedFreqBins(int iNumberFreqBins)
Definition: network.cpp:505
Declaration of Spectral class.
void setFFTSize(int iFFTSize)
Definition: network.cpp:512
QSharedPointer< NetworkEdge > SPtr
Definition: networkedge.h:83
qint16 getThresholdedDistribution() const
Definition: network.cpp:182
NetworkNode class declaration.
QPair< float, float > m_minMaxFrequency
Definition: network.h:407
QString getConnectivityMethod() const
Definition: network.cpp:202
Network class declaration.
QSharedPointer< NetworkNode > getNodeAt(int i)
Definition: network.cpp:162
QString m_sConnectivityMethod
Definition: network.h:403
bool isEmpty() const
Definition: network.cpp:438
const QList< QSharedPointer< NetworkEdge > > & getThresholdedEdges() const
Definition: network.cpp:148
void setVisualizationInfo(const VisualizationInfo &visualizationInfo)
Definition: network.cpp:477
QPair< double, double > m_minMaxFullWeights
Definition: network.h:405
QPair< double, double > m_minMaxThresholdedWeights
Definition: network.h:406
VisualizationInfo getVisualizationInfo() const
Definition: network.cpp:470
const QPair< float, float > & getFrequencyRange() const
Definition: network.cpp:404
QPair< int, int > getMinMaxThresholdedDegrees() const
Definition: network.cpp:241
QList< QSharedPointer< NetworkEdge > > m_lThresholdedEdges
Definition: network.h:397
QPair< int, int > getMinMaxThresholdedOutdegrees() const
Definition: network.cpp:313
QPair< int, int > getMinMaxFullOutdegrees() const
Definition: network.cpp:295
int getUsedFreqBins() const
Definition: network.cpp:498
QPair< int, int > getMinMaxFullIndegrees() const
Definition: network.cpp:259
Definition: event.h:282
QPair< int, int > getMinMaxThresholdedIndegrees() const
Definition: network.cpp:277