IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 36580


Ignore:
Timestamp:
Mar 7, 2014, 6:08:39 PM (12 years ago)
Author:
watersc1
Message:

ppBackgroundStack compiles. I know it's not useful yet, because I haven't implemented the 'apply' and 'save the outputs' parts.

Location:
trunk/ppBackground/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/ppBackground/src/Makefile.am

    r28281 r36580  
    1 bin_PROGRAMS = ppBackground
     1bin_PROGRAMS = ppBackground ppBackgroundStack
    22
    33if HAVE_SVNVERSION
    … …  
    2828ppBackground_LDFLAGS  = $(PSLIB_LIBS)   $(PSMODULE_LIBS)   $(PPSTATS_LIBS)   $(PSPHOT_LIBS)   $(PPBACKGROUND_LIBS)
    2929
     30ppBackgroundStack_CPPFLAGS = $(ppBackground_CPPFLAGS)
     31ppBackgroundStack_LDFLAGS = $(ppBackground_LDFLAGS)
     32
    3033ppBackground_SOURCES =          \
    3134        ppBackground.c          \
    … …  
    3841        ppBackgroundErrorCodes.c        \
    3942        ppBackgroundExit.c
     43
     44ppBackgroundStack_SOURCES = \
     45        ppBackgroundStack.c \
     46        ppBackgroundStackArguments.c \
     47        ppBackgroundStackCamera.c \
     48        ppBackgroundStackData.c \
     49        ppBackgroundStackLoop.c \
     50        ppBackgroundStackMath.c \
     51        ppBackgroundVersion.c \
     52        ppBackgroundErrorCodes.c \
     53        ppBackgroundExit.c
     54
    4055
    4156noinst_HEADERS = \

  • trunk/ppBackground/src/ppBackgroundStack.c

    r36579 r36580  
    1818    ppBackgroundErrorRegister();
    1919
    20     ppBackgroundData *data = ppBackgroundDataInit(&argc, argv);
     20    ppBackgroundStackData *data = ppBackgroundStackDataInit(&argc, argv);
    2121    if (!data) {
    2222        goto DIE;
    2323    }
    2424
    25     if (!ppBackgroundArguments(data, argc, argv)) {
     25    if (!ppBackgroundStackArguments(data, argc, argv)) {
    2626        goto DIE;
    2727    }
    2828
    29     if (!ppBackgroundCamera(data)) {
     29    if (!ppBackgroundStackCamera(data)) {
    3030        goto DIE;
    3131    }
    3232
    33     if (!ppBackgroundLoop(data)) {
     33    if (!ppBackgroundStackLoop(data)) {
    3434        goto DIE;
    3535    }
    … …  
    3939    psExit exitValue = ppBackgroundExitCode(PS_EXIT_SUCCESS); // Exit code
    4040
    41     if (data && data->stats && data->statsFile) {
    42         psString stats = psMetadataConfigFormat(data->stats); // Statistics to output
    43         if (!stats || strlen(stats) == 0) {
    44             psError(PPBACKGROUND_ERR_IO, false, "Unable to format statistics file");
    45         } else if (fprintf(data->statsFile, "%s", stats) != strlen(stats)) {
    46             psError(PPBACKGROUND_ERR_IO, true, "Unable to write statistics file");
    47         }
    48         psFree(stats);
    49         if (fclose(data->statsFile) == EOF) {
    50             psError(PPBACKGROUND_ERR_IO, true, "Unable to close statistics file");
    51         }
    52         data->statsFile = NULL;
    53         exitValue = ppBackgroundExitCode(exitValue);
    54     }
     41/*     if (data && data->stats && data->statsFile) { */
     42/*         psString stats = psMetadataConfigFormat(data->stats); // Statistics to output */
     43/*         if (!stats || strlen(stats) == 0) { */
     44/*             psError(PPBACKGROUND_ERR_IO, false, "Unable to format statistics file"); */
     45/*         } else if (fprintf(data->statsFile, "%s", stats) != strlen(stats)) { */
     46/*             psError(PPBACKGROUND_ERR_IO, true, "Unable to write statistics file"); */
     47/*         } */
     48/*         psFree(stats); */
     49/*         if (fclose(data->statsFile) == EOF) { */
     50/*             psError(PPBACKGROUND_ERR_IO, true, "Unable to close statistics file"); */
     51/*         } */
     52/*         data->statsFile = NULL; */
     53/*         exitValue = ppBackgroundExitCode(exitValue); */
     54/*     } */
    5555
    5656    if (data) {

  • trunk/ppBackground/src/ppBackgroundStack.h

    r36579 r36580  
    77#include "ppBackgroundErrorCodes.h"
    88
    9 #define PPBACKGROUND_RECIPE "PPBACKGROUND"      // Recipe name
     9#define PPBACKGROUND_RECIPE "PPBACKGROUND_STACK"      // Recipe name
    1010
    1111// Data for processing
    … …  
    3030
    3131/// Initialise data for processing
    32 ppBackgroundData *ppBackgroundDataInit(int *argc, char *argv[] // Command-line arguments
     32ppBackgroundStackData *ppBackgroundStackDataInit(int *argc, char *argv[] // Command-line arguments
    3333    );
    3434
    … …  
    3939
    4040/// Parse camera configurations
    41 bool ppBackgroundStackCamera(ppBackgroundData *data // Data for processing
     41bool ppBackgroundStackCamera(ppBackgroundStackData *data // Data for processing
    4242    );
    4343
    4444/// Loop over input data, processing
    45 bool ppBackgroundStackLoop(ppBackgroundData *data // Data for processing
     45bool ppBackgroundStackLoop(ppBackgroundStackData *data // Data for processing
    4646    );
    4747
    48 /// Determine the binning from the recipe if available.
    49 psImageBinning *ppBackgroundStackBinningByRecipe(const psImage *image, // Image for which to generate a bg model
    50                                                  const pmConfig *config, // Configuration
    51                                                  psString recipe_name,
    52                                                  psString Xbin_name,
    53                                                  psString Ybin_name
    54                                                  );
     48bool ppBackgroundStackModelFitOTASolution(ppBackgroundStackData *data);
     49bool ppBackgroundStackDataModelFit(ppBackgroundStackData *data);
     50bool ppBackgroundStackCalibApply(ppBackgroundStackData *data);
     51bool ppBackgroundStackModelFit(ppBackgroundStackData *data);
    5552
    56 
    57 /// Restore the background to an image
    58 bool ppBackgroundStackRestore(
    59     pmChip *chip,                       // Chip to correct
    60     const pmChip *background,           // Chip with background model
    61     const pmChip *pattern,              // Chip with pattern
    62     const pmFPAview *view,              // View to data
    63     pmConfig *config,                   // Configuration
    64     psImageMaskType maskBad             // value to use for bad pixels
    65     );
    6653
    6754/// Determine exit code

  • trunk/ppBackground/src/ppBackgroundStackArguments.c

    r36579 r36580  
    4848    psMetadataAddStr(arguments, PS_LIST_TAIL, "-image", 0, "Filename of image (required)", NULL);
    4949    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask", 0,  "Filename of mask", NULL);
    50     psMetadataAddBool(arguments, PS_LIST_TAIL, "-fitOTAs", 0, "");
    51     psMetadataAddStr(arguments, PS_LIST_TAIL, "-OTApath", 0, "");
     50    psMetadataAddBool(arguments, PS_LIST_TAIL, "-fitOTAs", 0, "", false);
     51    psMetadataAddStr(arguments, PS_LIST_TAIL, "-OTApath", 0, "", NULL);
    5252
    5353    if (argc == 1 || !psArgumentParse(arguments, &argc, argv) || argc != 2) {
    … …  
    5656
    5757    unsigned int numBad = 0; // Number of bad lines
    58     data->contents = psMetadataConfigRead(NULL, &numBad,psMetadataLookupStr(NULL, arguments, "-input"));
    59     if (!inputs || numBad > 0) {
     58    data->contents = psMetadataConfigRead(NULL, &numBad,psMetadataLookupStr(NULL, arguments, "-input"),false);
     59    if (!(data->contents) || numBad > 0) {
    6060      psError(PPBACKGROUND_ERR_CONFIG, false, "Unable to cleanly read MDC file with inputs.");
    6161      return(false);

  • trunk/ppBackground/src/ppBackgroundStackCamera.c

    r36579 r36580  
    3131{
    3232    bool status;                        // Status of file definition
    33 
     33    pmConfig *config = data->config;    // Because I'm reusing code.
     34    int u,v;
     35    // FIX Figure out what stacks we have to deal with.
     36    psString stackName = data->stacks->data[0];
     37    fileArguments("IMAGE", stackName, "Input image", data->config);
     38    pmFPAfile *stack = pmFPAfileDefineFromArgs(&status, data->config, "PPBACKGROUND.STACK",
     39                                               "IMAGE");
     40    if (!status || !stack) {
     41      psError(psErrorCodeLast(), false, "Failed to build file from PPBACKGROUND.STACK");
     42      return false;
     43    }
     44
     45    // Read over the input background models.   
    3446    psMetadataIterator *iter = psMetadataIteratorAlloc(data->contents, PS_LIST_HEAD, NULL); // Iterator
    3547    psMetadataItem *item; // Item from iteration
    36     int i = 0;
     48    //    int i = 0;
    3749    while ((item = psMetadataGetAndIncrement(iter))) {
    3850      if (item->type != PS_DATA_METADATA) {
    39         psError(PPBACKGROUND_ERR_ARGUMENTS, true
     51        psError(PPBACKGROUND_ERR_ARGUMENTS, true,
    4052                "Component %s of the input metadata is not of type METADATA", item->name);
    4153        psFree(iter);
    … …  
    4759      psString smfFileName = psMetadataLookupStr(NULL, input, "astrom");
    4860
    49       // FIX Figure out how to calculate the smf name
    50       // psString cam_file = pmFPAfileNameFromRule("PSASTRO.OUTPUT");
    51       // pmFPAfile *smfFile = pmFPAfileBindFromArgs(&status, NULL, config);
    52       // pmFPAfile *smfFile = pmFPAfileDefineInput(config,
     61      // Read the smf file from this item
    5362      fileArguments("astrom",smfFileName,"",config);
    5463      pmFPAfile *smfFile = pmFPAfileDefineFromArgs(&status, config, "PSWARP.ASTROM","astrom");
    5564
    5665      // Read the SMF data
    57 
    5866      pmFPAview *view = pmFPAviewAlloc(0); // Pointer into FPA hierarchy
    5967      if (!pmFPAfileIOChecks(config, view, PM_FPA_BEFORE)) {
    … …  
    95103        }
    96104        // read WCS data from the corresponding header
    97         pmHDU *hdu = pmFPAviewThisHDU (view, astromFile->fpa);
     105        pmHDU *hdu = pmFPAviewThisHDU (view, smfFile->fpa);
    98106        if (bilevelAstrometry) {
    99107          if (!pmAstromReadBilevelChip (chip, hdu->header)) {
    … …  
    108116          // we use a default FPA pixel scale of 1.0
    109117          psWarning("Reading WCS astrometry for chip %s.", chipName);
    110           if (!pmAstromReadWCS(astromFile->fpa, chip, hdu->header, 1.0)) {
     118          if (!pmAstromReadWCS(smfFile->fpa, chip, hdu->header, 1.0)) {
    111119            psError(psErrorCodeLast(), false, "Unable to read WCS astrometry for input FPA.");
    112120            psFree(view);
    … …  
    116124
    117125        // FIX Load model data for this chip
    118         psString modelFileName = psMetadataLookupStr(NULL, input->models, chipName);
     126        psString modelFileName = psMetadataLookupStr(NULL, input, chipName);
    119127        psFits *modelFits = psFitsOpen(modelFileName,"r");
    120         psImage *image = psFitsReadImage(modelFits,NULL,0);
     128        int nC, nR;
     129        psElemType *type;
     130        psRegion region;
     131        psFitsImageSize(&nC,&nR,type,modelFits,region);
     132        psImage *image = psFitsReadImage(modelFits,region,0);
    121133        psMetadata *header = psFitsReadHeader(NULL,modelFits);
    122134
    123135        // Allocate the data structures for this chip
    124         psImage *raim = psImageAlloc(image->cols,image->rows,PS_TYPE_F32);
    125         psImage *decim = psImageAlloc(image->cols,image->rows,PS_TYPE_F32);
    126         psImage *model = psImageAlloc(image->cols,image->rows,PS_TYPE_F32);
     136        psImage *raim = psImageAlloc(image->numCols,image->numRows,PS_TYPE_F32);
     137        psImage *decim = psImageAlloc(image->numCols,image->numRows,PS_TYPE_F32);
     138        psImage *model = psImageAlloc(image->numCols,image->numRows,PS_TYPE_F32);
    127139
    128140        // Read header and construct original positions
    … …  
    142154        psSphere *sky = psSphereAlloc(); // Sky coordinates
    143155       
    144         for (v = 0; v < image->nrows; v++) {
     156        for (v = 0; v < image->numRows; v++) {
    145157          pix->y = (v - yoffset) * ybin;
    146           for (u = 0; u < image->ncols; u++) {
     158          for (u = 0; u < image->numCols; u++) {
    147159            pix->x = (u - xoffset) * xbin;
    148160            psPlaneTransformApply(fp, chip->toFPA, pix);
    149161            psPlaneTransformApply(tp, smfFile->fpa->toTPA, fp);
    150             psDeproject(sky, tp, astromFile->fpa->toSky);
    151 
    152             // FIX project sky to stack projection cell grid.
    153             if (!data->radians) {
    154               sky->r *= 180.0 / M_PI;
    155               sky->d *= 180.0 / M_PI;
    156             }
    157             raim->data.F32[v][u] = sky->r;
    158             decim->data.F32[v][u] = sky->d;
     162            psDeproject(sky, tp, smfFile->fpa->toSky);
     163
     164            psProject(tp,sky,stack->fpa->toSky);
     165
     166            raim->data.F32[v][u] = tp->x;
     167            decim->data.F32[v][u] = tp->y;
    159168            model->data.F32[v][u] = 0.0;
    160169
    161170            // Check the bounds so we'll know how large of an area to model in the map
    162             if (sky->r < data->ra_min) { data->ra_min = sky->r; }
    163             else if (sky->r > data->ra_max) { data->ra_max = sky->r; }
    164             if (sky->d < data->dec_min) { data->dec_min = sky->d; }
    165             else if (sky->d > data->dec_max) { data->dec_max = sky->d; }
     171            if (tp->x < data->ra_min) { data->ra_min = tp->x; }
     172            else if (tp->x > data->ra_max) { data->ra_max = tp->x; }
     173            if (tp->y < data->dec_min) { data->dec_min = tp->y; }
     174            else if (tp->y > data->dec_max) { data->dec_max = tp->y; }
    166175          }
    167176        }
    … …  
    187196          // FIX this should try to find the imagefile.
    188197          if (data->fit_OTAS) { // We are fitting OTAs, so allocate a new image
    189             psImage *solution = psImageAlloc(image->cols,image->rows,PS_TYPE_F32);
     198            psImage *solution = psImageAlloc(image->numCols,image->numRows,PS_TYPE_F32);
    190199            psMetadataAddPtr(data->OTA_solutions,PS_LIST_TAIL, chipName, PS_DATA_UNKNOWN | PS_META_REPLACE, "OTA solution element", solution);
    191200          }
    … …  
    194203            psStringAppend(&solutionFileName, ".%s.fits",chipName);
    195204            psFits *solutionFits = psFitsOpen(solutionFileName,"r");
    196             psImage *solution = psFitsReadImage(solutionFits,NULL,0);
     205            psImage *solution = psFitsReadImage(solutionFits,region,0);
     206            psMetadataAddPtr(data->OTA_solutions,PS_LIST_TAIL, chipName, PS_DATA_UNKNOWN | PS_META_REPLACE, "OTA solution element", solution);
    197207          }
    198208        }
    … …  
    215225    }
    216226
     227    // Allocate the modelMap for the region we're covering.
     228
     229    psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV);
     230    psImageBinning *binning = psImageBinningAlloc();
     231    binning->nXruff = 100; // Number of samples
     232    binning->nYruff = 100;
     233    binning->nXfine = ceil(data->ra_max - data->ra_min) + 1; // This is the range we're looking at
     234    binning->nYfine = ceil(data->dec_max - data->dec_min) + 1;
     235
     236    data->modelMap = psImageMapNoImageAlloc( binning,stats);
     237   
    217238    return true;
    218239}

  • trunk/ppBackground/src/ppBackgroundStackData.c

    r36579 r36580  
    3636    data->smfs = psArrayAlloc(0);
    3737
    38     data->OTA_solutions = psMetadataAlloc(0);
    39     data->fitOTAs = false;
     38    data->OTA_solutions = psMetadataAlloc();
     39    data->fit_OTAS = false;
    4040    data->OTApath = NULL;
    4141
    … …  
    4949    data->outRoot = NULL;
    5050    data->config = NULL;
    51 
    52     data->
    5351
    5452    return data;

  • trunk/ppBackground/src/ppBackgroundStackLoop.c

    r36579 r36580  
    1313    )
    1414{
    15     pmConfig *config = data->config;                                        // Configuration data
    16 
     15  //    pmConfig *config = data->config;                                        // Configuration data
     16    int i;
    1717    //
    1818    // Solve the data into a consistent model.
    1919    { // This block does the initialization
    2020      // If we didn't load the OTA solution from an external source, we need to build one.
    21       if (data->fitOTAs) {
     21      if (data->fit_OTAS) {
    2222        if (!ppBackgroundStackModelFitOTASolution(data)) {
    2323          // Currently can't fail.
    … …  
    6767      // Calculate model for each pixel of output
    6868      // Close output image
    69      
     69    }     
    7070
    7171    return(true);

  • trunk/ppBackground/src/ppBackgroundStackMath.c

    r36579 r36580  
    2727bool ppBackgroundStackModelFitOTASolution(ppBackgroundStackData *data) {
    2828  long i;
    29  
    30   pmFPAview *view    = pmFPAviewAllow(0);
     29  int u,v;
     30  pmFPAview *view    = pmFPAviewAlloc(0);
    3131  psMetadataIterator *iter = psMetadataIteratorAlloc(data->OTA_solutions, PS_LIST_HEAD, NULL); // Iterate over all chips.
    3232  psMetadataItem *item;
    … …  
    3838      continue;
    3939    }
    40     psString *workingChip = item->name;
     40    psString workingChip = item->name;
    4141    psImage  *solution    = item->data.V;
    4242
    43     for (v = 0; v < solution->nrows; v++) {
    44       for (u = 0; u < solution->ncols; u++) {
     43    for (v = 0; v < solution->numRows; v++) {
     44      for (u = 0; u < solution->numCols; u++) {
    4545        psVector *tmp = psVectorAllocEmpty(data->smfs->n,PS_TYPE_F32); 
    4646       
    4747        for (i = 0; i < data->smfs->n; i++) {
    4848          pmFPAviewReset(view);
    49           pmFPAfile *smfFile = data->smfs.data[i];
     49          pmFPAfile *smfFile = data->smfs->data[i];
    5050         
    5151          pmChip *chip;                       // Chip from FPA
    … …  
    8484  for (i = 0; i < data->smfs->n; i++) {
    8585    pmFPAviewReset(view);
    86     pmFPAfile *smfFile = data->smfs.data[i];
     86    pmFPAfile *smfFile = data->smfs->data[i];
    8787   
    8888    pmChip *chip;                       // Chip from FPA
    … …  
    9595      psImage *dec   = psMetadataLookupPtr(NULL, chip->concepts, "bkg dec");
    9696     
    97       psVector *obs  = psVectorAlloc(image->nrows * image->ncols, PS_TYPE_F32);
    98       psVector *model= psVectorAlloc(image->nrows * image->ncols, PS_TYPE_F32);
    99      
    100       for (v = 0; v < image->nrows; v++) {
    101         for (u = 0; u < image->ncols; u++) {
    102           obs->data.F32[v * image->ncols + u] = image->data.F32[v][u];
    103           model->data.F32[v * image->ncols + u] = psImageMapEval(data->modelMap,ra->data.F32[v][u],dec->data.F32[v][u]);
     97      psVector *obs  = psVectorAlloc(image->numRows * image->numCols, PS_TYPE_F32);
     98      psVector *model= psVectorAlloc(image->numRows * image->numCols, PS_TYPE_F32);
     99     
     100      for (v = 0; v < image->numRows; v++) {
     101        for (u = 0; u < image->numCols; u++) {
     102          obs->data.F32[v * image->numCols + u] = image->data.F32[v][u];
     103          model->data.F32[v * image->numCols + u] = psImageMapEval(data->modelMap,ra->data.F32[v][u],dec->data.F32[v][u]);
    104104        }
    105105      }
    106106
    107107      psPolynomial1D *poly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD,1);
    108       status = psVectorFitPolynomial1d(poly,NULL,0,model,NULL,obs);
    109       psMetadataAddF32(chip->analysis,PS_LIST_TAIL,"bkg offset", PS_META_REPLACE, "background offset for this exposure/ota pair", poly->coeff.F64[0]);
    110       psMetadataAddF32(chip->analysis,PS_LIST_TAIL,"bkg scale", PS_META_REPLACE, "background scale for this exposure/ota pair", poly->coeff.F64[1]);
    111 
    112       psFree(tmp);
     108      int status = psVectorFitPolynomial1D(poly,NULL,0,model,NULL,obs);
     109      if (!status) {
     110        psMetadataAddF32(chip->analysis,PS_LIST_TAIL,"bkg offset", PS_META_REPLACE, "background offset for this exposure/ota pair", poly->coeff[0]);
     111        psMetadataAddF32(chip->analysis,PS_LIST_TAIL,"bkg scale", PS_META_REPLACE, "background scale for this exposure/ota pair", poly->coeff[1]);
     112      }
     113      //      psFree(tmp);
    113114    } // End OTA loop
    114115  } // End smf/exp loop
    … …  
    127128 
    128129  pmFPAview *view    = pmFPAviewAlloc(0);
    129   stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
     130  //  psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
    130131  for (i = 0; i < data->smfs->n; i++) {
    131132    pmFPAviewReset(view);
    132     pmFPAfile *smfFile = data->smfs.data[i];
     133    pmFPAfile *smfFile = data->smfs->data[i];
    133134   
    134135    pmChip *chip;                       // Chip from FPA
    … …  
    146147      psF32 scale  = psMetadataLookupF32(NULL,chip->concepts,"bkg scale");
    147148
    148       for (v = 0; v < image->nrows; v++) {
    149         for (u = 0; u < image->ncols; u++) {
     149      for (v = 0; v < image->numRows; v++) {
     150        for (u = 0; u < image->numCols; u++) {
    150151          model->data.F32[v][u] = scale * image->data.F32[v][u] - offset - camera->data.F32[v][u];
    151152        }
    … …  
    175176  for (i = 0; i < data->smfs->n; i++) {
    176177    pmFPAviewReset(view);
    177     pmFPAfile *smfFile = data->smfs.data[i];
     178    pmFPAfile *smfFile = data->smfs->data[i];
    178179   
    179180    pmChip *chip;                       // Chip from FPA
    … …  
    182183        continue;
    183184      }
    184       const char *chipName = psMetadataLookupStr(NULL, chip->concepts, "CHIP.NAME"); // Name of chip
     185      //      const char *chipName = psMetadataLookupStr(NULL, chip->concepts, "CHIP.NAME"); // Name of chip
    185186      psImage *calib = psMetadataLookupPtr(NULL, chip->concepts, "bkg calibrated data");
    186187      psImage *ra    = psMetadataLookupPtr(NULL, chip->concepts, "bkg ra");
    187188      psImage *dec    = psMetadataLookupPtr(NULL, chip->concepts, "bkg dec");
    188       for (v = 0; v < image->nrows; v++) {
    189         for (u = 0; u < image->ncols; u++) {
     189      for (v = 0; v < calib->numRows; v++) {
     190        for (u = 0; u < calib->numCols; u++) {
    190191          X->data.F32[j] = ra->data.F32[v][u];
    191192          Y->data.F32[j] = dec->data.F32[v][u];
    … …  
    197198  } // End smfs
    198199
    199   status = psImageMapClipFit(&fitStatus,data->modelMap,stats, NULL, 0, X, Y, Z, E);
     200  bool fitStatus;
     201  bool status = psImageMapClipFit(&fitStatus,data->modelMap,stats, NULL, 0, X, Y, Z, E);
     202 
    200203  psFree(X);
    201204  psFree(Y);
    … …  
    204207  psFree(stats);
    205208  psFree(view);
    206 }
     209  return(status);
     210}
Note: See TracChangeset for help on using the changeset viewer.