/*root is head or tail of meEdge being split, depending on direction toward
v*/
void updatePair(double **A, meEdge *nearEdge, meEdge *farEdge, meNode *v,
meNode *root, double dcoeff, int direction)
{
meEdge *sib;
switch(direction) /*the various cases refer to where the new vertex has
been inserted, in relation to the meEdge nearEdge*/
{
case UP: /*this case is called when v has been inserted above
or skew to farEdge*/
/*do recursive calls first!*/
if (NULL != farEdge->head->leftEdge)
updatePair(A,nearEdge,farEdge->head->leftEdge,v,root,dcoeff,UP);
if (NULL != farEdge->head->rightEdge)
updatePair(A,nearEdge,farEdge->head->rightEdge,v,root,dcoeff,UP);
A[farEdge->head->index][nearEdge->head->index] =
A[nearEdge->head->index][farEdge->head->index]
= A[farEdge->head->index][nearEdge->head->index]
+ dcoeff*A[farEdge->head->index][v->index]
- dcoeff*A[farEdge->head->index][root->index];
break;
case DOWN: /*called when v has been inserted below farEdge*/
if (NULL != farEdge->tail->parentEdge)
updatePair(A,nearEdge,farEdge->tail->parentEdge,v,root,dcoeff,DOWN);
sib = siblingEdge(farEdge);
if (NULL != sib)
updatePair(A,nearEdge,sib,v,root,dcoeff,UP);
A[farEdge->head->index][nearEdge->head->index] =
A[nearEdge->head->index][farEdge->head->index]
= A[farEdge->head->index][nearEdge->head->index]
+ dcoeff*A[v->index][farEdge->head->index]
- dcoeff*A[farEdge->head->index][root->index];
}
}
void BMEupdateAveragesMatrix(double **A, meEdge *e, meNode *v,meNode *newNode)
{
meEdge *sib, *par, *left, *right;
/*first, update the v,newNode entries*/
A[newNode->index][newNode->index] = 0.5*(A[e->head->index][e->head->index]
+ A[v->index][e->head->index]);
A[v->index][newNode->index] = A[newNode->index][v->index] =
A[v->index][e->head->index];
A[v->index][v->index] =
0.5*(A[e->head->index][v->index] + A[v->index][e->head->index]);
left = e->head->leftEdge;
right = e->head->rightEdge;
if (NULL != left)
updateSubTree(A,left,v,e->head,newNode,0.25,UP); /*updates left and below*/
if (NULL != right)
updateSubTree(A,right,v,e->head,newNode,0.25,UP); /*updates right and below*/
sib = siblingEdge(e);
if (NULL != sib)
updateSubTree(A,sib,v,e->head,newNode,0.25,SKEW); /*updates sib and below*/
par = e->tail->parentEdge;
if (NULL != par)
updateSubTree(A,par,v,e->head,newNode,0.25,DOWN); /*updates par and above*/
/*must change values A[e->head][*] last, as they are used to update
the rest of the matrix*/
A[newNode->index][e->head->index] = A[e->head->index][newNode->index]
= A[e->head->index][e->head->index];
A[v->index][e->head->index] = A[e->head->index][v->index];
updatePair(A,e,e,v,e->head,0.5,UP); /*updates e->head fields only*/
}
void PairList::initializePairs(LatticeList &ll, std::vector<std::string> &subelements, double &cutOff)
{
ll.calculate_lookup_table();
std::cout<<"elements size:"<<subelements.size()<<std::endl;
std::cout<<"number of sites "<< ll.getNbrOfSites()<<std::endl;
for(int k=0;k<subelements.size(); k++)
{
std::cout<<subelements[k]<<std::endl;
}
double dr;
bool addPairWhileUpdating=true;
Pair tempPair=Pair();
std::vector<double> dist;
dist.resize(1);
std::vector<std::vector< std::string> > all_element_combinations;
std::vector<double> dists;
for(int i=0; i < ll.get_original_atoms_count(); i++)
{
if(!(isAtomInSubElements(ll.getSite(i),subelements)))
{
continue;
}
for(int j=i+1; j<ll.getNbrOfSites(); j++)
{
if(!(isAtomInSubElements(ll.getSite(j),subelements)))
{
continue;
}
//dr=ll.getDistance(i,j);
dr=ll.fast_distance(i,j);
if(dr>cutOff)
{
continue;
}
//dists=ll.getPeriodicDistance(i,j,cutOff);
dist[0]=dr;
all_element_combinations = symmetric_cluster_function(dist,subelements);
// std::cout<<"d= "<<d<< " distance= "<<dists[d]<<std::endl;
// dist[0]=dists[d];
tempPair.setDistance(dist[0]);
tempPair.setCount(1);
for(int k=0; k<all_element_combinations.size(); k++)
{
tempPair.setSite1(all_element_combinations[k][0]);
tempPair.setSite2(all_element_combinations[k][1]);
updatePair(tempPair,addPairWhileUpdating);
}
}//end for j loop
}//end i loop
sortPairs();
}
/*Idea is: we are looking at the subtree rooted at rootEdge. The subtree
rooted at closer is closer to rootEdge after the NNI, while the subtree
rooted at further is further to rootEdge after the NNI. direction tells
the direction of the NNI with respect to rootEdge*/
void updateSubTreeAfterNNI(double **A, meNode *v, meEdge *rootEdge, meNode *closer, meNode *further,
double dcoeff, int direction)
{
meEdge *sib;
switch(direction)
{
case UP: /*rootEdge is below the center edge of the NNI*/
/*recursive calls to subtrees, if necessary*/
if (NULL != rootEdge->head->leftEdge)
updateSubTreeAfterNNI(A, v, rootEdge->head->leftEdge, closer, further, 0.5*dcoeff,UP);
if (NULL != rootEdge->head->rightEdge)
updateSubTreeAfterNNI(A, v, rootEdge->head->rightEdge, closer, further, 0.5*dcoeff,UP);
updatePair(A, rootEdge, rootEdge, closer, further, dcoeff, UP);
sib = siblingEdge(v->parentEdge);
A[rootEdge->head->index][v->index] =
A[v->index][rootEdge->head->index] =
0.5*A[rootEdge->head->index][sib->head->index] +
0.5*A[rootEdge->head->index][v->parentEdge->tail->index];
break;
case DOWN: /*rootEdge is above the center edge of the NNI*/
sib = siblingEdge(rootEdge);
if (NULL != sib)
updateSubTreeAfterNNI(A, v, sib, closer, further, 0.5*dcoeff, SKEW);
if (NULL != rootEdge->tail->parentEdge)
updateSubTreeAfterNNI(A, v, rootEdge->tail->parentEdge, closer, further, 0.5*dcoeff, DOWN);
updatePair(A, rootEdge, rootEdge, closer, further, dcoeff, DOWN);
A[rootEdge->head->index][v->index] =
A[v->index][rootEdge->head->index] =
0.5*A[rootEdge->head->index][v->leftEdge->head->index] +
0.5*A[rootEdge->head->index][v->rightEdge->head->index];
break;
case SKEW: /*rootEdge is in subtree skew to v*/
if (NULL != rootEdge->head->leftEdge)
updateSubTreeAfterNNI(A, v, rootEdge->head->leftEdge, closer, further, 0.5*dcoeff,SKEW);
if (NULL != rootEdge->head->rightEdge)
updateSubTreeAfterNNI(A, v, rootEdge->head->rightEdge, closer, further, 0.5*dcoeff,SKEW);
updatePair(A, rootEdge, rootEdge, closer, further, dcoeff, UP);
A[rootEdge->head->index][v->index] =
A[v->index][rootEdge->head->index] =
0.5*A[rootEdge->head->index][v->leftEdge->head->index] +
0.5*A[rootEdge->head->index][v->rightEdge->head->index];
break;
}
}
void updateSubTree(double **A, meEdge *nearEdge, meNode *v, meNode *root,
meNode *newNode, double dcoeff, int direction)
{
meEdge *sib;
switch(direction)
{
case UP: /*newNode is above the meEdge nearEdge*/
A[v->index][nearEdge->head->index] = A[nearEdge->head->index][v->index];
A[newNode->index][nearEdge->head->index] =
A[nearEdge->head->index][newNode->index] =
A[nearEdge->head->index][root->index];
if (NULL != nearEdge->head->leftEdge)
updateSubTree(A, nearEdge->head->leftEdge, v, root, newNode, 0.5*dcoeff, UP);
if (NULL != nearEdge->head->rightEdge)
updateSubTree(A, nearEdge->head->rightEdge, v, root, newNode, 0.5*dcoeff, UP);
updatePair(A, nearEdge, nearEdge, v, root, dcoeff, UP);
break;
case DOWN: /*newNode is below the meEdge nearEdge*/
A[nearEdge->head->index][v->index] = A[v->index][nearEdge->head->index];
A[newNode->index][nearEdge->head->index] =
A[nearEdge->head->index][newNode->index] =
0.5*(A[nearEdge->head->index][root->index]
+ A[v->index][nearEdge->head->index]);
sib = siblingEdge(nearEdge);
if (NULL != sib)
updateSubTree(A, sib, v, root, newNode, 0.5*dcoeff, SKEW);
if (NULL != nearEdge->tail->parentEdge)
updateSubTree(A, nearEdge->tail->parentEdge, v, root, newNode, 0.5*dcoeff, DOWN);
updatePair(A, nearEdge, nearEdge, v, root, dcoeff, DOWN);
break;
case SKEW: /*newNode is neither above nor below nearEdge*/
A[v->index][nearEdge->head->index] = A[nearEdge->head->index][v->index];
A[newNode->index][nearEdge->head->index] =
A[nearEdge->head->index][newNode->index] =
0.5*(A[nearEdge->head->index][root->index] +
A[nearEdge->head->index][v->index]);
if (NULL != nearEdge->head->leftEdge)
updateSubTree(A, nearEdge->head->leftEdge, v, root, newNode, 0.5*dcoeff,SKEW);
if (NULL != nearEdge->head->rightEdge)
updateSubTree(A, nearEdge->head->rightEdge, v, root, newNode, 0.5*dcoeff,SKEW);
updatePair(A, nearEdge, nearEdge, v, root, dcoeff, UP);
}
}
//--------------------------------------------------------------
void ofApp::update() {
//display frame rate as window title
ofSetWindowTitle(ofToString(ofGetFrameRate()));
//animation frameNumUpdate
if(isAnimating) {
frameCounter++;
//end recording and animation at 15"
if (frameCounter>=framesMaxNumber) {
stopAnimation();
renderer.stopRecording();
}
}
//receiveOsc----------------
if(gReceiveOSC) {
//receiveOsc();
updateOscFromDataFile(frameCounter);
} else {
}
//check trigger onset---------------------
if(oscOnset && isAnimating) {
if(frameCounter-lastFrameWithOnset > 10) {
isReallyOnset = true;
triggerOnset();
lastFrameWithOnset = frameCounter;
}
} else {
isReallyOnset=false;
}
//update graphics--------------------------------
updateInstanced();
updatePair();
//update post-processing------------------------
postManager.updateValues();
//light pos
light.setPosition(gLightPos->x * fw,
gLightPos->y * 0.8*fw,
0.05 * 0.8*fw );
///-------------------------------
//-----------------------------------
int rw = renderer.getFboWidth();
int rh = renderer.getFboHeight();
///draw openGL scene in drawFbo------------------
drawFboInstanced();
drawFboParticles();
drawFboSphere();
drawFboMain();
drawFboPost();
///-------------------------------
fisheyeAmount = 0.6;
renderer.getFbo()->begin();
ofClear(0);
fisheye.begin(fboPost.getTexture(), rw, rh, fisheyeAmount);///which fbo to render
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex3f(0, 0, 0);
glTexCoord2f(rw, 0);
glVertex3f(rw, 0, 0);
glTexCoord2f(rw, rh);
glVertex3f(rw, rh, 0);
glTexCoord2f(0,rh);
glVertex3f(0, rh, 0);
glEnd();
fisheye.end();
renderer.getFbo()->end();
//Record Renderer's FBO into a .mov file or png sequence
renderer.update();
}
int main(int argc, char **argv) {
printf(" \n");
printf("------------------------------\n");
printf(" \n");
int i = 0;
printf("initial value = %d\n", i);
update(&i);
printf("final value = %d\n", i);
printf(" \n");
printf("------------------------------\n");
printf(" \n");
PAIR pair = { 0, 0 };
printf("initial pair value = { %d, %d }\n", pair.x, pair.y);
updatePair(&pair);
printf("final pair value = { %d, %d }\n", pair.x, pair.y);
printf(" \n");
printf("------------------------------\n");
printf(" \n");
int aInt[5];
memset(&aInt, 0, sizeof(aInt));
printf("initial 1st element of array = %d\n", aInt[0]);
printf("initial 5th element of array = %d\n", aInt[4]);
updateArray(aInt); // aInt is of type int *, therefore I should pass aInt itself, not the reference
printf("final 1st element of array = %d\n", aInt[0]);
printf("final 5th element of array = %d\n", aInt[4]);
printf(" \n");
printf("------------------------------\n");
printf(" \n");
char *str = "initial string";
printf("initial str = %s\n", str);
updateString(&str);
printf("final str = %s\n", str);
printf(" \n");
printf("------------------------------\n");
printf(" \n");
int nbrPairs = 5;
PAIR aPairs[nbrPairs];
memset(&aPairs, 0, sizeof(aPairs));
printf("aPairs[1].x = %d\n", aPairs[1].x);
updateArrOfStructs(aPairs);
printf("aPairs[1].x = %d\n", aPairs[1].x);
printf(" \n");
printf("------------------------------\n");
printf(" \n");
int *aEntries, numEntries = 0;
updateDynamicArray(&aEntries, &numEntries);
if (numEntries != 0) {
printf("got %d entries\n", numEntries);
int j;
for (j = 0; j < numEntries; j++)
printf("aEntries[%d] = %d\n", j, aEntries[j]);
}
exit(EXIT_SUCCESS);
}
