source: trunk/src/testing/app/JuxtaView/main.cpp @ 4

/*=============================================================================

  Program: JuxtaView for SAGE
  Module:  main.cpp - main MPI control for JuxtaView
  Authors: Nicholas Schwarz, schwarz@evl.uic.edu,
           Arun Rao, arao@evl.uic.edu,
           Luc Renambot, luc@evl.uic.edu,
           et al.
  Date:    30 September 2004
  Modified: 9 September 2005

   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 to schwarz@evl.uic.edu or
 * http://www.evl.uic.edu/cavern/forum/

  Direct questions, comments, etc. to schwarz@evl.uic.edu or
  http://www.evl.uic.edu/cavern/forum/

=============================================================================*/


#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// for MPI
#include "mpi.h"

// for UI
#include "JuxtaUIServer.h"

// for communication with UI via QUANTA
#include <QUANTA/QUANTAinit.hxx>
#include <QUANTA/QUANTAnet_tcp_c.hxx>

// for converting global image coordinates, in pixels, to
// individual files and their respective extents
#include "GlobalCoordinatesToFileMapper.h"

// for reading tiff files
#include <tiffio.h>

// for SAGE
#include <sail.h>
#include <misc.h>

// SAGE Stuff
int winWidth, winHeight;
sail sageInf; // sail object

#define LEFT 0
#define RIGHT 1
#define UP 2
#define DOWN 3
#define FASTLEFT 4
#define FASTRIGHT 5
#define FASTUP 6
#define FASTDOWN 7
#define ZOOMOUT 8
#define ZOOMIN 9
#define QUIT 10
#define EXTENTS 11
#define OVERVIEW 12
#define FREETRANS 13
#define RESEND 14

// windows border definitions
#define DBDR_TBLR 0
#define DBDR_TB 1
#define DBDR_LR 2
#define DBDR_TL 3
#define DBDR_TR 4
#define DBDR_BL 5
#define DBDR_BR 6
#define DBDR_T 7
#define DBDR_B 8
#define DBDR_L 9
#define DBDR_R 10
#define DBDR_N 11
#define DBDR_TLR 12
#define DBDR_BLR 13
#define DBDR_TBL 14
#define DBDR_TBR 15

#include <time.h>


/* data set information */
typedef struct {
  long origin_x;         // image origin, usually 0,0
  long origin_y;         // image origin, usually 0,0
  long image_width;      // image width
  long image_height;     // image height
  long start_x;          // start position
  long start_y;          // start position
  long pan_amount;       // number of pixels to pan
  long fast_pan_amount;  // number of pixels to fast pan
  long fetch_w;          // horizontal extent to fetch, i.e. window size
  long fetch_h;          // vertical extent to fetch, i.e. window size
  int samplerate;        // sample rate for overview file
  char name[512];        // overview file name
} description;


/* extent within the global image in pixel coordinates and the command */
typedef struct {
  long x;
  long y;
  long w;
  long h;
  long command;
  long zoom;
  long border;
} info;


/* viewport in normalized coordinates */
typedef struct {
  float x_min;
  float y_min;
  float x_max;
  float y_max;
  long border;
  char ip[16];
} viewport;


