source: trunk/src/testing/app/volvis/vNet.cpp @ 4

/********************************************************************************
 * Volatile - Volume Visualization Software for SAGE
 * Copyright (C) 2004 Electronic Visualization Laboratory,
 * University of Illinois at Chicago
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following disclaimer
 *    in the documentation and/or other materials provided with the distribution.
 *  * Neither the name of the University of Illinois at Chicago nor
 *    the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Direct questions, comments etc about Volatile to www.evl.uic.edu/cavern/forum
 *********************************************************************************/

#if defined(V_DISTRIBUTED)
#include "vNet.h"
#include "global.h"
#include "vGeometry.h"
#include <string.h>

char* getServerIP(int rank, const char* serverFile) {
        string line;
        ifstream in(serverFile); // Read
        if (!in) {
                cerr <<"File "<<serverFile<<" cant be read\n";
                return NULL;
        }
        while(getline(in,line)) {
                istringstream line_stream(line);
                int tileRank;
                string serverIP;
                line_stream >> tileRank;
                line_stream >> serverIP;
                if (tileRank == rank)
                        return (char*)serverIP.c_str();
        }
        return NULL;
}


QUANTAts_mutex_c tfMutex;
vNet::vNet()
{
        master = 0;
        cmdFlushed = 1;
        readyToDie =0;          //dont want to die right away
}

vNet::~vNet() {
}

void vNet::init(int &argc, char** &argv)
{
        //init MPI
        int rc = MPI_Init(&argc, &argv);
        MPI_Comm comm;
        rc = MPI_Comm_size(MPI_COMM_WORLD, &noProcs);
        rc = MPI_Comm_rank(MPI_COMM_WORLD, &rank);
        if (setenv("DISPLAY", ":0", 1) == -1)
        {
                cerr<<"\nCannot display on Tile "<<rank<<endl;
                exit(1);
        }
}

//Clean up and exit
void vNet::deactivateTiles() {
        fillExitCommand();
}

void vNet::process() {
        if (master != rank)     //slaves
    {
                char* data = new char[COMMAND_SIZE];
                bzero(data, COMMAND_SIZE);
                cmdFlushed = 1;
                //listen from master node for commands
                MPI_Bcast(data, COMMAND_SIZE, MPI_BYTE, master, MPI_COMM_WORLD );
                //fprintf(stderr, "Proc %d/%d> Receiving command\n", rank, noProcs);
                processCmd(data);       //process the command
                glutPostRedisplay();
    }
        else
    { //master
                //Broadcast a command that has been set appropriately
                //fprintf(stderr, "Proc %d/%d> Sending command\n", rank, noProcs);
                tfMutex.lock();
                MPI_Bcast(buffer, COMMAND_SIZE, MPI_BYTE, master, MPI_COMM_WORLD );
                tfMutex.unlock();


                if (readyToDie == 1)
                {
                        int rc = MPI_Finalize(); //wait and clean up
                        exit(0);         //All dead, We can now exit
                }
                fillDummyCommand(); //just to keep everyone displaying
                //fprintf(stderr, "Proc %d/%d> After Sending command, before display\n", rank, noProcs);
                glutPostRedisplay();
    }
}

