コード例 #1
0
ファイル: pgplot-module.c プロジェクト: hankem/ISIS
/* read cursor position */
static int _pgcurs (void)
{
   float x, y;
   char ch;

   x = y = 0;
   ch = 0;

   (void) cpgcurs (&x, &y, &ch);
   (void) push_2_doubles (x, y);

   return (int) (unsigned char) ch;
}
コード例 #2
0
ファイル: exploredat.c プロジェクト: SixByNine/presto
int main(int argc, char *argv[])
{
   float minval = SMALLNUM, maxval = LARGENUM, inx = 0, iny = 0;
   int centern, offsetn;
   int zoomlevel, maxzoom = 0, minzoom, xid, psid;
   char *rootfilenm, inchar;
   datapart *lodp;
   dataview *dv;
   basicstats *statvals;

   if (argc == 1) {
      printf("\nusage:  exploredat datafilename\n\n");
      exit(0);
   }

   printf("\n\n");
   printf("      Interactive Data Explorer\n");
   printf("         by Scott M. Ransom\n");
   printf("            November, 2001\n");
   print_help();

   {
      int hassuffix = 0;
      char *suffix;

      hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix);
      if (hassuffix) {
         if (strcmp(suffix, "dat") != 0) {
            printf
                ("\nInput file ('%s') must be a single PRESTO data file ('.dat')!\n\n",
                 argv[1]);
            free(suffix);
            exit(0);
         }
         free(suffix);
      } else {
         printf("\nInput file ('%s') must be a PRESTO data file ('.dat')!\n\n",
                argv[1]);
         exit(0);
      }
   }

   /* Read the info file */

   readinf(&idata, rootfilenm);
   if (idata.object) {
      printf("Examining %s data from '%s'.\n\n",
             remove_whitespace(idata.object), argv[1]);
   } else {
      printf("Examining data from '%s'.\n\n", argv[1]);
   }
#ifdef USEMMAP
   mmap_file = open(argv[1], O_RDONLY);
   {
      int rt;
      struct stat buf;

      rt = fstat(mmap_file, &buf);
      if (rt == -1) {
         perror("\nError in fstat() in exploredat.c");
         printf("\n");
         exit(-1);
      }
      Ndat = buf.st_size / sizeof(float);
   }
   lodp = get_datapart(0, Ndat);
#else
   {
      int numsamp;

      datfile = chkfopen(argv[1], "rb");
      Ndat = chkfilelen(datfile, sizeof(float));
      numsamp = (Ndat > MAXPTS) ? (int) MAXPTS : (int) Ndat;
      lodp = get_datapart(0, numsamp);
   }
#endif

   /* Plot the initial data */

   centern = 0.5 * INITIALNUMPTS;
   if (centern > lodp->nn)
      centern = lodp->nn / 2;
   zoomlevel = LOGMAXDISPNUM - LOGINITIALNUMPTS;
   minzoom = LOGMAXDISPNUM - LOGMAXPTS;
   maxzoom = LOGMAXDISPNUM - LOGMINDISPNUM;
   dv = get_dataview(centern, zoomlevel, lodp);

   /* Prep the XWIN device for PGPLOT */

   xid = cpgopen("/XWIN");
   if (xid <= 0) {
      free_datapart(lodp);
#ifdef USEMMAP
      close(mmap_file);
#else
      fclose(datfile);
#endif
      free(dv);
      exit(EXIT_FAILURE);
   }
   cpgask(0);
   cpgpage();
   offsetn = plot_dataview(dv, minval, maxval, 1.0);

   do {
      cpgcurs(&inx, &iny, &inchar);
      if (DEBUGOUT)
         printf("You pressed '%c'\n", inchar);

      switch (inchar) {
      case ' ':                /* Toggle stats and sample plotting on/off */
         /* 0 = both, 1 = stats only, 2 = data only */
         plotstats++;
         plotstats = plotstats % 3;
         cpgpage();
         offsetn = plot_dataview(dv, minval, maxval, 1.0);
         break;
      case 'M':                /* Toggle between median and average */
      case 'm':
         usemedian = (usemedian) ? 0 : 1;
         free(dv);
         dv = get_dataview(centern, zoomlevel, lodp);
         cpgpage();
         offsetn = plot_dataview(dv, minval, maxval, 1.0);
         break;
      case 'A':                /* Zoom in */
      case 'a':
         centern = inx + offsetn;
      case 'I':
      case 'i':
         if (DEBUGOUT)
            printf("  Zooming in  (zoomlevel = %d)...\n", zoomlevel);
         if (zoomlevel < maxzoom) {
            zoomlevel++;
            free(dv);
            dv = get_dataview(centern, zoomlevel, lodp);
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
         } else
            printf("  Already at maximum zoom level (%d).\n", zoomlevel);
         break;
      case 'X':                /* Zoom out */
      case 'x':
      case 'O':
      case 'o':
         if (DEBUGOUT)
            printf("  Zooming out  (zoomlevel = %d)...\n", zoomlevel);
         if (zoomlevel > minzoom) {
            zoomlevel--;
            free(dv);
            dv = get_dataview(centern, zoomlevel, lodp);
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
         } else
            printf("  Already at minimum zoom level (%d).\n", zoomlevel);
         break;
      case '<':                /* Shift left 1 full screen */
         centern -= dv->numsamps + dv->numsamps / 8;
      case ',':                /* Shift left 1/8 screen */
         if (DEBUGOUT)
            printf("  Shifting left...\n");
         centern -= dv->numsamps / 8;
         {                      /* Should probably get the previous chunk from the datfile... */
            double lowestr;

            lowestr = 0.5 * dv->numsamps;
            if (centern < lowestr)
               centern = lowestr;
         }
         free(dv);
         dv = get_dataview(centern, zoomlevel, lodp);
         cpgpage();
         offsetn = plot_dataview(dv, minval, maxval, 1.0);
         break;
      case '>':                /* Shift right 1 full screen */
         centern += dv->numsamps - dv->numsamps / 8;
      case '.':                /* Shift right 1/8 screen */
         centern += dv->numsamps / 8;
         if (DEBUGOUT)
            printf("  Shifting right...\n");
         {                      /* Should probably get the next chunk from the datfile... */
            double highestr;

            highestr = lodp->nlo + lodp->nn - 0.5 * dv->numsamps;
            if (centern > highestr)
               centern = highestr;
         }
         free(dv);
         dv = get_dataview(centern, zoomlevel, lodp);
         cpgpage();
         offsetn = plot_dataview(dv, minval, maxval, 1.0);
         break;
      case '+':                /* Increase height of top edge */
         {
            float dy;

            if (maxval > 0.5 * LARGENUM) {
               printf("  Auto-scaling of top edge is off.\n");
               if (minval < 0.5 * SMALLNUM)
                  dy = dv->maxval - dv->minval;
               else
                  dy = dv->maxval - minval;
               maxval = dv->maxval + 0.1 * dy;
            } else {
               if (minval < 0.5 * SMALLNUM)
                  dy = maxval - dv->minval;
               else
                  dy = maxval - minval;
               maxval += 0.1 * dy;
            }
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
            break;
         }
      case '_':                /* Decrease height of top edge */
         {
            float dy;

            if (maxval > 0.5 * LARGENUM) {
               printf("  Auto-scaling of top edge is off.\n");
               if (minval < 0.5 * SMALLNUM)
                  dy = dv->maxval - dv->minval;
               else
                  dy = dv->maxval - minval;
               maxval = dv->maxval - 0.1 * dy;
            } else {
               if (minval < 0.5 * SMALLNUM)
                  dy = maxval - dv->minval;
               else
                  dy = maxval - minval;
               maxval -= 0.1 * dy;
            }
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
            break;
         }
      case '=':                /* Increase height of bottom edge */
         {
            float dy;

            if (minval < 0.5 * SMALLNUM) {
               printf("  Auto-scaling of bottom edge is off.\n");
               if (maxval > 0.5 * LARGENUM)
                  dy = dv->maxval - dv->minval;
               else
                  dy = maxval - dv->minval;
               minval = dv->minval + 0.1 * dy;
            } else {
               if (maxval > 0.5 * LARGENUM)
                  dy = dv->maxval - minval;
               else
                  dy = maxval - minval;
               minval += 0.1 * dy;
            }
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
            break;
         }
      case '-':                /* Decrease height of bottom edge */
         {
            float dy;

            if (minval < 0.5 * SMALLNUM) {
               printf("  Auto-scaling of bottom edge is off.\n");
               if (maxval > 0.5 * LARGENUM)
                  dy = dv->maxval - dv->minval;
               else
                  dy = maxval - dv->minval;
               minval = dv->minval - 0.1 * dy;
            } else {
               if (maxval > 0.5 * LARGENUM)
                  dy = dv->maxval - minval;
               else
                  dy = maxval - minval;
               minval -= 0.1 * dy;
            }
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
            break;
         }
      case 'S':                /* Auto-scale */
      case 's':
         printf("  Auto-scaling is on.\n");
         minval = SMALLNUM;
         maxval = LARGENUM;
         cpgpage();
         offsetn = plot_dataview(dv, minval, maxval, 1.0);
         break;
      case 'G':                /* Goto a time */
      case 'g':
         {
            char timestr[50];
            double time = -1.0;

            while (time < 0.0) {
               printf
                   ("  Enter the time (s) from the beginning of the file to go to:\n");
               fgets(timestr, 50, stdin);
               timestr[strlen(timestr) - 1] = '\0';
               time = atof(timestr);
            }
            offsetn = 0.0;
            centern = (int) (time / idata.dt + 0.5);
            printf("  Moving to time %.15g (data point %d).\n", time, centern);
            free(dv);
            dv = get_dataview(centern, zoomlevel, lodp);
            cpgpage();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
         }
         break;
      case '?':                /* Print help screen */
         print_help();
         break;
      case 'P':                /* Print the current plot */
      case 'p':
         {
            int len;
            char filename[200];

            printf("  Enter the filename to save the plot as:\n");
            fgets(filename, 195, stdin);
            len = strlen(filename) - 1;
            filename[len + 0] = '/';
            filename[len + 1] = 'C';
            filename[len + 2] = 'P';
            filename[len + 3] = 'S';
            filename[len + 4] = '\0';
            psid = cpgopen(filename);
            cpgslct(psid);
            cpgpap(10.25, 8.5 / 11.0);
            cpgiden();
            offsetn = plot_dataview(dv, minval, maxval, 1.0);
            cpgclos();
            cpgslct(xid);
            filename[len] = '\0';
            printf("  Wrote the plot to the file '%s'.\n", filename);
         }
         break;
      case 'V':                /* Show the basic statistics for the current dataview */
      case 'v':
         statvals = calc_stats(dv, lodp);
         printf("\n  Statistics:\n"
                "    Low sample               %d\n"
                "    Number of samples        %d\n"
                "    Low time (s)             %.7g\n"
                "    Duration of samples (s)  %.7g\n"
                "    Maximum value            %.7g\n"
                "    Minimum value            %.7g\n"
                "    Average value            %.7g\n"
                "    Median value             %.7g\n"
                "    Standard Deviation       %.7g\n"
                "    Skewness                 %.7g\n"
                "    Kurtosis                 %.7g\n\n",
                dv->lon, dv->numsamps, dv->lon * idata.dt, dv->numsamps * idata.dt,
                statvals->max, statvals->min, statvals->average,
                statvals->median, statvals->stdev,
                statvals->skewness, statvals->kurtosis);
         free(statvals);
         break;
      case 'Q':                /* Quit */
      case 'q':
         printf("  Quitting...\n");
         free(dv);
         cpgclos();
         break;
      default:
         printf("  Unrecognized option '%c'.\n", inchar);
         break;
      }
   } while (inchar != 'Q' && inchar != 'q');

   free_datapart(lodp);