/* begin - read config file given file name and return array of viewport */
viewport* read_config(const char* name) {

  // number of nodes in addition to master
  int num;

  // border
  char border[10];

  // file pointer
  FILE *fptr = NULL;

  // attempt to open the configuration file.
  if ((fptr = fopen(name, "r")) == NULL)
    return NULL;

  // read number of nodes
  fscanf(fptr, "%d", &num);

  // allocate space for node configuration
  viewport* viewports = (viewport*) malloc(sizeof(viewport) * num);

  // check if memory allocation succeded
  if (viewports == NULL)
    return NULL;

  // Read configuration data
  for (int i = 0 ; i < num ; i++)
    {
      // read viewports
      fscanf(fptr, "%f", &viewports[i].x_min);
      //printf("%f\n", viewports[i].x_min);
      fscanf(fptr, "%f", &viewports[i].y_min);
      //printf("%f\n", viewports[i].y_min);
      fscanf(fptr, "%f", &viewports[i].x_max);
      //printf("%f\n", viewports[i].x_max);
      fscanf(fptr, "%f", &viewports[i].y_max);
      //printf("%f\n", viewports[i].y_max);
      fscanf(fptr, "%s", border);
      //printf("%s\n\n", border);

      // determine and set border type
      if (!strcmp(border, "BDR_TBLR")) {
        viewports[i].border = DBDR_TBLR;
      }
      else if (!strcmp(border, "BDR_TB")) {
        viewports[i].border = DBDR_TB;
      }
      else if (!strcmp(border, "BDR_LR")) {
        viewports[i].border = DBDR_LR;
      }
      else if (!strcmp(border, "BDR_TL")) {
        viewports[i].border = DBDR_TL;
      }
      else if (!strcmp(border, "BDR_TR")) {
        viewports[i].border = DBDR_TR;
      }
      else if (!strcmp(border, "BDR_BL")) {
        viewports[i].border = DBDR_BL;
      }
      else if (!strcmp(border, "BDR_BR")) {
        viewports[i].border = DBDR_BR;
      }
      else if (!strcmp(border, "BDR_T")) {
        viewports[i].border = DBDR_T;
      }
      else if (!strcmp(border, "BDR_B")) {
        viewports[i].border = DBDR_B;
      }
      else if (!strcmp(border, "BDR_L")) {
        viewports[i].border = DBDR_L;
      }
      else if (!strcmp(border, "BDR_R")) {
        viewports[i].border = DBDR_R;
      }
      else if (!strcmp(border, "BDR_N")) {
        viewports[i].border = DBDR_N;
      }
      else if (!strcmp(border, "BDR_TLR")) {
        viewports[i].border = DBDR_TLR;
      }
      else if (!strcmp(border, "BDR_BLR")) {
        viewports[i].border = DBDR_BLR;
      }
      else if (!strcmp(border, "BDR_TBL")) {
        viewports[i].border = DBDR_TBL;
      }
      else if (!strcmp(border, "BDR_TBR")) {
        viewports[i].border = DBDR_TBR;
      }
      else {
        viewports[i].border = DBDR_N;
      }

      fscanf(fptr, "%s", viewports[i].ip);
      //printf("%s\n", viewports[i].ip);

    }

  // close file
  fclose(fptr);

  // return
  return viewports;

} /* end - read config file */


/* begin - read data description file given file name */
description read_data(const char* name) {

  // data description
  description data;

  // file pointer
  FILE *fptrd = NULL;

  // attempt to open the configuration file.
  if ((fptrd = fopen(name, "r")) == NULL) {
    printf("Can not read data description file.\n");
    exit(EXIT_FAILURE);
  }

  // read origin and extent
  fscanf(fptrd, "%ld %ld %ld %ld", &data.origin_x, &data.origin_y,
         &data.image_width, &data.image_height);

  // read starting position
  fscanf(fptrd, "%ld %ld", &data.start_x, &data.start_y);

  // read pan values
  fscanf(fptrd, "%ld %ld", &data.pan_amount, &data.fast_pan_amount);

  // width and height of data to fetch
  fscanf(fptrd, "%ld %ld", &data.fetch_w, &data.fetch_h);

  // overview file sample rate
  fscanf(fptrd, "%d", &data.samplerate);

  // overview file name
  fscanf(fptrd, "%s", data.name);

  // close file
  fclose(fptrd);

  // return true
  return data;

} /* end - read data description file */


/* begin - add border to the top; called by add_border */
void add_border_top(unsigned char* buffer, info extent) {

  unsigned char r = 139;
  unsigned char g = 161;
  unsigned char b = 105;

  for (long row = 0 ; row < 8 ; row++) {
    for (long col = 0 ; col < (extent.w / extent.zoom) ; col++) {
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3)] = r;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 1] = g;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 2] = b;
    }
  }

} /* end - add border to the top; called by add_border */


/* begin - add border to the top; called by add_border */
void add_border_bottom(unsigned char* buffer, info extent) {

  unsigned char r = 139;
  unsigned char g = 161;
  unsigned char b = 105;

  for (long row = (extent.h / extent.zoom) - 8 ;
       row < (extent.h / extent.zoom) ;
       row++) {
    for (long col = 0 ; col < (extent.w / extent.zoom) ; col++) {
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3)] = r;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 1] = g;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 2] = b;
    }
  }

} /* end - add border to the bottom; called by add_border */


/* begin - add border to the left; called by add_border */
void add_border_left(unsigned char* buffer, info extent) {

  unsigned char r = 139;
  unsigned char g = 161;
  unsigned char b = 105;

  for (long col = 0 ; col < 8 ; col++) {
    for (long row = 0 ; row < (extent.h / extent.zoom) ; row++) {
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3)] = r;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 1] = g;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 2] = b;
    }
  }

} /* end - add border to the left; called by add_border */


