00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <math.h>
00023 #include <stdio.h>
00024 #include <cpl.h>
00025 #include "midiGlobal.h"
00026 #include "midiLib.h"
00027 #include "imageProcessing.h"
00028 #include "memoryHandling.h"
00029 #include "createProdRefPix.h"
00030 #include "procRefPix.h"
00031 #include "errorHandling.h"
00032 #include "midiFitsUtility.h"
00033 #include "fitsAnalysisTec.h"
00034 #include "diagnostics.h"
00035 #include "qfits.h"
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062 void procRefPix (
00063 MidiFiles *fileNames,
00064 int *error)
00065 {
00066
00067
00068
00069 const char routine[] = "procRefPix";
00070 ImageFormat *format=NULL;
00071 ReferencePixel *refPix=NULL;
00072 int numOfExposures, maxNumOfBeams;
00073 FILE *signaturePtr=NULL;
00074
00075
00076
00077 if (diagnostic > 4)cpl_msg_info(cpl_func,"Invoking routine '%s' \n", routine);
00078 if (diagnostic > 4) fprintf (midiReportPtr, "Invoking routine '%s' \n", routine);
00079
00080
00081 signaturePtr = fopen ("MIDI_sig_pix.log", "w");
00082 fclose (signaturePtr);
00083
00084
00085 *error = 0;
00086 numOfExposures = 0;
00087 maxNumOfBeams = 0;
00088
00089
00090 format = callocImageFormat ();
00091
00092 analyseFitsRefPix (fileNames, format, &numOfExposures, &maxNumOfBeams, error);
00093 if (*error)
00094 {
00095 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot analyse REFPIX");
00096 freeImageFormat (format);
00097 return;
00098 }
00099
00100 refPix = callocRefPix (numOfExposures, maxNumOfBeams);
00101 computeRefPix (fileNames, refPix, error);
00102 if (*error)
00103 {
00104 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot process REFPIX");
00105 freeRefPix (refPix);
00106 freeImageFormat (format);
00107 return;
00108 }
00109
00110 createRefPixProd (fileNames, format, refPix, error);
00111 if (*error) midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot create REFPIX products");
00112
00113
00114 freeRefPix (refPix);
00115 freeImageFormat (format);
00116
00117 return;
00118 }
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143 void computeRefPix (
00144 MidiFiles *fileNames,
00145 ReferencePixel *refPix,
00146 int *error)
00147 {
00148
00149
00150
00151 const char routine[] = "computeRefPix";
00152 char *fileTemp, *classification;
00153 FILE *inFitsBatchPtr;
00154 ImageFormat *format;
00155 int localError, fileNumber, extNumOfImagingDataFile;
00156
00157
00158
00159 if (diagnostic > 4)cpl_msg_info(cpl_func,"Invoking routine '%s' \n", routine);
00160 if (diagnostic > 4) fprintf (midiReportPtr, "Invoking routine '%s' \n", routine);
00161
00162
00163 classification = (char *) calloc (MAX_STRING_LENGTH, sizeof (char));
00164 fileTemp = (char *) calloc (MAX_STRING_LENGTH, sizeof (char));
00165 format = callocImageFormat ();
00166
00167
00168 *error = 0;
00169 localError = 0;
00170 fileNumber = 0;
00171 refPix->exists = 0;
00172 format->hasData = 0;
00173
00174
00175 if ((inFitsBatchPtr = fopen (fileNames->inFitsBatch, "r")) == NULL)
00176 {
00177 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__,
00178 "Cannot open input FITS file list\n No data preprocessing has been carried out for this batch");
00179 freeImageFormat (format);
00180 free (fileTemp);
00181 free (classification);
00182 *error = 1;
00183 return;
00184 }
00185
00186
00187 while (fgets (fileTemp, MAX_STRING_LENGTH, inFitsBatchPtr) != NULL)
00188 {
00189 sprintf (classification, "%s", "");
00190 sscanf (fileTemp, "%s%s", fileNames->inFitsName, classification);
00191 if (diagnostic)cpl_msg_info(cpl_func,"\n Processing file %s \n", fileNames->inFitsName);
00192 fprintf(midiReportPtr, "\n Processing file %s \n", fileNames->inFitsName);
00193
00194
00195 extNumOfImagingDataFile = findImagingDataExtension (fileNames->inFitsName, TAB_IMAGING_DATA, &localError);
00196 if (localError)
00197 {
00198 *error = 1;
00199 break;
00200 }
00201
00202
00203 if (extNumOfImagingDataFile > 0)
00204 {
00205 getImageFormat (fileNames->inFitsName, extNumOfImagingDataFile, format, &localError);
00206 if (localError)
00207 {
00208 *error = 1;
00209 break;
00210 }
00211 }
00212 else format->hasData = 0;
00213
00214
00215 if (format->hasData)
00216 {
00217
00218 if ((strcmp (format->obsCatg, "CALIB") == 0) &&
00219 (strcmp (format->obsTech, "IMAGE") == 0) &&
00220 (strcmp (format->obsType, "FMTCHCK") == 0))
00221 {
00222
00223 sprintf (refPix->exposure[fileNumber].shutterId, "%s", format->shutterId);
00224 sprintf (refPix->exposure[fileNumber].beamCombiner, "%s", format->beamCombiner);
00225 if ((strcmp (format->beamCombiner, "HIGH_SENS") == 0) ||
00226 (strcmp (format->beamCombiner, "OPEN") == 0))
00227 refPix->exposure[fileNumber].numOfBeams = 2;
00228 else if (strcmp (format->beamCombiner, "SCI_PHOT") == 0)
00229 refPix->exposure[fileNumber].numOfBeams = 3;
00230
00231 if (diagnostic)cpl_msg_info(cpl_func," Beam combiner for file %d = %s\n", fileNumber+1,
00232 refPix->exposure[fileNumber].beamCombiner);
00233 if (diagnostic)cpl_msg_info(cpl_func," Shutter ID for file %d = %s\n", fileNumber+1,
00234 refPix->exposure[fileNumber].shutterId);
00235 if (diagnostic)cpl_msg_info(cpl_func," Number of beams for file %d = %d\n", fileNumber+1,
00236 refPix->exposure[fileNumber].numOfBeams);
00237 fprintf (midiReportPtr, " Beam combiner for file %d = %s\n", fileNumber+1,
00238 refPix->exposure[fileNumber].beamCombiner);
00239 fprintf (midiReportPtr, " Shutter ID for file %d = %s\n", fileNumber+1,
00240 refPix->exposure[fileNumber].shutterId);
00241 fprintf (midiReportPtr, " Number of beams for file %d = %d\n", fileNumber+1,
00242 refPix->exposure[fileNumber].numOfBeams);
00243
00244
00245 procCentroidsRefPix (fileNumber, fileNames->inFitsName, extNumOfImagingDataFile,
00246 format, refPix, &localError);
00247 if (localError) *error = 1;
00248
00249
00250 refPix->exists = 1;
00251
00252
00253 fileNumber++;
00254 if (fileNumber > refPix->numOfExposures)
00255 {
00256 *error = 1;
00257 break;
00258 }
00259 }
00260 else
00261 midiReportInfo (midiReportPtr, routine, __FILE__, __LINE__, "The above file is not suitable for this task");
00262 }
00263 else
00264 {
00265 if (diagnostic)
00266 {
00267 sprintf (midiMessage, "No data tables in %s. Not processed", fileNames->inFitsName);
00268 midiReportInfo (midiReportPtr, routine, __FILE__, __LINE__, midiMessage);
00269 }
00270 }
00271 }
00272
00273
00274 if ((refPix->exists) && !(*error) && (fileNumber == refPix->numOfExposures))
00275 {
00276 cpl_msg_info(cpl_func,"\nReference Pixel Position Inventry: \n");
00277 cpl_msg_info(cpl_func,"================================= \n");
00278 cpl_msg_info(cpl_func," Expected number of data files = %d\n", refPix->numOfExposures);
00279 cpl_msg_info(cpl_func," Number of data files processed = %d\n", fileNumber);
00280 cpl_msg_info(cpl_func,"\n");
00281
00282 fprintf (midiReportPtr, "\nReference Pixel Position Inventry: \n");
00283 fprintf (midiReportPtr, "================================= \n");
00284 fprintf (midiReportPtr, " Expected number of data files = %d\n", refPix->numOfExposures);
00285 fprintf (midiReportPtr, " Number of data files processed = %d\n", fileNumber);
00286 fprintf (midiReportPtr, "\n");
00287
00288
00289
00290 evaluateBeamPosition ();
00291 }
00292
00293 if (*error || localError)
00294 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot create an Image Centroid Data for this batch");
00295
00296
00297 fclose (inFitsBatchPtr);
00298
00299
00300 freeImageFormat (format);
00301 free (fileTemp);
00302 free (classification);
00303
00304 return;
00305 }
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337 void procCentroidsRefPix (
00338 int fileNumber,
00339 char *inFitsName,
00340 int extensionNumber,
00341 ImageFormat *format,
00342 ReferencePixel *refPix,
00343 int *error)
00344
00345 {
00346
00347
00348
00349 const char routine[] = "procCentroidsRefPix";
00350 qfits_table *pTable = NULL;
00351 short int *inData;
00352 char *tempStr, *string, *title, *dataName;
00353 int i, foundData = 0, scalingOffset, indexData, subWindowSize;
00354 float *aveImage;
00355
00356
00357
00358
00359 if (diagnostic > 4)cpl_msg_info(cpl_func,"Invoking routine '%s' \n", routine);
00360 if (diagnostic > 4) fprintf (midiReportPtr, "Invoking routine '%s' \n", routine);
00361
00362
00363 *error = 0;
00364
00365
00366 pTable = qfits_table_open (inFitsName, extensionNumber);
00367 if (!pTable)
00368 {
00369 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot load IMAGING_DATA");
00370 *error = 1;
00371 return;
00372 }
00373
00374
00375 for (i = 0; i < pTable->nc; i++)
00376 {
00377 if (strcmp (pTable->col[i].tlabel, "DATA1") == 0)
00378 {
00379 foundData = 1;
00380 indexData = i;
00381 }
00382 }
00383 if (foundData == 0)
00384 {
00385 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot find requested columns in data FITS file");
00386 qfits_table_close (pTable);
00387 *error = 1;
00388 return;
00389 }
00390
00391
00392 inData = (short int*) qfits_query_column (pTable, indexData, NULL);
00393
00394
00395 dataName = (char *) calloc (MAX_STRING_LENGTH, sizeof (char));
00396 for (i = 14; i < 25; i++)
00397 {
00398 sprintf (dataName, "TZERO%d", i);
00399 tempStr = qfits_query_ext (inFitsName, dataName, extensionNumber);
00400 if (tempStr != NULL)
00401 {
00402 if (diagnostic)cpl_msg_info(cpl_func,"Scaling Offset = %s\n", tempStr);
00403 if (diagnostic) fprintf (midiReportPtr, "Scaling Offset = %s\n", tempStr);
00404 sscanf (tempStr, "%d", &scalingOffset);
00405 break;
00406 }
00407 }
00408 if (tempStr == NULL)
00409 {
00410 scalingOffset = 0;
00411 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot read Scaling Offset. It is set to 0");
00412 }
00413 free (dataName);
00414
00415
00416 subWindowSize = format->iXWidth * format->iYWidth;
00417 aveImage = (float *) calloc (subWindowSize, sizeof(float));
00418 createAveragedImage (inData, scalingOffset, format, aveImage);
00419
00420
00421 title = (char *) calloc (MAX_STRING_LENGTH, sizeof (char));
00422 string = (char *) calloc (MAX_STRING_LENGTH, sizeof (char));
00423 sprintf (title, "AveImg%d", fileNumber+1);
00424 sprintf (string, "file %d", fileNumber+1);
00425 createFitsImage (string, title, inFitsName, format->iXWidth, format->iYWidth, aveImage);
00426
00427
00428 sprintf (string, "3dAveImg%d", fileNumber+1);
00429 sprintf (title, "Averaged Image, Beam Combiner %s", format->beamCombiner);
00430 if (plotFile) midiCreatePlotFile3D (string, title, "X", "Y", "Flux",
00431 0, aveImage, format->iXWidth, format->iYWidth, "lines", "3");
00432 free (string);
00433 free (title);
00434
00435
00436 computeTargetCentroidsRefPix (fileNumber, format, aveImage, refPix, error);
00437 if (*error) midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot determine target centroid");
00438
00439
00440 qfits_table_close (pTable);
00441 free (inData);
00442 free (aveImage);
00443
00444 return;
00445 }
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469 void computeTargetCentroidsRefPix (
00470 int fileNumber,
00471 ImageFormat *format,
00472 float *image,
00473 ReferencePixel *refPix,
00474 int *error)
00475 {
00476
00477
00478
00479 const char routine[] = "computeTargetCentroidsRefPix";
00480 int dimension = 2, xPinhole, yPinhole, sizeSearch;
00481 double xTarget, yTarget, sizeXTarget, sizeYTarget;
00482
00483
00484
00485 if (diagnostic > 4)cpl_msg_info(cpl_func,"Invoking routine '%s' \n", routine);
00486 if (diagnostic > 4) fprintf (midiReportPtr, "Invoking routine '%s' \n", routine);
00487
00488
00489 *error = 0;
00490
00491
00492 if ((strcmp (refPix->exposure[fileNumber].beamCombiner, "HIGH_SENS") == 0) ||
00493 (strcmp (refPix->exposure[fileNumber].beamCombiner, "OPEN") == 0))
00494 {
00495
00496 if (strcmp (refPix->exposure[fileNumber].shutterId, "ABOPEN") == 0)
00497 {
00498
00499 sizeSearch = SIZE_SEARCH_REF_PIX;
00500 xPinhole = X1_REF_PIX_ABOPEN;
00501 yPinhole = Y1_REF_PIX_ABOPEN;
00502 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00503 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00504 if (*error)
00505 {
00506 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00507 return;
00508 }
00509
00510 refPix->exposure[fileNumber].centroid[0].xCoord = xTarget;
00511 refPix->exposure[fileNumber].centroid[0].yCoord = yTarget;
00512 refPix->exposure[fileNumber].centroid[0].size = 0.5 * (sizeXTarget + sizeYTarget);
00513
00514
00515 xPinhole = X2_REF_PIX_ABOPEN;
00516 yPinhole = Y2_REF_PIX_ABOPEN;
00517 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00518 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00519 if (*error)
00520 {
00521 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00522 return;
00523 }
00524
00525 refPix->exposure[fileNumber].centroid[1].xCoord = xTarget;
00526 refPix->exposure[fileNumber].centroid[1].yCoord = yTarget;
00527 refPix->exposure[fileNumber].centroid[1].size = 0.5 * (sizeXTarget + sizeYTarget);
00528 }
00529 else if (strcmp (refPix->exposure[fileNumber].shutterId, "AOPEN") == 0)
00530 {
00531
00532 sizeSearch = SIZE_SEARCH_REF_PIX;
00533 xPinhole = X1_REF_PIX_HS_AOPEN;
00534 yPinhole = Y1_REF_PIX_HS_AOPEN;
00535 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00536 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00537 if (*error)
00538 {
00539 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00540 return;
00541 }
00542
00543 refPix->exposure[fileNumber].centroid[0].xCoord = xTarget;
00544 refPix->exposure[fileNumber].centroid[0].yCoord = yTarget;
00545 refPix->exposure[fileNumber].centroid[0].size = 0.5 * (sizeXTarget + sizeYTarget);
00546
00547
00548 xPinhole = X2_REF_PIX_HS_AOPEN;
00549 yPinhole = Y2_REF_PIX_HS_AOPEN;
00550 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00551 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00552 if (*error)
00553 {
00554 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00555 return;
00556 }
00557
00558 refPix->exposure[fileNumber].centroid[1].xCoord = xTarget;
00559 refPix->exposure[fileNumber].centroid[1].yCoord = yTarget;
00560 refPix->exposure[fileNumber].centroid[1].size = 0.5 * (sizeXTarget + sizeYTarget);
00561 }
00562 else if (strcmp (refPix->exposure[fileNumber].shutterId, "BOPEN") == 0)
00563 {
00564
00565 sizeSearch = SIZE_SEARCH_REF_PIX;
00566 xPinhole = X1_REF_PIX_HS_BOPEN;
00567 yPinhole = Y1_REF_PIX_HS_BOPEN;
00568 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00569 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00570 if (*error)
00571 {
00572 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00573 return;
00574 }
00575
00576 refPix->exposure[fileNumber].centroid[0].xCoord = xTarget;
00577 refPix->exposure[fileNumber].centroid[0].yCoord = yTarget;
00578 refPix->exposure[fileNumber].centroid[0].size = 0.5 * (sizeXTarget + sizeYTarget);
00579
00580
00581 xPinhole = X2_REF_PIX_HS_BOPEN;
00582 yPinhole = Y2_REF_PIX_HS_BOPEN;
00583 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00584 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00585 if (*error)
00586 {
00587 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00588 return;
00589 }
00590
00591 refPix->exposure[fileNumber].centroid[1].xCoord = xTarget;
00592 refPix->exposure[fileNumber].centroid[1].yCoord = yTarget;
00593 refPix->exposure[fileNumber].centroid[1].size = 0.5 * (sizeXTarget + sizeYTarget);
00594 }
00595 else
00596 {
00597 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Unknown Shutter ID");
00598 *error = 1;
00599 return;
00600 }
00601 }
00602 else if (strcmp (refPix->exposure[fileNumber].beamCombiner, "SCI_PHOT") == 0)
00603 {
00604
00605 if (strcmp (refPix->exposure[fileNumber].shutterId, "AOPEN") == 0)
00606 {
00607 sizeSearch = SIZE_SEARCH_REF_PIX;
00608 xPinhole = X1_REF_PIX_SP_AOPEN;
00609 yPinhole = Y1_REF_PIX_SP_AOPEN;
00610 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00611 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00612 if (*error)
00613 {
00614 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00615 return;
00616 }
00617
00618 refPix->exposure[fileNumber].centroid[0].xCoord = xTarget;
00619 refPix->exposure[fileNumber].centroid[0].yCoord = yTarget;
00620 refPix->exposure[fileNumber].centroid[0].size = 0.5 * (sizeXTarget + sizeYTarget);
00621
00622 xPinhole = X2_REF_PIX_SP_AOPEN;
00623 yPinhole = Y2_REF_PIX_SP_AOPEN;
00624 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00625 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00626 if (*error)
00627 {
00628 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00629 return;
00630 }
00631
00632 refPix->exposure[fileNumber].centroid[1].xCoord = xTarget;
00633 refPix->exposure[fileNumber].centroid[1].yCoord = yTarget;
00634 refPix->exposure[fileNumber].centroid[1].size = 0.5 * (sizeXTarget + sizeYTarget);
00635
00636 xPinhole = X3_REF_PIX_SP_AOPEN;
00637 yPinhole = Y3_REF_PIX_SP_AOPEN;
00638 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00639 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00640 if (*error)
00641 {
00642 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00643 return;
00644 }
00645
00646 refPix->exposure[fileNumber].centroid[2].xCoord = xTarget;
00647 refPix->exposure[fileNumber].centroid[2].yCoord = yTarget;
00648 refPix->exposure[fileNumber].centroid[2].size = 0.5 * (sizeXTarget + sizeYTarget);
00649 }
00650 else if (strcmp (refPix->exposure[fileNumber].shutterId, "BOPEN") == 0)
00651 {
00652 sizeSearch = SIZE_SEARCH_REF_PIX;
00653 xPinhole = X1_REF_PIX_SP_BOPEN;
00654 yPinhole = Y1_REF_PIX_SP_BOPEN;
00655 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00656 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00657 if (*error)
00658 {
00659 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00660 return;
00661 }
00662
00663 refPix->exposure[fileNumber].centroid[0].xCoord = xTarget;
00664 refPix->exposure[fileNumber].centroid[0].yCoord = yTarget;
00665 refPix->exposure[fileNumber].centroid[0].size = 0.5 * (sizeXTarget + sizeYTarget);
00666
00667 xPinhole = X2_REF_PIX_SP_BOPEN;
00668 yPinhole = Y2_REF_PIX_SP_BOPEN;
00669 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00670 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00671 if (*error)
00672 {
00673 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00674 return;
00675 }
00676
00677 refPix->exposure[fileNumber].centroid[1].xCoord = xTarget;
00678 refPix->exposure[fileNumber].centroid[1].yCoord = yTarget;
00679 refPix->exposure[fileNumber].centroid[1].size = 0.5 * (sizeXTarget + sizeYTarget);
00680
00681 xPinhole = X3_REF_PIX_SP_BOPEN;
00682 yPinhole = Y3_REF_PIX_SP_BOPEN;
00683 midiGaussianFit (fileNumber, dimension, image, format->iXWidth, format->iYWidth, xPinhole, yPinhole,
00684 sizeSearch, &xTarget, &yTarget, &sizeXTarget, &sizeYTarget, error);
00685 if (*error)
00686 {
00687 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Cannot perform a Gaussian fit");
00688 return;
00689 }
00690
00691 refPix->exposure[fileNumber].centroid[2].xCoord = xTarget;
00692 refPix->exposure[fileNumber].centroid[2].yCoord = yTarget;
00693 refPix->exposure[fileNumber].centroid[2].size = 0.5 * (sizeXTarget + sizeYTarget);
00694 }
00695 else
00696 {
00697 midiReportWarning (midiReportPtr, routine, __FILE__, __LINE__, "Unknown Shutter ID");
00698 *error = 1;
00699 return;
00700 }
00701 }
00702
00703 return;
00704 }
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721 void evaluateBeamPosition (void)
00722 {
00723
00724
00725
00726 const char routine[] = "evaluateBeamPosition";
00727
00728
00729
00730 if (diagnostic > 4)cpl_msg_info(cpl_func,"Invoking routine '%s' \n", routine);
00731 if (diagnostic > 4) fprintf (midiReportPtr, "Invoking routine '%s' \n", routine);
00732
00733 midiReportTbd (midiReportPtr, routine, __FILE__, __LINE__, "Entire routine to be written");
00734
00735 return;
00736 }
00737
00738