#ifdef USEMMAP
   close(mmap_file);
#else
   fclose(datfile);
#endif
   printf("Done\n\n");
   return 0;
}
コード例 #3
0
ファイル: dialog.C プロジェクト: SixByNine/sigproc
int dialog::manage(float * x, float * y, char * ans, int * plotno){

  int leave;
  int button = 0;
  *plotno = -1;
  *ans = ' ';
  static float lastx, lasty;

  *x=lastx;
  *y=lasty;

  leave = 0;
  while (!leave){

  // get a keypress
    cpgsvp(0.0,1.0,0.0,1.0);
    cpgswin(0.0,1.0,0.0,1.0);
    cpgcurs(x,y,ans);
    lastx=*x;
    lasty=*y;
    button = -1;
  // First of all, check if it is inside a plot
     for (int i=0;i<nplotregion;i++){
       if (plotregions[i].inside(x,y)){


         button = -1;
         *plotno = i;
	 leave = 1;
        } 
     }
  // Then check if it is inside a button
     for (int i=0;i<nbutton;i++){
       buttons[i].pressed = 0;
       if (buttons[i].inside(*x,*y)){
         button = i;
         buttons[i].pressed = 1;
	 leave = 1;
        } 
     }

  // Then radio controls
     for (int i=0;i<nradio;i++){
       if (radios[i].inside(*x,*y)){
        //  zero all in the group
        for (int j=0;j<nradio;j++) 
          if (radios[j].groupid==radios[i].groupid) {
	    radios[j].on=0;
	    radios[j].draw();
	  }
        // draw this one
	radios[i].on=1;
	  radios[i].draw();
	  leave = 0;
        } 
      }

  // Then check boxes controls
     for (int i=0;i<ncheck;i++){
       if (checks[i].inside(*x,*y)){
         checks[i].toggle();
         checks[i].draw();
	 leave=0;
        } 
     }
  // else stay in loop unless q pressed.
  }
  return(button);
}
コード例 #4
0
ファイル: find_dither.c プロジェクト: MCTwo/CodeCDF
void get_init_shift(Secat *cat1, int ncat1, Secat *cat2, int ncat2, 
		    Pos *initshift)
{
  int no_error = 1;    /* Flag set to 0 on error */
  float cx,cy;         /* Cursor position */
  char cchar='0';      /* Character returned by cursor command */
  Pos cpos;            /* Cursor position */
  Secat bestmatch1;    /* Closest match to cursor position in image 1 */
  Secat bestmatch2;    /* Closest match to cursor position in image 2 */


  /*
   * Get the desired position in image 1
   */

  printf("---------------------------------------------------------------\n");
  if(no_error) {
    cx = 0.0;
    cy = 0.0;
    printf("\n");
    printf("Find a compact object that is clearly detected in both images\n");
    printf("Click the mouse on the object in the FIRST image\n");
    cpgslct(1);
    if(cpgcurs(&cx,&cy,&cchar)>0) {
      printf("\nMouse clicked at: %7.2f %7.2f\n",cx,cy);
      cpos.x = cx;
      cpos.y = cy;
      bestmatch1 = find_closest(cpos,cat1,ncat1);
      printf("Position of closest match is: %7.2f %7.2f\n",
	     bestmatch1.x,bestmatch1.y);
      markcatobj(bestmatch1);
    }
    else {
      fprintf(stderr,"*** Invalid cursor input ***\n");
      no_error = 0;
    }
  }

  /*
   * Now get position in image 2
   */

  if(no_error) {
    printf("\n Now click the mouse on the object in the SECOND image\n");
    cpgslct(2);
    if(cpgcurs(&cx,&cy,&cchar)>0) {
      printf("\nMouse clicked at: %7.2f %7.2f\n",cx,cy);
      cpos.x = cx;
      cpos.y = cy;
      bestmatch2 = find_closest(cpos,cat2,ncat2);
      printf("Position of closest match is: %7.2f %7.2f\n\n",
	     bestmatch2.x,bestmatch2.y);
      markcatobj(bestmatch2);
    }
    else {
      fprintf(stderr,"*** Invalid cursor input ***\n");
      no_error = 0;
    }
  }

  /*
   * Calculate x,y offsets from selected position in image 1
   */

  printf("---------------------------------------------------------------\n");
  if(no_error) {
    initshift->x = bestmatch2.x - bestmatch1.x;
    initshift->y = bestmatch2.y - bestmatch1.y;
    printf("\nInital estimate of shift between images: %8.2f %8.2f\n",
	   initshift->x,initshift->y);
  }

}
コード例 #5
0
ファイル: zapbirds.c プロジェクト: jintaoluo/presto_on_gpu
static void process_bird(double basebin, int harm, double *lofreq, double *hifreq)
{
   int ii, plotnumpts = 1000, not_done_yet = 1, plotoffset;
   int lodatabin, firstcorrbin, numgoodpts, replot = 1;
   char inchar;
   float med, xx[2], yy[2], inx, iny;
   float powargr, powargi, pwr, maxpow = 0.0, maxbin = 0.0;
   double truebin, pred_freq, average;
   double firstbin = 0.0, lastbin = 0.0, numbins = 0.0;
   fcomplex *data, *result;

   /* 'bin' means normal resolution FFT amplitude */
   /* 'pt'  means an interpolated FFT amplitude   */
   /* 'pts'=='bins' only if NUMBETWEEN==1         */

   *lofreq = *hifreq = 0.0;
   truebin = basebin * harm;
   pred_freq = truebin / T;
   xx[0] = xx[1] = pred_freq;
   data = get_rawbins(fftfile, truebin, BINSTOGET, &med, &lodatabin);
   if (lodatabin <= 0) {
      data[abs(lodatabin)].r = 1.0;
      data[abs(lodatabin)].i = 1.0;
   }
   firstcorrbin = (int) truebin - MAXBINSTOSHOW / 2;
   average = med / -log(0.5);
   result = gen_cvect(FFTLEN);
   numgoodpts = corr_complex(data, BINSTOGET, RAW,
                             kernel, FFTLEN, FFT,
                             result, MAXPTSTOSHOW,
                             firstcorrbin - lodatabin, NUMBETWEEN, khw, CORR);
   for (ii = 0; ii < numgoodpts; ii++) {
      pwr = POWER(result[ii].r, result[ii].i) / average;
      if (pwr > maxpow) {
         maxpow = pwr;
         maxbin = firstcorrbin + dr * ii;
      }
   }
   printf("\nHarmonic %d of %.15g Hz (%.15g Hz, bin = %.15g)\n",
          harm, basebin / T, pred_freq, truebin);
   printf("  Max power = %.2f at %.15g Hz (bin = %.15g)\n",
          maxpow, maxbin / T, maxbin);
   do {
      cpgsci(1);
      if (replot) {
         plotoffset = MAXPTSTOSHOW / 2 - plotnumpts / 2;
         firstbin = firstcorrbin + dr * plotoffset;
         numbins = dr * plotnumpts;
         lastbin = firstbin + numbins;
         plot_spectrum(result + plotoffset, plotnumpts, firstbin, dr, T, average);
         cpgswin(0.0, 1.0, 0.0, 1.0);
         xx[0] = xx[1] = (truebin - firstbin) / numbins;
         yy[0] = 0.0;
         yy[1] = 1.0;
         cpgsci(2);             /* red */
         cpgline(2, xx, yy);    /* Predicted freq */
         cpgsci(7);             /* yellow */
         if (*lofreq) {
            xx[0] = xx[1] = ((*lofreq * T) - firstbin) / numbins;
            cpgline(2, xx, yy); /* Boundary */
         }
         if (*hifreq) {
            xx[0] = xx[1] = ((*hifreq * T) - firstbin) / numbins;
            cpgline(2, xx, yy); /* Boundary */
         }
      }
      replot = 1;
      cpgsci(7);                /* yellow */
      cpgcurs(&inx, &iny, &inchar);
      switch (inchar) {
      case ' ':
      case 'A':
      case 'a':
         xx[0] = xx[1] = inx;
         cpgline(2, xx, yy);    /* New boundary */
         if (*lofreq == 0.0) {
            *lofreq = (inx * numbins + firstbin) / T;
            printf("  Added 1st boundary at %.12g Hz\n", *lofreq);
         } else {
            *hifreq = (inx * numbins + firstbin) / T;
            printf("  Added 2nd boundary at %.12g Hz\n", *hifreq);
         }
         replot = 0;
         break;
      case 'I':                /* Zoom in */
      case 'i':
         plotnumpts /= 2;
         if (plotnumpts <= 8)
            plotnumpts = 8;
         printf("  Zooming in...\n");
         break;
      case 'O':                /* Zoom out */
      case 'o':
         plotnumpts *= 2;
         if (plotnumpts > MAXPTSTOSHOW)
            plotnumpts = MAXPTSTOSHOW;
         printf("  Zooming out...\n");
         break;
      case 'C':                /* Clear/Delete the points */
      case 'c':
      case 'D':
      case 'd':
      case 'X':
      case 'x':
         *lofreq = *hifreq = 0.0;
         printf("  Clearing boundaries.\n");
         break;
      case 'Q':                /* Quit/Next birdie */
      case 'q':
      case 'N':
      case 'n':
         *lofreq = *hifreq = 0.0;
         free(data);
         vect_free(result);
         printf("  Skipping to next harmonic.\n");
         return;
      default:
         printf("  Unrecognized option '%c'.\n", inchar);
         break;
      }
      if (*lofreq && *hifreq)
         not_done_yet = 0;
   } while (not_done_yet);
   if (*hifreq < *lofreq) {
      double tmpfreq;
      tmpfreq = *lofreq;
      *lofreq = *hifreq;
      *hifreq = tmpfreq;
   }
   free(data);
   vect_free(result);
}
コード例 #6
0
ファイル: explorefft.c プロジェクト: bretonr/presto
int main(int argc, char *argv[])
{
   float maxpow = 0.0, inx = 0.0, iny = 0.0;
   double centerr, offsetf;
   int zoomlevel, maxzoom, minzoom, xid, psid;
   char *rootfilenm, inchar;
   fftpart *lofp;
   fftview *fv;

   if (argc == 1) {
      printf("\nusage:  explorefft fftfilename\n\n");
      exit(0);
   }

   printf("\n\n");
   printf("      Interactive FFT Explorer\n");
   printf("         by Scott M. Ransom\n");
   printf("            October, 2001\n");
   print_help();

   {
      int hassuffix = 0;
      char *suffix;

      hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix);
      if (hassuffix) {
         if (strcmp(suffix, "fft") != 0) {
            printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", argv[1]);
            free(suffix);
            exit(0);
         }
         free(suffix);
      } else {
         printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", argv[1]);
         exit(0);
      }
   }

   /* Read the info file */

   readinf(&idata, rootfilenm);
   if (strlen(remove_whitespace(idata.object)) > 0) {
      printf("Examining %s data from '%s'.\n\n",
             remove_whitespace(idata.object), argv[1]);
   } else {
      printf("Examining data from '%s'.\n\n", argv[1]);
   }
   N = idata.N;
   T = idata.dt * idata.N;