/* begin - add border to the right; called by add_border */
void add_border_right(unsigned char* buffer, info extent) {

  unsigned char r = 139;
  unsigned char g = 161;
  unsigned char b = 105;

  for (long col = (extent.w / extent.zoom) - 8 ;
       col < (extent.w / extent.zoom) ;
       col++) {
    for (long row = 0 ; row < (extent.h / extent.zoom) ; row++) {
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3)] = r;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 1] = g;
      buffer[row * 3 * (extent.w / extent.zoom) + (col * 3) + 2] = b;
    }
  }

} /* end - add border to the right; called by add_border */


/* begin - add border to the buffer */
void add_border(unsigned char* buffer, info extent) {

  switch(extent.border) {
  case DBDR_TBLR:
    add_border_top(buffer, extent);
    add_border_bottom(buffer, extent);
    add_border_left(buffer, extent);
    add_border_right(buffer, extent);
    break;
  case DBDR_TB:
    add_border_top(buffer, extent);
    add_border_bottom(buffer, extent);
    break;
  case DBDR_LR:
    add_border_left(buffer, extent);
    add_border_right(buffer, extent);
    break;
  case DBDR_TL:
    add_border_top(buffer, extent);
    add_border_left(buffer, extent);
    break;
  case DBDR_TR:
    add_border_top(buffer, extent);
    add_border_right(buffer, extent);
    break;
  case DBDR_BL:
    add_border_bottom(buffer, extent);
    add_border_left(buffer, extent);
    break;
  case DBDR_BR:
    add_border_bottom(buffer, extent);
    add_border_right(buffer, extent);
    break;
  case DBDR_T:
    add_border_top(buffer, extent);
    break;
  case DBDR_B:
    add_border_bottom(buffer, extent);
    break;
  case DBDR_L:
    add_border_left(buffer, extent);
    break;
  case DBDR_R:
    add_border_right(buffer, extent);
    break;
  case DBDR_N:
    break;
  case DBDR_TLR:
    add_border_top(buffer, extent);
    add_border_left(buffer, extent);
    add_border_right(buffer, extent);
    break;
  case DBDR_BLR:
    add_border_bottom(buffer, extent);
    add_border_left(buffer, extent);
    add_border_right(buffer, extent);
    break;
  case DBDR_TBL:
    add_border_top(buffer, extent);
    add_border_bottom(buffer, extent);
    add_border_left(buffer, extent);
    break;
  case DBDR_TBR:
    add_border_top(buffer, extent);
    add_border_bottom(buffer, extent);
    add_border_right(buffer, extent);
    break;
  }

} /* end - add border to the buffer */


