IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2843


Ignore:
Timestamp:
Dec 28, 2004, 8:40:04 PM (21 years ago)
Author:
eugene
Message:

fixes for -Wall -Werror (mostly get_argument lines)

Location:
trunk/Ohana/src/opihi
Files:
94 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/cmd.astro/Makefile

    r2833 r2843  
    5151$(SDIR)/spec.$(ARCH).o             \
    5252$(SDIR)/star.$(ARCH).o             \
    53 $(SDIR)/testfit.$(ARCH).o          \
    5453$(SDIR)/transform.$(ARCH).o
    5554

  • trunk/Ohana/src/opihi/cmd.astro/biassub.c

    r2598 r2843  
    1010
    1111  NoVector = TRUE;
    12   if (N = get_argument (argc, argv, "-v")) {
     12  if ((N = get_argument (argc, argv, "-v"))) {
    1313    NoVector = FALSE;
    1414    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.astro/coords.c

    r2598 r2843  
    99
    1010  mode = 0;
    11   if (N = get_argument (argc, argv, "-p")) {
     11  if ((N = get_argument (argc, argv, "-p"))) {
    1212    remove_argument (N, &argc, argv);
    1313    X = atof(argv[N]);
    … …  
    1717    mode = 1;
    1818  }
    19   if (N = get_argument (argc, argv, "-c")) {
     19  if ((N = get_argument (argc, argv, "-c"))) {
    2020    if (mode == 1) {
    2121      fprintf (stderr, "only one of -p or -c can be used\n");

  • trunk/Ohana/src/opihi/cmd.astro/ctimes.c

    r2598 r2843  
    99
    1010  Variable = (char *) NULL;
    11   if (N = get_argument (argc, argv, "-var")) {
     11  if ((N = get_argument (argc, argv, "-var"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Variable = strcreate (argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/czplot.c

    r2598 r2843  
    1010
    1111  Ngraph = -1;
    12   if (N = get_argument (argc, argv, "-n")) {
     12  if ((N = get_argument (argc, argv, "-n"))) {
    1313    remove_argument (N, &argc, argv);
    1414    Ngraph = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/drizzle.c

    r2598 r2843  
    1919
    2020  ZERO = FALSE;
    21   if (N = get_argument (argc, argv, "-zero")) {
     21  if ((N = get_argument (argc, argv, "-zero"))) {
    2222    ZERO = TRUE;
    2323    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.astro/flux.c

    r2598 r2843  
    44 
    55  int i, j, k, xmin, ymin, xmax, ymax;
    6   int oldsignal;
     6  void *oldsignal;
    77  double ax, ay, s, S, flux;
    88  double bx[5], by[5], x[5], y[5], bb[5];
    … …  
    5151   we have to add up the angles for concave contours */
    5252  flux = 0;
    53   oldsignal = (int) signal (SIGINT, handle_interrupt);
     53  oldsignal = signal (SIGINT, handle_interrupt);
    5454  interrupt = FALSE;
    5555  for (j = ymin; (j < ymax) && !interrupt; j++) {
    … …  
    6868    }
    6969  }
    70   signal (SIGINT, (void *) oldsignal);
     70  signal (SIGINT, oldsignal);
    7171
    7272  fprintf (GetOutfile(), "flux: %f\n", flux);

  • trunk/Ohana/src/opihi/cmd.astro/gauss.c

    r2598 r2843  
    1010
    1111  Nimage = -1;
    12   if (N = get_argument (argc, argv, "-n")) {
     12  if ((N = get_argument (argc, argv, "-n"))) {
    1313    remove_argument (N, &argc, argv);
    1414    Nimage = atof (argv[N]);
    … …  
    1818
    1919  Nborder = 3;
    20   if (N = get_argument (argc, argv, "-border")) {
     20  if ((N = get_argument (argc, argv, "-border"))) {
    2121    remove_argument (N, &argc, argv);
    2222    Nborder  = atof(argv[N]);
    … …  
    2626 
    2727  max = 60000;
    28   if (N = get_argument (argc, argv, "-sat")) {
     28  if ((N = get_argument (argc, argv, "-sat"))) {
    2929    remove_argument (N, &argc, argv);
    3030    max  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/imfit.c

    r2598 r2843  
    11# include "astro.h"
    22
    3 # define SUBTRACT 0
    4 
    5 static float (*fitfunc)(float, float, float *, int, float *);
    6 
    73float fgaussTD (float, float, float *, int, float *);
    8 float fgalaxyTD (float, float, float *, int, float *);
    9 float fbarTD (float, float, float *, int, float *);
    10 void fix_ellipsegauss_pars (float *par, int Npar);
    11 
    12 /*** for some reason, fgaussTD fails occasionally if we use these two vars... */
    13 static float f1, f2;
    144
    155int imfit (int argc, char **argv) {
    166
    17   int i, j, N, done, Npts, Subtract;
    18   double Npar, DZ, DZ2;
    19   float dx, dy, chisq, nchisq;
    20   float **covar;
    21   float *V, *x, *y, *z, *dz, *par, tmpsky, DFact;
    22   int sx, sy, nx, ny;
    23   char *c, line[64];
     7  int i, j, N, Npts, Npar, Save, VERBOSE;
     8  int sx, sy, nx, ny, Nx, Ny;
     9  float chisq, ochisq, dchisq;
     10  float *x, *y, *z, *dz, *par, *V;
     11  char line[64];
    2412  Buffer *buf;
    2513
    26   Subtract = FALSE;
    27   if (N = get_argument (argc, argv, "-sub")) {
    28     remove_argument (N, &argc, argv);
    29     Subtract  = TRUE;
    30   }
    31 
    32   DFact = 1;
    33   if (N = get_argument (argc, argv, "-D")) {
    34     remove_argument (N, &argc, argv);
    35     DFact  = atof(argv[N]);
    36     remove_argument (N, &argc, argv);
    37   }
    38 
    39   fitfunc = fgaussTD;
    40   if (N = get_argument (argc, argv, "-gal")) {
    41     remove_argument (N, &argc, argv);
    42     fitfunc = fgalaxyTD;
    43   }
    44   if (N = get_argument (argc, argv, "-bar")) {
    45     remove_argument (N, &argc, argv);
    46     fitfunc = fbarTD;
     14  Save = FALSE;
     15  if ((N = get_argument (argc, argv, "-save"))) {
     16    remove_argument (N, &argc, argv);
     17    Save = TRUE;
     18  }
     19
     20  VERBOSE = FALSE;
     21  if ((N = get_argument (argc, argv, "-v"))) {
     22    remove_argument (N, &argc, argv);
     23    VERBOSE = TRUE;
    4724  }
    4825
    … …  
    5330
    5431  if ((buf = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE);
    55 
    56   f1 = 1;
    57   if ((c = get_variable ("BETA1")) != (char *) NULL) f1 = atof (c);
    58 
    59   f2 = 1;
    60   if ((c = get_variable ("BETA2")) != (char *) NULL) f2 = atof (c);
    61 
    6232  sx = atof (argv[2]);
    6333  sy = atof (argv[3]);
    6434  nx = atof (argv[4]);
    6535  ny = atof (argv[5]);
    66 
    67   if ((sx < 0) || (sy < 0) ||
    68       (sx+nx > buf[0].matrix.Naxis[0]) ||
    69       (sy+ny > buf[0].matrix.Naxis[1])) {
    70     fprintf (stderr, "region out of range\n");
    71     return (FALSE);
    72   }
     36  Nx = buf[0].matrix.Naxis[0];
     37  Ny = buf[0].matrix.Naxis[1];
     38
     39  if (sx < 0) goto range;
     40  if (sy < 0) goto range;
     41  if (sx + nx >= Nx) goto range;
     42  if (sy + ny >= Ny) goto range;
    7343
    7444  Npar = 7;
    … …  
    7848  /* convert array z[x,y] to x[i], y[i], z[i] */
    7949  Npts = nx*ny;
    80   ALLOCATE (x, float, 2*Npts);
    81   ALLOCATE (y, float, 2*Npts);
    82   ALLOCATE (z, float, 2*Npts);
     50  ALLOCATE (x,  float, 2*Npts);
     51  ALLOCATE (y,  float, 2*Npts);
     52  ALLOCATE (z,  float, 2*Npts);
    8353  ALLOCATE (dz, float, 2*Npts);
    8454
    85   for (N = j = 0; j < ny; j++) {
     55  N = 0;
     56  for (j = 0; j < ny; j++) {
    8657    V = (float *)(buf[0].matrix.buffer) + (j+sy)*buf[0].matrix.Naxis[0] + sx;
    8758    for (i = 0; i < nx; i++, V++, N++) {
    88       dx = i + sx;
    89       dy = j + sy;
     59      x[N] = i + sx;
     60      y[N] = j + sy;
    9061      z[N] = *V;
    9162      dz[N] = 1.0 / *V;  /* temporarily no gain (or, gain = 1) */
    92       x[N] = dx;
    93       y[N] = dy;
    9463    }
    9564  }
    … …  
    9766  /* make initial guesses on parameters */
    9867  /* fitting X^2 / (2*Sx), Y^2 / (2*Sy) */
    99   get_aperture_stats (&buf[0].matrix, (int)(sx + 0.5*nx), (int)(sy + 0.5*ny), 15, 2, 65000);
    10068  par[0] = atof (get_variable ("Xg"));
    10169  par[1] = atof (get_variable ("Yg"));
    102   par[2] = SQ (atof (get_variable ("SXg")) / 2.355);
    103   par[3] = SQ (atof (get_variable ("SYg")) / 2.355);
    104   par[4] = 0;
    105   par[5] = atof (get_variable ("Zcg")) / 15.0;
    106   /* par[5] is peak intensity, Zcg is total flux, scale down some */
     70  par[2] = 2.35 * sqrt(2.0) / atof (get_variable ("SXg"));
     71  par[3] = 2.35 * sqrt(2.0) / atof (get_variable ("SYg"));
     72  par[4] = 0.0;
     73  par[5] = atof (get_variable ("Zpk"));
    10774  par[6] = atof (get_variable ("Sg"));
    10875
    109   /* soften the errors */
    110   for (i = 0; i < Npts; i++) {
    111     double tmp1;
    112     tmp1 = fitfunc (x[i], y[i], par, Npar, (float *) NULL);
    113     if (!finite (tmp1)) {
    114       fprintf (stderr, "nan for tmp @ %d (%f %f %f)\n", i, x[i], y[i], z[i]);
    115     } else {
    116       DZ = DFact * fabs (z[i] - tmp1);
    117       DZ2 = DFact * fabs (z[i] - tmp1);
    118       dz[i] *= 1 / (dz[i]*DZ + 1);  /* dz[i] = 1 / (DZ + 1/dz[i]) */
     76  /* run fit routine */
     77  ochisq = mrq2dinit (x, y, z, dz, Npts, par, Npar, fgaussTD, VERBOSE);
     78  dchisq = ochisq;
     79
     80  for (i = 0; (i < 20) && ((dchisq <= 0.0) || (dchisq > 0.1*(Npts - Npar))); i++) {
     81    chisq = mrq2dmin (x, y, z, dz, Npts, par, Npar, fgaussTD, VERBOSE);
     82    dchisq = ochisq - chisq;
     83    ochisq = chisq;
     84    if (VERBOSE) fprintf (stderr, "dchisq: %f, Ndof: %d\n", dchisq, Npts - Npar);
     85  } 
     86
     87  /** create output image **/
     88  if (Save) {
     89    Buffer *out;
     90    float *Vi, *Vo, vr, vf, *dpar;
     91
     92    if ((out = SelectBuffer ("out",   ANYBUFFER, TRUE)) == NULL) return (FALSE);
     93    ALLOCATE (dpar, float, 2*Npar);
     94 
     95    free (out[0].header.buffer);
     96    free (out[0].matrix.buffer);
     97    strcpy (out[0].file, "(empty)");
     98    out[0].header.bitpix = -32;
     99    out[0].header.bscale = 1.0;
     100    out[0].header.bzero  = 0.0;
     101    out[0].header.unsign = FALSE;
     102    out[0].header.Naxes = 2;
     103    out[0].header.Naxis[0] = 2*nx;
     104    out[0].header.Naxis[1] = 2*ny;
     105    CreateBuffer (out);
     106
     107    /* four panels: 1) raw image. 2) fit  3) raw - fit   4) ?? */
     108    Vi = (float *)buf[0].matrix.buffer;
     109    Vo = (float *)out[0].matrix.buffer;
     110    for (j = 0; j < ny; j++) {
     111      for (i = 0; i < nx; i++) {
     112        vf = fgaussTD ((float)(i+sx), (float)(j+sy), par, Npar, dpar);
     113        vr = Vi[(i+sx)+(j+sy)*Nx];
     114        Vo[(i   )+(j   )*2*nx] = vr;
     115        Vo[(i+nx)+(j   )*2*nx] = vf;
     116        Vo[(i   )+(j+ny)*2*nx] = vr - vf;
     117        Vo[(i+nx)+(j+ny)*2*nx] = 0;
     118      }
    119119    }
    120   }
    121   /* run fit routine */
    122   chisq = mrq2dinit (x, y, z, dz, Npts, par, Npar, fitfunc);
    123   done = FALSE;
    124   for (i = 0; (i < 30) && !done; i++) {
    125     nchisq = mrq2dmin (x, y, z, dz, Npts, par, Npar, fitfunc);
    126     if (chisq - nchisq < 0.1) done = TRUE;
    127     if (nchisq > 0) chisq = nchisq;
    128   } 
    129   covar = mrq2dcovar (Npar);
     120    free (dpar);
     121  }
     122
     123  /* parameter renormalize */
     124  par[2] = 2.35*sqrt(2.0) / par[2];
     125  par[3] = 2.35*sqrt(2.0) / par[3];
     126  for (i = 0; i < Npar; i++) {
     127    sprintf (line, "PAR%d", i);
     128    set_variable (line, (double) par[i]);
     129    if (VERBOSE) fprintf (stderr, "%f ", par[i]);
     130  }
     131  if (VERBOSE) fprintf (stderr, "  %f\n", chisq/Npts);
     132
     133  free (par);
     134  free (x);
     135  free (y);
     136  free (z);
     137  free (dz);
     138
    130139  mrq2dfree (Npar);
     140  return (TRUE);
     141
     142range:
     143  fprintf (stderr, "region out of range\n");
     144  return (FALSE);
     145}
     146
     147/* pars: x, y, sx, sy, sxy, I, sky */
     148float fgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     149
     150  float X, Y, px, py;
     151  float z, r, q, f;
     152
     153  X = x - par[0];
     154  Y = y - par[1];
     155 
     156  px = par[2]*X;
     157  py = par[3]*Y;
     158
     159  z = 0.5*SQ(px) + 0.5*SQ(py) + par[4]*X*Y;
     160  r = exp (-z);
     161  q = par[5]*r;
     162  f = q + par[6];
     163
     164  dpar[0] = q*(2*px*par[2] + par[4]*Y);
     165  dpar[1] = q*(2*py*par[3] + par[4]*X);
     166  dpar[2] = -2*q*px*X;
     167  dpar[3] = -2*q*py*Y;
     168  dpar[4] = -q*X*Y;
     169  dpar[5] = +r;
     170  dpar[6] = +1;
     171
     172  return (f);
     173}
     174/* alternate for exp(-z) */
     175/* E = 1.0 / (1 + f1*Z + f2*(0.5*Z*Z + 0.1666666*Z*Z*Z)); */  /* ~ exp (-Z) */
     176/* E = 1.0 / (1 +    Z +    (0.5*Z*Z + 0.1666666*Z*Z*Z)); */  /* ~ exp (-Z) */
     177
     178# if (0)
     179/* pars: x, y, sx, sy, sxy, I, sky */
     180float fgalaxyTD (float x, float y, float *par, int Npar, float *dpar) {
     181
     182  float X, Y, Z, E, F, q, R, f, p2, p3;
     183
     184  X = x - par[0];
     185  Y = y - par[1];
     186 
     187  p2 = X / par[2];
     188  p3 = Y / par[3];
     189
     190  Z = sqrt (0.5*p2*X + X*Y*par[4] + 0.5*p3*Y);                 /* R */
     191  E = 1.0 / (1 + Z);   
     192
     193  q = par[5] * E;
     194  R = q*E;
     195  F = 0.5 / Z;
     196 
     197  f = q + par[6];
     198
     199  dpar[0] = F*R*(p2 + par[4]*Y);
     200  dpar[1] = F*R*(p3 + par[4]*X);
     201  dpar[2] = F*0.5*R*p2*p2;
     202  dpar[3] = F*0.5*R*p3*p3;
     203  dpar[4] = -R*X*Y*F;
     204   
     205  dpar[5] = E;
     206  dpar[6] = 1;
     207  return (f);
     208}
     209
     210/* pars: x, y, sx, sy, sxy, I, sky */
     211float fbarTD (float x, float y, float *par, int Npar, float *dpar) {
     212
     213  float X, Y, Z, E, F, q, R, f, p2, p3;
     214
     215  X = x - par[0];
     216  Y = y - par[1];
     217 
     218  p2 = X / par[2];
     219  p3 = Y / par[3];
     220
     221  Z = 0.5*p2*X + X*Y*par[4] + 0.5*p3*Y;                 /* R */
     222  E = 1.0 / (1 + Z*Z*Z);   
     223
     224  q = par[5] * E;
     225  F = 3*Z*Z;
     226  R = q*E*F;
     227 
     228  f = q + par[6];
     229
     230  dpar[0] = R*(p2 + par[4]*Y);
     231  dpar[1] = R*(p3 + par[4]*X);
     232  dpar[2] = 0.5*R*p2*p2;
     233  dpar[3] = 0.5*R*p3*p3;
     234  dpar[4] = -R*X*Y;
     235   
     236  dpar[5] = E;
     237  dpar[6] = 1;
     238  return (f);
     239}
     240
     241/* convert from x,y to major,minor */
     242void fix_ellipsegauss_pars (float *par, int Npar) {
     243
     244  float p2, p4, angle, t1, t2, tmp, area;
     245
     246  /* par[0], par[1] = Xo, Yo - stay the same */
     247
     248  p2 = 1/par[2];
     249  p4 = 1/par[3];
     250
     251  angle = 0.5 * atan2 (-2*par[4], p4 - p2);
     252
     253  tmp = sqrt (SQ(p2 - p4) + 4*SQ(par[4]));
     254  t1 = (p2 + p4 + tmp) / 2;
     255  t2 = t1 - tmp;
     256
     257  par[2] = 2.35482*sqrt(1/t2);
     258  par[3] = 2.35482*sqrt(1/t1);
     259  par[4] = DEG_RAD * angle;
     260
     261  area = 2*M_PI/sqrt(t1*t2);
     262
     263  par[5] *= area;
     264
     265}
     266# endif
     267
     268/***  options for later
     269
     270  Subtract = FALSE;
     271  if ((N = get_argument (argc, argv, "-sub"))) {
     272    remove_argument (N, &argc, argv);
     273    Subtract  = TRUE;
     274  }
     275
     276  DFact = 1;
     277  if ((N = get_argument (argc, argv, "-D"))) {
     278    remove_argument (N, &argc, argv);
     279    DFact  = atof(argv[N]);
     280    remove_argument (N, &argc, argv);
     281  }
     282
     283  fitfunc = fgaussTD;
     284  if ((N = get_argument (argc, argv, "-gal"))) {
     285    remove_argument (N, &argc, argv);
     286    fitfunc = fgalaxyTD;
     287  }
     288  if ((N = get_argument (argc, argv, "-bar"))) {
     289    remove_argument (N, &argc, argv);
     290    fitfunc = fbarTD;
     291  }
     292
     293
     294  f1 = 1;
     295  if ((c = get_variable ("BETA1")) != (char *) NULL) f1 = atof (c);
     296
     297  f2 = 1;
     298  if ((c = get_variable ("BETA2")) != (char *) NULL) f2 = atof (c);
    131299
    132300  if (Subtract) {
    … …  
    144312  }
    145313
    146   fix_ellipsegauss_pars (par, Npar);
    147 
    148   for (i = 0; i < Npar; i++) {
    149     sprintf (line, "PAR%d", i);
    150     set_variable (line, (double) par[i]);
    151     fprintf (stderr, "%f ", par[i]);
    152   }
    153   fprintf (stderr, "  %f\n", nchisq/(1.0*Npts));
    154 
    155   free (par);
    156   free (x);
    157   free (y);
    158   free (z);
    159   free (dz);
    160 
    161   return (TRUE);
    162 
    163 }
    164 
    165 /* pars: x, y, sx, sy, sxy, I, sky */
    166 float fgaussTD (float x, float y, float *par, int Npar, float *dpar) {
    167 
    168   float X, Y, Z, E, F, q, R, f, p2, p3;
    169 
    170   X = x - par[0];
    171   Y = y - par[1];
    172  
    173   p2 = X / par[2];
    174   p3 = Y / par[3];
    175 
    176   Z = 0.5*p2*X + X*Y*par[4] + 0.5*p3*Y;                 /* R^2 */
    177   /* E = 1.0 / (1 + f1*Z + f2*(0.5*Z*Z + 0.1666666*Z*Z*Z)); */  /* ~ exp (-Z) */
    178   E = 1.0 / (1 + Z + (0.5*Z*Z + 0.1666666*Z*Z*Z));   /* ~ exp (-Z) */
    179   F = (f1 + f2*(Z + 0.5*Z*Z));
    180 
    181   q = par[5] * E;
    182   R = q*E*F;
    183  
    184   f = q + par[6];
    185 
    186   if (dpar != (float *) NULL) {
    187     dpar[0] = R*(p2 + par[4]*Y);
    188     dpar[1] = R*(p3 + par[4]*X);
    189     dpar[2] = 0.5*R*p2*p2;
    190     dpar[3] = 0.5*R*p3*p3;
    191     dpar[4] = -R*X*Y;
    192    
    193     dpar[5] = E;
    194     dpar[6] = 1;
    195   }
    196 
    197   /*
    198   if ((fabs(X) < 2) && (fabs(Y) < 2)) {
    199     int i;
    200 
    201     for (i = 0; i < Npar; i++) {
    202       fprintf (stderr, "%d  %f  %f\n", i, par[i], dpar[i]);
    203     }
    204     fprintf (stderr, "func: (%f, %f)  %f\n", X, Y, f);
    205   }
    206   */
    207 
    208   if (!finite (f)) {
    209     fprintf (stderr, "nan for fgaussTD\n");
    210   }
    211 
    212   return (f);
    213 
    214 }
    215 
    216 /* pars: x, y, sx, sy, sxy, I, sky */
    217 float fgalaxyTD (float x, float y, float *par, int Npar, float *dpar) {
    218 
    219   float X, Y, Z, E, F, q, R, f, p2, p3;
    220 
    221   X = x - par[0];
    222   Y = y - par[1];
    223  
    224   p2 = X / par[2];
    225   p3 = Y / par[3];
    226 
    227   Z = sqrt (0.5*p2*X + X*Y*par[4] + 0.5*p3*Y);                 /* R */
    228   E = 1.0 / (1 + Z);   
    229 
    230   q = par[5] * E;
    231   R = q*E;
    232   F = 0.5 / Z;
    233  
    234   f = q + par[6];
    235 
    236   if (dpar != (float *) NULL) {
    237     dpar[0] = F*R*(p2 + par[4]*Y);
    238     dpar[1] = F*R*(p3 + par[4]*X);
    239     dpar[2] = F*0.5*R*p2*p2;
    240     dpar[3] = F*0.5*R*p3*p3;
    241     dpar[4] = -R*X*Y*F;
    242    
    243     dpar[5] = E;
    244     dpar[6] = 1;
    245   }
    246 
    247   /*
    248   if ((fabs(X) < 2) && (fabs(Y) < 2)) {
    249     int i;
    250 
    251     for (i = 0; i < Npar; i++) {
    252       fprintf (stderr, "%d  %f  %f\n", i, par[i], dpar[i]);
    253     }
    254     fprintf (stderr, "func: (%f, %f)  %f\n", X, Y, f);
    255   }
    256   */
    257   return (f);
    258 
    259 }
    260 
    261 
    262 /* pars: x, y, sx, sy, sxy, I, sky */
    263 float fbarTD (float x, float y, float *par, int Npar, float *dpar) {
    264 
    265   float X, Y, Z, E, F, q, R, f, p2, p3;
    266 
    267   X = x - par[0];
    268   Y = y - par[1];
    269  
    270   p2 = X / par[2];
    271   p3 = Y / par[3];
    272 
    273   Z = 0.5*p2*X + X*Y*par[4] + 0.5*p3*Y;                 /* R */
    274   E = 1.0 / (1 + Z*Z*Z);   
    275 
    276   q = par[5] * E;
    277   F = 3*Z*Z;
    278   R = q*E*F;
    279  
    280   f = q + par[6];
    281 
    282   if (dpar != (float *) NULL) {
    283     dpar[0] = R*(p2 + par[4]*Y);
    284     dpar[1] = R*(p3 + par[4]*X);
    285     dpar[2] = 0.5*R*p2*p2;
    286     dpar[3] = 0.5*R*p3*p3;
    287     dpar[4] = -R*X*Y;
    288    
    289     dpar[5] = E;
    290     dpar[6] = 1;
    291   }
    292 
    293   /*
    294   if ((fabs(X) < 2) && (fabs(Y) < 2)) {
    295     int i;
    296 
    297     for (i = 0; i < Npar; i++) {
    298       fprintf (stderr, "%d  %f  %f\n", i, par[i], dpar[i]);
    299     }
    300     fprintf (stderr, "func: (%f, %f)  %f\n", X, Y, f);
    301   }
    302   */
    303   return (f);
    304 
    305 }
    306 
    307 
    308 void fix_ellipsegauss_pars (float *par, int Npar) {
    309 
    310   float p2, p4, angle, t1, t2, tmp, area;
    311 
    312   /* par[0], par[1] = Xo, Yo - stay the same */
    313 
    314   p2 = 1/par[2];
    315   p4 = 1/par[3];
    316 
    317   angle = 0.5 * atan2 (-2*par[4], p4 - p2);
    318 
    319   tmp = sqrt (SQ(p2 - p4) + 4*SQ(par[4]));
    320   t1 = (p2 + p4 + tmp) / 2;
    321   t2 = t1 - tmp;
    322 
    323   par[2] = 2.35482*sqrt(1/t2);
    324   par[3] = 2.35482*sqrt(1/t1);
    325   par[4] = DEG_RAD * angle;
    326 
    327   area = 2*M_PI/sqrt(t1*t2);
    328 
    329   par[5] *= area;
    330 
    331 }
    332 
    333 
     314***/

  • trunk/Ohana/src/opihi/cmd.astro/init.c

    r2598 r2843  
    2929int spec                    PROTO((int, char **));
    3030int star                    PROTO((int, char **));
    31 int testfit                 PROTO((int, char **));
    3231int times                   PROTO((int, char **));
    3332int transform               PROTO((int, char **));

  • trunk/Ohana/src/opihi/cmd.astro/medianmap.c

    r2598 r2843  
    1212
    1313  Ignore = FALSE;
    14   if (N = get_argument (argc, argv, "-ignore")) {
     14  if ((N = get_argument (argc, argv, "-ignore"))) {
    1515    Ignore = TRUE;
    1616    remove_argument (N, &argc, argv);
    … …  
    2121  min = 0.45;
    2222  max = 0.55;
    23   if (N = get_argument (argc, argv, "-range")) {
     23  if ((N = get_argument (argc, argv, "-range"))) {
    2424    remove_argument (N, &argc, argv);
    2525    min  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/mkgauss.c

    r2598 r2843  
    1212
    1313  Xo = Yo = 0;
    14   if (N = get_argument (argc, argv, "-c")) {
     14  if ((N = get_argument (argc, argv, "-c"))) {
    1515    remove_argument (N, &argc, argv);
    1616    Xo = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/objload.c

    r2598 r2843  
    1212 
    1313  Nimage = -1;
    14   if (N = get_argument (argc, argv, "-n")) {
     14  if ((N = get_argument (argc, argv, "-n"))) {
    1515    remove_argument (N, &argc, argv);
    1616    Nimage = atof (argv[N]);
    … …  
    2020
    2121  Type = 0;
    22   if (N = get_argument (argc, argv, "-t")) {
     22  if ((N = get_argument (argc, argv, "-t"))) {
    2323    remove_argument (N, &argc, argv);
    2424    Type = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/outline2.c

    r2598 r2843  
    351351  free (buffer);
    352352  free (line);
    353  
     353  return (TRUE);
    354354}

  • trunk/Ohana/src/opihi/cmd.astro/region.c

    r2598 r2843  
    1313  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
    1414
    15   if (N = get_argument (argc, argv, "-ew")) {
     15  if ((N = get_argument (argc, argv, "-ew"))) {
    1616    remove_argument (N, &argc, argv);
    1717    graphmode.flipeast = TRUE;
    1818  }
    1919
    20   if (N = get_argument (argc, argv, "+ew")) {
     20  if ((N = get_argument (argc, argv, "+ew"))) {
    2121    remove_argument (N, &argc, argv);
    2222    graphmode.flipeast = FALSE;
    2323  }
    2424
    25   if (N = get_argument (argc, argv, "-ns")) {
     25  if ((N = get_argument (argc, argv, "-ns"))) {
    2626    remove_argument (N, &argc, argv);
    2727    graphmode.flipnorth = TRUE;
    2828  }
    2929
    30   if (N = get_argument (argc, argv, "+ns")) {
     30  if ((N = get_argument (argc, argv, "+ns"))) {
    3131    remove_argument (N, &argc, argv);
    3232    graphmode.flipnorth = FALSE;

  • trunk/Ohana/src/opihi/cmd.astro/rotcurve.c

    r2598 r2843  
    1414
    1515  min = -1000;
    16   if (N = get_argument (argc, argv, "-min")) {
     16  if ((N = get_argument (argc, argv, "-min"))) {
    1717    remove_argument (N, &argc, argv);
    1818    min = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/sexigesimal.c

    r2598 r2843  
    88
    99  HMS = TRUE;
    10   if (N = get_argument (argc, argv, "-hms")) {
     10  if ((N = get_argument (argc, argv, "-hms"))) {
    1111    HMS = TRUE;
    1212    remove_argument (N, &argc, argv);
    1313  }
    14   if (N = get_argument (argc, argv, "-hh")) {
     14  if ((N = get_argument (argc, argv, "-hh"))) {
    1515    HMS = FALSE;
    1616    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.astro/spec.c

    r2598 r2843  
    1111
    1212  Nlong = 31;
    13   if (N = get_argument (argc, argv, "-Nlong")) {
     13  if ((N = get_argument (argc, argv, "-Nlong"))) {
    1414    remove_argument (N, &argc, argv);
    1515    Nlong  = 0.5*atof(argv[N]);
    … …  
    1919 
    2020  Ngap = 15;
    21   if (N = get_argument (argc, argv, "-Ngap")) {
     21  if ((N = get_argument (argc, argv, "-Ngap"))) {
    2222    remove_argument (N, &argc, argv);
    2323    Ngap  = 0.5*atof(argv[N]);
    … …  
    2727 
    2828  Nrow = 1;
    29   if (N = get_argument (argc, argv, "-Nrow")) {
     29  if ((N = get_argument (argc, argv, "-Nrow"))) {
    3030    remove_argument (N, &argc, argv);
    3131    Nrow  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.astro/star.c

    r2598 r2843  
    88
    99  Nborder = 3;
    10   if (N = get_argument (argc, argv, "-border")) {
     10  if ((N = get_argument (argc, argv, "-border"))) {
    1111    remove_argument (N, &argc, argv);
    1212    Nborder  = atof(argv[N]);
    … …  
    1616 
    1717  max = 60000;
    18   if (N = get_argument (argc, argv, "-sat")) {
     18  if ((N = get_argument (argc, argv, "-sat"))) {
    1919    remove_argument (N, &argc, argv);
    2020    max  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.basic/break.c

    r2598 r2843  
    55  int N, value;
    66
    7   if (N = get_argument (argc, argv, "-auto")) {
     7  if ((N = get_argument (argc, argv, "-auto"))) {
    88    remove_argument (N, &argc, argv);
    99    value = -1;

  • trunk/Ohana/src/opihi/cmd.basic/list.c

    r2598 r2843  
    1313
    1414  RunCommand = FALSE;
    15   if (N = get_argument (argc, argv, "-x")) {
     15  if ((N = get_argument (argc, argv, "-x"))) {
    1616    remove_argument (N, &argc, argv);
    1717    Cmd = strcreate (argv[N]);

  • trunk/Ohana/src/opihi/cmd.basic/local.c

    r2598 r2843  
    99
    1010  STATIC = FALSE;
    11   if (N = get_argument (argc, argv, "-static")) {
     11  if ((N = get_argument (argc, argv, "-static"))) {
    1212    remove_argument (N, &argc, argv);
    1313    STATIC = TRUE;

  • trunk/Ohana/src/opihi/cmd.basic/run_if.c

    r2792 r2843  
    55
    66  int ThisList, depth, done, status, BreakOnTrue;
    7   int logic, equals;
     7  int logic;
    88  char *input, *outline, *val;
    99  int nloop, size;
    … …  
    102102  }
    103103  return (TRUE);
    104 
    105  syntax:
    106   fprintf (stderr, "syntax error in if-statement\n");
    107   return (FALSE);
    108104}
    109105

  • trunk/Ohana/src/opihi/cmd.basic/sprintf.c

    r2598 r2843  
    66int sprintf_opihi (int argc, char **argv) {
    77
    8   int i, Nchar;
     8  int i;
    99  char line[NCHAR], tmp[NCHAR], fmt[NCHAR];
    1010  char *p1, *p2, *q;

  • trunk/Ohana/src/opihi/cmd.data/Makefile

    r2833 r2843  
    4848$(SDIR)/grid.$(ARCH).o          \
    4949$(SDIR)/gridify.$(ARCH).o       \
     50$(SDIR)/ungridify.$(ARCH).o     \
    5051$(SDIR)/histogram.$(ARCH).o     \
    5152$(SDIR)/imcut.$(ARCH).o         \
    … …  
    106107$(SDIR)/vbin.$(ARCH).o             \
    107108$(SDIR)/vclip.$(ARCH).o            \
     109$(SDIR)/vgauss.$(ARCH).o           \
    108110$(SDIR)/vgrid.$(ARCH).o            \
    109111$(SDIR)/vload.$(ARCH).o            \

  • trunk/Ohana/src/opihi/cmd.data/accum.c

    r2598 r2843  
    99
    1010  Normalize = FALSE;
    11   if (N = get_argument (argc, argv, "-norm")) {
     11  if ((N = get_argument (argc, argv, "-norm"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Normalize = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/box.c

    r2598 r2843  
    99 
    1010  strcpy (Ticks, "2222");
    11   if (N = get_argument (argc, argv, "-ticks")) {
     11  if ((N = get_argument (argc, argv, "-ticks"))) {
    1212    remove_argument (N, &argc, argv);
    1313    strcpy (Ticks, argv[N]);
    … …  
    2020 
    2121  strcpy (Labels, "2222");
    22   if (N = get_argument (argc, argv, "-labels")) {
     22  if ((N = get_argument (argc, argv, "-labels"))) {
    2323    remove_argument (N, &argc, argv);
    2424    strcpy (Labels, argv[N]);
    … …  
    3131
    3232  strcpy (Axis, "2222");
    33   if (N = get_argument (argc, argv, "-axis")) {
     33  if ((N = get_argument (argc, argv, "-axis"))) {
    3434    remove_argument (N, &argc, argv);
    3535    strcpy (Axis, argv[N]);
    … …  
    4242
    4343  Ngraph = -1;
    44   if (N = get_argument (argc, argv, "-n")) {
     44  if ((N = get_argument (argc, argv, "-n"))) {
    4545    remove_argument (N, &argc, argv);
    4646    Ngraph = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/center.c

    r2598 r2843  
    99 
    1010  Nimage = -1;
    11   if (N = get_argument (argc, argv, "-n")) {
     11  if ((N = get_argument (argc, argv, "-n"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Nimage = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/clear.c

    r2598 r2843  
    77
    88  Ngraph = -1;
    9   if (N = get_argument (argc, argv, "-n")) {
     9  if ((N = get_argument (argc, argv, "-n"))) {
    1010    remove_argument (N, &argc, argv);
    1111    Ngraph = atof (argv[N]);
    … …  
    1515
    1616  ClearSection = FALSE;
    17   if (N = get_argument (argc, argv, "-s")) {
     17  if ((N = get_argument (argc, argv, "-s"))) {
    1818    remove_argument (N, &argc, argv);
    1919    ClearSection = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/clip.c

    r2598 r2843  
    99
    1010  DO_NAN = FALSE;
    11   if (N = get_argument (argc, argv, "-nan")) {
     11  if ((N = get_argument (argc, argv, "-nan"))) {
    1212    remove_argument (N, &argc, argv);
    1313    nan_val  = atof(argv[N]);
    … …  
    1717
    1818  DO_INF = FALSE;
    19   if (N = get_argument (argc, argv, "-inf")) {
     19  if ((N = get_argument (argc, argv, "-inf"))) {
    2020    remove_argument (N, &argc, argv);
    2121    inf_val  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/create.c

    r2598 r2843  
    99  Vector *vec;
    1010 
    11   if (N = get_argument (argc, argv, "-image")) {
     11  if ((N = get_argument (argc, argv, "-image"))) {
    1212    remove_argument (N, &argc, argv);
    1313    return (imcreate (argc, argv));

  • trunk/Ohana/src/opihi/cmd.data/cursor.c

    r2598 r2843  
    44
    55  char buffer[40], string[20], key;
    6   int i, N, Nsource, Source, IsImage, oldsignal;
     6  int i, N, Nsource, Source, IsImage;
    77  double X, Y, R, D, Z;
     8  void *oldsignal;
    89  Graphdata graphmode;
    910  Buffer *buf;
    1011
    1112  Nsource = -1;
    12   if (N = get_argument (argc, argv, "-n")) {
     13  if ((N = get_argument (argc, argv, "-n"))) {
    1314    remove_argument (N, &argc, argv);
    1415    Nsource = atof (argv[N]);
    1516    remove_argument (N, &argc, argv);
    1617  }
    17   if (N = get_argument (argc, argv, "-g")) {
     18  if ((N = get_argument (argc, argv, "-g"))) {
    1819    remove_argument (N, &argc, argv);
    1920    SetImageDevice (FALSE);
    2021  } 
    21   if (N = get_argument (argc, argv, "-i")) {
     22  if ((N = get_argument (argc, argv, "-i"))) {
    2223    remove_argument (N, &argc, argv);
    2324    SetImageDevice (TRUE);
    … …  
    4445  write (Source, string, 4); /* ask Source to look for the keystrokes */
    4546 
    46   oldsignal = (int) signal (SIGINT, handle_interrupt);
     47  oldsignal = signal (SIGINT, handle_interrupt);
    4748  interrupt = FALSE;
    4849  Z = -1.0;
    … …  
    8687  }
    8788
    88   signal (SIGINT, (void *) oldsignal);
     89  signal (SIGINT, oldsignal);
    8990  write (Source, "NCUR", 4); /* ask Source to look for the keystrokes */
    9091  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/cut.c

    r2598 r2843  
    1212
    1313  Mode = SUM;
    14   if (N = get_argument (argc, argv, "-median")) {
     14  if ((N = get_argument (argc, argv, "-median"))) {
    1515    remove_argument (N, &argc, argv);
    1616    Mode = MEDIAN;
    1717  }
    18   if (N = get_argument (argc, argv, "-mean")) {
     18  if ((N = get_argument (argc, argv, "-mean"))) {
    1919    remove_argument (N, &argc, argv);
    2020    Mode = MEAN;

  • trunk/Ohana/src/opihi/cmd.data/delete.c

    r2598 r2843  
    66
    77  Quiet = FALSE;
    8   if (N = get_argument (argc, argv, "-q")) {
     8  if ((N = get_argument (argc, argv, "-q"))) {
    99    Quiet = TRUE;
    1010    remove_argument (N, &argc, argv);
    1111  }
    12   if (N = get_argument (argc, argv, "-quiet")) {
     12  if ((N = get_argument (argc, argv, "-quiet"))) {
    1313    Quiet = TRUE;
    1414    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/device.c

    r2598 r2843  
    77
    88  Nsource = -1;
    9   if (N = get_argument (argc, argv, "-n")) {
     9  if ((N = get_argument (argc, argv, "-n"))) {
    1010    remove_argument (N, &argc, argv);
    1111    Nsource = atof (argv[N]);
    1212    remove_argument (N, &argc, argv);
    1313  }
    14   if (N = get_argument (argc, argv, "-g")) {
     14  if ((N = get_argument (argc, argv, "-g"))) {
    1515    remove_argument (N, &argc, argv);
    1616    SetImageDevice (FALSE);
    1717  } 
    18   if (N = get_argument (argc, argv, "-i")) {
     18  if ((N = get_argument (argc, argv, "-i"))) {
    1919    remove_argument (N, &argc, argv);
    2020    SetImageDevice (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/erase.c

    r2598 r2843  
    88 
    99  Nimage = -1;
    10   if (N = get_argument (argc, argv, "-n")) {
     10  if ((N = get_argument (argc, argv, "-n"))) {
    1111    remove_argument (N, &argc, argv);
    1212    Nimage = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/fft2d.c

    r2598 r2843  
    99
    1010  isign = 1;
    11   if (N = get_argument (argc, argv, "-inverse")) {
     11  if ((N = get_argument (argc, argv, "-inverse"))) {
    1212    remove_argument (N, &argc, argv);
    1313    isign = -1;

  • trunk/Ohana/src/opihi/cmd.data/fit.c

    r2598 r2843  
    1111
    1212  Quiet = FALSE;
    13   if (N = get_argument (argc, argv, "-q")) {
     13  if ((N = get_argument (argc, argv, "-q"))) {
    1414    Quiet = TRUE;
    1515    remove_argument (N, &argc, argv);
    1616  }
    17   if (N = get_argument (argc, argv, "-quiet")) {
     17  if ((N = get_argument (argc, argv, "-quiet"))) {
    1818    Quiet = TRUE;
    1919    remove_argument (N, &argc, argv);
    … …  
    2121
    2222  Weight = FALSE;
    23   if (N = get_argument (argc, argv, "-dy")) {
     23  if ((N = get_argument (argc, argv, "-dy"))) {
    2424    remove_argument (N, &argc, argv);
    2525    if ((dyvec = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);   

  • trunk/Ohana/src/opihi/cmd.data/fit2d.c

    r2598 r2843  
    1111
    1212  Weight = FALSE;
    13   if (N = get_argument (argc, argv, "-dy")) {
     13  if ((N = get_argument (argc, argv, "-dy"))) {
    1414    remove_argument (N, &argc, argv);
    1515    if ((dyvec = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);   

  • trunk/Ohana/src/opihi/cmd.data/grid.c

    r2598 r2843  
    1010
    1111  Ngraph = -1;
    12   if (N = get_argument (argc, argv, "-n")) {
     12  if ((N = get_argument (argc, argv, "-n"))) {
    1313    remove_argument (N, &argc, argv);
    1414    Ngraph = atof (argv[N]);
    … …  
    1919  MajorTick = TRUE;
    2020  MinorTick = FALSE;
    21   if (N = get_argument (argc, argv, "-all")) {
     21  if ((N = get_argument (argc, argv, "-all"))) {
    2222    remove_argument (N, &argc, argv);
    2323    MinorTick = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/gridify.c

    r2598 r2843  
    1111
    1212  if (argc != 11) {
    13     fprintf (stderr, "USAGE: vectobuf x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
     13    fprintf (stderr, "USAGE: gridify x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
    1414    return (FALSE);
    1515  }

  • trunk/Ohana/src/opihi/cmd.data/imcut.c

    r2598 r2843  
    1414  }
    1515
    16   if ((buf  = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) goto usage;
     16  if ((buf  = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) goto missed;
    1717  if ((xvec = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) goto usage;
    1818  if ((yvec = SelectVector (argv[3], ANYVECTOR, TRUE)) == NULL) goto usage;

  • trunk/Ohana/src/opihi/cmd.data/imhist.c

    r2598 r2843  
    1111
    1212  min = max = 0.0;
    13   if (N = get_argument (argc, argv, "-range")) {
     13  if ((N = get_argument (argc, argv, "-range"))) {
    1414    remove_argument (N, &argc, argv);
    1515    min = atof (argv[N]);
    … …  
    2121  sx = sy = 0.0;
    2222  nx = ny = 0.0;
    23   if (N = get_argument (argc, argv, "-region")) {
     23  if ((N = get_argument (argc, argv, "-region"))) {
    2424    remove_argument (N, &argc, argv);
    2525    sx = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/imsmooth.c

    r2826 r2843  
    6363  }
    6464
     65  free (temp);
    6566  free (gaussnorm);
    6667  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/init.c

    r2826 r2843  
    2929int grid             PROTO((int, char **));
    3030int gridify          PROTO((int, char **));
     31int ungridify        PROTO((int, char **));
    3132int histogram        PROTO((int, char **));
    3233int imcut            PROTO((int, char **));
    … …  
    8889int vect_select      PROTO((int, char **));
    8990int vgrid            PROTO((int, char **));
     91int vgauss           PROTO((int, char **));
    9092int vload            PROTO((int, char **));
    9193int vstat            PROTO((int, char **));
    … …  
    126128  {"grid",         grid,             "plot cartesian grid"},
    127129  {"gridify",      gridify,          "convert vector triplet to buffer"},
     130  {"ungridify",    ungridify,        "convert buffer region to vector triplet"},
    128131  {"header",       header,           "print buffer header"},
    129132  {"histogram",    histogram,        "generate histogram from vector"},
    … …  
    184187  {"vclip",        vclip,            "clip values in a vector to be within a range"},
    185188  {"select",       vect_select,      "selective vector assignment"},
    186   {"vgrid",        vgrid,            "get info from imreg database"},
     189  {"vgauss",       vgauss,           ""},
     190  {"vgrid",        vgrid,            ""},
    187191  {"vload",        vload,            "load vectors on Kii"},
    188192  {"vstat",        vstat,            "get info from imreg database"},

  • trunk/Ohana/src/opihi/cmd.data/integrate.c

    r2598 r2843  
    99
    1010  VERBOSE = FALSE;
    11   if (N = get_argument (argc, argv, "-v")) {
     11  if ((N = get_argument (argc, argv, "-v"))) {
    1212    VERBOSE = TRUE;
    1313    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/jpeg.c

    r2598 r2843  
    66  int N, Source, Nsource, IsImage;
    77 
    8   if (N = get_argument (argc, argv, "--help")) {
     8  if ((N = get_argument (argc, argv, "--help"))) {
    99    fprintf (stderr, "USAGE: jpeg [-name file] [-g | -i] [-n device] [-ppm]\n");
    1010    return (FALSE);
    … …  
    1313  /* image type */
    1414  strcpy (type, "PNGF");
    15   if (N = get_argument (argc, argv, "-ppm")) {
     15  if ((N = get_argument (argc, argv, "-ppm"))) {
    1616    remove_argument (N, &argc, argv);
    1717    strcpy (type, "PPMF");
    … …  
    2020  /* file name */
    2121  filename[0] = 0;
    22   if (N = get_argument (argc, argv, "-name")) {
     22  if ((N = get_argument (argc, argv, "-name"))) {
    2323    remove_argument (N, &argc, argv);
    2424    strcpy (filename, argv[N]);
    … …  
    2828  /* display source */
    2929  Nsource = -1;
    30   if (N = get_argument (argc, argv, "-n")) {
     30  if ((N = get_argument (argc, argv, "-n"))) {
    3131    remove_argument (N, &argc, argv);
    3232    Nsource = atof (argv[N]);
    3333    remove_argument (N, &argc, argv);
    3434  }
    35   if (N = get_argument (argc, argv, "-g")) {
     35  if ((N = get_argument (argc, argv, "-g"))) {
    3636    remove_argument (N, &argc, argv);
    3737    SetImageDevice (FALSE);
    3838  } 
    39   if (N = get_argument (argc, argv, "-i")) {
     39  if ((N = get_argument (argc, argv, "-i"))) {
    4040    remove_argument (N, &argc, argv);
    4141    SetImageDevice (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/keyword.c

    r2598 r2843  
    1212
    1313  asfloat = FALSE;
    14   if (N = get_argument (argc, argv, "-f")) {
     14  if ((N = get_argument (argc, argv, "-f"))) {
    1515    remove_argument (N, &argc, argv);
    1616    asfloat = TRUE;
    … …  
    1818 
    1919  ascomment = FALSE;
    20   if (N = get_argument (argc, argv, "-c")) {
     20  if ((N = get_argument (argc, argv, "-c"))) {
    2121    remove_argument (N, &argc, argv);
    2222    ascomment = TRUE;
    … …  
    2424 
    2525  delete = FALSE;
    26   if (N = get_argument (argc, argv, "-d")) {
     26  if ((N = get_argument (argc, argv, "-d"))) {
    2727    remove_argument (N, &argc, argv);
    2828    delete = TRUE;
    … …  
    3131  /* return TRUE for missing keyword if soft */
    3232  soft = FALSE;
    33   if (N = get_argument (argc, argv, "-soft")) {
     33  if ((N = get_argument (argc, argv, "-soft"))) {
    3434    remove_argument (N, &argc, argv);
    3535    soft = TRUE;
    … …  
    3838  /* identify write modes */
    3939  Wmode = NONE;
    40   if (N = get_argument (argc, argv, "-w")) {
     40  if ((N = get_argument (argc, argv, "-w"))) {
    4141    remove_argument (N, &argc, argv);
    4242    strcpy (line, argv[N]);
    … …  
    4444    Wmode = STRING;
    4545  }
    46   if (N = get_argument (argc, argv, "-wf")) {
     46  if ((N = get_argument (argc, argv, "-wf"))) {
    4747    remove_argument (N, &argc, argv);
    4848    strcpy (line, argv[N]);
    … …  
    5050    Wmode = FLOAT;
    5151  }
    52   if (N = get_argument (argc, argv, "-wd")) {
     52  if ((N = get_argument (argc, argv, "-wd"))) {
    5353    remove_argument (N, &argc, argv);
    5454    strcpy (line, argv[N]);
    … …  
    5656    Wmode = INT;
    5757  }
    58   if (N = get_argument (argc, argv, "-wc")) {
     58  if ((N = get_argument (argc, argv, "-wc"))) {
    5959    remove_argument (N, &argc, argv);
    6060    strcpy (line, argv[N]);
    … …  
    6262    Wmode = KEYCOMMENT;
    6363  }
    64   if (N = get_argument (argc, argv, "-ws")) {
     64  if ((N = get_argument (argc, argv, "-ws"))) {
    6565    remove_argument (N, &argc, argv);
    6666    strcpy (line, argv[N]);
    … …  
    6868    Wmode = COMMENT;
    6969  }
    70   if (N = get_argument (argc, argv, "-wb")) {
     70  if ((N = get_argument (argc, argv, "-wb"))) {
    7171    remove_argument (N, &argc, argv);
    7272    strcpy (line, argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/labels.c

    r2598 r2843  
    3030  }
    3131
    32   if (N = get_argument (argc, argv, "-fn")) {
     32  if ((N = get_argument (argc, argv, "-fn"))) {
    3333    remove_argument (N, &argc, argv);
    3434    strcpy (name, argv[N]);
    … …  
    4343  }
    4444
    45   if (N = get_argument (argc, argv, "-x")) {
     45  if ((N = get_argument (argc, argv, "-x"))) {
    4646    remove_argument (N, &argc, argv);
    4747    SendLabel (argv[N], Xgraph, 0);
    … …  
    4949  }
    5050
    51   if (N = get_argument (argc, argv, "-y")) {
     51  if ((N = get_argument (argc, argv, "-y"))) {
    5252    remove_argument (N, &argc, argv);
    5353    SendLabel (argv[N], Xgraph, 1);
    … …  
    5555  }
    5656
    57   if (N = get_argument (argc, argv, "+x")) {
     57  if ((N = get_argument (argc, argv, "+x"))) {
    5858    remove_argument (N, &argc, argv);
    5959    SendLabel (argv[N], Xgraph, 2);
    … …  
    6161  }
    6262
    63   if (N = get_argument (argc, argv, "+y")) {
     63  if ((N = get_argument (argc, argv, "+y"))) {
    6464    remove_argument (N, &argc, argv);
    6565    SendLabel (argv[N], Xgraph, 3);
    … …  
    6767  }
    6868
    69   if (N = get_argument (argc, argv, "-ul")) {
     69  if ((N = get_argument (argc, argv, "-ul"))) {
    7070    remove_argument (N, &argc, argv);
    7171    SendLabel (argv[N], Xgraph, 4);
    … …  
    7373  }
    7474
    75   if (N = get_argument (argc, argv, "-ur")) {
     75  if ((N = get_argument (argc, argv, "-ur"))) {
    7676    remove_argument (N, &argc, argv);
    7777    SendLabel (argv[N], Xgraph, 5);
    … …  
    7979  }
    8080
    81   if (N = get_argument (argc, argv, "-ll")) {
     81  if ((N = get_argument (argc, argv, "-ll"))) {
    8282    remove_argument (N, &argc, argv);
    8383    SendLabel (argv[N], Xgraph, 6);
    … …  
    8585  }
    8686
    87   if (N = get_argument (argc, argv, "-lr")) {
     87  if ((N = get_argument (argc, argv, "-lr"))) {
    8888    remove_argument (N, &argc, argv);
    8989    SendLabel (argv[N], Xgraph, 7);

  • trunk/Ohana/src/opihi/cmd.data/limits.c

    r2598 r2843  
    1111
    1212  APPLY = FALSE;
    13   if (N = get_argument (argc, argv, "-a")) {
     13  if ((N = get_argument (argc, argv, "-a"))) {
    1414    remove_argument (N, &argc, argv);
    1515    APPLY = TRUE;
    … …  
    1717
    1818  Ngraph = -1;
    19   if (N = get_argument (argc, argv, "-n")) {
     19  if ((N = get_argument (argc, argv, "-n"))) {
    2020    remove_argument (N, &argc, argv);
    2121    Ngraph = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/line.c

    r2598 r2843  
    99  /* choose the appropriate graphing window */
    1010  Ngraph = -1;
    11   if (N = get_argument (argc, argv, "-n")) {
     11  if ((N = get_argument (argc, argv, "-n"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Ngraph = atof (argv[N]);
    … …  
    1717
    1818  /* evaluate various plotting options */
    19   if (N = get_argument (argc, argv, "-lt")) {
     19  if ((N = get_argument (argc, argv, "-lt"))) {
    2020    remove_argument (N, &argc, argv);
    2121    graphmode.ltype = atof(argv[N]);
    2222    remove_argument (N, &argc, argv);
    2323  }
    24   if (N = get_argument (argc, argv, "-lw")) {
     24  if ((N = get_argument (argc, argv, "-lw"))) {
    2525    remove_argument (N, &argc, argv);
    2626    graphmode.lweight = atof(argv[N]);
    2727    remove_argument (N, &argc, argv);
    2828  }
    29   if (N = get_argument (argc, argv, "-pt")) {
     29  if ((N = get_argument (argc, argv, "-pt"))) {
    3030    remove_argument (N, &argc, argv);
    3131    graphmode.ptype = atof(argv[N]);
    3232    remove_argument (N, &argc, argv);
    3333  }
    34   if (N = get_argument (argc, argv, "+eb")) {
     34  if ((N = get_argument (argc, argv, "+eb"))) {
    3535    remove_argument (N, &argc, argv);
    3636    graphmode.ebar = TRUE;
    3737  }
    38   if (N = get_argument (argc, argv, "-eb")) {
     38  if ((N = get_argument (argc, argv, "-eb"))) {
    3939    remove_argument (N, &argc, argv);
    4040    graphmode.ebar = FALSE;
    4141  }
    42   if (N = get_argument (argc, argv, "-sz")) {
     42  if ((N = get_argument (argc, argv, "-sz"))) {
    4343    remove_argument (N, &argc, argv);
    4444    graphmode.size = atof(argv[N]);
    4545    remove_argument (N, &argc, argv);
    4646  }
    47   if (N = get_argument (argc, argv, "-c")) {
     47  if ((N = get_argument (argc, argv, "-c"))) {
    4848    remove_argument (N, &argc, argv);
    4949    graphmode.color = GetColor (argv[N]);
    … …  
    5151    remove_argument (N, &argc, argv);
    5252  }
    53   if (N = get_argument (argc, argv, "-x")) {
     53  if ((N = get_argument (argc, argv, "-x"))) {
    5454    remove_argument (N, &argc, argv);
    5555    graphmode.style = atof(argv[N]);
    … …  
    5959  /* decide on error bars */
    6060  dxm = dxp = dym = dyp = NULL;
    61   if (N = get_argument (argc, argv, "-dx")) {
     61  if ((N = get_argument (argc, argv, "-dx"))) {
    6262    remove_argument (N, &argc, argv);
    6363    if ((dxm = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    6464    remove_argument (N, &argc, argv);
    6565  }
    66   if (N = get_argument (argc, argv, "+dx")) {
     66  if ((N = get_argument (argc, argv, "+dx"))) {
    6767    remove_argument (N, &argc, argv);
    6868    if ((dxp = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    6969    remove_argument (N, &argc, argv);
    7070  }
    71   if (N = get_argument (argc, argv, "-dy")) {
     71  if ((N = get_argument (argc, argv, "-dy"))) {
    7272    remove_argument (N, &argc, argv);
    7373    if ((dym = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    7474    remove_argument (N, &argc, argv);
    7575  }
    76   if (N = get_argument (argc, argv, "+dy")) {
     76  if ((N = get_argument (argc, argv, "+dy"))) {
    7777    remove_argument (N, &argc, argv);
    7878    if ((dyp = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);

  • trunk/Ohana/src/opihi/cmd.data/list_header.c

    r2598 r2843  
    1010
    1111  LOADHEAD = FALSE;
    12   if (N = get_argument (argc, argv, "-w")) {
     12  if ((N = get_argument (argc, argv, "-w"))) {
    1313    remove_argument (N, &argc, argv);
    1414    strcpy (filename, argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/load.c

    r2598 r2843  
    1414 
    1515  Nimage = -1;
    16   if (N = get_argument (argc, argv, "-n")) {
     16  if ((N = get_argument (argc, argv, "-n"))) {
    1717    remove_argument (N, &argc, argv);
    1818    Nimage = atof (argv[N]);
    … …  
    2222
    2323  ISCEL = FALSE;
    24   if (N = get_argument (argc, argv, "-c")) {
     24  if ((N = get_argument (argc, argv, "-c"))) {
    2525    remove_argument (N, &argc, argv);
    2626    ISCEL = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/plot.c

    r2598 r2843  
    99  /* choose the appropriate graphing window */
    1010  Ngraph = -1;
    11   if (N = get_argument (argc, argv, "-n")) {
     11  if ((N = get_argument (argc, argv, "-n"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Ngraph = atof (argv[N]);
    … …  
    1717
    1818  /* evaluate various plotting options */
    19   if (N = get_argument (argc, argv, "-lt")) {
     19  if ((N = get_argument (argc, argv, "-lt"))) {
    2020    remove_argument (N, &argc, argv);
    2121    graphmode.ltype = atof(argv[N]);
    2222    remove_argument (N, &argc, argv);
    2323  }
    24   if (N = get_argument (argc, argv, "-lw")) {
     24  if ((N = get_argument (argc, argv, "-lw"))) {
    2525    remove_argument (N, &argc, argv);
    2626    graphmode.lweight = atof(argv[N]);
    2727    remove_argument (N, &argc, argv);
    2828  }
    29   if (N = get_argument (argc, argv, "-pt")) {
     29  if ((N = get_argument (argc, argv, "-pt"))) {
    3030    remove_argument (N, &argc, argv);
    3131    graphmode.ptype = atof(argv[N]);
    3232    remove_argument (N, &argc, argv);
    3333  }
    34   if (N = get_argument (argc, argv, "+eb")) {
     34  if ((N = get_argument (argc, argv, "+eb"))) {
    3535    remove_argument (N, &argc, argv);
    3636    graphmode.ebar = TRUE;
    3737  }
    38   if (N = get_argument (argc, argv, "-eb")) {
     38  if ((N = get_argument (argc, argv, "-eb"))) {
    3939    remove_argument (N, &argc, argv);
    4040    graphmode.ebar = FALSE;
    4141  }
    42   if (N = get_argument (argc, argv, "-sz")) {
     42  if ((N = get_argument (argc, argv, "-sz"))) {
    4343    remove_argument (N, &argc, argv);
    4444    graphmode.size = atof(argv[N]);
    4545    remove_argument (N, &argc, argv);
    4646  }
    47   if (N = get_argument (argc, argv, "-c")) {
     47  if ((N = get_argument (argc, argv, "-c"))) {
    4848    remove_argument (N, &argc, argv);
    4949    graphmode.color = GetColor (argv[N]);
    … …  
    5151    remove_argument (N, &argc, argv);
    5252  }
    53   if (N = get_argument (argc, argv, "-x")) {
     53  if ((N = get_argument (argc, argv, "-x"))) {
    5454    remove_argument (N, &argc, argv);
    5555    graphmode.style = atof(argv[N]);
    … …  
    5959  /* decide on error bars */
    6060  dxmvec = dxpvec = dymvec = dypvec = NULL;
    61   if (N = get_argument (argc, argv, "-dx")) {
     61  if ((N = get_argument (argc, argv, "-dx"))) {
    6262    remove_argument (N, &argc, argv);
    6363    if ((dxmvec = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);   
    6464    remove_argument (N, &argc, argv);
    6565  }
    66   if (N = get_argument (argc, argv, "+dx")) {
     66  if ((N = get_argument (argc, argv, "+dx"))) {
    6767    remove_argument (N, &argc, argv);
    6868    if ((dxpvec = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);   
    6969    remove_argument (N, &argc, argv);
    7070  }
    71   if (N = get_argument (argc, argv, "-dy")) {
     71  if ((N = get_argument (argc, argv, "-dy"))) {
    7272    remove_argument (N, &argc, argv);
    7373    if ((dymvec = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);   
    7474    remove_argument (N, &argc, argv);
    7575  }
    76   if (N = get_argument (argc, argv, "+dy")) {
     76  if ((N = get_argument (argc, argv, "+dy"))) {
    7777    remove_argument (N, &argc, argv);
    7878    if ((dypvec = SelectVector (argv[N], OLDVECTOR, TRUE)) == NULL) return (FALSE);   

  • trunk/Ohana/src/opihi/cmd.data/point.c

    r2598 r2843  
    1212
    1313  Nimage = -1;
    14   if (N = get_argument (argc, argv, "-n")) {
     14  if ((N = get_argument (argc, argv, "-n"))) {
    1515    remove_argument (N, &argc, argv);
    1616    Nimage = atof (argv[N]);
    … …  
    2020 
    2121  ISCEL = FALSE;
    22   if (N = get_argument (argc, argv, "-c")) {
     22  if ((N = get_argument (argc, argv, "-c"))) {
    2323    remove_argument (N, &argc, argv);
    2424    ISCEL = TRUE;
    … …  
    2626 
    2727  ISPIX = FALSE;
    28   if (N = get_argument (argc, argv, "-p")) {
     28  if ((N = get_argument (argc, argv, "-p"))) {
    2929    remove_argument (N, &argc, argv);
    3030    ISPIX = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/pop.c

    r2598 r2843  
    99
    1010  var = (char *) NULL;
    11   if (N = get_argument (argc, argv, "-var")) {
     11  if ((N = get_argument (argc, argv, "-var"))) {
    1212    remove_argument (N, &argc, argv);
    1313    var = strcreate (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/ps.c

    r2598 r2843  
    66  int N, Source, Nsource, RawImage, NoScale, IsImage;
    77 
    8   if (N = get_argument (argc, argv, "--help")) {
     8  if ((N = get_argument (argc, argv, "--help"))) {
    99    fprintf (stderr, "USAGE: ps [-name file.ps] [-g | -i] [-n device] [-raw] [-scale]\n");
    1010    return (FALSE);
    … …  
    1313  /* raw image? */
    1414  RawImage = FALSE;
    15   if (N = get_argument (argc, argv, "-raw")) {
     15  if ((N = get_argument (argc, argv, "-raw"))) {
    1616    remove_argument (N, &argc, argv);
    1717    RawImage = TRUE;
    … …  
    1919  /* scale image? */
    2020  NoScale = FALSE;
    21   if (N = get_argument (argc, argv, "-noscale")) {
     21  if ((N = get_argument (argc, argv, "-noscale"))) {
    2222    remove_argument (N, &argc, argv);
    2323    NoScale = TRUE;
    … …  
    2525  /* what file? */
    2626  filename[0] = 0;
    27   if (N = get_argument (argc, argv, "-name")) {
     27  if ((N = get_argument (argc, argv, "-name"))) {
    2828    remove_argument (N, &argc, argv);
    2929    strcpy (filename, argv[N]);
    … …  
    3232  /* which tool */
    3333  Nsource = -1;
    34   if (N = get_argument (argc, argv, "-n")) {
     34  if ((N = get_argument (argc, argv, "-n"))) {
    3535    remove_argument (N, &argc, argv);
    3636    Nsource = atof (argv[N]);
    … …  
    3838  }
    3939  /* which device */
    40   if (N = get_argument (argc, argv, "-g")) {
     40  if ((N = get_argument (argc, argv, "-g"))) {
    4141    remove_argument (N, &argc, argv);
    4242    SetImageDevice (FALSE);
    4343  } 
    44   if (N = get_argument (argc, argv, "-i")) {
     44  if ((N = get_argument (argc, argv, "-i"))) {
    4545    remove_argument (N, &argc, argv);
    4646    SetImageDevice (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/queues.c

    r2598 r2843  
    2020
    2121  var = (char *) NULL;
    22   if (N = get_argument (argc, argv, "-var")) {
     22  if ((N = get_argument (argc, argv, "-var"))) {
    2323    remove_argument (N, &argc, argv);
    2424    var = strcreate (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/radial.c

    r2598 r2843  
    33int circstats (int argc, char **argv) {
    44 
    5   int i, j, Nmode, Imode;
     5  int i, j;
    66  double Npix, S1, S2, max, min, Sum, Mean, Stdev, IgnoreValue;
    77  double xc, yc, radius, R2, r;
    … …  
    1212
    1313  Ignore = FALSE;
    14   if (N = get_argument (argc, argv, "-ignore")) {
     14  if ((N = get_argument (argc, argv, "-ignore"))) {
    1515    Ignore = TRUE;
    1616    remove_argument (N, &argc, argv);
    … …  
    2020
    2121  Quiet = FALSE;
    22   if (N = get_argument (argc, argv, "-q")) {
     22  if ((N = get_argument (argc, argv, "-q"))) {
    2323    Quiet = TRUE;
    2424    remove_argument (N, &argc, argv);
    2525  }
    26   if (N = get_argument (argc, argv, "-quiet")) {
     26  if ((N = get_argument (argc, argv, "-quiet"))) {
    2727    Quiet = TRUE;
    2828    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/rd.c

    r2598 r2843  
    1111
    1212  JustHead = FALSE;
    13   if (N = get_argument (argc, argv, "-head")) {
     13  if ((N = get_argument (argc, argv, "-head"))) {
    1414    remove_argument (N, &argc, argv);
    1515    JustHead = TRUE;
    … …  
    1717
    1818  plane = 1;
    19   if (N = get_argument (argc, argv, "-plane")) {
     19  if ((N = get_argument (argc, argv, "-plane"))) {
    2020    remove_argument (N, &argc, argv);
    2121    plane  = atof(argv[N]);
    … …  
    2525  extend = FALSE;
    2626  Nextend = -1;
    27   if (N = get_argument (argc, argv, "-x")) {
     27  if ((N = get_argument (argc, argv, "-x"))) {
    2828    remove_argument (N, &argc, argv);
    2929    Nextend  = atof(argv[N]);
    … …  
    3434  ccdsel = FALSE;
    3535  ccdid = (char *) NULL;
    36   if (N = get_argument (argc, argv, "-n")) {
     36  if ((N = get_argument (argc, argv, "-n"))) {
    3737    remove_argument (N, &argc, argv);
    3838    ccdid  = strcreate (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/read_vectors.c

    r2598 r2843  
    3030
    3131  /* auto-sense table type */
    32   if (N = get_argument (argc, argv, "-fits")) {
     32  if ((N = get_argument (argc, argv, "-fits"))) {
    3333    remove_argument (N, &argc, argv);
    3434    extname = strcreate (argv[N]);
    … …  
    4141
    4242  Nskip = 0;
    43   if (N = get_argument (argc, argv, "-skip")) {
     43  if ((N = get_argument (argc, argv, "-skip"))) {
    4444    remove_argument (N, &argc, argv);
    4545    Nskip = atof (argv[N]);
    … …  
    223223    if (Nval == 0) return (FALSE);
    224224
    225     ALLOCATE (vec, Vector, Nval);
     225    ALLOCATE (vec, Vector *, Nval);
    226226    for (j = 0; j < Nval; j++) {
    227227      if (Nval == 1)

  • trunk/Ohana/src/opihi/cmd.data/rebin.c

    r2598 r2843  
    1111
    1212  Normalize = FALSE;
    13   if (N = get_argument (argc, argv, "-norm")) {
     13  if ((N = get_argument (argc, argv, "-norm"))) {
    1414    remove_argument (N, &argc, argv);
    1515    Normalize = TRUE;
    … …  
    1717
    1818  VERBOSE = FALSE;
    19   if (N = get_argument (argc, argv, "-v")) {
     19  if ((N = get_argument (argc, argv, "-v"))) {
    2020    remove_argument (N, &argc, argv);
    2121    VERBOSE = TRUE;
    … …  
    2424  Ignore = FALSE;
    2525  IgnoreValue = 0.0;
    26   if (N = get_argument (argc, argv, "-ignore")) {
     26  if ((N = get_argument (argc, argv, "-ignore"))) {
    2727    Ignore = TRUE;
    2828    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/resize.c

    r2598 r2843  
    99  /* display source */
    1010  Nsource = -1;
    11   if (N = get_argument (argc, argv, "-n")) {
     11  if ((N = get_argument (argc, argv, "-n"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Nsource = atof (argv[N]);
    1414    remove_argument (N, &argc, argv);
    1515  }
    16   if (N = get_argument (argc, argv, "-g")) {
     16  if ((N = get_argument (argc, argv, "-g"))) {
    1717    remove_argument (N, &argc, argv);
    1818    SetImageDevice (FALSE);
    1919  } 
    20   if (N = get_argument (argc, argv, "-i")) {
     20  if ((N = get_argument (argc, argv, "-i"))) {
    2121    remove_argument (N, &argc, argv);
    2222    SetImageDevice (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/rotate.c

    r2598 r2843  
    1111  Xo = 0;
    1212  Yo = 0;
    13   if (N = get_argument (argc, argv, "-center")) {
     13  if ((N = get_argument (argc, argv, "-center"))) {
    1414    newCenter = TRUE;
    1515    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/save.c

    r2598 r2843  
    88 
    99  Nimage = -1;
    10   if (N = get_argument (argc, argv, "-n")) {
     10  if ((N = get_argument (argc, argv, "-n"))) {
    1111    remove_argument (N, &argc, argv);
    1212    Nimage = atof (argv[N]);
    … …  
    1616
    1717  ISCEL = FALSE;
    18   if (N = get_argument (argc, argv, "-c")) {
     18  if ((N = get_argument (argc, argv, "-c"))) {
    1919    remove_argument (N, &argc, argv);
    2020    ISCEL = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/section.c

    r2598 r2843  
    99
    1010  List = FALSE;
    11   if (N = get_argument (argc, argv, "-list")) {
     11  if ((N = get_argument (argc, argv, "-list"))) {
    1212    remove_argument (N, &argc, argv);
    1313    List = TRUE;
    … …  
    1515
    1616  Ngraph = -1;
    17   if (N = get_argument (argc, argv, "-n")) {
     17  if ((N = get_argument (argc, argv, "-n"))) {
    1818    remove_argument (N, &argc, argv);
    1919    Ngraph = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/shift.c

    r2598 r2843  
    1010
    1111  ROLL = FALSE;
    12   if (N = get_argument (argc, argv, "-roll")) {
     12  if ((N = get_argument (argc, argv, "-roll"))) {
    1313    remove_argument (N, &argc, argv);
    1414    ROLL = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/stats.c

    r2598 r2843  
    1111
    1212  Ignore = FALSE;
    13   if (N = get_argument (argc, argv, "-ignore")) {
     13  if ((N = get_argument (argc, argv, "-ignore"))) {
    1414    Ignore = TRUE;
    1515    remove_argument (N, &argc, argv);
    … …  
    1919
    2020  Quiet = FALSE;
    21   if (N = get_argument (argc, argv, "-q")) {
     21  if ((N = get_argument (argc, argv, "-q"))) {
    2222    Quiet = TRUE;
    2323    remove_argument (N, &argc, argv);
    2424  }
    25   if (N = get_argument (argc, argv, "-quiet")) {
     25  if ((N = get_argument (argc, argv, "-quiet"))) {
    2626    Quiet = TRUE;
    2727    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/style.c

    r2598 r2843  
    55int style (int argc, char **argv) {
    66 
    7   int i, N, Ngraph;
     7  int N, Ngraph;
    88  Graphdata graphmode;
    99
    1010  Ngraph = -1;
    11   if (N = get_argument (argc, argv, "-n")) {
     11  if ((N = get_argument (argc, argv, "-n"))) {
    1212    remove_argument (N, &argc, argv);
    1313    Ngraph = atof (argv[N]);
    … …  
    2424  }
    2525
    26   if (N = get_argument (argc, argv, "-lt")) {
     26  if ((N = get_argument (argc, argv, "-lt"))) {
    2727    remove_argument (N, &argc, argv);
    2828    graphmode.ltype = atof(argv[N]);
    … …  
    3030  }
    3131
    32   if (N = get_argument (argc, argv, "-lw")) {
     32  if ((N = get_argument (argc, argv, "-lw"))) {
    3333    remove_argument (N, &argc, argv);
    3434    graphmode.lweight = atof(argv[N]);
    … …  
    3636  }
    3737
    38   if (N = get_argument (argc, argv, "-pt")) {
     38  if ((N = get_argument (argc, argv, "-pt"))) {
    3939    remove_argument (N, &argc, argv);
    4040    graphmode.ptype = atof(argv[N]);
    … …  
    4242  }
    4343
    44   if (N = get_argument (argc, argv, "+eb")) {
     44  if ((N = get_argument (argc, argv, "+eb"))) {
    4545    remove_argument (N, &argc, argv);
    4646    graphmode.ebar = TRUE;
    4747  }
    4848
    49   if (N = get_argument (argc, argv, "-eb")) {
     49  if ((N = get_argument (argc, argv, "-eb"))) {
    5050    remove_argument (N, &argc, argv);
    5151    graphmode.ebar = FALSE;
    5252  }
    5353
    54   if (N = get_argument (argc, argv, "-sz")) {
     54  if ((N = get_argument (argc, argv, "-sz"))) {
    5555    remove_argument (N, &argc, argv);
    5656    graphmode.size = atof(argv[N]);
    … …  
    5858  }
    5959
    60   if (N = get_argument (argc, argv, "-c")) {
     60  if ((N = get_argument (argc, argv, "-c"))) {
    6161    remove_argument (N, &argc, argv);
    6262    graphmode.color = GetColor (argv[N]);
    … …  
    6565  }
    6666
    67   if (N = get_argument (argc, argv, "-x")) {
     67  if ((N = get_argument (argc, argv, "-x"))) {
    6868    remove_argument (N, &argc, argv);
    6969    graphmode.style = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/textline.c

    r2598 r2843  
    1010
    1111  Ngraph = -1;
    12   if (N = get_argument (argc, argv, "-n")) {
     12  if ((N = get_argument (argc, argv, "-n"))) {
    1313    remove_argument (N, &argc, argv);
    1414    Ngraph = atof (argv[N]);
    … …  
    1717  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
    1818
    19   if (N = get_argument (argc, argv, "-fn")) {
     19  if ((N = get_argument (argc, argv, "-fn"))) {
    2020    remove_argument (N, &argc, argv);
    2121    strcpy (name, argv[N]);
    … …  
    3232  /* FracPositions uses coordinates of 0-1 relative to axis range */
    3333  FracPositions = FALSE;
    34   if (N = get_argument (argc, argv, "-frac")) {
     34  if ((N = get_argument (argc, argv, "-frac"))) {
    3535    remove_argument (N, &argc, argv);
    3636    FracPositions = TRUE;
    … …  
    3838
    3939  angle = 0.0;
    40   if (N = get_argument (argc, argv, "-rot")) {
     40  if ((N = get_argument (argc, argv, "-rot"))) {
    4141    remove_argument (N, &argc, argv);
    4242    angle = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/tv.c

    r2598 r2843  
    1313
    1414  Nimage = -1;
    15   if (N = get_argument (argc, argv, "-n")) {
     15  if ((N = get_argument (argc, argv, "-n"))) {
    1616    remove_argument (N, &argc, argv);
    1717    Nimage = atof (argv[N]);
    … …  
    2121
    2222  /* shell exits on pipe close, FIX */
    23   if (N = get_argument (argc, argv, "-kill")) {
     23  if ((N = get_argument (argc, argv, "-kill"))) {
    2424    close (Ximage);
    2525    Ximage = 0;
    … …  
    2929  min = max = 0.0;
    3030  ISLOG = FALSE;
    31   if (N = get_argument (argc, argv, "-log")) {
     31  if ((N = get_argument (argc, argv, "-log"))) {
    3232    remove_argument (N, &argc, argv);
    3333    ISLOG = TRUE;

  • trunk/Ohana/src/opihi/cmd.data/tvcontour.c

    r2598 r2843  
    7676 
    7777  Nimage = -1;
    78   if (N = get_argument (argc, argv, "-n")) {
     78  if ((N = get_argument (argc, argv, "-n"))) {
    7979    remove_argument (N, &argc, argv);
    8080    Nimage = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/tvgrid.c

    r2598 r2843  
    1515
    1616  Nimage = -1;
    17   if (N = get_argument (argc, argv, "-n")) {
     17  if ((N = get_argument (argc, argv, "-n"))) {
    1818    remove_argument (N, &argc, argv);
    1919    Nimage = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/vbin.c

    r2598 r2843  
    1212
    1313  Normalize = FALSE;
    14   if (N = get_argument (argc, argv, "-norm")) {
     14  if ((N = get_argument (argc, argv, "-norm"))) {
    1515    remove_argument (N, &argc, argv);
    1616    Normalize = TRUE;
    … …  
    1818
    1919  VERBOSE = FALSE;
    20   if (N = get_argument (argc, argv, "-v")) {
     20  if ((N = get_argument (argc, argv, "-v"))) {
    2121    remove_argument (N, &argc, argv);
    2222    VERBOSE = TRUE;
    … …  
    2525  Ignore = FALSE;
    2626  IgnoreValue = 0.0;
    27   if (N = get_argument (argc, argv, "-ignore")) {
     27  if ((N = get_argument (argc, argv, "-ignore"))) {
    2828    Ignore = TRUE;
    2929    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/vclip.c

    r2598 r2843  
    99
    1010  DO_NAN = FALSE;
    11   if (N = get_argument (argc, argv, "-nan")) {
     11  if ((N = get_argument (argc, argv, "-nan"))) {
    1212    remove_argument (N, &argc, argv);
    1313    nan_val  = atof(argv[N]);
    … …  
    1717
    1818  DO_INF = FALSE;
    19   if (N = get_argument (argc, argv, "-inf")) {
     19  if ((N = get_argument (argc, argv, "-inf"))) {
    2020    remove_argument (N, &argc, argv);
    2121    inf_val  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/vload.c

    r2826 r2843  
    33int vload (int argc, char **argv) {
    44 
    5   int i, N, n, Nline, ISCEL;
     5  int i, N, n, Nline;
    66  int Ximage, Nimage;
    77  double dx, dy;
    88  char *buffer, *line;
    9   Buffer *buf;
    109  Vector *vecx, *vecy;
    1110 
    1211  Nimage = -1;
    13   if (N = get_argument (argc, argv, "-n")) {
     12  if ((N = get_argument (argc, argv, "-n"))) {
    1413    remove_argument (N, &argc, argv);
    1514    Nimage = atof (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/vstat.c

    r2774 r2843  
    1313
    1414  Ignore = FALSE;
    15   if (N = get_argument (argc, argv, "-ignore")) {
     15  if ((N = get_argument (argc, argv, "-ignore"))) {
    1616    Ignore = TRUE;
    1717    remove_argument (N, &argc, argv);
    … …  
    2121
    2222  Quiet = FALSE;
    23   if (N = get_argument (argc, argv, "-q")) {
     23  if ((N = get_argument (argc, argv, "-q"))) {
    2424    Quiet = TRUE;
    2525    remove_argument (N, &argc, argv);
    2626  }
    27   if (N = get_argument (argc, argv, "-quiet")) {
     27  if ((N = get_argument (argc, argv, "-quiet"))) {
    2828    Quiet = TRUE;
    2929    remove_argument (N, &argc, argv);

  • trunk/Ohana/src/opihi/cmd.data/wd.c

    r2598 r2843  
    1212
    1313  Extend  = FALSE;
    14   if (N = get_argument (argc, argv, "-extend")) {
     14  if ((N = get_argument (argc, argv, "-extend"))) {
    1515    remove_argument (N, &argc, argv);
    1616    Extend  = TRUE;
    … …  
    1818
    1919  newZero  = FALSE;
    20   if (N = get_argument (argc, argv, "-bzero")) {
     20  if ((N = get_argument (argc, argv, "-bzero"))) {
    2121    remove_argument (N, &argc, argv);
    2222    outZero  = atof(argv[N]);
    … …  
    2626
    2727  newScale = FALSE;
    28   if (N = get_argument (argc, argv, "-bscale")) {
     28  if ((N = get_argument (argc, argv, "-bscale"))) {
    2929    remove_argument (N, &argc, argv);
    3030    outScale = atof(argv[N]);
    … …  
    3434
    3535  newBitpix = FALSE;
    36   if (N = get_argument (argc, argv, "-bitpix")) {
     36  if ((N = get_argument (argc, argv, "-bitpix"))) {
    3737    remove_argument (N, &argc, argv);
    3838    outBitpix = atof(argv[N]);
    … …  
    4242
    4343  newUnsign = FALSE;
    44   if (N = get_argument (argc, argv, "-unsign")) {
     44  if ((N = get_argument (argc, argv, "-unsign"))) {
    4545    remove_argument (N, &argc, argv);
    4646    outUnsign = -1;

  • trunk/Ohana/src/opihi/cmd.data/write_vectors.c

    r2598 r2843  
    1111  /* look for format option */
    1212  format = (char *) NULL;
    13   if (N = get_argument (argc, argv, "-f")) {
     13  if ((N = get_argument (argc, argv, "-f"))) {
    1414    remove_argument (N, &argc, argv);
    1515    format = strcreate (argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/zap.c

    r2598 r2843  
    99
    1010  value = 0;
    11   if (N = get_argument (argc, argv, "-v")) {
     11  if ((N = get_argument (argc, argv, "-v"))) {
    1212    remove_argument (N, &argc, argv);
    1313    value  = atof(argv[N]);

  • trunk/Ohana/src/opihi/cmd.data/zplot.c

    r2598 r2843  
    1010
    1111  Ngraph = -1;
    12   if (N = get_argument (argc, argv, "-n")) {
     12  if ((N = get_argument (argc, argv, "-n"))) {
    1313    remove_argument (N, &argc, argv);
    1414    Ngraph = atof (argv[N]);

  • trunk/Ohana/src/opihi/include/data.h

    r2598 r2843  
    1010/* in misc/queues.c */
    1111void InitQueues ();
     12void ListQueues ();
    1213Queue *FindQueue (char *name);
    1314Queue *CreateQueue (char *name);
    … …  
    4950float mrqmin (float *x, float *y, float *dy, int Npts,
    5051              float *par, int Npar,
    51               float (funcs)(float, float *, int, float *));
     52              float (funcs)(float, float *, int, float *), int VERBOSE);
    5253
    53 int mrqinit (float *x, float *y, float *dy, int Npts,
    54              float *par, int Npar,
    55              float (funcs)(float, float *, int, float *));
     54float mrqinit (float *x, float *y, float *dy, int Npts,
     55               float *par, int Npar,
     56               float (funcs)(float, float *, int, float *), int VERBOSE);
    5657
    5758float **mrqcovar (int Npar);
    … …  
    6667float mrq2dmin (float *x, float *t, float *y, float *dy, int Npts,
    6768                float *par, int Npar,
    68                 float (funcs)(float, float, float *, int, float *));
     69                float (funcs)(float, float, float *, int, float *), int VERBOSE);
    6970
    7071float mrq2dinit (float *x, float *t, float *y, float *dy, int Npts,
    7172                 float *par, int Npar,
    72                  float (funcs)(float, float, float *, int, float *));
     73                 float (funcs)(float, float, float *, int, float *), int VERBOSE);
    7374
    7475float **mrq2dcovar (int Npar);
    … …  
    8687/* misc/starfuncs.c */
    8788double get_aperture_stats (Matrix *matrix, int X, int Y, int Npix, int Nborder, double max);
     89int set_rough_radii (double Ra, double Ri, double Ro);
     90int get_rough_star (float *data, int Nx, int Ny, int x, int y, float *xc, float *yc, float *sx, float *sy, float *sxy, float *zs, float *zp, float *sk);
    8891
    8992/* misc/precess.c */
    … …  
    97100int read_table_vectors (int argc, char **argv, char *extname);
    98101# endif
     102

  • trunk/Ohana/src/opihi/include/dvomath.h

    r2792 r2843  
    6666int           SM_binary             PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, char *op));
    6767int           SS_binary             PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, char *op));
     68int           WW_binary             PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, char *op));
    6869int           S_unary               PROTO((StackVar *OUT, StackVar *V1, char *op));
    6970int           V_unary               PROTO((StackVar *OUT, StackVar *V1, char *op));

  • trunk/Ohana/src/opihi/include/external.h

    r2598 r2843  
    2222#   define ENOENT          2
    2323# endif
     24
     25# define strlen(A) ((int)strlen(A))

  • trunk/Ohana/src/opihi/include/mana.h

    r2826 r2843  
    1 # include "opihi.h"
     1# include "data.h"
    22
    33# ifndef MANA_H

  • trunk/Ohana/src/opihi/include/shell.h

    r2598 r2843  
    4646char         *parse                     PROTO((char *line));
    4747char        **parse_commands            PROTO((char *, int *));
     48void          welcome                   PROTO(());
    4849
    4950int           is_for_loop               PROTO((char *line));

  • trunk/Ohana/src/opihi/lib.data/mrq2dmin.c

    r2598 r2843  
    22
    33/* need to pass in a function of the form:
    4 
    5    funcs (x, t, a, Npar, dyda)
    6 
    7    returns f (x, t) for Npar parameters a, also df/da at x,t
    8 
     4   funcs (x, t, a, Npar, dy/da)
     5   returns y (x,t) for Npar parameters a along with dy/da at (x,t)
    96   dy carries 1/sig^2
    10 
    117*/
    128
    … …  
    2117
    2218  int k, j, i;
    23   float ydiff, wt, chisq, value;
     19  float ydiff, wt, chisq;
    2420
    2521  for (j = 0; j < Npar; j++) {
    … …  
    3228
    3329    ydiff = funcs (x[i], t[i], par, Npar, dyda) - y[i];
    34     value = SQ(ydiff) * fabs(dy[i]);
    35     if (value < 0.0) fprintf (stderr, "neg chi: %f %f\n", value, chisq);
    36     chisq += value;
     30    chisq += SQ(ydiff) * dy[i];
    3731   
    38     if (!finite (dyda[i])) { dyda[i] = 1e10; }
    39     if (!finite (dy[i])) { dyda[i] = 1e10; }
    40 
    4132    for (j = 0; j < Npar; j++) {
    4233      wt = dyda[j] * dy[i];
    … …  
    5647float mrq2dmin (float *x, float *t, float *y, float *dy, int Npts,
    5748              float *par, int Npar,
    58               float (funcs)(float, float, float *, int, float *)) {
     49              float (funcs)(float, float, float *, int, float *), int VERBOSE) {
    5950
    6051  int j, k;
    … …  
    6859  }
    6960
     61  /* keep this test in here? */
    7062  if (!fgaussj (talpha, Npar, tbeta, 1)) {
    7163    lambda *= 10.0;
    … …  
    7365  }
    7466
    75   /* if we keep some fixed, set partry to just them
    76      for (j = 0; j < Npar; j++) partry[j] = par[j]; */
    77 
    7867  for (j = 0; j < Npar; j++) partry[j] = par[j] - tbeta[j][0];
    7968
    8069  chisq = mrq2dcof (x, t, y, dy, Npts, partry, Npar, talpha, tbeta, funcs);
     70  if (VERBOSE) {
     71    fprintf (stderr, "chisq: %f  ", chisq);
     72    fprintf (stderr, "lambda: %f  ", lambda);
     73    for (j = 0; j < Npar; j++) {
     74      fprintf (stderr, "%f ", partry[j]);
     75    }
     76    fprintf (stderr, "\n");
     77  }
    8178
    8279  /* if good, save temp values */
    … …  
    10097float mrq2dinit (float *x, float *t, float *y, float *dy, int Npts,
    10198              float *par, int Npar,
    102               float (funcs)(float, float, float *, int, float *)) {
     99              float (funcs)(float, float, float *, int, float *), int VERBOSE) {
    103100
    104101  int i;
    … …  
    121118 
    122119  ochisq = mrq2dcof (x, t, y, dy, Npts, par, Npar, alpha, beta, funcs);
     120  if (VERBOSE) {
     121    fprintf (stderr, "chisq: %f  ", ochisq);
     122    fprintf (stderr, "lambda: %f  ", lambda);
     123    for (i = 0; i < Npar; i++) {
     124      fprintf (stderr, "%f ", par[i]);
     125    }
     126    fprintf (stderr, "\n");
     127  }
    123128
    124129  return (ochisq);

  • trunk/Ohana/src/opihi/lib.data/mrqmin.c

    r2598 r2843  
    22
    33/* need to pass in a function of the form:
    4 
    54   funcs (x, a, Npar, dyda)
    6 
    75   returns f (x) for Npar parameters a, also df/da at x
    8 
    96   dy carries 1/sig^2
    10 
    117*/
    12 
    138
    149static float **alpha, **talpha;
    … …  
    5247float mrqmin (float *x, float *y, float *dy, int Npts,
    5348              float *par, int Npar,
    54               float (funcs)(float, float *, int, float *)) {
     49              float (funcs)(float, float *, int, float *), int VERBOSE) {
    5550
    5651  int j, k;
    … …  
    6661  fgaussj (talpha, Npar, tbeta, 1);
    6762
    68   /* if we keep some fixed, set partry to just them
    69      for (j = 0; j < Npar; j++) partry[j] = par[j]; */
    70 
    7163  for (j = 0; j < Npar; j++) partry[j] = par[j] - tbeta[j][0];
    7264
    7365  chisq = mrqcof (x, y, dy, Npts, partry, Npar, talpha, tbeta, funcs);
     66  if (VERBOSE) {
     67    fprintf (stderr, "chisq: %f  ", chisq);
     68    fprintf (stderr, "lambda: %f  ", lambda);
     69    for (j = 0; j < Npar; j++) {
     70      fprintf (stderr, "%f ", partry[j]);
     71    }
     72    fprintf (stderr, "\n");
     73  }
    7474
    7575  /* if good, save temp values */
    … …  
    9191}
    9292
    93 int mrqinit (float *x, float *y, float *dy, int Npts,
     93float mrqinit (float *x, float *y, float *dy, int Npts,
    9494              float *par, int Npar,
    95               float (funcs)(float, float *, int, float *)) {
     95              float (funcs)(float, float *, int, float *), int VERBOSE) {
    9696
    9797  int i;
    … …  
    109109    ALLOCATE (tbeta[i], float, Npar);
    110110  }
    111 
    112111 
    113   lambda = 0.001;
     112  lambda = 0.01;
    114113 
    115114  ochisq = mrqcof (x, y, dy, Npts, par, Npar, alpha, beta, funcs);
    116 
    117   return (TRUE);
     115  if (VERBOSE) {
     116    fprintf (stderr, "chisq: %f  ", ochisq);
     117    fprintf (stderr, "lambda: %f  ", lambda);
     118    for (i = 0; i < Npar; i++) {
     119      fprintf (stderr, "%f ", par[i]);
     120    }
     121    fprintf (stderr, "\n");
     122  }
     123  return (ochisq);
    118124}
    119 
    120 
    121125
    122126/* don't invoke this in the middle of a run, only near the end */
    123127float **mrqcovar (int Npar) {
    124 
    125128  fgaussj (alpha, Npar, beta, 1);
    126129  return (alpha);
    127 
    128130}
    129 
    130131
    131132void mrqfree (int Npar) {
    … …  
    145146  free (partry);
    146147  free (dyda);
    147 
    148148}

  • trunk/Ohana/src/opihi/lib.data/starfuncs.c

    r2827 r2843  
    9292}
    9393
     94static double Raper  =  5;
     95static double Rinner = 10;
     96static double Router = 15;
     97static double *sky = NULL;
     98
     99int set_rough_radii (double Ra, double Ri, double Ro) {
     100
     101  Raper = Ra;
     102  Rinner = Ri;
     103  Router = Ro;
     104  if (sky == NULL) {
     105    ALLOCATE (sky, double, SQ(2*Router + 1));
     106  } else {
     107    REALLOCATE (sky, double, SQ(2*Router + 1));
     108  }
     109  return (TRUE);
     110}
     111
    94112/* use a circular aperture */
    95113int get_rough_star (float *data, int Nx, int Ny, int x, int y,
    96                        float *xc, float *yc,
    97                        float *sx, float *sy,
    98                        float *zs, float *zp) {
    99 
    100   double *sky;
    101   double Raper, Rinner, Router, Ra2, Ri2, Ro2, rad2;
     114                    float *xc, float *yc,
     115                    float *sx, float *sy, float *sxy,
     116                    float *zs, float *zp, float *sk) {
     117
     118  double Ra2, Ri2, Ro2, rad2;
    102119  int i, j, Npts, Nsky;
    103120  int Xs, Xe, Ys, Ye, off, Xc, Yc;
    104121  double peak, fsky, value;
    105   double Sx, Sy, Sx2, Sy2, Sum;
     122  double Sx, Sy, Sx2, Sy2, Sxy, Sum;
    106123 
    107124  /* define circular boundaries */
    108   Raper  = 15;  Ra2 = SQ(Raper);
    109   Rinner = 25;  Ri2 = SQ(Rinner);
    110   Router = 35;  Ro2 = SQ(Router);
     125  Ra2 = SQ(Raper);
     126  Ri2 = SQ(Rinner);
     127  Ro2 = SQ(Router);
    111128
    112129  /* measure the sky level */
    113   ALLOCATE (sky, double, SQ(2*Router + 1));
    114 
    115130  /* boundaries for the outer sky region */
    116131  Xs = MAX (x - Router, 0);
    … …  
    119134  Ye = MIN (y + Router + 1, Ny);
    120135
     136/* this sample uses a circular aperture */
     137# if (0)
    121138  Nsky = 0; 
    122139  for (j = Ys; j < Ye; j++) {
    … …  
    135152  }
    136153  fsky = fsky / Npts;
    137   free (sky);
     154# else
     155
     156/* this sample uses a square outer annulus, without loop if tests */
     157  Nsky = 0; 
     158  Xs = MAX (x - Router, 0);
     159  Xe = MIN (x - Rinner + 1, Nx);
     160  Ys = MAX (y - Rinner, 0);
     161  Ye = MIN (y + Rinner + 1, Ny);
     162  for (j = Ys; j < Ye; j++) {
     163    off = j*Nx;
     164    for (i = Xs; i < Xe; i++) {
     165      sky[Nsky] = data[i+off];
     166      Nsky ++;
     167    }
     168  }
     169  Xs = MAX (x + Rinner, 0);
     170  Xe = MIN (x + Router + 1, Nx);
     171  for (j = Ys; j < Ye; j++) {
     172    off = j*Nx;
     173    for (i = Xs; i < Xe; i++) {
     174      sky[Nsky] = data[i+off];
     175      Nsky ++;
     176    }
     177  }
     178  Xs = MAX (x - Rinner, 0);
     179  Xe = MIN (x - Rinner + 1, Nx);
     180  Ys = MAX (y - Router, 0);
     181  Ye = MIN (y - Rinner + 1, Ny);
     182  for (j = Ys; j < Ye; j++) {
     183    off = j*Nx;
     184    for (i = Xs; i < Xe; i++) {
     185      sky[Nsky] = data[i+off];
     186      Nsky ++;
     187    }
     188  }
     189  Ys = MAX (y + Rinner, 0);
     190  Ye = MIN (y + Router + 1, Ny);
     191  for (j = Ys; j < Ye; j++) {
     192    off = j*Nx;
     193    for (i = Xs; i < Xe; i++) {
     194      sky[Nsky] = data[i+off];
     195      Nsky ++;
     196    }
     197  }
     198  sort (sky, Nsky);
     199  for (Npts = fsky = 0, i = 0.25*Nsky; i < 0.75*Nsky; i++, Npts += 1.0) {
     200    fsky += sky[i];
     201  }
     202  fsky = fsky / Npts;
     203# endif
    138204
    139205  /* boundaries for the star region */
    … …  
    145211  /** note that this will fail on negative flux objects */
    146212  peak = Npts = 0;
    147   Sx = Sy = Sx2 = Sy2 = Sum = 0;
     213  Sx = Sy = Sx2 = Sy2 = Sxy = Sum = 0;
    148214  for (j = Ys; j < Ye; j++) {
    149215    off = j*Nx;
    … …  
    158224      Sx2 += Xc*Xc*value;
    159225      Sy2 += Yc*Yc*value;
     226      Sxy += Xc*Yc*value;
    160227      Sum += value;
    161228      Npts ++;
    … …  
    168235  *sx = sqrt (fabs (Sx2 / Sum - SQ(*xc)));
    169236  *sy = sqrt (fabs (Sy2 / Sum - SQ(*yc)));
     237  *sxy = Sxy / Sum;
    170238  *xc += x;
    171239  *yc += y;
    172240  *zs = Sum;
    173241  *zp = peak;
     242  *sk = fsky;
    174243  /* note sigma is rough: round-off errors can introduce errors */
    175244  /* using values relative to x,y should minimize this effect */

  • trunk/Ohana/src/opihi/lib.shell/BufferOps.c

    r2598 r2843  
    211211  fprintf (stderr, "try %d\n", n);
    212212  for (i = 0; i < Nbuffers; i++) {
    213     fprintf (stderr, "%d  %x\n", i, (int) buffers[i]);
    214     fprintf (stderr, "%d  %x  %s\n", i, (int) buffers[i][0].name, buffers[i][0].name);
    215     fprintf (stderr, "%d  %x  %s\n", i, (int) buffers[i][0].file, buffers[i][0].file);
    216     fprintf (stderr, "%d  %x  %x\n", i, (int) &buffers[i][0].header, (int) buffers[i][0].header.buffer);
    217     fprintf (stderr, "%d  %x  %x\n", i, (int) &buffers[i][0].matrix, (int) buffers[i][0].matrix.buffer);
     213    fprintf (stderr, "%d  %lx\n", i, (long) buffers[i]);
     214    fprintf (stderr, "%d  %lx  %s\n", i, (long) buffers[i][0].name, buffers[i][0].name);
     215    fprintf (stderr, "%d  %lx  %s\n", i, (long) buffers[i][0].file, buffers[i][0].file);
     216    fprintf (stderr, "%d  %lx  %lx\n", i, (long) &buffers[i][0].header, (long) buffers[i][0].header.buffer);
     217    fprintf (stderr, "%d  %lx  %lx\n", i, (long) &buffers[i][0].matrix, (long) buffers[i][0].matrix.buffer);
    218218    fprintf (stderr, "%d  %d  %d  %f %f\n", i, buffers[i][0].bitpix, buffers[i][0].unsign, buffers[i][0].bscale, buffers[i][0].bzero);
    219219  }

  • trunk/Ohana/src/opihi/lib.shell/check_stack.c

    r2801 r2843  
    44
    55  int i, Nx, Ny, Nv, size;
    6   char *c, line[128];
     6  char *c;
    77
    88  Nv = Nx = -1;

  • trunk/Ohana/src/opihi/lib.shell/evaluate_stack.c

    r2801 r2843  
    191191  for (i = 0; i < Nstack; i++) {
    192192    if (IsBufferPtr (stack[i].buffer) && (stack[i].type == 'm')) {
    193       if (VERBOSE) fprintf (stderr, "free %s (buff) (%x)\n", stack[i].name, (int) stack[i].buffer);
     193      if (VERBOSE) fprintf (stderr, "free %s (buff) (%lx)\n", stack[i].name, (long) stack[i].buffer);
    194194      free (stack[i].buffer[0].header.buffer);
    195195      free (stack[i].buffer[0].matrix.buffer);
    … …  
    198198    }   
    199199    if (IsVectorPtr (stack[i].vector) && (stack[i].type == 'v')) {
    200       if (VERBOSE) fprintf (stderr, "free %s (vect) (%x)\n", stack[i].name, (int) stack[i].vector);
     200      if (VERBOSE) fprintf (stderr, "free %s (vect) (%lx)\n", stack[i].name, (long) stack[i].vector);
    201201      free (stack[i].vector[0].elements);
    202202      free (stack[i].vector);
    203203      stack[i].vector = NULL;
    204204    }   
    205     if (VERBOSE) fprintf (stderr, "free %s (name) (%d) (%x)\n", stack[i].name, i, (int) stack[i].name);
     205    if (VERBOSE) fprintf (stderr, "free %s (name) (%d) (%lx)\n", stack[i].name, i, (long) stack[i].name);
    206206    free (stack[i].name);
    207207    stack[i].name = NULL;

  • trunk/Ohana/src/opihi/lib.shell/exec_loop.c

    r2598 r2843  
    33int exec_loop (Macro *loop) {
    44
    5   int n, Nlines, j, status, ThisList, Signal;
     5  void *Signal;
     6  int n, Nlines, j, status, ThisList;
    67  char *outline;
    78 
    … …  
    1920
    2021  /* set up interrupts */
    21   Signal = (int) signal (SIGINT, handle_interrupt);
     22  Signal = signal (SIGINT, handle_interrupt);
    2223  interrupt = FALSE;
    2324
    … …  
    3536    if (loop_break || loop_continue) break;
    3637  }
    37   signal (SIGINT, (void *) Signal);
     38  signal (SIGINT, Signal);
    3839
    3940  /* free up the list and decrement the shell level */

  • trunk/Ohana/src/opihi/mana/rawstars.c

    r2827 r2843  
    11# include "mana.h"
    2 
    3 int get_rough_star (float *data, int Nx, int Ny, int x, int y, float *xc, float *yc, float *sx, float *sy, float *zs, float *zp);
    42
    53int rawstars (int argc, char **argv) {
    64 
    7   int i, x, y, Nx, Ny, Np;
     5  int i, x, y, N, Nx, Ny, Np;
    86  float *v;
     7  double Raper, Rinner, Router;
    98  Vector *xp, *yp;
    10   Vector *xc, *yc, *sx, *sy, *zs, *zp;
     9  Vector *xc, *yc, *sx, *sy, *sxy, *zs, *zp, *sk;
    1110  Buffer *buff;
     11
     12  Raper = 5;
     13  if ((N = get_argument (argc, argv, "-Raper"))) {
     14    remove_argument (N, &argc, argv);
     15    Raper = atof (argv[N]);
     16    remove_argument (N, &argc, argv);
     17  }
     18  Rinner = 10;
     19  if ((N = get_argument (argc, argv, "-Rinner"))) {
     20    remove_argument (N, &argc, argv);
     21    Rinner = atof (argv[N]);
     22    remove_argument (N, &argc, argv);
     23  }
     24  Router = 15;
     25  if ((N = get_argument (argc, argv, "-Router"))) {
     26    remove_argument (N, &argc, argv);
     27    Router = atof (argv[N]);
     28    remove_argument (N, &argc, argv);
     29  }
    1230
    1331  if (argc < 4) goto usage;
    … …  
    2139  }
    2240
     41  set_rough_radii (Raper, Rinner, Router);
     42
    2343  /* output vectors */
    2444  if ((xc = SelectVector ("xc", ANYVECTOR, TRUE)) == NULL) return (FALSE);
    … …  
    2646  if ((sx = SelectVector ("sx", ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2747  if ((sy = SelectVector ("sy", ANYVECTOR, TRUE)) == NULL) return (FALSE);
     48  if ((sxy = SelectVector ("sxy", ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2849  if ((zs = SelectVector ("zs", ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2950  if ((zp = SelectVector ("zp", ANYVECTOR, TRUE)) == NULL) return (FALSE);
     51  if ((sk = SelectVector ("sk", ANYVECTOR, TRUE)) == NULL) return (FALSE);
    3052
    3153  Nx = buff[0].matrix.Naxis[0];
    … …  
    3759  REALLOCATE (sx[0].elements, float, Np);
    3860  REALLOCATE (sy[0].elements, float, Np);
     61  REALLOCATE (sxy[0].elements, float, Np);
    3962  REALLOCATE (zs[0].elements, float, Np);
    4063  REALLOCATE (zp[0].elements, float, Np);
     64  REALLOCATE (sk[0].elements, float, Np);
    4165  xc[0].Nelements = yc[0].Nelements = sx[0].Nelements = Np;
    4266  sy[0].Nelements = zs[0].Nelements = zp[0].Nelements = Np;
     67  sxy[0].Nelements = sk[0].Nelements = Np;
    4368
    4469  v = (float *) buff[0].matrix.buffer;
    … …  
    5681                    &sx[0].elements[i],
    5782                    &sy[0].elements[i],
     83                    &sxy[0].elements[i],
    5884                    &zs[0].elements[i],
    59                     &zp[0].elements[i]);
     85                    &zp[0].elements[i],
     86                    &sk[0].elements[i]);
    6087  }
    6188
Note: See TracChangeset for help on using the changeset viewer.