#ifdef USEMMAP
   printf("Memory mapping the input FFT.  This may take a while...\n");
   mmap_file = open(argv[1], O_RDONLY);
   {
      int rt;
      struct stat buf;

      rt = fstat(mmap_file, &buf);
      if (rt == -1) {
         perror("\nError in fstat() in explorefft.c");
         printf("\n");
         exit(-1);
      }
      Nfft = buf.st_size / sizeof(fcomplex);
   }
   lofp = get_fftpart(0, Nfft);
#else
   {
      int numamps;

      fftfile = chkfopen(argv[1], "rb");
      Nfft = chkfilelen(fftfile, sizeof(fcomplex));
      numamps = (Nfft > MAXBINS) ? (int) MAXBINS : (int) Nfft;
      lofp = get_fftpart(0, numamps);
   }
#endif

   /* Plot the initial data */

   {
      int initnumbins = INITIALNUMBINS;

      if (initnumbins > Nfft) {
         initnumbins = next2_to_n(Nfft) / 2;
         zoomlevel = LOGDISPLAYNUM - (int) (log(initnumbins) / log(2.0));
         minzoom = zoomlevel;
      } else {
         zoomlevel = LOGDISPLAYNUM - LOGINITIALNUMBINS;
         minzoom = LOGDISPLAYNUM - LOGMAXBINS;
      }
      maxzoom = LOGDISPLAYNUM - LOGMINBINS;
      centerr = initnumbins / 2;
   }
   fv = get_fftview(centerr, zoomlevel, lofp);

   /* Prep the XWIN device for PGPLOT */

   xid = cpgopen("/XWIN");
   if (xid <= 0) {
      free(fv);
#ifdef USEMMAP
      close(mmap_file);
#else
      fclose(fftfile);
#endif
      free_fftpart(lofp);
      exit(EXIT_FAILURE);
   }
   cpgscr(15, 0.4, 0.4, 0.4);
   cpgask(0);
   cpgpage();
   offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);

   do {
      cpgcurs(&inx, &iny, &inchar);
      if (DEBUGOUT)
         printf("You pressed '%c'\n", inchar);

      switch (inchar) {
      case 'A':                /* Zoom in */
      case 'a':
         centerr = (inx + offsetf) * T;
      case 'I':
      case 'i':
         if (DEBUGOUT)
            printf("  Zooming in  (zoomlevel = %d)...\n", zoomlevel);
         if (zoomlevel < maxzoom) {
            zoomlevel++;
            free(fv);
            fv = get_fftview(centerr, zoomlevel, lofp);
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         } else
            printf("  Already at maximum zoom level (%d).\n", zoomlevel);
         break;
      case 'X':                /* Zoom out */
      case 'x':
      case 'O':
      case 'o':
         if (DEBUGOUT)
            printf("  Zooming out  (zoomlevel = %d)...\n", zoomlevel);
         if (zoomlevel > minzoom) {
            zoomlevel--;
            free(fv);
            fv = get_fftview(centerr, zoomlevel, lofp);
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         } else
            printf("  Already at minimum zoom level (%d).\n", zoomlevel);
         break;
      case '<':                /* Shift left 1 full screen */
         centerr -= fv->numbins + fv->numbins / 8;
      case ',':                /* Shift left 1/8 screen */
         if (DEBUGOUT)
            printf("  Shifting left...\n");
         centerr -= fv->numbins / 8;
         {                      /* Should probably get the previous chunk from the fftfile... */
            double lowestr;

            lowestr = 0.5 * fv->numbins;
            if (centerr < lowestr)
               centerr = lowestr;
         }
         free(fv);
         fv = get_fftview(centerr, zoomlevel, lofp);
         cpgpage();
         offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         break;
      case '>':                /* Shift right 1 full screen */
         centerr += fv->numbins - fv->numbins / 8;
      case '.':                /* Shift right 1/8 screen */
         if (DEBUGOUT)
            printf("  Shifting right...\n");
         centerr += fv->numbins / 8;
         {                      /* Should probably get the next chunk from the fftfile... */
            double highestr;

            highestr = lofp->rlo + lofp->numamps - 0.5 * fv->numbins;
            if (centerr > highestr)
               centerr = highestr;
         }
         free(fv);
         fv = get_fftview(centerr, zoomlevel, lofp);
         cpgpage();
         offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         break;
      case '+':                /* Increase height of powers */
      case '=':
         if (maxpow == 0.0) {
            printf("  Auto-scaling is off.\n");
            maxpow = 1.1 * fv->maxpow;
         }
         maxpow = 3.0 / 4.0 * maxpow;
         cpgpage();
         offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         break;
      case '-':                /* Decrease height of powers */
      case '_':
         if (maxpow == 0.0) {
            printf("  Auto-scaling is off.\n");
            maxpow = 1.1 * fv->maxpow;
         }
         maxpow = 4.0 / 3.0 * maxpow;
         cpgpage();
         offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         break;
      case 'S':                /* Auto-scale */
      case 's':
         if (maxpow == 0.0)
            break;
         else {
            printf("  Auto-scaling is on.\n");
            maxpow = 0.0;
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
            break;
         }
      case 'G':                /* Goto a frequency */
      case 'g':
         {
            char freqstr[50];
            double freq = -1.0;

            while (freq < 0.0) {
               printf("  Enter the frequency (Hz) to go to:\n");
               fgets(freqstr, 50, stdin);
               freqstr[strlen(freqstr) - 1] = '\0';
               freq = atof(freqstr);
            }
            offsetf = 0.0;
            centerr = freq * T;
            printf("  Moving to frequency %.15g.\n", freq);
            free(fv);
            fv = get_fftview(centerr, zoomlevel, lofp);
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2);
         }
         break;
      case 'H':                /* Show harmonics */
      case 'h':
         {
            double retval;

            retval = harmonic_loop(xid, centerr, zoomlevel, lofp);
            if (retval > 0.0) {
               offsetf = 0.0;
               centerr = retval;
               free(fv);
               fv = get_fftview(centerr, zoomlevel, lofp);
               cpgpage();
               offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2);
            }
         }
         break;
      case '?':                /* Print help screen */
         print_help();
         break;
      case 'D':                /* Show details about a selected point  */
      case 'd':
         {
            double newr;

            printf("  Searching for peak near freq = %.7g Hz...\n", (inx + offsetf));
            newr = find_peak(inx + offsetf, fv, lofp);
            centerr = newr;
            free(fv);
            fv = get_fftview(centerr, zoomlevel, lofp);
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2);
         }
         break;
      case 'L':                /* Load a zaplist */
      case 'l':
         {
            int ii, len;
            char filename[200];
            double *lobins, *hibins;

            printf("  Enter the filename containing the zaplist to load:\n");
            fgets(filename, 199, stdin);
            len = strlen(filename) - 1;
            filename[len] = '\0';
            numzaplist = get_birdies(filename, T, 0.0, &lobins, &hibins);
            lenzaplist = numzaplist + 20;       /* Allow some room to add more */
            if (lenzaplist)
               free(zaplist);
            zaplist = (bird *) malloc(sizeof(bird) * lenzaplist);
            for (ii = 0; ii < numzaplist; ii++) {
               zaplist[ii].lobin = lobins[ii];
               zaplist[ii].hibin = hibins[ii];
            }
            vect_free(lobins);
            vect_free(hibins);
            printf("\n");
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         }
         break;
      case 'Z':                /* Add a birdie to a zaplist */
      case 'z':
         {
            int badchoice = 2;
            float lox, hix, loy, hiy;
            double rs[2];
            char choice;

            if (numzaplist + 1 > lenzaplist) {
               lenzaplist += 10;
               zaplist = (bird *) realloc(zaplist, sizeof(bird) * lenzaplist);
            }
            cpgqwin(&lox, &hix, &loy, &hiy);
            printf("  Click the left mouse button on the first frequency limit.\n");
            while (badchoice) {
               cpgcurs(&inx, &iny, &choice);
               if (choice == 'A' || choice == 'a') {
                  rs[2 - badchoice] = ((double) inx + offsetf) * T;
                  cpgsave();
                  cpgsci(7);
                  cpgmove(inx, 0.0);
                  cpgdraw(inx, hiy);
                  cpgunsa();
                  badchoice--;
                  if (badchoice == 1)
                     printf
                         ("  Click the left mouse button on the second frequency limit.\n");
               } else {
                  printf("  Option not recognized.\n");
               }
            };
            if (rs[1] > rs[0]) {
               zaplist[numzaplist].lobin = rs[0];
               zaplist[numzaplist].hibin = rs[1];
            } else {
               zaplist[numzaplist].lobin = rs[1];
               zaplist[numzaplist].hibin = rs[0];
            }
            printf("    The new birdie has:  f_avg = %.15g  f_width = %.15g\n\n",
                   0.5 * (zaplist[numzaplist].hibin + zaplist[numzaplist].lobin) / T,
                   (zaplist[numzaplist].hibin - zaplist[numzaplist].lobin) / T);
            numzaplist++;
            qsort(zaplist, numzaplist, sizeof(bird), compare_birds);
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         }
         break;
      case 'P':                /* Print the current plot */
      case 'p':
         {
            int len;
            char filename[200];

            printf("  Enter the filename to save the plot as:\n");
            fgets(filename, 196, stdin);
            len = strlen(filename) - 1;
            filename[len + 0] = '/';
            filename[len + 1] = 'P';
            filename[len + 2] = 'S';
            filename[len + 3] = '\0';
            psid = cpgopen(filename);
            cpgslct(psid);
            cpgpap(10.25, 8.5 / 11.0);
            cpgiden();
            cpgscr(15, 0.8, 0.8, 0.8);
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
            cpgclos();
            cpgslct(xid);
            cpgscr(15, 0.4, 0.4, 0.4);
            filename[len] = '\0';
            printf("  Wrote the plot to the file '%s'.\n", filename);
         }
         break;
      case 'N':                /* Changing power normalization */
      case 'n':
         {
            float inx2 = 0.0, iny2 = 0.0;
            char choice;
            unsigned char badchoice = 1;

            printf("  Specify the type of power normalization:\n"
                   "       m,M  :  Median values determined locally\n"
                   "       d,D  :  DC frequency amplitude\n"
                   "       r,R  :  Raw powers (i.e. no normalization)\n"
                   "       u,U  :  User specified interval (the average powers)\n");
            while (badchoice) {
               cpgcurs(&inx2, &iny2, &choice);
               switch (choice) {
               case 'M':
               case 'm':
                  norm_const = 0.0;
                  maxpow = 0.0;
                  badchoice = 0;
                  printf
                      ("  Using local median normalization.  Autoscaling is on.\n");
                  break;
               case 'D':
               case 'd':
                  norm_const = 1.0 / r0;
                  maxpow = 0.0;
                  badchoice = 0;
                  printf
                      ("  Using DC frequency (%f) normalization.  Autoscaling is on.\n",
                       r0);
                  break;
               case 'R':
               case 'r':
                  norm_const = 1.0;
                  maxpow = 0.0;
                  badchoice = 0;
                  printf
                      ("  Using raw powers (i.e. no normalization).  Autoscaling is on.\n");
                  break;
               case 'U':
               case 'u':
                  {
                     char choice2;
                     float xx = inx, yy = iny;
                     int lor, hir, numr;
                     double avg, var;

                     printf
                         ("  Use the left mouse button to select a left and right boundary\n"
                          "  of a region to calculate the average power.\n");
                     do {
                        cpgcurs(&xx, &yy, &choice2);
                     } while (choice2 != 'A' && choice2 != 'a');
                     lor = (int) ((xx + offsetf) * T);
                     cpgsci(7);
                     cpgmove(xx, 0.0);
                     cpgdraw(xx, 10.0 * fv->maxpow);
                     do {
                        cpgcurs(&xx, &yy, &choice2);
                     } while (choice2 != 'A' && choice2 != 'a');
                     hir = (int) ((xx + offsetf) * T);
                     cpgmove(xx, 0.0);
                     cpgdraw(xx, 10.0 * fv->maxpow);
                     cpgsci(1);
                     if (lor > hir) {
                        int tempr;
                        tempr = hir;
                        hir = lor;
                        lor = tempr;
                     }
                     numr = hir - lor + 1;
                     avg_var(lofp->rawpowers + lor - lofp->rlo, numr, &avg, &var);
                     printf("  Selection has:  average = %.5g\n"
                            "                  std dev = %.5g\n", avg, sqrt(var));
                     norm_const = 1.0 / avg;
                     maxpow = 0.0;
                     badchoice = 0;
                     printf
                         ("  Using %.5g as the normalization constant.  Autoscaling is on.\n",
                          avg);
                     break;
                  }
               default:
                  printf("  Unrecognized choice '%c'.\n", choice);
                  break;
               }
            }
            free(fv);
            fv = get_fftview(centerr, zoomlevel, lofp);
            cpgpage();
            offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
         }
         break;
      case 'Q':                /* Quit */
      case 'q':
         printf("  Quitting...\n");
         free(fv);
         cpgclos();
         break;
      default:
         printf("  Unrecognized option '%c'.\n", inchar);
         break;
      }
   } while (inchar != 'Q' && inchar != 'q');

   free_fftpart(lofp);