/* begin - main */
int main(int argc, char** argv) {

  bool quit = false; // exit flag

  info extent;  // extent that each node fetches

  long zoom = 1;      // zoom out factor
  long max_zoom = 7;  // max zoom out factor

  int rank = 0;  // node rank
  int size = 0;  // number of nodes
  int frameRate = 5;

  MPI_Datatype pinfo;  // info structure
  MPI_Datatype ipinfo; // ip infor structure

  // MPI Initialization
  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &size);
  MPI_Type_contiguous(7, MPI_LONG, &pinfo);
  MPI_Type_contiguous(16, MPI_CHAR, &ipinfo);
  MPI_Type_commit(&pinfo);
  MPI_Type_commit(&ipinfo);

  // Print some information about the program
  printf("----------------------------------------------------------------\n");
  printf("JuxtaView for SAGE - Node %d of %d\n", rank, size);
  printf("9 September 2005\n");
  printf("----------------------------------------------------------------\n");

  // sync
  MPI_Barrier(MPI_COMM_WORLD);

  /* *********************************************************************** */
  /* Begin - Master node                                                     */

  if (rank == 0) {

    /* Initialize QUANTA */
    QUANTAinit();

    /* Create a server for the UI */
    JuxtaUIServer* server = new JuxtaUIServer();

    /* Initialize server for UI */
    if (!server -> Init(argv[4])) {
      delete server;
      printf("Can not create a UI server.\n");
      return EXIT_FAILURE;
    }

    /* read viewports for each node */
    viewport* viewports = read_config(argv[1]);
    //cout << "********MASTER********** config " << argv[1] << endl;

    /* check that viewports were read correctly */
    if (viewports == NULL) {
      printf("Can not read config file.\n");
      return EXIT_FAILURE;
    }

    /* read data description file */
    //description data = read_data("juxtadata.conf");
    description data = read_data(argv[2]);
    //cout << "********MASTER********** data " << argv[2]<< endl;

    /* begin - read overview file */

    //if the bitmap hasn't been read yet then read it!
    //for now just read the whole tiff file
    TIFF* tiffile = TIFFOpen(data.name, "r");

    uint32 width = 1, height = 1;

    if(tiffile)
      {
        //get the image width and height
        TIFFGetField(tiffile, TIFFTAG_IMAGEWIDTH, &width);
        TIFFGetField(tiffile, TIFFTAG_IMAGELENGTH, &height);
      }

    //get the pixels
    int samplerate = data.samplerate;
    int bmpW = width / samplerate;
    int bmpH = height / samplerate;
    if( bmpW == 0)
      bmpW = 1;
    if( bmpH == 0)
      bmpH = 1;

    unsigned char* bitmap = new unsigned char[bmpW * bmpH * 3];
    fprintf(stderr,"Loading overview of size %d x %d\n",bmpW,bmpH);
    memset(bitmap,0,bmpW * bmpH * 3);
    if(tiffile)
      {
        char* scanline = (char*) _TIFFmalloc( TIFFScanlineSize(tiffile));

        for( int row = 0; row < bmpH; row++)
          {
            TIFFReadScanline(tiffile,scanline,row * samplerate);
            for( int i = 0; i < bmpW; i++)
              {
                memcpy(bitmap + (i * 3) + (row * 3 * bmpW),
                       scanline + (samplerate * i * 3),
                       3);
              }
          }

        _TIFFfree(scanline);
        TIFFClose(tiffile);
      }

    /* end - read overview file */

    printf("Origin X: %ld\n", data.origin_x);
    printf("Origin Y: %ld\n", data.origin_y);
    printf("Image Width: %ld\n", data.image_width);
    printf("Image Height: %ld\n", data.image_height);
    printf("Start x: %ld\n", data.start_x);
    printf("Start y: %ld\n", data.start_y);
    printf("Pan amount: %ld\n", data.pan_amount);
    printf("Fast pan amount: %d\n", data.fast_pan_amount);
    printf("Fetch w: %ld\n", data.fetch_w);
    printf("Fetch h: %ld\n", data.fetch_h);

    /* extent to fetch */
    long Xg = data.start_x;  // current x position in global image
    long Yg = data.start_y;  // current y position in global image
    long Wg = data.fetch_w;  // width of extent to fetch
    long Hg = data.fetch_h;  // height of extent to fetch

    for (int j = 0 ; j < size - 1 ; j++) {
      MPI_Send(&(viewports[j].x_min), 1, MPI_FLOAT, j+1, 1, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    for (int j = 0 ; j < size - 1 ; j++) {
      MPI_Send(&(viewports[j].y_min), 1, MPI_FLOAT, j+1, 1, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    for (int j = 0 ; j < size - 1 ; j++) {
      MPI_Send(&(viewports[j].x_max), 1, MPI_FLOAT, j+1, 1, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    for (int j = 0 ; j < size - 1 ; j++) {
      MPI_Send(&(viewports[j].y_max), 1, MPI_FLOAT, j+1, 1, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    for (int j = 0 ; j < size - 1 ; j++) {
      MPI_Send(viewports[j].ip, 1, ipinfo, j+1, 1, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);

    // insert code here to show first frame before GUI starts

    // calculate and send extent for each node
    for (int i = 0 ; i < size - 1 ; i++) {
      extent.x = ((long)(Wg * viewports[i].x_min)) + Xg;
      extent.y = ((long)(Hg * viewports[i].y_min)) + Yg;
      extent.w = (long)(Wg * (viewports[i].x_max - viewports[i].x_min));
      extent.h = (long)(Hg * (viewports[i].y_max - viewports[i].y_min));
      extent.zoom = zoom;
      extent.border = viewports[i].border;
      MPI_Send(&extent, 1, pinfo, i+1, 1, MPI_COMM_WORLD);
    }

    // synchronize
    MPI_Barrier(MPI_COMM_WORLD);


    //cout << "Master entering loop" << endl;

    /* begin - event loop */
    while (!quit) {

      // block until incoming message from UI
      char* msg = server -> WaitForMessage();

      //printf("Before: xg %ld, yg %ld, wg %ld, hg %ld\n", Xg, Yg, Wg, Hg);

      // pan left
      if (!strcmp(msg, JVPAN_LEFT)) {
        if (Xg - data.pan_amount >= data.origin_x) {
          Xg = Xg - data.pan_amount;
        }
        else {
          Xg = data.origin_x;
        }
        extent.command = LEFT;
      }

      // pan right
      else if (!strcmp(msg, JVPAN_RIGHT)) {
        if (Xg + Wg + data.pan_amount <
            data.origin_x + data.image_width) {
          Xg = Xg + data.pan_amount;
        }
        else {
          Xg = Xg + (data.origin_x + data.image_width) - (Xg + Wg) - 1;
        }
        extent.command = RIGHT;
      }

      // pan up
      else if (!strcmp(msg, JVPAN_UP)) {
        if (Yg - data.pan_amount >= data.origin_y) {
          Yg = Yg - data.pan_amount;
        }
        else {
          Yg = data.origin_y;
        }
        extent.command = UP;
      }

      // pan down
      else if (!strcmp(msg, JVPAN_DOWN)) {
        if (Yg + Hg + data.pan_amount <=
            data.origin_y + data.image_height) {
          Yg = Yg + data.pan_amount;
        }
        else {
          Yg = Yg + (data.origin_y + data.image_height) - (Yg + Hg) - 1;
        }
        extent.command = DOWN;
      }

      // fast pan left
      else if(!strcmp(msg, JVFAST_PAN_LEFT)) {
        if (Xg - data.fast_pan_amount >= data.origin_x) {
          Xg = Xg - data.fast_pan_amount;
        }
        else {
          Xg = data.origin_x;
        }
        extent.command = FASTLEFT;
      }

      // fast pan right
      else if(!strcmp(msg, JVFAST_PAN_RIGHT)) {
        if (Xg + Wg + data.fast_pan_amount <
            data.origin_x + data.image_width) {
          Xg = Xg + data.fast_pan_amount;
        }
        else {
          Xg = Xg + (data.origin_x + data.image_width) - (Xg + Wg) - 1;
        }
        extent.command = FASTRIGHT;
      }

      // fast pan up
      else if(!strcmp(msg, JVFAST_PAN_UP)) {
        if (Yg - data.fast_pan_amount >= data.origin_y) {
          Yg = Yg - data.fast_pan_amount;
        }
        else {
          Yg = data.origin_y;
        }
        extent.command = FASTUP;
      }

      // fast pan down
      else if(!strcmp(msg, JVFAST_PAN_DOWN)) {
        if (Yg + Hg + data.fast_pan_amount <=
            data.origin_y + data.image_height) {
          Yg = Yg + data.fast_pan_amount;
        }
        else {
          Yg = Yg + (data.origin_y + data.image_height) - (Yg + Hg) -1;
        }
        extent.command = FASTDOWN;
      }

      // zoom out
      else if(!strcmp(msg, JVZOOM_OUT)) {
        if (zoom + 1 <= max_zoom) {

          // calcualte new upper left corner and extents
          long center_x = Xg + (Wg / 2);
          long center_y = Yg + (Hg / 2);
          long tXg = center_x - ((Wg + data.fetch_w) / 2);
          long tYg = center_y - ((Hg + data.fetch_h) / 2);
          long tHg = Hg + data.fetch_h;
          long tWg = Wg + data.fetch_w;

          // check that zoomed out image is within the image size
          if (tWg <= data.image_width && tHg <= data.image_height) {

            // new x position is too far left
            if (tXg < data.origin_x) {
              tXg = data.origin_x;
            }

            // new y position is too far up
            if (tYg < data.origin_y) {
              tYg = data.origin_y;
            }

            // new x extent is too far right
            if (tXg + tWg >= data.origin_x + data.image_width) {
              long delta_x = (tXg + tWg) - (data.origin_x + data.image_width);
              tXg = tXg - delta_x - 1;
            }

            // new y extent is too far down
            if (tYg + tHg >= data.origin_y + data.image_height) {
              long delta_y = (tYg + tHg) - (data.origin_y + data.image_height);
              tYg = tYg - delta_y - 1;
            }

            // update everthing
            zoom++;
            Xg = tXg;
            Yg = tYg;
            Hg = tHg;
            Wg = tWg;

          }

        }
        extent.command = ZOOMOUT;
      }

      // zoom in
      else if(!strcmp(msg, JVZOOM_IN)) {
        if (zoom - 1 >= 1) {
          if ((Yg + Hg - data.fetch_h <= data.origin_y + data.image_height) &&
              (Xg + Wg - data.fetch_w <= data.origin_x + data.image_width)) {
            long center_x = Xg + (Wg / 2);
            long center_y = Yg + (Hg / 2);
            Xg = center_x - ((Wg - data.fetch_w) / 2);
            Yg = center_y - ((Hg - data.fetch_h) / 2);
            extent.command = ZOOMIN;
            zoom--;
            Hg -= data.fetch_h;
            Wg -= data.fetch_w;
          }
        }
        extent.command = ZOOMIN;
      }

      // free translation
      else if (!strcmp(msg, JVTRANSLATE)) {

        // normalized free translation coordinates
        float nx = 0.0;
        float ny = 0.0;

        // get normalized free translation coordinates
        server -> GetNormalizedFreeTranslation(&nx, &ny);

        // convert normalized values to actual pixel coordinates
        long tXg = (long) (nx * data.image_width);
        long tYg = (long) (ny * data.image_height);

        // set command
        extent.command = FREETRANS;

        // check left x
        if (tXg < data.origin_x)
          Xg = data.origin_x;
        else
          Xg = tXg;

        // check top y
        if (tYg < data.origin_y)
          Yg = data.origin_y;
        else
          Yg = tYg;

        // check right x
        if (tXg + Wg >= data.origin_x + data.image_width)
          Xg = Xg + (data.origin_x + data.image_width) - (Xg + Wg) - 1;
        else
          Xg = tXg;

        // check bottom y
        if (tYg + Hg >= data.origin_y + data.image_height)
          Yg = Yg + (data.origin_y + data.image_height) - (Yg + Hg) - 1;
        else
          Yg = tYg;

        //cout << "Freetrans tXg: " << tXg << " tYg: " << tYg << endl;
        //cout << "Freetrans Xg: " << Xg << " Yg: " << Yg << endl;
        //cout << "End of freetrans" << endl;
      }

      // send normalized extent of displayed area
      else if (!strcmp(msg, JVEXTENTS)) {
        float nx = (float) Xg / (float) data.image_width;
        float ny = (float) Yg / (float) data.image_height;
        float nw = (float) Wg / (float) data.image_width;
        float nh = (float) Hg / (float) data.image_height;

        //cout << "MASTER: normalized extents nx: " << nx
        //     << " ny: " << ny << " nw: " << nw << " nh: " << nh << endl;
        server -> SendNormalizedExtents(nx, ny, nw, nh);
        extent.command = EXTENTS;
        //cout << "End of extents" << endl;
      }

      else if (!strcmp(msg, JVOVERVIEW)) {
        server -> SendOverview(bmpW, bmpH, bitmap);
        extent.command = OVERVIEW;
      }

      // quit
      else if(!strcmp(msg, JVQUIT)) {
        quit = true;
        extent.command = QUIT;
      }

      // resend
      else if(!strcmp(msg, JVRESEND)) {
        extent.command = RESEND;
      }

      //printf("After: xg %d, yg %d, wg %d, hg %d\n", Xg, Yg, Wg, Hg);

      //fprintf(logfile,"Message Returned: %s\n",msg);

      // calculate and send extent for each node
      for (int i = 0 ; i < size - 1 ; i++) {
        extent.x = ((long)(Wg * viewports[i].x_min)) + Xg;
        extent.y = ((long)(Hg * viewports[i].y_min)) + Yg;
        extent.w = (long)(Wg * (viewports[i].x_max - viewports[i].x_min));
        extent.h = (long)(Hg * (viewports[i].y_max - viewports[i].y_min));
        extent.zoom = zoom;
        extent.border = viewports[i].border;
        MPI_Send(&extent, 1, pinfo, i+1, 1, MPI_COMM_WORLD);
      }

      // synchronize
      MPI_Barrier(MPI_COMM_WORLD);

      // free memory used by message from UI
      //cout << "Master deleting message - begin" << endl;
      //delete [] msg;
      //cout << "Master deleting message - end" << endl;

    } /* end - event loop */

    // free memory used by viewport list
    free(viewports);

    // free memory used by overview
    free(bitmap);

  }

  /* End - Master node                                                       */
  /* *************************************************************************/

  /* *********************************************************************** */
  /* Begin - Slave node                                                      */

  else {

    // first time slave is run
    bool virgin = true;

    // MPI status variable
    MPI_Status status;

    // create GlobalCoordinatesToFileMapper instance
    GlobalCoordinatesToFileMapper gmapper;

    // initialize GlobalCoordinatesToFileMapper instance
    // TODO: change this to command line argument!!
    //gmapper.Initialize("juxtalayout.conf");
    gmapper.Initialize(argv[3]);
    //cout << "********SLAVE********** layout " << endl;

    // big image buffer
    unsigned char* pixelarray = NULL;

    // zoom adjusted image buffer
    unsigned char* buffer = NULL;

    // viewport information
    viewport view;

    // get viewport information
    MPI_Recv(&(view.x_min), 1, MPI_FLOAT, 0, 1, MPI_COMM_WORLD, &status);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Recv(&(view.y_min), 1, MPI_FLOAT, 0, 1, MPI_COMM_WORLD, &status);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Recv(&(view.x_max), 1, MPI_FLOAT, 0, 1, MPI_COMM_WORLD, &status);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Recv(&(view.y_max), 1, MPI_FLOAT, 0, 1, MPI_COMM_WORLD, &status);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Recv(view.ip, 1, ipinfo, 0, 1, MPI_COMM_WORLD, &status);
    MPI_Barrier(MPI_COMM_WORLD);

    /*
    cout << "Rank: " << rank << " x_min: " << view.x_min << endl;
    cout << "Rank: " << rank << " y_min: " << view.y_min << endl;
    cout << "Rank: " << rank << " x_max: " << view.x_max << endl;
    cout << "Rank: " << rank << " y_max: " << view.y_max << endl;
    */


    /* begin - event loop */
    while(!quit) {

      //fprintf(stderr, "Proc %d> Receiving\n", rank);

      // receive command from master
      MPI_Recv(&extent, 1, pinfo, 0, 1, MPI_COMM_WORLD, &status);
      //cout << "Rank: " << rank << " V1" << endl;
      if (virgin) {

        // initialize SAGE

        sailConfig scfg;
        scfg.init("JuxtaView.conf");
        scfg.setAppName("JuxtaView");
        if (argc > 6)
                scfg.nwID = atoi(argv[6]);
        scfg.rank = rank - 1;

        scfg.resX = (extent.w / extent.zoom);
        scfg.resY = (extent.h / extent.zoom);

        sageRect renderImageMap;
        renderImageMap.left = view.x_min;
        renderImageMap.right = view.x_max;
        renderImageMap.bottom = 1.0 - view.y_max;
        renderImageMap.top = 1.0 - view.y_min;

        scfg.imageMap = renderImageMap;
        scfg.pixFmt = PIXFMT_888;
        //scfg.rowOrd = TOP_TO_BOTTOM;
        scfg.rowOrd = TOP_TO_BOTTOM;

        if (scfg.rank == 0)
                scfg.master = true;
        else
                scfg.master = false;

        sageInf.init(scfg);

        if (argc > 7)
                frameRate = atoi(argv[7]);

        //cout << "Rank: " << rank << " V1.1" << endl;

        // create zoom adjusted image buffer
        if (buffer)
                delete [] buffer;

        buffer = (unsigned char*)sageInf.getBuffer();

        //cout << "Rank: " << rank << " V1.2" << endl;

        // no longer a virgin
        virgin = false;
      }

      //cout << "Rank: " << rank << " V1.3" << endl;

      // quit
      if (extent.command == QUIT) {

        // set quit flag
        quit = true;

        // synchronize
        MPI_Barrier(MPI_COMM_WORLD);

      }

      // resend
      else if (extent.command == RESEND) {
        if (!virgin) {
          // synchronize
          MPI_Barrier(MPI_COMM_WORLD);
                         /*
                         useconds_t interval = (useconds_t)floor(1.0/frameRate*1000000.0);
                         usleep(interval);
          // swap buffer
          sageInf.swapBuffer();
                         buffer = (unsigned char *)sageInf.getBuffer();
                         */
        }
      }

      // get and display data
      else {
        //cout << "Rank: " << rank << " V2" << endl;
        // print the current query for this node
        //cout << "QueryExtent at node " << rank << " " << extent.x << " "
        //     << extent.y << " " << extent.w << " " << extent.h << endl;

        // create big image buffer
        if (!pixelarray)
          pixelarray = new unsigned char[extent.w * extent.h * 3];

        // set extent of data to fetch
        gmapper.SetQueryExtent(extent.x, extent.y, extent.w, extent.h);

        // make query - this actually makes the mapper calculate
        // all the files this program should load
        gmapper.Query();

        // print the state of the mapper
        //gmapper.PrintSelf(cout);

        // number of columns and rows in the query result
        long columnResult = 0;
        long rowResult = 0;

        // get the array of FileInfo and the number of rows and columns of
        // the 2D array of FileInfo
        FileInfo* files =
          gmapper.GetQueryFileInfoArray(&columnResult, &rowResult);

        // print the number of columns and rows in the query result
        //cout << "FileInfoArrayDimensions: " << columnResult << " "
        //     << rowResult << endl;

        // NOTE: THIS DOES NOT WORK. IT'S A MESS!!!
        // ANOTHER NOTE: IT WORKS NOW, BUT VERY, VERY SLOWLY
        // ////////////////////////////////////////////////////////////////////
        // Begin - read from files

        long localx = 0;
        long localy = 0;
        long localw = 0;
        long localh = 0;
        long globalw = extent.w;
        long globalh = extent.h;

        //cout << "Extent.w: " << extent.w << " Extent.h: "
        //     << extent.h << endl;
        //cout << "Rank: " << rank << " V3" << endl;

        int array_index = 0;
        int array_max = columnResult * rowResult;

        //cout << "Rank: " << rank << " V4" << endl;

        memset(pixelarray, 0, globalw * globalh * 3);

        //cout << "Rank: " << rank << " V5" << endl;

        for(long c = 0; array_index < array_max && c < globalw; ){
          for(long r = 0; array_index < array_max && r < globalh; ){

            TIFF* tiffile = NULL;
            tiffile = TIFFOpen(files[array_index].GetFileName(), "r");

            // if the tif exists
            if (tiffile != NULL) {

              //get the scanlines needed
              unsigned char *scanline =
                (unsigned char *) _TIFFmalloc(TIFFScanlineSize(tiffile));

              files[array_index].GetExtent(&localx, &localy, &localw, &localh);
              //cout << "Rank: " << rank
              //           << "file: " << files[array_index].GetFileName()
              //           << "localx: " << localx
              //           << "localy: " << localy
              //           << "localw: " << localw
              //           << "localh: " << localh
              //           << endl;

              for (int l = 0,  k = localy ; k < localy + (localh) ; k++, l++)
                {
                  //cout << "Rank: " << rank << " row: " << k << endl;
                  TIFFReadScanline(tiffile,scanline,k);
                  //for(int j = 0; j < localw; j++){
                  memcpy(&(pixelarray[ (r + l) * globalw *3 + c * 3]),
                         &(scanline[localx * 3]),localw * 3);
                }

              _TIFFfree(scanline);
              TIFFClose(tiffile);

            }

            array_index++;
            r += localh;
          }
          c += localw;
        }

        //cout << "Rank: " << rank << " V6" << endl;

        // End - read from files
        // ////////////////////////////////////////////////////////////////////

        // clear the zoom adjusted image buffer
        memset(buffer,
               0,
               (extent.w / extent.zoom) * (extent.h / extent.zoom) * 3);

        // adjust for zoom by skipping pixels
        // NOTE: Zooming is from the upper left, not the center, I know
        // that's bad, so some day I'll fix it.
        for (long r = 0, rz = 0 ; r < extent.h ; r += extent.zoom, rz++) {
          for (long c = 0, cz = 0 ; c < extent.w ; c += extent.zoom, cz++) {
            buffer[rz * 3 * (extent.w / extent.zoom) + (cz * 3)] =
              pixelarray[r * 3 * extent.w + (c * 3)];
            buffer[rz * 3 * (extent.w / extent.zoom) + (cz * 3) + 1] =
              pixelarray[r * 3 * extent.w + (c * 3) + 1];
            buffer[rz * 3 * (extent.w / extent.zoom) + (cz * 3) + 2] =
              pixelarray[r * 3 * extent.w + (c * 3) + 2];
          }
        }

        // delete big image buffer
        //cout << "slave deleting pixelarray - begin" << endl;
        delete [] pixelarray;
        //cout << "slave deleting pixelarray - end" << endl;
        pixelarray = NULL;

        // add borders
        add_border(buffer, extent);

        // synchronize
        MPI_Barrier(MPI_COMM_WORLD);

        // swap buffer
        sageInf.swapBuffer();
        buffer = (unsigned char *)sageInf.getBuffer();

      }

    } /* end - event loop */

    if (rank == 1)
      sageInf.shutdown();

    // delete zoom adjusted image buffer
    delete [] buffer;
    buffer = NULL;

  }

  /* End - Slave node                                                        */
  /* *************************************************************************/

  // finalize
  MPI_Finalize();

  // exit
  return EXIT_SUCCESS;

} /* end - main */