view model/review.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

/*
    Copyright (c) Applied Psychology Unit, Medical Research Council. 1988, 1989
    ===========================================================================

    Permission to use, copy, modify, and distribute this software without fee
    is hereby granted for research purposes, provided that this copyright
    notice appears in all copies and in all supporting documentation, and that
    the software is not redistributed for any fee (except for a nominal shipping
    charge). Anyone wanting to incorporate all or part of this software in a
    commercial product must obtain a license from the Medical Research Council.

    The MRC makes no representations about the suitability of this
    software for any purpose.  It is provided "as is" without express or implied
    warranty.

    THE MRC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
    ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE
    A.P.U. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
    DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

/*
    review.c
    ========

    formerly known as revsai.c - reviews .ctn screen dump files from disk.


    Copyright (c), 1989  The Medical Research Council, Applied Psychology Unit.


    Authors : Paul Manson and John Holdsworth.
    Written : 11th March, 1989

    Edited  :

    03 April 1989 (Paul Manson) -- A new star on the horizon! The all-singing, all-dancing
				   new revue emerges from the ashes of last week's version.

    19 April 1989 (Paul Manson) -- Added the <input> option. Changed the name to revsai.

    27 April 1989 (Paul Manson) -- The port to the DecStation (and by implication, the VAX)
				   has revealed several problems and bugs. All such known
				   bugs have been fixed. The <memory> option has been
				   introduced (for non-PCs only) to permit rapid reviewing
				   on X-windows servers. NOTE THAT THE SCREEN SIZE FOR NON
				   PC MACHINES HAS BEEN HARD_CODED! THIS SHOULD CHANGE!

    05 May   1989 (Paul Manson) -- The above problem has been temporarily rectified by
				   using the default width and height options to indicate
				   the actual screen size. Also, the options format change
				   has been accounted for.

    11 May   1989 (Paul Manson) -- Altered options to conform to the new(est) r'egime.

    15 May   1989 (Paul Manson) -- Incorporated the PC-style wildcarding into the Unix version.
				   Made display use "NULL" instead of (char *) 0.

    05 June  1989 (Paul Manson) -- Altered a couple of the option comments to reflect their
				   behaviour more accurately. I also encountered the rather
				   suspicious "bug" whereby revsai gets a segmentation fault
				   whenever it is run on an old "sai" file ... those generated
				   by sai now appear to be OK... If this really is a problem,
				   it should be tracked down!

    06 July  1989 (Paul Manson) -- As well as altering revsai to accomodate all of the new
				   options names, I note that the abovementioned bug appears
				   to have disappeared without trace; hopefully it was just
				   due to previous (buggy) files, etc.

    3 August 1993 (M. Akeroyd) --  Added declarations of "colourstr"  and "planemaskstr".
                                   They aren't used, but are in X.c (and thus libglib.a),
				   and are therfore required to fool the linker.

    25 March 1994 (M. Akeroyd) --  Added colour. mono etc, so that 'review' would actually work.
                                   (the previuos cahnge just made it compile.)
*/

#include <string.h>
#include <stdio.h>
#include <math.h>

#if defined(THINK_C) || defined(NeXT) 
#include <stdlib.h>
#else
#include <malloc.h>
#endif

#include "windows.h"
#include "options.h"


char *monostr, *colourstr, *planemaskstr;   /* MAA 3-8-1993 */
char *fgcolourstr, *bgcolourstr;  /* MAA 19-8-1993 */
#ifndef  lint
static char *sccs_id = "@(#)review.c	1.13 Paul Manson, John Holdsworth (MRC-APU) 5/31/91";
#endif

#define max(A,B) (((A) > (B)) ? (A) : (B))
#define LENGTH_STR "remainder"
#define MAX_LENGTH (9999)

#define CENTER_STR "center"
#define IMAGE_SUFFIX ".ctn"

#ifdef PC
#define READ_BINARY "rb"
#else
#define READ_BINARY "r"
#endif

/* configurables */