void vNet::processCmd(char* data)
{
        //Unpack data - contains command name and arguments
        dataPack.initUnpack(data, COMMAND_SIZE);
        char key[24];
        int len;
        dataPack.unpackInt(&len);   //str length of command
        dataPack.unpack(key, len);
        if (!strcmp(key,"DUMMY"))
        {
                //do nothing - ignore (this is just to synchronize display calls of all tiles with master)
        }
        else if (!strcmp(key,"VOL_ROTN")) {
                //set the global transform rotn to be this one
                for (int i=0;i<16;i++)
                        dataPack.unpackFloat(&renderList[global.curPrimIdx]->xform.rotn[i]);
        }
        else if (!strcmp(key,"VOL_CUTROTN")) {
                global.cut.update = true;
                //set the cut rotn to be this one
                dataPack.unpackFloat(&global.cut.angle);
                for (int i=0;i<3;i++)
                        dataPack.unpackFloat(&global.cut.axis[i]);
        }
        else if (!strcmp(key,"VOL_LOWRES")) { //use tag to distinguish messages
                //set the global transform lowresrto be this one
                dataPack.unpackInt(&global.volren.lowRes);
        }
        else if (!strcmp(key,"VOL_TRANSLATION")) { //use tag to distinguish messages
                //set the global transform lowresrto be this one
                for (int i=0;i<3;i++)
                        dataPack.unpackFloat(&renderList[global.curPrimIdx]->xform.trans[i]);
        }
        else if (!strcmp(key,"VOL_ZOOM")) { //use tag to distinguish messages
                //set the global transform lowresrto be this one
                float zoomFactor;
                dataPack.unpackFloat(&zoomFactor);
                renderList[global.curPrimIdx]->xform.scale += zoomFactor;
                //global.env.eye[2] += zoomFactor;
        }
        else if (!strcmp(key,"VOL_CUTZOOM")) { //use tag to distinguish messages
                //set the global transform lowresrto be this one
                float zoomFactor;
                dataPack.unpackFloat(&zoomFactor);
                global.cut.user[3] += zoomFactor;
        }
        else if (!strcmp(key,"VOL_SAMPLERATE")) { //use tag to distinguish messages
                //set the global transform lowresrto be this one
                float scaleSample;
                dataPack.unpackFloat(&scaleSample);
                global.volren.goodSamp *= scaleSample;
                global.volren.interactSamp *= scaleSample;
                global.volren.sampleRate = global.volren.goodSamp;
        }
        else if (!strcmp(key,"VOL_PRINTFPS")) {
                global.ui.printFPS = !global.ui.printFPS;
                if (global.ui.printFPS)
                        glutIdleFunc(idle);
                else
                        glutIdleFunc(0);
        }
        else if (!strcmp(key,"VOL_CUTPLANE")) {
                global.ui.cutEnabled = !global.ui.cutEnabled;
        }
        else if (!strcmp(key,"VOL_BOUNDBOX")) {
                global.ui.bboxEnabled = !global.ui.bboxEnabled;
        }
        else if (!strcmp(key,"VOL_NAVROAM")) {
                global.ui.navMode = V_ROAM;
        }
        else if (!strcmp(key,"VOL_NAVPROBE")) {
                global.ui.navMode = V_PROBE;
        }
        else if (!strcmp(key,"VOL_ISOSURFACE")) {
                int isoValue;
                float tx, ty, scale;
                dataPack.unpackInt(&isoValue);
                dataPack.unpackFloat(&tx);
                dataPack.unpackFloat(&ty);
                dataPack.unpackFloat(&scale);
                global.volume->setIsoValue(isoValue);
                NetVertexBuffer* theGeom = global.volume->isoSurface();
                vGeometry* newIso = new vGeometry(theGeom);
                newIso->xform.trans[0] = tx;
                newIso->xform.trans[1] = ty;
                newIso->xform.scale = scale;
                fprintf(stderr,"VOL_ISOSURFACE: New geom translation %f %f scale %f\n",newIso->xform.trans[0],newIso->xform.trans[1],
                        newIso->xform.scale);
                renderList.push_back(newIso);
        }
        else if (!strcmp(key,"VOL_LUT")) {
                for (int i=0;i<256*4;i++) {
                        dataPack.unpackChar((char*)&global.volren.deptex[i]);
                }
                dataPack.unpackInt(&global.volren.lowRes);
                global.volren.loadTLUT = 1;
        }
        else if (!strcmp(key,"VOL_SAVEGRADIENTVOL")) {
                global.volume->saveGradient();
        }
        else if (!strcmp(key,"VOL_ROAM")) {
                int x, y, z;
                dataPack.unpackInt(&x);
                dataPack.unpackInt(&y);
                dataPack.unpackInt(&z);
                global.volume->roam(x,y,z);
                global.volren.loadVolume = 1;
        }
        else if (!strcmp(key,"VOL_PROBE")) {
                int x, y, z;
                dataPack.unpackInt(&x);
                dataPack.unpackInt(&y);
                dataPack.unpackInt(&z);
                global.volume->probe(x,y,z);
        }
        /*
        else if (!strcmp(key,"VOL_POINTERPOS")) {
                dataPack.unpackFloat(&global.pointerPos[0]);
                dataPack.unpackFloat(&global.pointerPos[1]);
                dataPack.unpackFloat(&global.pointerPos[2]);
                global.curPrimIdx= 0;
                //select each primitive to see which is selected
                for (int i=0;i< renderList.size();i++) {
                        if (renderList[i]->select()) {
                                global.curPrimIdx= i;
                                break;
                        }
                }
        }
        */
        else if (!strcmp(key,"VOL_SELECT")) {
                dataPack.unpackInt(&global.curPrimIdx);
                for (int i=0;i<renderList.size();i++) {
                        if (i==global.curPrimIdx)
                                renderList[i]->setSelected(true);
                        else
                                renderList[i]->setSelected(false);
                }
        }
        else if (!strcmp(key,"VOL_TOGGLEANIMATE")) {
                for (int i=0;i<renderList.size();i++)
                        renderList[i]->toggleAnimate();
        }
        else if (!strcmp(key,"VOL_UPDATEANIM")) {
                for (int i=0;i<renderList.size();i++) {
                        if (renderList[i]->isAnimating()) {
                                renderList[i]->next();
                        }
                }
        }
        else if (!strcmp(key,"EXIT"))
        {
                int rc = MPI_Finalize(); //clean up mpi stuff
                if (data) delete data;   //be responsible
                deallocateAll();
                exit(0);
        }
        if (data) delete data;
}