#ifdef USEMMAP
   close(mmap_file);
#else
   fclose(fftfile);
#endif
   if (lenzaplist)
      free(zaplist);
   printf("Done\n\n");
   return 0;
}
コード例 #7
0
ファイル: explorefft.c プロジェクト: bretonr/presto
static double harmonic_loop(int xid, double rr, int zoomlevel, fftpart * fp)
{
   float inx = 0.0, iny = 0.0;
   double retval = 0.0;
   int xid2, psid, badchoice = 1;
   char choice;

   xid2 = cpgopen("/XWIN");
   cpgpap(10.25, 8.5 / 11.0);
   cpgask(0);
   cpgslct(xid2);
   plot_harmonics(rr, zoomlevel, fp);
   printf("  Click on the harmonic to go it,\n"
          "    press 'P' to print, or press 'Q' to close.\n");
   while (badchoice) {
      cpgcurs(&inx, &iny, &choice);
      if (choice == 'Q' || choice == 'q') {
         badchoice = 0;
      } else if (choice == 'P' || choice == 'p') {
         int len, numharmbins;
         double offsetf;
         char filename[200];
         fftpart *harmpart;
         fftview *harmview;

         printf("  Enter the filename to save the plot as:\n");
         fgets(filename, 195, stdin);
         len = strlen(filename) - 1;
         strcpy(filename + len, "/CPS");
         psid = cpgopen(filename);
         cpgslct(psid);
         cpgpap(10.25, 8.5 / 11.0);
         cpgiden();
         cpgscr(15, 0.8, 0.8, 0.8);
         numharmbins = (1 << (LOGDISPLAYNUM - zoomlevel));
         harmpart = get_fftpart((int) (rr - numharmbins), 2 * numharmbins);
         harmview = get_fftview(rr, zoomlevel, harmpart);
         free_fftpart(harmpart);
         offsetf = plot_fftview(harmview, 0.0, 1.0, rr, 2);
         cpgpage();
         plot_harmonics(rr, zoomlevel, fp);
         cpgclos();
         cpgslct(xid2);
         cpgscr(15, 0.4, 0.4, 0.4);
         filename[len] = '\0';
         printf("  Wrote the plot to the file '%s'.\n", filename);
      } else if (choice == 'A' || choice == 'a') {
         if (iny > 1.0)
            retval = rr * (int) (inx);
         else if (iny > 0.0)
            retval = rr * ((int) (inx) + 4.0);
         else if (iny > -1.0)
            retval = rr / (int) (inx);
         else
            retval = rr / ((int) (inx) + 4.0);
         badchoice = 0;
      } else {
         printf("  Option not recognized.\n");
      }
   };
   cpgclos();
   cpgslct(xid);
   return retval;
}
コード例 #8
0
ファイル: pfits_bpass.c プロジェクト: SixByNine/kwikfit
int main(int argc,char *argv[])
{
  int i;
  char fname[128];
  dSet *data; 
  float freq,bw,chanbw;
  int nchan,npol;
  float bpass[4096];
  float fx[4096];
  float miny,maxy,minx,maxx;
  float ominy,omaxy,ominx,omaxx;
  float mx,my,mx2,my2;
  float binw;
  char key;
  char grDev[128]="/xs";
  int interactive=1;
  int noc1=0;
  int zapChannels[4096];
  int nzap=0;
  int overlay=-1;
  float overlayVal[MAX_OVERLAY];
  char overlayStr[MAX_OVERLAY][128];
  char overlayFile[128];
  int noverlay=0;
  fitsfile *fp;

  data = initialiseDset();
  

  for (i=0;i<argc;i++)
    {
      if (strcmp(argv[i],"-f")==0)
	strcpy(fname,argv[++i]);
      else if (strcmp(argv[i],"-noc1")==0)
	noc1=1;
      else if (strcmp(argv[i],"-g")==0)
	{
	  strcpy(grDev,argv[++i]);
	  interactive=0;
	}
      else if (strcmp(argv[i],"-h")==0)
	help();
      else if (strcmp(argv[i],"-overlay")==0)
	{
	  strcpy(overlayFile,argv[++i]);
	  overlay=1;
	}
    }
  if (overlay==1)
    {
      FILE *fin;
      char line[1024];
      noverlay=0;

      if (!(fin = fopen(overlayFile,"r")))
	  printf("Unable to open overlay file >%s<\n",overlayFile);
      else
	{
	  while (!feof(fin))
	    {
	      fgets(overlayStr[noverlay],1024,fin);
	      if (fscanf(fin,"%f",&overlayVal[noverlay])==1)
		{
		  if (overlayStr[noverlay][strlen(overlayStr[noverlay])-1] == '\n')
		    overlayStr[noverlay][strlen(overlayStr[noverlay])-1]='\0';
		  noverlay++;
		}
	    }
	  fclose(fin);
	}
    }
  fp   = openFitsFile(fname); 
  loadPrimaryHeader(fp,data);
  displayHeaderInfo(data);
  readBandpass(fp,bpass);
  nchan = data->phead.nchan;
  freq  = data->phead.freq;
  bw    = data->phead.bw;
  chanbw = data->phead.chanbw;

  for (i=0;i<nchan;i++)
    {
      fx[i] = freq-bw/2+(i+0.5)*chanbw;
      if (i==noc1)
	{
	  miny = maxy = bpass[i];
	  minx = maxx = fx[i];
	}
      else if (i!=0)
	{
	  if (bpass[i] > maxy) maxy = bpass[i];
	  if (bpass[i] < miny) miny = bpass[i];
	  if (fx[i] > maxx) maxx = fx[i];
	  if (fx[i] < minx) minx = fx[i];
	}
    }
  ominx = minx;
  omaxx = maxx;
  ominy = miny;
  omaxy = maxy;
  binw = fx[1]-fx[0];
  printf("Complete\n");

  cpgbeg(0,grDev,1,1);
  cpgask(0);
  do {
    cpgenv(minx,maxx,miny,maxy,0,1);
    cpglab("Frequency (MHz)","Amplitude (arbitrary)",fname);
    cpgbin(nchan-noc1,fx+noc1,bpass+noc1,0);
    if (overlay==1)
      {
	float tx[2],ty[2];
	cpgsls(4); cpgsci(2); cpgsch(0.8);
	for (i=0;i<noverlay;i++)
	  {
	    tx[0] = tx[1] = overlayVal[i];
	    ty[0] = miny;
	    ty[1] = maxy;
	    if (tx[1] > minx && tx[1] < maxx)
	      {
		cpgline(2,tx,ty);
		//		cpgtext(tx[1],ty[1]-0.05*(maxy-miny),overlayStr[i]);
		cpgptxt(tx[1]-0.004*(maxx-minx),ty[0]+0.05*(maxy-miny),90,0.0,overlayStr[i]);
	      }
	  }
	cpgsci(1); cpgsls(1); cpgsch(1);
      }
    if (interactive==1)
      {
	cpgcurs(&mx,&my,&key);
	if (key=='A')
	  {
	    int cc=-1;
	    int i;
	    for (i=0;i<nchan-1;i++)
	      {
		//		if ((bw > 0 && (mx > fx[i]-binw/2 && mx < fx[i]+binw/2)) ||
		//		    (bw < 0 && (mx > fx[i]+binw/2 && mx < fx[i]-binw/2)))
		if ((bw > 0 && (mx > fx[i] && mx < fx[i]+binw)) ||
		    (bw < 0 && (mx > fx[i] && mx < fx[i]+binw)))
		  {
		    cc = i;
		    break;
		  }
	      }
	    printf("mouse x = %g MHz, mouse y = %g, channel = %d, channel frequency = %g MHz\n",mx,my,cc,fx[cc]);
	  }
	else if (key=='X')
	  {
	    int cc=-1;
	    int i;
	    printf("Deleting %g %g %g\n",mx,fx[10],binw);
	    for (i=0;i<nchan-1;i++)
	      {
		//		if ((bw > 0 && (mx > fx[i]-binw/2 && mx < fx[i]+binw/2)) ||
		//		    (bw < 0 && (mx > fx[i]+binw/2 && mx < fx[i]-binw/2)))
		if ((bw > 0 && (mx > fx[i] && mx < fx[i]+binw)) ||
		    (bw < 0 && (mx > fx[i] && mx < fx[i]+binw)))
		  {
		    cc = i;
		    break;
		  }
	      }
	    printf("Want to delete = %d\n",cc);
	    if (cc != -1)
	      {
		bpass[cc] = 0;
		omaxy = bpass[noc1];
		zapChannels[nzap++] = cc;
		for (i=noc1;i<nchan;i++)
		  {
		    if (omaxy < bpass[i]) omaxy = bpass[i];
		  }
	      }
	  }
	else if (key=='z')
	  {
	    cpgband(2,0,mx,my,&mx2,&my2,&key);
	    if (mx > mx2) {maxx = mx; minx = mx2;}
	    else {maxx = mx2; minx = mx;}
	    
	    if (my > my2) {maxy = my; miny = my2;}
	    else {maxy = my2; miny = my;}	   
	  }
	else if (key=='u')
	  {
	    minx = ominx;
	    maxx = omaxx;
	    miny = ominy;
	    maxy = omaxy;
	  }
	else if (key=='l') // List the channels and frequencies to zap
	  {
	    int i;
	    sortInt(zapChannels,nzap);
	    printf("-------------------------------------------------------\n");
	    printf("Zap channels with first channel = 0\n\n");
	    for (i=0;i<nzap;i++)
	      printf("%d ",zapChannels[i]);
	    printf("\n\n");
	    printf("Zap channels with first channel = 1\n\n");
	    for (i=0;i<nzap;i++)
	      printf("%d ",zapChannels[i]+1);
	    printf("\n\n");
	    printf("Zap channels frequencies:\n\n");
	    for (i=0;i<nzap;i++)
	      printf("%g ",fx[zapChannels[i]]);
	    printf("\n\n");
	    printf("-------------------------------------------------------\n");
	  }
	else if (key=='%') // Enter percentage of the band edges to zap
	  {
	    float percent;
	    int i;

	    printf("Enter band edge percentage to zap ");
	    scanf("%f",&percent);
	    for (i=0;i<nchan;i++)
	      {
		if (i < nchan*percent/100.0 || i > nchan-(nchan*percent/100.0))
		  {
		    bpass[i] = 0;		    
		    zapChannels[nzap++] = i;

		  }
	      }
	    omaxy = bpass[noc1];
	    for (i=noc1;i<nchan;i++)
	      {
		if (omaxy < bpass[i]) omaxy = bpass[i];
	      }

	    // Unzoom
	    minx = ominx;
	    maxx = omaxx;
	    miny = ominy;
	    maxy = omaxy;
	  }

      }
  } while (key != 'q' && interactive==1);
  cpgend();
}
コード例 #9
0
ファイル: splk_plug.C プロジェクト: gdesvignes/tempo2
void doPlot(pulsar *psr,int npsr,int overlay)
{
  int i,j,fitFlag=1,exitFlag=0,scale1=0,scale2,count,p,xautoscale=1,k,graphics=1;
  int yautoscale=1,plotpre=1;
  int time=0;
  char xstr[1000],ystr[1000];
  float x[MAX_OBSN],y[MAX_OBSN],yerr1[MAX_OBSN],yerr2[MAX_OBSN],tmax,tmin,tmaxy1,tminy1,tmaxy2,tminy2;
  float minx,maxx,miny,maxy,plotx1,plotx2,ploty1,ploty2,mean;
  float mouseX,mouseY;
  float fontSize=1.8;
  char key;
  float widthPap=0.0,aspectPap=0.618;

  /* Obtain a graphical PGPLOT window */
  if (overlay==1)
    cpgbeg(0,"?",2,1);
  else
    cpgbeg(0,"?",2,npsr);
  cpgpap(widthPap,aspectPap);
  cpgsch(fontSize);
  cpgask(0);

  do {
    for (p=0;p<npsr;p++)
      {
	scale2 = psr[p].nobs;
	for (j=0;j<2;j++)
	  {
	    if (j==0) fitFlag=1;
	    else if (j==1) fitFlag=2;

	    ld_sprintf(xstr,"MJD-%.1Lf",psr[0].param[param_pepoch].val[0]); 
	    sprintf(ystr,"Residual (\\gmsec)");

	    count=0;
	    for (i=0;i<psr[p].nobs;i++)
	      {
		if (psr[p].obsn[i].deleted == 0  &&
	    (psr[p].param[param_start].paramSet[0]!=1 || psr[p].param[param_start].fitFlag[0]!=1 ||
	      psr[p].param[param_start].val[0] < psr[p].obsn[i].bat) &&
	    (psr[p].param[param_finish].paramSet[0]!=1 || psr[p].param[param_finish].fitFlag[0]!=1 ||
	     psr[p].param[param_finish].val[0] > psr[p].obsn[i].bat))
		  {
		    if (xautoscale==1)
		      x[count] = (double)(psr[p].obsn[i].bat-psr[p].param[param_pepoch].val[0]);
		    else
		      x[count] = (double)(psr[p].obsn[i].bat-psr[0].param[param_pepoch].val[0]);
		    
		    if (fitFlag==1)  /* Get pre-fit residual */
		      y[count] = (double)psr[p].obsn[i].prefitResidual*1.0e6;
		    else if (fitFlag==2) /* Post-fit residual */
		      y[count] = (double)psr[p].obsn[i].residual*1.0e6;
		    count++;
		  }
	      }
	    /* Remove mean from the residuals and calculate error bars */
	    mean = findMean(y,psr,p,scale1,count);
	    count=0;
	    for (i=0;i<psr[p].nobs;i++)
	      {
		if (psr[p].obsn[i].deleted==0   &&
	    (psr[p].param[param_start].paramSet[0]!=1 || psr[p].param[param_start].fitFlag[0]!=1 ||
	      psr[p].param[param_start].val[0] < psr[p].obsn[i].bat) &&
	    (psr[p].param[param_finish].paramSet[0]!=1 || psr[p].param[param_finish].fitFlag[0]!=1 ||
	     psr[p].param[param_finish].val[0] > psr[p].obsn[i].bat))
		  {
		    psr[p].obsn[i].residual-=mean/1.0e6;
		    y[count]-=mean;
		    yerr1[count] = y[count]-(float)psr[p].obsn[i].toaErr;
		    yerr2[count] = y[count]+(float)psr[p].obsn[i].toaErr;
		    count++;
		  }
	      }
	    
	    /* Get scaling for graph */
	    minx = findMin(x,psr,p,scale1,count);
	    maxx = findMax(x,psr,p,scale1,count);
	    if (xautoscale==1)
	      {
		plotx1 = minx-(maxx-minx)*0.1;
		plotx2 = maxx+(maxx-minx)*0.1;
	      }
	    else
	      {
		plotx1 = tmin-(tmax-tmin)*0.1;
		plotx2 = tmax+(tmax-tmin)*0.1;
	      }
	    miny = findMin(y,psr,p,scale1,count);
	    maxy = findMax(y,psr,p,scale1,count);

	    if (yautoscale==1)
	      {
		ploty1 = miny-(maxy-miny)*0.1;
		ploty2 = maxy+(maxy-miny)*0.1;
	      }
	    else
	      {
		if (j==0)
		  {
		    ploty1 = tminy1-(tmaxy1-tminy1)*0.1;
		    ploty2 = tmaxy1+(tmaxy1-tminy1)*0.1;
		  }
		else
		  {
		    ploty1 = tminy2-(tmaxy2-tminy2)*0.1;
		    ploty2 = tmaxy2+(tmaxy2-tminy2)*0.1;
		  }
	      }

	    /* Plot the residuals */	    
	    if (plotpre==1 || j!=0)
	      {
		float xx[MAX_OBSN],yy[MAX_OBSN],yyerr1[MAX_OBSN],yyerr2[MAX_OBSN];
		int num=0,colour;
		if (overlay==0 || (overlay==1 && p==0))
		  {
		    cpgenv(plotx1,plotx2,ploty1,ploty2,0,0);
		    cpglab(xstr,ystr,psr[p].name);	    
		  }

		for (colour=0;colour<5;colour++)
		  {
		    num=0;
		    for (i=0;i<count;i++)
		      {
			if ((colour==0 && psr[p].obsn[i].freq<=500) ||
			    (colour==1 && psr[p].obsn[i].freq>500 && psr[p].obsn[i].freq<=1000) ||
			    (colour==2 && psr[p].obsn[i].freq>1000 && psr[p].obsn[i].freq<=1500) ||
			    (colour==3 && psr[p].obsn[i].freq>1500 && psr[p].obsn[i].freq<=3300) ||
			    (colour==4 && psr[p].obsn[i].freq>3300))
			  {
			    xx[num]=x[i];
			    yy[num]=y[i];
			    yyerr1[num]=yerr1[i];
			    yyerr2[num]=yerr2[i];
			    num++;
			  }
		      }
		    cpgsci(colour+1);
		    if (overlay==1)
		      cpgsci(p+1);
		    cpgpt(num,xx,yy,16);
		    cpgerry(num,xx,yyerr1,yyerr2,1);
		  }
		cpgsci(1);
	      }
	  }
      }
    printf("------------------------------\n");
    printf("`a'     set aspect ratio\n");
    printf("`f'     set font size\n");
    printf("`g'     set graphics device\n");
    printf("`q'     quit\n");
    printf("`x'     toggle autoscale x axis\n");
    printf("`y'     toggle autoscale y axis\n");
    printf("`p'     toggle prefit plotting\n");
    printf("`r'     output residuals to file\n");

    if (graphics==1)
      {
	cpgcurs(&mouseX,&mouseY,&key);
	
	/* Check key press */
	if (key=='q') exitFlag=1;
	if (key=='p') {
	  plotpre*=-1;
	  if (plotpre==-1)
	    {
	      cpgend();
	      if (overlay==1)
		cpgbeg(0,"/xs",1,1);
	      else
		cpgbeg(0,"/xs",1,npsr);
	      cpgpap(widthPap,aspectPap);
	      cpgsch(fontSize);
	      cpgask(0);	      
	    }
	  else
	    {
	      cpgend();
	      if (overlay==1)
		cpgbeg(0,"/xs",2,1);
	      else
		cpgbeg(0,"/xs",2,npsr);
	      cpgpap(widthPap,aspectPap);
	      cpgsch(fontSize);
	      cpgask(0);	      
	    }
	}
	else if (key=='a') /* Change aspect ratio */
	  {
	    printf("Please enter a new aspect ratio ");
	    scanf("%f",&aspectPap);
	    cpgend();
	    cpgbeg(0,"/xs",2,npsr);
	    cpgpap(widthPap,aspectPap);
	    cpgsch(fontSize);
	    cpgask(0);	      
	  }
	else if (key=='f') /* Change font size */
	  {
	    printf("Please enter a new font size ");
	    scanf("%f",&fontSize);
	    cpgend();
	    cpgbeg(0,"/xs",2,npsr);
	    cpgpap(widthPap,aspectPap);
	    cpgsch(fontSize);
	    cpgask(0);	      
	  }
	else if (key=='g')
	  {
	    graphics=0;
	    cpgend();
	    if (plotpre==-1)
	      {
		cpgend();
		if (overlay==1)
		  cpgbeg(0,"?",1,1);
		else
		  cpgbeg(0,"?",1,npsr);
		cpgpap(widthPap,aspectPap);
		cpgsch(fontSize);
		cpgask(0);	      
	      }
	    else
	      {
		cpgend();
		if (overlay==1)
		  cpgbeg(0,"?",1,1);
		else
		  cpgbeg(0,"?",2,npsr);
		cpgpap(widthPap,aspectPap);
		cpgsch(fontSize);
		cpgask(0);	      
	      }
	  }
	else if (key=='r') /* Output residuals to file */
	  {
	    FILE *fout;
	    char fname[1000];
	    int ii,jj;

	    for (ii=0;ii<npsr;ii++)
	      {
		sprintf(fname,"%s.res",psr[ii].name);
		fout = fopen(fname,"w");
		/* Print header */
		fprintf(fout,"#PSR %s\n",psr[ii].name);
		ld_fprintf(fout,"#F0  %.14Lf\n",psr[ii].param[param_f].val[0]);
		fprintf(fout,"#RAJ %s\n",psr[ii].rajStrPre);
		fprintf(fout,"#DECJ %s\n",psr[ii].decjStrPre);
		for (jj=0;jj<psr[ii].nobs;jj++)
		  fprintf(fout,"%.5lf %.5lg %.5lg\n",
			  (double)(psr[ii].obsn[jj].bat-psr[0].param[param_pepoch].val[0]),
			  (double)(psr[ii].obsn[jj].residual),(double)(psr[ii].obsn[jj].toaErr)/1.0e6);
		fclose(fout);
	      }
	  }
	else if (key=='x') 
	  {
	    xautoscale*=-1;
	    if (xautoscale==-1)
	      {
		for (k=0;k<npsr;k++)
		  {
		    count=0;
		    for (i=0;i<psr[k].nobs;i++)
		      {
			if (psr[k].obsn[i].deleted==0   &&
			    (psr[k].param[param_start].paramSet[0]!=1 || psr[k].param[param_start].fitFlag[0]!=1 ||
			     psr[k].param[param_start].val[0] < psr[k].obsn[i].bat) &&
			    (psr[k].param[param_finish].paramSet[0]!=1 || psr[k].param[param_finish].fitFlag[0]!=1 ||
			     psr[k].param[param_finish].val[0] > psr[k].obsn[i].bat))

			  {x[count] = (double)(psr[k].obsn[i].bat-psr[0].param[param_pepoch].val[0]); count++;}
		      }
		    minx = findMin(x,psr,k,scale1,count);
		    maxx = findMax(x,psr,k,scale1,count);
		    if (k==0)
		      {
			tmin = minx;
			tmax = maxx;
			printf("Have1 tmin = %f, tmax = %f\n",tmin,tmax);
		      }
		    else
		      {
			if (tmin > minx) tmin = minx;
			if (tmax < maxx) tmax = maxx;
			printf("Have2 tmin = %f, tmax = %f\n",tmin,tmax);

		      }
		  }
	      }
	  }       
	else if (key=='y') 
	  {
	    yautoscale*=-1;
	    if (yautoscale==-1)
	      {
		for (k=0;k<npsr;k++)
		  {
		    count=0;
		    for (i=0;i<psr[k].nobs;i++)
		      {
			if (psr[k].obsn[i].deleted==0   &&
			    (psr[k].param[param_start].paramSet[0]!=1 || psr[k].param[param_start].fitFlag[0]!=1 ||
			     psr[k].param[param_start].val[0] < psr[k].obsn[i].bat) &&
			    (psr[k].param[param_finish].paramSet[0]!=1 || psr[k].param[param_finish].fitFlag[0]!=1 ||
			     psr[k].param[param_finish].val[0] > psr[k].obsn[i].bat))			  
			  {y[count] = (double)psr[k].obsn[i].prefitResidual*1e6; count++;}
		      }
		    miny = findMin(y,psr,k,scale1,count);
		    maxy = findMax(y,psr,k,scale1,count);
		    if (k==0)
		      {
			tminy1 = miny;
			tmaxy1 = maxy;
		      }
		    else
		      {
			if (tminy1 > miny) tminy1 = miny;
			if (tmaxy1 < maxy) tmaxy1 = maxy;
		      }

		    count=0;
		    for (i=0;i<psr[k].nobs;i++)
		      {
			if (psr[k].obsn[i].deleted==0   &&
			    (psr[k].param[param_start].paramSet[0]!=1 || psr[k].param[param_start].fitFlag[0]!=1 ||
			     psr[k].param[param_start].val[0] < psr[k].obsn[i].bat) &&
			    (psr[k].param[param_finish].paramSet[0]!=1 || psr[k].param[param_finish].fitFlag[0]!=1 ||
			     psr[k].param[param_finish].val[0] > psr[k].obsn[i].bat))
			  {y[count] = (double)psr[k].obsn[i].residual*1e6; count++;}
		      }
		    miny = findMin(y,psr,k,scale1,count);
		    maxy = findMax(y,psr,k,scale1,count);
		    if (k==0)
		      {
			tminy2 = miny;
			tmaxy2 = maxy;
		      }
		    else
		      {
			if (tminy2 > miny) tminy2 = miny;
			if (tmaxy2 < maxy) tmaxy2 = maxy;
		      }
		  }
		printf("Have tminy2 = %g %g\n",tminy2,tmaxy2);
	      }
	  }       
	else printf("Unknown key press %c\n",key);
      }
    else
      {
	graphics=1;

	cpgend();
	if (plotpre==-1)
	  {
	    cpgend();
	    if (overlay==1)
	      cpgbeg(0,"/xs",1,1);
	    else
	      cpgbeg(0,"/xs",1,npsr);
	    cpgpap(widthPap,aspectPap);
	    cpgsch(fontSize);
	    cpgask(0);	      
	  }
	else
	  {
	    cpgend();
	    if (overlay==1)
	      cpgbeg(0,"/xs",2,1);
	    else
	      cpgbeg(0,"/xs",2,npsr);
	    cpgpap(widthPap,aspectPap);
	    cpgsch(fontSize);
	    cpgask(0);	      
	  }
      }
  } while (exitFlag==0);
  
  cpgend();
}