static char *helpstr                               ;
static char *speed1str, *speed2str                 ;
static char *xstr, *ystr, *widthstr,  *heightstr   ;
static char *start1str,   *stop1str,  *step1str    ;
static char *start2str,   *stop2str,  *step2str    ;
static char *minstr ,     *maxstr  ,  *framestr    ;
static char *in1str,      *in2str,    *downstr     ;

#if !defined( PC )
extern void exit();
static char *memorystr;
#endif

static Option res[] = {
 { "help",       "none",       &helpstr,   "<wave1> [<wave2>]\n\n\
	Redisplays stored images from memory or directly from disk.\n\
	Review responds to various simple commands, viz.\n\n\
	1\t Activate only wave1 (default when only one wave named).\n\
	2\t Activate only wave2.\n\
	b or B\t Activate Both waves (default when two waves named).\n\n\
	a or A\t Animate cartoon wave(s). Hitting space bar is equivalent.\n\
	s or S\t Single-step activated wave(s). Hit space bar to step.\n\
	+\t Animate activated wave(s) faster.\n\
	-\t Animate activated wave(s) slower.\n\n\
	q or Q\t Quit Revue.\n", SilentOption },
 { "input1",   NULL_OPTION,  &in1str,     "Default input file name 1",               InputOption},
 { "start1" ,     "0" ,      &start1str , "Start point in wave 1 (in ms)",           InputOption},
 { "length1", LENGTH_STR,    &stop1str  , "Length of wave 1 to display (in ms)",     InputOption},
 { "step1"  ,     "1" ,      &step1str  , "Display every step-th image of wave 1",   InputOption},
 { "speed1",     "1" ,       &speed1str,  "Image 1 display speed (1 is  fastest)", InputOption},

 { "input2",   NULL_OPTION,  &in2str,     "Default input file name 2\n",             InputOption},
 { "start2" ,     "0" ,      &start2str , "Start point in wave 2 (in ms)",           InputOption},
 { "length2", LENGTH_STR,    &stop2str  , "Length of wave 2 to display (in ms)",     InputOption},
 { "step2"  ,     "1" ,      &step2str  , "Display every step-th image of wave 2",   InputOption},
 { "speed2",     "1" ,       &speed2str,  "Image 2 display speed (1 is  fastest)",   InputOption},

 { "x0_win",  CENTER_STR,    &xstr,       "Left edge of window (in pixels)" ,        SilentOption},
 { "y0_win",  CENTER_STR,    &ystr,       "Upper edge of window (in pixels)",        SilentOption},
 { "width_screen", "960",    &widthstr,   "Physical screen width  in pixels",        SilentOption},
 { "height_screen","750",    &heightstr,  "Physical screen height in pixels",        SilentOption},

/* MAA: 25 March 1994
 * These next added because they are used from within X.c (although defined in gen.c), and thus the graphics
 * calls. They are of NO meaning, however; they define how the Model makes the bitmaps.
 * Once made, you cannot edit bitmaps ... 
 */
 { "fg_col",         "black", &fgcolourstr, "Foreground Colour.\n",                   SilentOption},
 { "bg_col",         "white", &bgcolourstr, "Background Colour.\n",                   SilentOption},
 {    "mono_ctn",   ON_OPTION, &monostr, "Force monochrome (single plane) cartoons.", SilentOption},
 {  "colour_ctn",  OFF_OPTION, &colourstr, "Force colour (multi-plane) cartoons.", SilentOption},
 {"planemask_ctn", "1", &planemaskstr, "Planemask for creating cartoons.\n", SilentOption},
/* MAA: End of that bit */

#if !defined( PC )
 { "memory",     ON_OPTION,  &memorystr,  "Read images into memory for reviewing\n", InputOption},
#endif
 ( char * ) 0 } ;