// Called when tile needs to be refreshed
bool vNet::readTileConfig(const char* configFile) {
        cerr << rank<<" readTileConfig : filename is "<<configFile<<endl;
        string line;
        ifstream in(configFile); // Read
        if (!in) {
                cerr <<"File "<<configFile<<" cant be read\n";
                return false;
        }
        global.env.frustumList.clear();
        global.env.viewportList.clear();
        while(getline(in,line)) {
                istringstream line_stream(line);
                int tileRank;
                float   minX, maxX, minY, maxY;
                float   vpx, vpy, vpwidth, vpheight;
                line_stream >> tileRank;
                //read the tile extent
                line_stream >> minX;
                line_stream >> maxX;
                line_stream >> minY;
                line_stream >> maxY;

                //read the viewport for each frustum
                if (line_stream.eof()) { //fill in default values
                        vpx = vpy = 0.0;
                        vpwidth = vpheight = 1.0f;
                }
                else {
                        line_stream >> vpx;
                        line_stream >> vpy;
                        line_stream >> vpwidth;
                        line_stream >> vpheight;
                }

                if (tileRank == rank)  //if the rank matches, store the values
                {
                        //fprintf(stderr, "\nTile %d Image offsets: %d %d ", rank, xOffset, yOffset);
                        vFrustum curFrustum;
                        vViewport curvp;
                        curFrustum.left = (minX - 50.0) / 50.0;
                        curFrustum.right = (maxX - 50.0) / 50.0;
                        curFrustum.bottom = (minY - 50.0) / 50.0;
                        curFrustum.top = (maxY - 50.0) / 50.0;
                        float fov = 45.0f*M_PI/180.0f;
                        float b = global.env.clip[0] * (float) tan(fov * 0.5);
                        fprintf(stderr,"Node %d aspect %f\n",rank,global.win.aspect);
                        float r = b * global.win.aspect;
                        curFrustum.left *= r;  //left
                        curFrustum.right *= r;   //right
                        curFrustum.bottom *= b;  //bottom
                        curFrustum.top *= b;   //top

                        //now add the current frustum to the frustum list
                        global.env.frustumList.push_back(curFrustum);

                        curvp.x = vpx;
                        curvp.y = vpy;
                        curvp.width = vpwidth;
                        curvp.height = vpheight;
                        global.env.viewportList.push_back(curvp);
                        fprintf(stderr,"*******viewport %f %f %f %f\n",curvp.x, curvp.y, curvp.width, curvp.height);
                }
        }  //end while
        return true;
}
void vNet::packCommand(const char* cmdString, int flushed)
{
        memset(buffer, 0, COMMAND_SIZE);
        dataPack.initPack(buffer, COMMAND_SIZE);
        char cmd[25];
        strcpy(cmd, cmdString);
        int len = strlen(cmd) +1;
        dataPack.packInt(len);
        dataPack.pack(cmd, len );
        cmdFlushed = flushed;
        //the command is sent during the display call
}

