render.cc

MatlabVisualization Package

#include "render.h"
#include <iostream>
#include <fstream>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "mpi.h"

const int IMAGE_TAG = 1;
const int AXES_INDENT = 50;
const int TICK_LENGTH = 10;
const int NUM_BOX_SIZE = 16;
const int NUM_DISTANCE = NUM_BOX_SIZE / 2;

#define _RECTANGLE_

Render::Render(int w, int h, int rank, double *data, int start_row, 
	       int start_column, int nrows, int ncols, 
	       DistLayout *data_layout, bool render_spy) {

  r = rank;
  data_buffer = data;
  image_buffer = NULL;
  send_buffer = NULL;
  depth_buffer = NULL;
  send_depth = NULL;
  valid_procs = NULL;
  is_spy = render_spy;
  nonzero = 0;

  num_blocks = data_layout->blocks;
  blocks_data = data_layout->block_data;
  MPI_Comm_size(MPI_COMM_WORLD, &num_procs);

  if (rank != DISPLAY_NODE) {
    if (!num_blocks || 
	((blocks_data[0] == blocks_data[2]) &&
	 (blocks_data[1] == blocks_data[3]))) {
      // there is no data on this node
      valid = 0;
    }
    else {
      valid = 1;
    }
    MPI_Send(&valid, 1, MPI_INT, 0, IMAGE_TAG, MPI_COMM_WORLD);
    if (!valid) {
      if (!is_spy) {
	double minval = HUGE;
	double maxval = MINISCULE;
	MPI_Allreduce(&minval, &minZ, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
	MPI_Allreduce(&maxval, &maxZ, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
	if (is_spy) 
	  MPI_Allreduce(&nonzero, &num_nonzeros, 1, MPI_INT, 
			MPI_SUM, MPI_COMM_WORLD);
      }
      return;
    }
  }
  else {
    valid = 1;
    MPI_Status status;
    valid_procs = new int[num_procs];
    
    for (int proc = 1; proc < num_procs; proc++) {
      MPI_Recv(&valid, 1, MPI_INT, proc, IMAGE_TAG,
	       MPI_COMM_WORLD, &status);
      valid_procs[proc] = valid;
    }
  }

  width = w; height = h;
  nr = nrows; nc = ncols; 
  sr = start_row; sc = start_column;
  lCols = data_layout->lCols;//Total number of rows or columns on this node.
  lRows = data_layout->lRows; 

  if (!is_spy) {
    // find out minimum and maximum value in the matrix
    double minval, maxval;
    minval = maxval = data_buffer[0];

    for (int i = 0; i < lRows; i++)
      for (int j = 0; j < lCols; j++) {
	double val = data_buffer[i * lCols + j];
	if (val < minval)
	  minval = val;

	if (val > maxval)
	  maxval = val;
      }
    
    MPI_Allreduce(&minval, &minZ, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
    MPI_Allreduce(&maxval, &maxZ, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
  }

  axes_length = min (width, height) / 2;

  reshape();
  initTexture();

}

Render::~Render() {

  if (image_buffer)
    free(image_buffer);

  if (send_buffer)
    free(send_buffer);

  if (depth_buffer)
    free(depth_buffer);
 
  if (send_depth)
    free(send_depth);
  
  if (valid_procs)
    delete []valid_procs;

  /* destroy the context */
  OSMesaDestroyContext(ctx);
 
}

void Render::collect_images() {

#ifdef _RECTANGLE_

  int x, y, image_rows, image_cols, buf_size;
  unsigned char *recv_image_buf;
  GLfloat *recv_depth_buf;

  MPI_Status status;

  for (int proc = 1; proc < num_procs; proc++) {
    if (valid_procs[proc]) {
      MPI_Recv(image_info, 4, MPI_INT, proc, IMAGE_TAG, MPI_COMM_WORLD, 
	       &status);
   
      x = image_info[0];
      y = image_info[1];
      image_rows = image_info[2];
      image_cols = image_info[3];
      buf_size = image_rows * image_cols;
    
      recv_image_buf = (unsigned char*) malloc(sizeof(unsigned char) * 
					       buf_size);
      MPI_Recv(recv_image_buf, buf_size, MPI_BYTE, proc, IMAGE_TAG,
	       MPI_COMM_WORLD, &status);

      if (!is_spy) {
	recv_depth_buf = (GLfloat*) malloc(sizeof(GLfloat) * 
					   buf_size);

	MPI_Recv(recv_depth_buf, buf_size, MPI_FLOAT, proc, IMAGE_TAG,
		 MPI_COMM_WORLD, &status);
      }

      int k = 0;
    
      for (int i = y; i < image_rows + y; i++)
	for (int j = x; j < image_cols + x; j++) {
	  int index = i * width + j;
	  if (!is_spy) {
	    if (depth_buffer[index] > recv_depth_buf[k]) {
	      send_buffer[index] = recv_image_buf[k];
	      depth_buffer[index] = recv_depth_buf[k];
	    }
	  }
	  else if (recv_image_buf[k] != WHITE) {
	    send_buffer[index] = recv_image_buf[k];
	  }

	  k++;
	}
    
      free(recv_image_buf);

      if (!is_spy) {
	free(recv_depth_buf);
      }
    }
  }

#else

int buf_size = width * height;
  MPI_Status status;

  int k = 0;
  GLubyte *buf = (GLubyte*) image_buffer;

  for (int i = 0; i < buf_size * 4; i += 4)
    send_buffer[k++] = buf[i];

  unsigned char** images = new unsigned char*[num_procs];
  GLfloat** depths = new GLfloat*[num_procs];
  MPI_Request* requests = new MPI_Request[2 * num_procs];
  MPI_Status* statuses = new MPI_Status[2 * num_procs];
  int num_recvs = 0;

  for (int proc = 1; proc < num_procs; proc++) {
    if (valid_procs[proc]) {
      images[proc] = new unsigned char[buf_size];

      MPI_Irecv(images[proc], buf_size, MPI_BYTE, proc, IMAGE_TAG, 
		MPI_COMM_WORLD, &requests[num_recvs++]);
      if (!is_spy) {
	depths[proc] = new GLfloat[buf_size];
	MPI_Irecv(depths[proc], buf_size, MPI_FLOAT, proc, IMAGE_TAG,
		  MPI_COMM_WORLD, &requests[num_recvs++]);
      }
    }
  }

  MPI_Waitall(num_recvs, requests, statuses);

  unsigned char *image;
  GLfloat* depth;

  for (int proc = 1; proc < num_procs; proc++) {
    if (valid_procs[proc]) {
      image = images[proc];
      depth = depths[proc];
      if (!is_spy) {
	for (int i = 0; i < buf_size; i++)
	  if (depth_buffer[i] > depth[i]) {
	    send_buffer[i] = image[i];
	    depth_buffer[i] = depth[i];
	  }
      }
      else {
	for (int i = 0; i < buf_size; i++) {
	  if (image[i] != WHITE) {
	    send_buffer[i] = image[i];
	  }
	}
      }
 
      delete []image;
      if (!is_spy)
	delete []depth;
    }
  }

  delete []images;
  delete []requests;
  delete []statuses;
  delete []depths;

#endif

  int buf_index, image_index, color_index;
  for (int j = 0; j < width; j++) 
    for (int i = 0; i < height; i++) {
      buf_index = i * width + j;
      color_index = (int) ((unsigned char*) send_buffer)[buf_index];
      image_index = 3 * (j * height + (height - i));
      final_image[image_index + 0] = colormap[color_index][0];
      final_image[image_index + 1] = colormap[color_index][1];
      final_image[image_index + 2] = colormap[color_index][2];

    }

#ifdef _DEBUG_RENDER_

  char *filename = new char[20];

  sprintf(filename, "image.rgb");
  
  ofstream image_file(filename);
  assert(image_file.good());
 
  for (int i = 0; i < width * height * 3; i++) {
    image_file << final_image[i] << " ";
  }
  
  image_file << endl;
  image_file.close();

#endif

}

float* Render::draw() {

  if (!valid)
    return final_image;
  else if (2 * AXES_INDENT > width ||
	   2 * AXES_INDENT > height) {
    cout << "Please make the size of the drawing area larger !!!\n";
    return final_image;
  }

  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  
  if (r == DISPLAY_NODE) {
    coordinatesGL();
    coordinates();
  }
 
  dataGL();

  for (int i = 0; i < num_blocks; i++)
    if (draw_help(i))
      break;
 
  glFinish();
 
  if (!is_spy) {
    depth_buffer = (GLfloat*) malloc(sizeof(GLfloat) * width * height);
    glReadPixels(0, 0, width, height, GL_DEPTH_COMPONENT, 
		 GL_FLOAT, depth_buffer);
  }

  done_drawing();

  rectangle();

  if (r == DISPLAY_NODE)
    collect_images();
  else
    send();

  return final_image;
}

void Render::done_drawing() {}

void Render::axes(double x1, double y1, double z1, 
		  double x2, double y2, double z2) {

  line(x1, y1, z1, x2, y2, z2);
  ticks(x1, y1, z1, x2, y2, z2);
  
}

void Render::line(double x1, double y1, double z1, 
		  double x2, double y2, double z2) {

  glBegin(GL_LINES);
  glVertex3d(x1, y1, z1);
  glVertex3d(x2, y2, z2);
  glEnd();
  
}

void Render::ticks(double x1, double y1, double z1,
		   double x2, double y2, double z2) {

  if (x1 == x2) {
    ticks_help(x1, y1, y2, sr, nr + 1, true);
  }
  else {
    ticks_help(y1, x1, x2, sc, nc + 1, false);
  }

}

void Render::ticks_help(double constant, double var1, double var2,
			int first_tick, int last_tick, bool x_axis) {

  int line_length = (int) (var2 - var1);
  
  int tick_distance = min(MIN_TICK_DISTANCE, line_length);

  // Find out how many ticks we can have
  int num_ticks = line_length / tick_distance;
  
  int gap = (line_length % tick_distance) * 
    (last_tick - first_tick) / line_length;
  
  double stride = (double) (last_tick - first_tick - gap) / (double) num_ticks;

  int up_down = -1;

  if (!x_axis) {
    if (constant < height / 2) {
      up_down = 1;
    }
  }
  else if (constant < width / 2) {
    up_down = 1;
  }

  for (double i = first_tick; i <= (int) last_tick; i += stride) {
    double offset = var1 + ((i - first_tick) / stride) * tick_distance;
    if (!x_axis) {
      line(offset, constant, 0, offset, constant + TICK_LENGTH * up_down, 0);
  
      if (up_down == -1) {
	// awful hack to get around texture problem
	glColor3f(1, 0, 0);
	num((int) i, offset - NUM_BOX_SIZE / 2, constant + 2, 0);
	glColor3ub(BLACK, 0, 0);
      }
    }
    else {
      line(constant, offset, 0, constant + TICK_LENGTH * up_down, offset, 0);
  
      if (up_down == 1) {
	glColor3f(1, 0, 0);
	num((int) i, constant - NUM_BOX_SIZE, offset - NUM_BOX_SIZE / 2, 0);
	glColor3ub(BLACK, 0, 0);
      }
    }
  }
}

void Render::num(int num, double x, double y, double z) {
  
  int temp = num;
  num = abs(num);
  for (int i = 0; i < 10; i++) {
    double temp_num = (double) num / 10;
    single_num(num - ((int) temp_num * 10), x, y, z);
    x -= NUM_DISTANCE;
    if (temp_num < 1.) {
      if (temp < 0) {
	single_num(10, x, y, z);
      }
      break;
    }
    if (is_spy && x < 0)
      break;
    num = (int) temp_num;
  }
  
}

void Render::single_num(int num, double x, double y, double z) {   

    glEnable(GL_TEXTURE_2D);

    glBindTexture(GL_TEXTURE_2D, tex_ids[num]);

    glBegin(GL_QUADS);

    if (is_spy) {
      glTexCoord3i(0, 0, 0); glVertex3d(x, y, z);
      glTexCoord3i(0, 1, 0); glVertex3d(x, y + NUM_BOX_SIZE, z);
      glTexCoord3i(1, 1, 0); glVertex3d(x + NUM_BOX_SIZE, y + NUM_BOX_SIZE, z);
      glTexCoord3i(1, 0, 0); glVertex3d(x + NUM_BOX_SIZE, y, z);
    }
    else {
      glTexCoord3d(0.4, 0, 0); glVertex3d(x, y, z);
      glTexCoord3d(0.4, 1, 0); glVertex3d(x, y, z - NUM_BOX_SIZE);
      glTexCoord3d(1, 1, 0); glVertex3d(x + 0.6 * NUM_BOX_SIZE, y, 
					z - NUM_BOX_SIZE);
      glTexCoord3d(1, 0, 0); glVertex3d(x + 0.6 * NUM_BOX_SIZE, y, z);
    }

    glEnd();

    glDisable(GL_TEXTURE_2D);

}

void Render::initTexture() {

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glGenTextures(11, tex_ids);

  for (int i = 0; i < 11; i++) {
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    
    glBindTexture(GL_TEXTURE_2D, tex_ids[i]);
    
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    if (!is_spy) {
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, 
		   GL_UNSIGNED_BYTE, textures[i]);
    }
    else {
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, 
		   GL_UNSIGNED_BYTE, textures_spy[i]);
    }
  }

}
void Render::reshape() {

  /* Allocate the image buffer */
  if (image_buffer)
    free(image_buffer);

  image_buffer = malloc(width * height * 4 * sizeof(GLubyte));

  if (!image_buffer) {
    cout << "Alloc image buffer failed!\n" << endl;
    exit(1);
  }

  send_buffer = (unsigned char*) malloc(width * height * 
					sizeof(unsigned char));

  if (!send_buffer) {
    cout << "Alloc send buffer failed!\n" << endl;
    exit(1);
  }

  send_depth = (GLfloat*) malloc(width * height *
				       sizeof(GLfloat));

  if (!send_depth) {
    cout << "Alloc depth buffer failed!\n" << endl;
    exit(1);
  }

  ctx = OSMesaCreateContext( OSMESA_RGBA, NULL );
  
  if (!ctx) {
    cout << "OSMesaCreateContext failed!" << endl;
    exit(1);
  }
    
  /* Bind the buffer to the context and make it current */
  if (!OSMesaMakeCurrent(ctx, image_buffer, GL_UNSIGNED_BYTE, width, height)) {
    cout << "OSMesaMakeCurrent failed!" << endl;
    exit(1);
  }

  if (r == DISPLAY_NODE)
    final_image = new float[width * height * 3];
  
}

void Render::rectangle() {

#ifdef _RECTANGLE_ 

  int lx, ly, rx, ry;
  rx = ry = 0;
  lx = width;
  ly = height;
  
  int image_buffer_width = width * 4;

  GLubyte *buf = (GLubyte*) image_buffer;

  for (int i = 0; i < height; i++)
    for (int j = 0; j < image_buffer_width; j += 4) {
      if ((int) buf[i * image_buffer_width + j]) {
	int j_index = j / 4;
	if (lx > j_index)
	  lx = j_index;

	if (ly > i)
	  ly = i;

	if (j_index > rx)
	  rx = j_index;

	if (i > ry)
	  ry = i;
      }
    }

  int rect_rows = max(ry - ly + 1, 0);
  int rect_cols = max(rx - lx + 1, 0);

  image_info[0] = lx;
  image_info[1] = ly;
  image_info[2] = rect_rows;
  image_info[3] = rect_cols;

  int k = 0;

  if (r != DISPLAY_NODE) {
    for (int i = ly; i < rect_rows + ly; i++)
      for (int j = lx; j < rect_cols + lx; j++) {
	send_buffer[k] = buf[i * image_buffer_width + j * 4];
	if (!is_spy) {
	  send_depth[k] = depth_buffer[i * width + j];
	}
	k++;
      }
  }
  else {
    for (int i = 0; i < width * height * 4; i += 4)
      send_buffer[k++] = buf[i];
  }

#endif

}

void Render::send() {

#ifdef _RECTANGLE_

  int buf_size = image_info[2] * image_info[3];
  MPI_Send(image_info, 4, MPI_INT, 0, IMAGE_TAG, MPI_COMM_WORLD);
  MPI_Send(send_buffer, buf_size, MPI_BYTE, 0, IMAGE_TAG, MPI_COMM_WORLD);
  if (!is_spy) {
    MPI_Send(send_depth, buf_size, MPI_FLOAT, 0, IMAGE_TAG, MPI_COMM_WORLD);
  } 

#else

  int buf_size = width * height;

  int k = 0;
  GLubyte *buf = (GLubyte*) image_buffer;

  for (int i = 0; i < width * height * 4; i += 4) {
    send_buffer[k] = buf[i];
    if (!is_spy) {
      send_depth[k] = depth_buffer[k];
    }
    k++;
  }
  
  MPI_Request requests[2];
  MPI_Status statuses[2];

  int count = 0;

  MPI_Isend(send_buffer, buf_size, MPI_BYTE, 0, IMAGE_TAG, MPI_COMM_WORLD,
	    &requests[count++]);
  if (!is_spy) {
    MPI_Isend(send_depth, buf_size, MPI_FLOAT, 0, IMAGE_TAG, MPI_COMM_WORLD,
	      &requests[count++]);
  } 

  MPI_Waitall(count, requests, statuses);

#endif

}