static Option hiddenRes[] = {
 { "downsample",     "20",   &downstr,    "Image file frame size (in ms)",           InputOption},
 { "frstep_aid",     "20",   &framestr,   "Image file frame size (in ms)",           InputOption},
 { "mincf_afb",     "220",   &minstr  ,   "Minimum Center Frequency in Hertz",       InputOption},
 { "maxcf_afb",    "4400",   &maxstr  ,   "Maximum Center Frequency in Hertz",       InputOption},
 { "width_win",     "900",   &widthstr,   "Window width  (pixels)",                  InputOption},
 { "height_win",    "600",   &heightstr,  "Window height (pixels)",                  InputOption},
 ( char * ) 0 } ;

#define ONE (1)
#define TWO (2)
#define BOTH (0)

#define FALSE (0)
#define TRUE (1)
#define OVERTHETOP (10000)
#define AXES_WIDTH (15)

static int msToImages(frame, ms)
  double frame;
  double ms   ;
{
  return (((int) (ms / frame)) + 1); /* Round Up */
}

/* File Name Suffix Conversion Parameters */

#define BACKSLASH_CHAR  '\\'
#define SLASH_CHARACTER '/'
#define NULL_CHARACTER  '\000'
#define DOT_CHARACTER '.'

/******************************************************************************************/
/*                                                                                        */
/*    AlterSuffix(). Returns its argument fileName with a newSuffix appended in place of  */
/*                   any previous suffix it may have had. It should be noted that this    */
/*                   suffix must include any DOT it wishes to have appended to the name.  */
/*                                                                                        */
/******************************************************************************************/

char *AlterSuffix(fileName, newSuffix)
     char *fileName, *newSuffix;
{
  char *temp, *temp2, *lastPart;
  int i;

  temp = malloc((unsigned) (strlen(fileName) + strlen(newSuffix) + 1));

  temp = strcpy(temp, fileName);

#if defined( PC )
  /* Change all backslashes to forward slashes */
  for (i = 0; temp[i] != NULL_CHARACTER; i++)
    if (temp[i] == BACKSLASH_CHAR)
      temp[i] = SLASH_CHARACTER;
#endif

  if ((lastPart = strrchr(temp, SLASH_CHARACTER)) == NULL)
    lastPart = temp;
  else
    lastPart++; /* Skip over the actual "/" */

  /* lastPart points to the tail name of the path */

  if ((temp2 = strchr(lastPart, DOT_CHARACTER)) == NULL)
    temp = strcat(temp, newSuffix);
  else
    temp2 = strcpy(temp2, newSuffix);

  return (temp);
}

/* -----------------------------------------------------------------------------------

   A Routine to extend revsai for in-memory animation. This copies every image from
   <start> to <stop> by <step> into the images buffer for the window <w>. It then
   expects contiguous animation of these images. The integer returned is the number
   of images that were saved; subsequent image Recall() calls should refer to images
   in the range [1 .. this returned value].

   ----------------------------------------------------------------------------------- */

static int readIntoMemory(w, filePtr, start, stop, step)
     WindowObject w;
     FILE *filePtr ;
     int      start;
     int       stop;
     int       step;
{
  int fileImage, memImage;

  memImage = 0;

  fileImage = start;

  while (fileImage <= stop && Read(w, filePtr, fileImage)) {
    Store(w);
    fileImage += step;
    memImage++;
  }

  return (memImage);
}

