////////////////////////////////////////////////////////////////////////////
// sender.cc
//
// Paul McCartney, Winter 1995
//
// Copyright 1995, Washington University Computer Science Department
// All Rights Reserved
//
// RCS:  $Id: sender.cc,v 1.9 1995/10/27 22:40:02 paul Exp $
//
// This module is a "server" for reading images from a RVG medical image
// file, encoding each image as a Playground tuple, and sending out each
// image to external modules.
//
// PLAYGROUND VARIABLES:
//
//  frame  (output) -  PGimage tuple, storing image data
//  file   (input)  -  string, specifying which RVG file to read from disk 
////////////////////////////////////////////////////////////////////////////
#include "PGimage.hh"
#include "PG.hh"
#include <string.h>
#include <iostream.h>
#include <fstream.h>

const int cNFrames = 32;
const int cFrameWidth = 64;
const int cFrameHeight = 64;

PGimage gFrame;
PGstring gFilename;
unsigned short buf[cNFrames][cFrameHeight][cFrameWidth];


// scan all of the images, and all of the pixels, returning the maximum
// pixel value.
unsigned short
FindMax()
{
  unsigned short v;
  unsigned short max = 0;
  for (int f=0; f<cNFrames; f++) {
    for (int y=0; y<cFrameHeight; y++) {
      for (int x=0; x<cFrameWidth; x++) {
        v = buf[f][y][x];
        if (v > max)
          max = v;
      }
    } 
  }
  return max;
}


// read all of the images from an RVG file.  Scale each pixel value so
// that the maximum pixel value is 255.  The image information is stored
// in the "buf" global variable.
bool
ReadRVG(const char* fname)
{
  ifstream inFile(fname);
  if (!inFile) {
    cout << "Unsuccessful read." << endl;
    return false;
  }
  inFile.seekg(512*4);
  inFile.read((char*)buf, cNFrames*cFrameWidth*cFrameHeight*2); // each pixel is 2 bytes

  float scale = 255.0 / (float)(FindMax());
  for (int f=0; f<cNFrames; f++) {
    for (int y=0; y<cFrameHeight; y++) {
      for (int x=0; x<cFrameWidth; x++) {
        buf[f][y][x] = (unsigned short)(scale * (float)buf[f][y][x]);
      }
    }
  }
  cout << "Successfully read RVG images." << endl;
  return true;
}


// send a single frame, based on the frame number
void
SendFrame(int num)
{
  PG::beginAtomicStep();

  gFrame.id = num;
  int offset = 0;
  unsigned char* pixels = gFrame.pixels.getBlock();

  for (int y=0; y<cFrameHeight; y++) {
    for (int x=0; x<cFrameWidth; x++) {
      pixels[offset] = (unsigned char)(buf[num][63-y][x]);
      offset++;
    }
  }
  gFrame.Send();
  cout << "Sent frame: " << num << endl;

  PG::endAtomicStep();
}


void
InitializeFrame()
{
  gFrame.SetSize(cFrameWidth, cFrameHeight);
  gFrame.SetColorTableSize(256);
  for (int i=0; i<256; i++)
    gFrame.SetColorEntry(i, i, i, i);
}


////////////////////////////////////////////////////////////////////////////
/////////////////////////////Reactive Control///////////////////////////////
////////////////////////////////////////////////////////////////////////////

// reaction method, used to set the current RVG file.  Immediately send
// out all of the frames.

class FnameReactor : public PGreactor {
public:
  virtual void react(PGvariable&) {
    cout << "Received new filename: " << gFilename << endl;
    if (ReadRVG(gFilename))
      for (int i=0; i<cNFrames; i++)
        SendFrame(i);
  };
};


int
main(int argc, char** argv)
{
  PG::initialize("sender");

  InitializeFrame();

  gFrame.publish("frame", PG::READ);
  gFilename.publish("fname", PG::WRITE);

  FnameReactor r;
  gFilename.setReactor(&r);

  while (1)
    PG::sleep(0, 200);

  PG::terminate();
  return 0;
}