{

if(useUserSolver)

userSolver->reset();

else

solver->reset();

emitters.clear();

{

solver = new FluidSolver(GRID_SIZE, 0.1f, 0.00f, 0.0f);

kinect = new KinectController();

userSolver = new FluidSolverMultiUser(kinect->getMaxUsers(), GRID_SIZE,0.1f, 0.00f, 0.0f);

emitters.reserve(MAX_EMITTERS);

for(int i = 0; i < MAX_EMITTERS; i++)

{

Emitter newEmit = {Point(0, 0), Point2f(0, 0), 1, 2, 1, 0};

emitters.push_back(newEmit);

}

N = GRID_SIZE;

flow = Mat::zeros(N, N, CV_32FC2);

useFlow = true;

#if DEBUG

namedWindow("Users",1);

namedWindow("flow", 1);

#endif

return ( 1 );

{

if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE))

glutLeaveGameMode();

exit(0);

{

int x, y;

bool noButtonsPressed = !mouseDown[0] && !mouseDown[2] && !mouseDown[1];

if (noButtonsPressed) return;

// determine mouse position on the fluid grid by divide screenspace by N gridspaces

x = (int)(( mx / (float)winX) * N + 1);

y = (int)(((winY - my) / (float)winY) * N + 1);

bool isMouseOutsideFluidGrid = (x < 1) || (x > N) || (y < 1) || (y > N);

if (isMouseOutsideFluidGrid) return;

if (mouseDown[0]) { //left mouse button

flSolver->addHorzVelocityAt(x, y, force * (mx - omx));

flSolver->addVertVelocityAt(x, y, force * (omy - my));

}

if (mouseDown[1]) // middle mouse button

flSolver->setBoundAt(x, y, true);

if (mouseDown[2]) // right mouse button

if(useUserSolver)

userSolver->addDensityAt(1, x, y, source);

else

flSolver->addDensityAt(x, y, source);

omx = mx;

omy = my;

return;

{

Mat smallUsersMatrix = Mat::zeros(N, N, CV_8UC1);

Mat smallDepthMatrix = Mat::zeros(N, N, CV_8UC1);

// depth tracking

kinect->update();

depthMatrix = kinect->getDepthMat();

if(depthMatrix.empty())

{

cout<<"ERROR: Cannot load depth frame"<<endl;

return -1;

}

// Process depthImage, resize to simulation size.

resize(depthMatrix, smallDepthMatrix, smallDepthMatrix.size(), 0, 0, INTER_CUBIC);

depthImage = smallDepthMatrix;

// Copy filtered depthImage for optical flow to use.

smallDepthMatrix.copyTo(currFlowImg);

if(useUserSolver)

{

// Process UserID matrix.

usersMatrix = kinect->getUsersMat();

resize(usersMatrix, smallUsersMatrix, smallUsersMatrix.size(), 0, 0, INTER_CUBIC);

}

return 0;

{

for( int y = 0; y < img.rows; y++ )

for( int x = 0; x < img.cols; x++ )

{

uchar &pixelVal = img.at<uchar>(y, x);

//add + 1 to coordinates because fluid matrix indicies range from 1 - N

if( pixelVal > 0)

flSolver->setBoundAt(x, y, true);

else

flSolver->setBoundAt(x, y, false);

}

double, const Scalar& color)

{

for(int y = 0; y < cflowmap.rows; y += step)

for(int x = 0; x < cflowmap.cols; x += step)

{

const Point2f& fxy = flow.at<Point2f>(y, x);

line(cflowmap, Point(x,y), Point(cvRound(x+fxy.x), cvRound(y+fxy.y)), color);

circle(cflowmap, Point(x,y), 2, color, -1);

}

{

if(prevFlowImg.data)

{

#if USE_GPU

GpuMat d_frameL(prevFlowImg), d_frameR(currFlowImg);

GpuMat d_flowx, d_flowy;

FarnebackOpticalFlow calcFlowFB;

Mat flowx, flowy;

calcFlowFB(d_frameL, d_frameR, d_flowx, d_flowy);

d_flowx.download(flowx);

d_flowy.download(flowy);

Mat planes[] = {flowx, flowy};

planes->copyTo(flow);

#else

calcOpticalFlowFarneback(prevFlowImg, currFlowImg, flow, 0.5, 3, 15, 3, 5, 1.2, 0);

#endif

for(int y = 1; y < N; y++)

{ for(int x = 1; x < N; x++)

{

const Point2f& fxy = flow.at<Point2f>(y, x);

flSolver->addHorzVelocityAt(x, y, FLOW_SCALE * fxy.x);

flSolver->addVertVelocityAt(x, y, FLOW_SCALE * fxy.y);

}

}

}

#if DEBUG

cvtColor(prevFlowImg, cflow, CV_GRAY2BGR);

drawOptFlowMap(flow, cflow, 16, 1.5, CV_RGB(0, 255, 0));

imshow("flow", cflow);

#endif

std::swap(prevFlowImg, currFlowImg);

{

//TODO: convert emitters to fixed array. Bug being caught in loop right now.

int i = 0;

while (i < e.size())

{

bool emitterHasExpired = (e[i].lifespan - e[i].lifeElapsed == 0);

if(emitterHasExpired)

e.erase(e.begin() + i);

else

{

Point lowerCoord, upperCoord;

//calculate scalar for temporal falloff overlifespan

float lifescalar = (e[i].lifespan - e[i].lifeElapsed) / e[i].lifespan;

//prevent radius from referencing cells outside simulation matrix

//TODO: clean up line breaks here

lowerCoord.y = (e[i].center.y - e[i].radius) < 1 ? 1 : (e[i].center.y - e[i].radius);

lowerCoord.x = (e[i].center.x - e[i].radius) < 1 ? 1 : (e[i].center.x - e[i].radius);

upperCoord.y = (e[i].center.y + e[i].radius) > N ? N : (e[i].center.y + e[i].radius);

upperCoord.x = (e[i].center.x + e[i].radius) > N ? N : (e[i].center.x + e[i].radius);

for(int y = lowerCoord.y; y <= upperCoord.y; y++)

for(int x = lowerCoord.x; x <= upperCoord.x; x++)

{

//calculate falloff from center

float vscalar = fabs(y - e[i].center.y) / e[i].radius;

float uscalar = fabs(x - e[i].center.x) / e[i].radius;

float dscalar = (vscalar+uscalar) / 2;

float horzVel = e[i].vel.x * uscalar;

float vertVel = e[i].vel.y * vscalar;

float density = source * dscalar * lifescalar;

flSolver->addHorzVelocityAt(x, y, horzVel);

flSolver->addVertVelocityAt(x, y, vertVel);

if(useUserSolver)

userSolver->addDensityAt(e[i].userID, x, y, density);

else

flSolver->addDensityAt(x, y, density);

}

e[i].lifeElapsed++;

i++;

}

}

{

Emitter newEmit = {Point(center_x, center_y), Point2f(force_u, force_v), lifespan, 0, radius, userID};

emitters.push_back(newEmit);

#if DEBUG

cout<<"Emitter created: "<<emitters.size()<<endl;

#endif

{

//precondition: optical flow has been calculated

float fu, fv;

fu = fv = 0.0;

int emitter_lifespan = 15;

int emitter_radius = 6;

int velocityEmissionThreshold = -0.05; //creates emitters based on velocity emission

if(useFlow)

{

// Only look for emitters in splash rows.

for( int j = 1; j < SPLASH_ROWS; j++)

{ for(int i = 1; i <= N; i++)

{

bool vertBoundChangesToYes = !flSolver->isBoundAt(i, j) && flSolver->isBoundAt(i, j+1);

if(vertBoundChangesToYes)

{

const Point2f& opticalFlowVelocity = flow.at<Point2f>(i, j);

fu = .8 * opticalFlowVelocity.x;

fv = .8 * opticalFlowVelocity.y;

if(opticalFlowVelocity.y < velocityEmissionThreshold)

{

if(useUserSolver)

{

int userID = resizedUsersMatrix.at<uchar>(i, j+1);

createEmitterAt(i, j-1, fu, fv, 6, 3, userID);

}

else

createEmitterAt(i, j-1, fu, fv, 6, 3, 1);

}

}

}

}

renderEmitters(flSolver, emitters);

}

else

{

// TODO: move this code into a separate function?

// emit splashes on either side of whole silhouette

for (int j = 1; j <= N; j++)

{

for (int i = 1; i <= N; i++)

{

bool horzBoundChangesToYes = !flSolver->isBoundAt(i, j) && flSolver->isBoundAt(i+1, j);

bool horzBoundChangesToNo = flSolver->isBoundAt(i, j) && !flSolver->isBoundAt(i+1, j);

if(horzBoundChangesToYes)

{

fu = -0.05; // emit velocity in negative direction

fv = 0.1;

flSolver->addHorzVelocityAt(i, j, force * fu);

flSolver->addVertVelocityAt(i, j, force * fv);

}

else if(horzBoundChangesToNo)

{

fu = 0.05; // emit velocity in positive direction

fv = 0.1;

flSolver->addHorzVelocityAt(i+1, j, force * fu);

flSolver->addVertVelocityAt(i+1, j, force * fv);

}

}

}

}

{

mode = newMode;

//we have changed modes, initialize new modes

clearData();

switch(newMode)

{

case 0:

source = 20.0f;

dvel = false;

dbound = false;

dusers = false;

useFlow = true;

useUserSolver = false;

useWhiteBackground = false;

cout<<"Changing to mode 0: Single color density"<<endl;

break;

case 1:

source = 20.0f;

dvel = true;

dbound = false;

dusers = false;

useFlow = false;

useUserSolver = false;

useWhiteBackground = false;

cout<<"Changing to mode 1: Vectors without optical flow"<<endl;

break;

case 2:

source = 20.0f;

dvel = false;

dbound = false;

dusers = true;

useFlow = true;

useUserSolver = true;

useWhiteBackground = false;

cout<<"Changing to mode 2: Multi-color user emission"<<endl;

break;

case 3:

source = 20.0f;

dvel = false;

dbound = false;

dusers = false;

useFlow = true;

useUserSolver = true;

useWhiteBackground = true;

cout<<"Changing to mode 3: White background"<<endl;

break;

}

{

if(autoChangeMode && (iterations > iterationsPerMode))

{

iterations = 0;

mode++;

if(mode > maxMode)

mode = 0;

changeMode(mode);

}

else

iterations++;

{

int i, j;

float x, y, h;

h = 1.0f / N;

glColor3f(1.0f, 1.0f, 1.0f);

glLineWidth(1.0f);

glBegin(GL_LINES);

for (i = 1; i <= N; i++)

{

x = (i - 0.5f) * h;

for (j = 1; j <= N; j++)

{

y = (j - 0.5f) * h;

glVertex2f(x, y);

glVertex2f(x + flSolver->getHorzVelocityAt(i,j),

y + flSolver->getVertVelocityAt(i,j));

}

}

glEnd();

{

int i, j;

float x, y, h;

h = 1.0f / N; //calculate unit length of each cell

glBegin(GL_QUADS);

for (i = 0; i <= N; i++)

{

x = i * h;

for (j = 0; j <= N; j++)

{

y = j * h;

if(flSolver->isBoundAt(i,j)) {

glColor3f (0.30f, 0.30f, 0.30f); glVertex2f (x, y);

glColor3f (0.30f, 0.30f, 0.30f); glVertex2f (x+h, y);

glColor3f (0.30f, 0.30f, 0.30f); glVertex2f (x+h, y+h);

glColor3f (0.30f, 0.30f, 0.30f); glVertex2f (x, y+h);

}

}

}

glEnd();

{

// H is given on [0, 6] or UNDEFINED. S and V are given on [0, 1].

// RGB are each returned on [0, 1].

float h = HSV.H, s = HSV.S, v = HSV.V, m, n, f;

int i;

RGBType RGB;

if (h == UNDEFINED)

RETURN_RGB(v, v, v);

i = floor(h);

f = h - i;

if ( !(i&1) )

f = 1 - f; // if i is even

m = v * (1 - s);

n = v * (1 - s * f);

switch (i)

{

case 6 :

case 0 : RETURN_RGB(v, n, m);

case 1 : RETURN_RGB(n, v, m);

case 2 : RETURN_RGB(m, v, n)

case 3 : RETURN_RGB(m, n, v);

case 4 : RETURN_RGB(n, m, v);

case 5 : RETURN_RGB(v, m, n);

}

{

RGBType RGB;

float R, G, B;

R=G=B=0;

for(int i = 0; i < MAX_USERS; i++)

{

float densityVal = userSolver->getDensityAt(i, x, y);

if(useWhiteBackground)

{

R += colorsWhiteBG[i][0] * densityVal;

G += colorsWhiteBG[i][1] * densityVal;

B += colorsWhiteBG[i][2] * densityVal;

}

else

{

R += colors[i][0] * densityVal;

G += colors[i][1] * densityVal;

B += colors[i][2] * densityVal;

}

}

RGB.R = R; RGB.B = B; RGB.G = G;

return RGB;

{

int i, j;

float x, y, h;

RGBType rgb00, rgb10, rgb11, rgb01;

float d00, d10, d11, d01;

float hue = 3.25;

float sat = 1.0;

h = 1.0f/N;

glBegin ( GL_QUADS );

for ( i=1 ; i<=N ; i++ )

{

x = (i-0.5f)*h;

for ( j=1 ; j<=N ; j++ )

{

y = (j-0.5f)*h;

if(useUserSolver)

{

//render density color for each point based on blending user values

rgb00 = getWeightedColor(i,j);

rgb10 = getWeightedColor(i+1,j);

rgb11 = getWeightedColor(i+1,j+1);

rgb01 = getWeightedColor(i,j+1);

}

else

{

//if a cell is a bounds cell, do not apply a density color

d00 = flSolver->isBoundAt(i,j) ? 0 : BG_OFFSET + flSolver->getDensityAt(i,j);

d10 = flSolver->isBoundAt(i+1,j) ? 0 : BG_OFFSET + flSolver->getDensityAt(i+1,j);

d11 = flSolver->isBoundAt(i+1,j+1) ? 0 : BG_OFFSET + flSolver->getDensityAt(i+1,j+1);

d01 = flSolver->isBoundAt(i,j+1) ? 0 : BG_OFFSET + flSolver->getDensityAt(i,j+1);

//hsv to rgb using the density in the cell

HSVType hsv00 = {hue, sat, d00};

rgb00 = HSV_to_RGB(hsv00);

HSVType hsv10 = {hue, sat, d10};

rgb10 = HSV_to_RGB(hsv10);

HSVType hsv11 = {hue, sat, d11};

rgb11 = HSV_to_RGB(hsv11);

HSVType hsv01 = {hue, sat, d01};

rgb01 = HSV_to_RGB(hsv01);

}

glColor3f (rgb00.R, rgb00.G, rgb00.B); glVertex2f ( x, y );

glColor3f (rgb10.R, rgb10.G, rgb10.B); glVertex2f ( x+h, y );

glColor3f (rgb11.R, rgb11.G, rgb11.B); glVertex2f ( x+h, y+h );

glColor3f (rgb01.R, rgb01.G, rgb01.B); glVertex2f ( x, y+h );

}

}

glEnd ();

{

int i, j;

float x, y, h;

int d00, index;

h = 1.0f/N;

glBegin ( GL_QUADS );

for ( i=0 ; i<=N ; i++ )

{

x = i*h;

for ( j=0 ; j<=N ; j++ )

{

y = j*h;

index = j * N + i;

d00 = resizedUsersMatrix.data[index];

if(d00 != 0)

{

GLfloat R = colors[d00][0];

GLfloat G = colors[d00][1];

GLfloat B = colors[d00][2];

//cout<<"found a color for user: "<<d00<<": ("<<R<<", "<<G<<", "<<B<<")"<<endl;

glColor3f ( R, G, B ); glVertex2f ( x, y );

glColor3f ( R, G, B ); glVertex2f ( x+h, y );

glColor3f ( R, G, B ); glVertex2f ( x+h, y+h );

glColor3f ( R, G, B ); glVertex2f ( x, y+h );

}

}

}

glEnd ();

{

switch ( key )

{

case 'c':

case 'C':

clearData();

break;

case 27 : //escape key

cleanupExit();

break;

case 'f':

case 'F':

//toggle optical flow

useFlow = !useFlow;

cout<<"Optical Flow: "<<useFlow<<endl;

break;

case 'v':

case 'V':

dvel = !dvel;

cout<<"Display Velocity"<<endl;

break;

case 'b':

case 'B':

dbound = !dbound;

break;

case '1': //single color fluid

changeMode(0);

break;

case '2': //vectors without optical flow

changeMode(1);

break;

case '3': //multi color fluid

changeMode(2);

break;

case '4': //white bg

changeMode(3);

break;

case '0': //toggle auto mode change

autoChangeMode = !autoChangeMode;

cout<<"Auto Change Mode: "<<autoChangeMode<<endl;

break;

case 'u':

case 'U':

dusers = !dusers;

cout<<"Draw Users: "<<dusers<<endl;

break;

case '+':

kinect->reset();

break;

case 'o':

case 'O':

kinect->setDepth(+200);

break;

case 'k':

case 'K':

kinect->setDepth (-200);

break;

case 'Q' :

case 'q' :

toggleFullscreen();

break;

}

{

omx = mx = x;

omx = my = y;

mouseDown[button] = state == GLUT_DOWN;

{

mx = x;

my = y;

{

glutReshapeWindow ( width, height );

winX = width;

winY = height;

{

bool fullscreen = glutGameModeGet(GLUT_GAME_MODE_ACTIVE);

if(!fullscreen) glutSetWindow(winID);

glutPostRedisplay();