main( argc, argv )
int argc ;
char *argv[] ;
{
    WindowObject w1, w2;
    int   screenWidth,  screenHeight ;
    int   firstWidth ,  firstHeight  ;
    int   secondWidth,  secondHeight ;
    int   firstPixels,  secondPixels ;
    FILE *firstWave  , *secondWave   ;

    int OneWave, TwoWaves, spareWidth,
	spareHeight                  ;

    int waveMode , image1    , image2;
    int            count1    , count2;
    int stopFirst, stopSecond        ;
    int start1   , stop1     , step1 ;
    int start2   , stop2     , step2 ;
    int speed1   , speed2            ;

    char command, *firstWaveName,
      *secondWaveName,
      *programName;

    double mincf1, mincf2, maxcf1, maxcf2, frame1, frame2;
    int inMemory, x, y;

    programName = argv[0];

    (void) getopts( res, &argc, &argv );

    /* Extract any information from the opts which is NECESSARY for the
       operation of revue */

    screenWidth = atoi( widthstr );
    screenHeight= atoi( heightstr);

#if defined( PC )
    inMemory = FALSE;
#else
    inMemory = isON( memorystr );
#endif

    if (argc > 2 || (argc == 0 && isNULL(in1str))) {
      (void) helpopts(res, programName);
      exit(1);
    }
    else {
      OneWave = ((argc == 0 && !isNULL(in1str)) ||
		 (argc == 1 &&  isNULL(in2str)));
      TwoWaves = !OneWave;
    }

    if (argc == 0)
      firstWaveName = AlterSuffix(in1str, IMAGE_SUFFIX) ;
    else
      firstWaveName = AlterSuffix(argv[0], IMAGE_SUFFIX);

    if ((firstWave = fopen(firstWaveName, READ_BINARY )) == NULL) {
      (void) fprintf(stderr, "Could not open the image file %s.\n", firstWaveName);
      exit(1);
    }

    (void) readopts(res, firstWave);

    if (fseek(firstWave, 0l, 0)) {
	(void) fprintf(stderr, "revsai: Could not re-seek the %s file.\n",
		       firstWaveName);
	exit(1);
    }

    (void) readopts(hiddenRes, firstWave);

    if( framestr == (char *) 0 )
		if( downstr == (char *) 0 )
		 	frame1 = 1 ;
		else
			frame1 = atof(downstr);
    else if ((frame1 = atof(framestr)) < 0.0)
	frame1 = 0.0;

    firstWidth  = atoi( widthstr );
    firstHeight = atoi( heightstr);

    start1 = msToImages(frame1, atof( start1str ));

    if (strcmp(stop1str, LENGTH_STR) == 0)
      stop1 = MAX_LENGTH;
    else
      stop1  = msToImages(frame1, atof( stop1str  )) + start1;

    step1  = atoi( step1str  );
    if (step1 < 1)
      step1 = 1;

    firstPixels = 1; /* atoi( pixelstr ); */

    mincf1 = atof( minstr );
    maxcf1 = atof( maxstr );

    if (TwoWaves) {

      if (argc == 1)
	secondWaveName = AlterSuffix(in2str, IMAGE_SUFFIX);
      else
	secondWaveName = AlterSuffix(argv[1],IMAGE_SUFFIX);

      if ((secondWave = fopen(secondWaveName, READ_BINARY )) == NULL) {
	(void) fprintf(stderr, "Could not open the image file %s.\n",
		       secondWaveName);
	exit(1);
      }

      (void) readopts(res, secondWave);
      if (fseek(secondWave, 0l, 0)) {
	  (void) fprintf(stderr, "revsai: Could not re-seek the %s file.\n",
			 secondWaveName);
	  exit(1);
      }
      (void) readopts(hiddenRes, secondWave);

      if( framestr == (char *) 0 )
		if( downstr == (char *) 0 )
		 	frame2 = 1. ;
		else
		  frame2 = atof(downstr);
      else if ((frame2 = atof(framestr)) < 0.0)
	  frame2 = atof(downstr);

      secondWidth  = atoi( widthstr );
      secondHeight = atoi( heightstr);

      start2 = msToImages(frame2, atof( start2str ));

      if (strcmp(stop2str, LENGTH_STR) == 0)
	stop2 = MAX_LENGTH;
      else
	stop2  = msToImages(frame2, atof( stop2str  )) + start2;

      step2  = atoi( step2str  );
      if (step2 < 1)
	step2 = 1;

      secondPixels = 1; /* atoi( pixelstr ); */

      mincf2 = atof( minstr );
      maxcf2 = atof( maxstr );

    }


    /* Open display window(s) */

    if (TwoWaves) {
      /* Center them both for height, but try to fit them both on the screen
	 at once, width-wise. Firstly, get the REAL screen size */
#if defined( PC )
      w1 = newDisplayWindow(firstWaveName, -1, -1, OVERTHETOP, OVERTHETOP, 1);
      screenWidth  = Width(w1);
      screenHeight = Height(w1);
      Close(w1);
#endif

      if (screenHeight < firstHeight || screenHeight < secondHeight) {
	(void) fprintf(stderr, "revsai: One (or both) of the waves specified was too\n        high for this screen.\n");
	exit(1);
      }
      if (screenWidth < firstWidth + secondWidth) {
	(void) fprintf(stderr, "revsai: These two waves are too wide to be viewed side-by-side.\n        Please revue them one at a time, or perhaps generate them smaller.\n");
	exit(1);
      }

      spareWidth  = screenWidth  - (firstWidth  + secondWidth  + (2 * AXES_WIDTH));
      spareHeight = screenHeight - (firstHeight + (2 * AXES_WIDTH));

      w1 = newDisplayWindow(firstWaveName, spareWidth/6 + AXES_WIDTH, spareHeight/2,
			    firstWidth, firstHeight, firstPixels);
      Axes(w1, firstWaveName, 0.0, frame1, "Image Frame Size (in ms)",
	       mincf1, maxcf1, "Center Frequency (in Hz)");

      spareHeight = screenHeight - (secondHeight + (2 * AXES_WIDTH));

      w2 = newDisplayWindow(secondWaveName, (5 * spareWidth / 6) +
				     firstWidth + (2 * AXES_WIDTH),
				     spareHeight/2, secondWidth, secondHeight,
				     secondPixels);
      Axes(w2, secondWaveName, 0.0, frame2, "Image Frame Size (in ms)",
	       mincf2, maxcf2, "Center Frequency (in Hz)");
    }
    else {
      /* Easy .. MetaPC Centers it for us */
      if (OptionStringsEqual(xstr, CENTER_STR))
	x = -1;
      else
	x = atoi(xstr);

      if (OptionStringsEqual(ystr, CENTER_STR))
	y = -1;
      else
	y = atoi(ystr);

      w1 = newDisplayWindow(firstWaveName, x, y, firstWidth, firstHeight,
			    firstPixels );
      Axes(w1, firstWaveName, 0.0, frame1, "Image Frame Size (in ms)",
	       mincf1, maxcf1, "Center Frequency (in Hz)");

#if defined( SUN )
      /* Kludge to overcome the window-sizing inconsistency when
	 you open a SunView window with a frame */

      if (Height(w1) >  firstHeight || Width(w1) >  firstWidth) {
#else
      if (Height(w1) != firstHeight || Width(w1) != firstWidth) {
#endif
	(void) fprintf(stderr, "revsai: The wave you wish to view is too large (ie. either too wide\nor too tall) for the current screen.\n");
	exit(1);
      }
    }

    /* Do the actual reviewing */

    if (TwoWaves)
      waveMode = BOTH;
    else
      waveMode = ONE ;

    speed1 = atoi( speed1str );
    if (speed1 < 1)
      speed1 = 1;
    speed2 = atoi( speed2str );
    if (speed2 < 1)
      speed2 = 1;

    /* Initially, just open the files and display the first frame of each, */
    /* UNLESS the inMemory switch is set, in which case you should read in */
    /* all of the images and adjust start, stop to suit.                   */

    if (inMemory) {
	stop1 = readIntoMemory(w1, firstWave, start1, stop1, step1);
	start1 = 1; /* Now runs from 0 to the adjusted stop */
	step1  = 1; /* Now the images are contiguous        */
	if (TwoWaves) {
	  stop2 = readIntoMemory(w2, secondWave, start2, stop2, step2);
	  start2 = 1; /* Now runs from 0 to the adjusted stop */
	  step2  = 1; /* Now the images are contiguous        */
	}
    }
    else {
      if (!Read(w1, firstWave, start1)) {
	(void) fprintf(stderr, "revsai: Could not read the first image from the first wave.\n");
	exit(1);
      }

      if (TwoWaves && !Read(w2, secondWave, start2)) {
	(void) fprintf(stderr, "revsai: Couldn't read the first image from the second wave.\n");
	exit(1);
      }
    }

    /* Sit and take commands */

    while ((command = Pause(w1)) != 'q' && command != 'Q') {
      switch (command) {
      case '1':
	    /* Toggle to Wave number One */
	    waveMode = ONE;
	break;
      case '2':
	    /* Try to toggle to Wave number Two */
	    if (TwoWaves)
	      waveMode = TWO;
	    break;
      case 'b': case 'B':
	    /* Try to toggle to Both Waves */
	    if (TwoWaves)
	      waveMode = BOTH;
	    break;
      case '+':
	    /* Speed up current Wave(s) */
	if (waveMode == ONE || waveMode == BOTH)
	  speed1 = ((speed1 > 1) ? (speed1 /= 2) : (1));
	    if (waveMode == TWO || waveMode == BOTH)
	  speed2 = ((speed2 > 1) ? (speed2 /= 2) : (1));
	    break;
      case '-':
	    /* Slow down current Wave(s) */
	if (waveMode == ONE || waveMode == BOTH)
	  speed1 *= 2;
	    if (waveMode == TWO || waveMode == BOTH)
	  speed2 *= 2;
	    break;
      case 's': case 'S':
	stopFirst  = (waveMode == TWO);
	stopSecond = (waveMode == ONE);
	image1 = start1;
	image2 = start2;
	while (!(stopFirst && stopSecond) && (Pause(w1) == ' ')) {
	    if (!stopFirst) {
		if (inMemory)
			  Recall(w1, image1);
		else
			  stopFirst  = !Read(w1, firstWave , image1);
		if (!stopFirst) {
			  image1 += step1;
			  stopFirst = (image1 > stop1);
		}
	    }
	    if (!stopSecond) {
		if (inMemory)
			  Recall(w2, image2);
			else
			  stopSecond = !Read(w2, secondWave, image2);
		if (!stopSecond) {
			  image2 += step2;
			  stopSecond = (image2 > stop2);
		}
	    }
	}
	break;
      case 'a': case 'A': case ' ':
	stopFirst  = (waveMode == TWO);
	stopSecond = (waveMode == ONE);
	image1 = start1;
	image2 = start2;
	count1 = count2 = 0    ;
	while (!(stopFirst && stopSecond)) {
		if (stopFirst || image1 > stop1) {
		if (waveMode == BOTH && !stopSecond && image2 <= stop2 &&
		    image1 > start1  && count1 == 0) {
			/* Redisplay the previous image for constant speed */
			if (inMemory)
			  Recall(w1, image1-1);
			else
			  stopFirst = !Read(w1, firstWave, image1-1);
		    }
		    stopFirst = TRUE;
		}
		else {
		    if (inMemory)
		      Recall(w1, image1);
		    else
		      stopFirst = !Read(w1, firstWave, image1);
		    if (!stopFirst)
			    if (++count1 >= speed1) {
			      image1 += step1;
			      count1  = 0    ;
			}
	    }
		if (stopSecond || image2 > stop2) {
		if (waveMode == BOTH && !stopFirst && image1 <= stop1 &&
		    image2 > start2  && count2 == 0) {
			/* Redisplay the previous image for constant speed */
			if (inMemory)
			  Recall(w2, image2-1);
			else
			  stopSecond = !Read(w2, secondWave, image2-1);
			}
		    stopSecond = TRUE;
		}
		else {
		    if (inMemory)
		      Recall(w2, image2);
		    else
		      stopSecond = !Read(w2, secondWave, image2);
		    if (!stopSecond)
			    if (++count2 >= speed2) {
			      image2 += step2;
			      count2  = 0    ;
			}
	    }
	}
	break;
      default:
	    break;
      }
    }
    if (fclose(firstWave)) {
	(void) fprintf(stderr, "revsai: Could not close file % correctly.\n",
		       firstWaveName);
	exit(1);
    }
    if (TwoWaves && fclose(secondWave)) {
	(void) fprintf(stderr, "revsai: Could not close file % correctly.\n",
		       secondWaveName);
	exit(1);
    }
  }