//send vol rotation
void vNet::setRotn(float rotn[16]) {
        packCommand("VOL_ROTN");
        for (int i=0;i<16;i++)
                dataPack.packFloat(rotn[i]);
}

//send the transfer function
void vNet::setLUT(int size, unsigned char* data) {
        tfMutex.lock();
        packCommand("VOL_LUT");
        for (int i=0;i<size;i++)
                dataPack.packChar(data[i]);
        tfMutex.unlock();
}

//send the cutplane rotation in axis angle
void vNet::setCutRotation(float angle, float axis[3]) {
        packCommand("VOL_CUTROTN");
        dataPack.packFloat(angle);
        for (int i=0;i<3;i++)
                dataPack.packFloat(axis[i]);
}

//set the zoom of the cutplane
void vNet::setCutZoom(float dzoom) {
        packCommand("VOL_CUTZOOM");
        dataPack.packFloat(dzoom);
}

//send lowres
void vNet::setLowRes(int lowRes) {
        packCommand("VOL_LOWRES");
        dataPack.packInt(lowRes);
        //fprintf(stderr,"In setLowRes: lowres %d\n",lowRes);
}

//save GRadient Info
void vNet::saveGradientVolume() {
         packCommand("VOL_SAVEGRADIENTVOL");
}

//do select
void vNet::select(float pointerPos[3]) {
        packCommand("VOL_POINTERPOS");
        for (int i=0;i<3;i++)
                dataPack.packFloat(pointerPos[i]);
}

//do select
void vNet::select(int index) {
        packCommand("VOL_SELECT");
        dataPack.packInt(index);
}

//set translation
void vNet::setTranslation(float translation[3]) {
        packCommand("VOL_TRANSLATION");
        for (int i=0;i<3;i++)
                dataPack.packFloat(translation[i]);
}

//set zoom
void vNet::setZoom(float factor) {
        packCommand("VOL_ZOOM");
        dataPack.packFloat(factor);
}

//scale sample rate
void vNet::scaleSampleRate(float factor) {
        packCommand("VOL_SAMPLERATE");
        dataPack.packFloat(factor);
}

//animate volume
void vNet::animateVolume() {
        packCommand("VOL_TOGGLEANIMATE");
}

//animate volume
void vNet::updateAnim() {
        packCommand("VOL_UPDATEANIM");
}


//toggle printing frame rate
void vNet::togglePrintFPS() {
        packCommand("VOL_PRINTFPS");
}

//toggle printing frame rate
void vNet::toggleCutPlane() {
        packCommand("VOL_CUTPLANE");
}

//toggle display of bound box
void vNet::toggleBoundBox() {
        packCommand("VOL_BOUNDBOX");
}

//set roam
void vNet::setRoam() {
        packCommand("VOL_NAVROAM");
}

//set probe
void vNet::setProbe() {
        packCommand("VOL_NAVPROBE");
}

//send the roam factor
void vNet::roamVolume(int roamX, int roamY, int roamZ) {
        packCommand("VOL_ROAM");
        dataPack.packInt(roamX);
        dataPack.packInt(roamY);
        dataPack.packInt(roamZ);
}

//send the roam factor
void vNet::probeVolume(int probeX, int probeY, int probeZ) {
        packCommand("VOL_PROBE");
        dataPack.packInt(probeX);
        dataPack.packInt(probeY);
        dataPack.packInt(probeZ);

}

//send command to get the isosurface and display it
void vNet::getIsosurface(int isoValue, float tx, float ty, float scale) {
        packCommand("VOL_ISOSURFACE");
        dataPack.packInt(isoValue);
        dataPack.packFloat(tx);
        dataPack.packFloat(ty);
        dataPack.packFloat(scale);

}

//send command to get the isopoint and display it
void vNet::getIsopoint(int isoValue, float tx, float ty, float scale) {
        packCommand("VOL_ISOPOINT");
        dataPack.packInt(isoValue);
        dataPack.packFloat(tx);
        dataPack.packFloat(ty);
        dataPack.packFloat(scale);

}

//send empty broadcasts to clients
void vNet::fillDummyCommand()
{
        packCommand("DUMMY", 1);
}

//fill up a command to do MPI_Finalize (clean up MPI)
void vNet::fillExitCommand()
{
        packCommand("EXIT");
        readyToDie =1;          //set flag -ready to exit now
}


#endif