//---------------------------------------------------------------------------

#define	_SIGEVENT    //prevent compiler errors when time.h and siginfo.h cannot cooperate

#include <string.h>
#include <stdio.h>
#include "global.h"
#include "imatrix.h"
#include "calstars.h"
#include "novas.h"
#include "swephexp.h"

//****************************************************************************
/*          ******************* TruncCat *******************
   create a new "reduced" star catalog from the original catalog 
   inputs - catfilename - the source catalog text file
            newcatfilename - the new file of the new catalog that is generated
   output - 1 if succeeded
   The function simply delete all stars which their magnitude is above 5.6 
   (or any other value) and create a new catalog that contains only the stars
   that are brighter.
*/
int TruncCat(char *catfilename,char *newctafilename)
{  FILE *OldCatFile,*NewCatFile;
   char st[500],*not_eof,oneval[20];
   double val;
   OldCatFile=fopen(catfilename,"r");           /* open file */
   if (!OldCatFile) return(0);                  /* could not open the file */
   NewCatFile=fopen(newctafilename,"w");        /* open file for writing*/
   if (!NewCatFile) return(0);                  /* could not open the file */
   not_eof=fgets(st,500,OldCatFile);            /* read one line */
   while (not_eof)
   {  strncpy(oneval,&st[188],4);
      oneval[4]=0;
      val=atof(oneval);                         /* only stars with magnitude which is less than 5 */
      if (val<5.6)
      {  fprintf(NewCatFile,"%s",st);
      }
      not_eof=fgets(st,500,OldCatFile);         /* read the next line */
   }
   fclose(OldCatFile);
   fclose(NewCatFile);
   return(1);                                   /* function ended successfully */
}
/************************************************************************/
/*             ************** CreateStars **************
   Create the stars' list.
   This function also set initial values such as locations, obsevatories, etc...
   inputs - catfilename - the star catalog text file name
            sky_objects_file_name - the name of the external objects file (if one is specified) 
   output - 1 if succeeded 
   This function also assign the attributes of each star (magnitude, concam magnitude, ra, dec etc...)
*/
int CreateStars(char *catfilename,char *sky_objects_file_name)
{ int stars_counter=0;
  char st[500],*not_eof,oneval[20],*p;
  FILE *CatFile,*SkyObjectsFile;
  double value;
  /* set the locations */
  /* a default custom observatory */
  /* this space should be read from 'location' file by the function
  /* "LoadObservatory" in the file global.c */  
  locations[CUSTOM].height=0;
  locations[CUSTOM].temperature=0;
  locations[CUSTOM].pressure=1000;
  locations[CUSTOM].ang_offset=0;
  locations[CUSTOM].dist_coefficient=1;
  locations[CUSTOM].bad.x1=0;
  locations[CUSTOM].bad.x2=0;
  locations[CUSTOM].bad.y1=0;
  locations[CUSTOM].bad.y2=0;
  locations[CUSTOM].clear_threshold=0.7;
  locations[CUSTOM].color= (255 << 16) | (255 << 8) | (255);
  strcpy(locations[CUSTOM].name,"");

  /* ramon (wise observatory) */
  /* fits: MID_X = 510    MID_Y = 506  */
  locations[RAMON].latitude=30.596; //32.11; //32+07/60
  locations[RAMON].longitude=34.77; //34+46/60+9/3600
  locations[RAMON].height=300;
  locations[RAMON].temperature=15;
  locations[RAMON].pressure=1000;
  locations[RAMON].ang_offset=0;
  locations[RAMON].dist_coefficient=1;
  locations[RAMON].bad.x1=0;
  locations[RAMON].bad.x2=0;
  locations[RAMON].bad.y1=0;
  locations[RAMON].bad.y2=0;
  locations[RAMON].clear_threshold=0.7;
  
  locations[RAMON].MID_X=510;
  locations[RAMON].MID_Y=506;
  locations[RAMON].color= (0 << 16) | (255 << 8) | (255);
  strcpy(locations[RAMON].name,"Wise Observatory,\nIsrael");

  /* Rosemary Hill Observatory */
  /* jpg:  MID_X = 248 + 25   MID_Y = 235 + 10 */
  /* fits: MID_X = 527        MID_Y = 480      */
  locations[RHO].latitude=29.4;  //29+(24/60)+(8/3600)
  locations[RHO].longitude=-82.58; //-82-(35/60)-(20/3600)
  locations[RHO].height=40;
  locations[RHO].temperature=20;
  locations[RHO].pressure=1000;
  locations[RHO].ang_offset=0.15;
  locations[RHO].dist_coefficient=1;
  locations[RHO].bad.x1=0;
  locations[RHO].bad.x2=0;
  locations[RHO].bad.y1=0;
  locations[RHO].bad.y2=0;
  locations[RHO].clear_threshold=0.7;

  locations[RHO].MID_X=527;
  locations[RHO].MID_Y=480;
  locations[RHO].color=(0 << 16) | (128 << 8) | (255);
  strcpy(locations[RHO].name,"Rosemary Hill Observatory,\nFlorida");

  /* kitt peak observatory */
  /* jpg:  MID_X = 248 + 56   MID_Y = 235 + 41 */
  /* fits: MID_X = 482        MID_Y = 505      */
  locations[KITT_PEAK].latitude=31.967;
  locations[KITT_PEAK].longitude=-113.6;
  locations[KITT_PEAK].height=2083;
  locations[KITT_PEAK].temperature=20;
  locations[KITT_PEAK].pressure=1000;
  locations[KITT_PEAK].ang_offset=5.6;
  locations[KITT_PEAK].dist_coefficient=1;
  locations[KITT_PEAK].bad.x1=0;
  locations[KITT_PEAK].bad.x2=0;
  locations[KITT_PEAK].bad.y1=0;
  locations[KITT_PEAK].bad.y2=0;
  locations[KITT_PEAK].clear_threshold=0.16;

  locations[KITT_PEAK].MID_X=482;
  locations[KITT_PEAK].MID_Y=505;
  locations[KITT_PEAK].color=(128 << 16) | (255 << 8) | (128);
  strcpy(locations[KITT_PEAK].name,"Kitt Peak,\nArizona");

  /* mount wilson observatory */
  /* MID_X = 248 - 18    MID_Y = 235 + 9 */
  /* fits: MID_X = 496   MID_Y = 502     */
  locations[WILSON].latitude=34.167;
  locations[WILSON].longitude=-118.052;
  locations[WILSON].height=1742;
  locations[WILSON].temperature=20;
  locations[WILSON].pressure=1000;
  locations[WILSON].ang_offset=-13.5;
  locations[WILSON].dist_coefficient=1;
  locations[WILSON].bad.x1=0;
  locations[WILSON].bad.x2=0;
  locations[WILSON].bad.y1=0;
  locations[WILSON].bad.y2=0;
  locations[WILSON].clear_threshold=0.4;

  locations[WILSON]. MID_X=496;
  locations[WILSON].MID_Y=502;
  locations[WILSON].color=(255 << 16) | (128 << 8) | (128);
  strcpy(locations[WILSON].name,"Mt. Wilson,\nCalifornia");

  /* mauna kea observatory (hawaii) */
  /* jpg: MID_X = 248 + 6       MID_Y = 235 + 46 */
  /* old fits: MID_X = 530    MID_Y = 517  */
  /* fits: MID_X=502          MID_Y = 562  */
  locations[MAUNA_KEA].latitude=19.8258;
  locations[MAUNA_KEA].longitude=-155.4719;
  locations[MAUNA_KEA].height=4123;
  locations[MAUNA_KEA].temperature=20;
  locations[MAUNA_KEA].pressure=1000;
  locations[MAUNA_KEA].ang_offset=+3.5; //5.2 /* old 5.2 */
  locations[MAUNA_KEA].dist_coefficient=1; /* old 1.07 */
  locations[MAUNA_KEA].bad.x1=0;
  locations[MAUNA_KEA].bad.x2=0;
  locations[MAUNA_KEA].bad.y1=0;
  locations[MAUNA_KEA].bad.y2=0;
  locations[MAUNA_KEA].clear_threshold=0.85;

  locations[MAUNA_KEA].MID_X=502; //492;
  locations[MAUNA_KEA].MID_Y=562; //554;
  locations[MAUNA_KEA].color=(218 << 16) | (209 << 8) | (37);
  strcpy(locations[MAUNA_KEA].name,"Mauna Kea,\nHawaii");

  /* haleakala observatory (hawaii) */
  /* jpg: MID_X = 248 + 6       MID_Y = 235 + 46 */
  /* old fits: MID_X = 512    MID_Y = 554 */
  /* fits: MID_X=534          MID_Y = 514  */
  locations[HALEAKALA].latitude=20.7072;
  locations[HALEAKALA].longitude=-156.2559;
  locations[HALEAKALA].height=3048;
  locations[HALEAKALA].temperature=20;
  locations[HALEAKALA].pressure=1000;
  locations[HALEAKALA].ang_offset=-7.2;
  locations[HALEAKALA].dist_coefficient=1.08; /* old 1 */
  locations[HALEAKALA].bad.x1=0;
  locations[HALEAKALA].bad.x2=0;
  locations[HALEAKALA].bad.y1=0;
  locations[HALEAKALA].bad.y2=0;
  locations[HALEAKALA].clear_threshold=0.85;

  locations[HALEAKALA].MID_X=540;
  locations[HALEAKALA].MID_Y=517;
  locations[HALEAKALA].color=(255 << 16) | (255 << 8) | (255);
  strcpy(locations[HALEAKALA].name,"Haleakala,\nHawaii");

  /* cerro pachon observatory */
  /* jpg: MID_X = 248 + 6       MID_Y = 235 + 46 */
  /* old fits: MID_X = 510    MID_Y = 534 */
  /* fits: MID_X=512          MID_Y = 534  */
  locations[CERRO_PACHON].latitude=-30.16;      /* South 30 deg 14.405' */
  locations[CERRO_PACHON].longitude=-70.7358;  /* West  70 deg 44.149' */
  locations[CERRO_PACHON].height=2715;
  locations[CERRO_PACHON].temperature=20;
  locations[CERRO_PACHON].pressure=1000;
  locations[CERRO_PACHON].ang_offset=-1.5;
  locations[CERRO_PACHON].dist_coefficient=1.08; /* old 1 */
  locations[CERRO_PACHON].bad.x1=0;
  locations[CERRO_PACHON].bad.x2=586;
  locations[CERRO_PACHON].bad.y1=0;
  locations[CERRO_PACHON].bad.y2=380;
  locations[CERRO_PACHON].clear_threshold=0.90;

  locations[CERRO_PACHON].MID_X=512;
  locations[CERRO_PACHON].MID_Y=534;
  locations[CERRO_PACHON].color=(255 << 16) | (0 << 8) | (255);
  strcpy(locations[CERRO_PACHON].name,"Cerro Pachon,\nChile");

  /* canary island observatory (spain) */
  /* jpg: MID_X = 248 + 17 MID_Y = 235 - 21~ */
  /* fits: MID_X = 518     MID_Y = 556 */
  locations[CANARY_ISLAND].latitude=28.303;
  locations[CANARY_ISLAND].longitude=-16.509;
  locations[CANARY_ISLAND].height=2406;
  locations[CANARY_ISLAND].temperature=25;
  locations[CANARY_ISLAND].pressure=1000;
  locations[CANARY_ISLAND].ang_offset=-9;
  locations[CANARY_ISLAND].dist_coefficient=1.06;
  locations[CANARY_ISLAND].bad.x1=0;
  locations[CANARY_ISLAND].bad.x2=0;
  locations[CANARY_ISLAND].bad.y1=0;
  locations[CANARY_ISLAND].bad.y2=0;
  locations[CANARY_ISLAND].clear_threshold=0.85;

  locations[CANARY_ISLAND].MID_X=518;
  locations[CANARY_ISLAND].MID_Y=556;
  locations[CANARY_ISLAND].color=(255 << 16) | (128 << 8) | (0);
  strcpy(locations[CANARY_ISLAND].name,"Canary Islands,\nSpain");

  /* south africa large telescope observatory (south africa) */
  /* jpg: MID_X = 248 + 17 MID_Y = 235 - 21~ */
  /* fits: MID_X = 504     MID_Y = 521 */
  locations[SOUTH_AFRICA].latitude=-(32+22/60+46/3600);
  locations[SOUTH_AFRICA].longitude=20+48/60+38.5/3600;
  locations[SOUTH_AFRICA].height=1798;
  locations[SOUTH_AFRICA].temperature=15;
  locations[SOUTH_AFRICA].pressure=900;
  locations[SOUTH_AFRICA].ang_offset=-1;
  locations[SOUTH_AFRICA].dist_coefficient=1.068;
  locations[SOUTH_AFRICA].bad.x1=0;
  locations[SOUTH_AFRICA].bad.x2=0;
  locations[SOUTH_AFRICA].bad.y1=0;
  locations[SOUTH_AFRICA].bad.y2=0;
  locations[SOUTH_AFRICA].clear_threshold=0.85;

  locations[SOUTH_AFRICA].MID_X=504;
  locations[SOUTH_AFRICA].MID_Y=521;
  locations[SOUTH_AFRICA].color=(0 << 16) | (128 << 8) | (0);
  strcpy(locations[SOUTH_AFRICA].name,"South Africa");

  /* siding spring observatory (australia) */
  locations[SIDING_SPRING].latitude=-32.27;
  locations[SIDING_SPRING].longitude=149.07;
  locations[SIDING_SPRING].height=1130;
  locations[SIDING_SPRING].temperature=18;
  locations[SIDING_SPRING].pressure=900;
  locations[SIDING_SPRING].ang_offset=-1.5;
  locations[SIDING_SPRING].dist_coefficient=1.06;
  locations[SIDING_SPRING].bad.x1=0;
  locations[SIDING_SPRING].bad.x2=0;
  locations[SIDING_SPRING].bad.y1=0;
  locations[SIDING_SPRING].bad.y2=0;
  locations[SIDING_SPRING].clear_threshold=0.85;

  locations[SIDING_SPRING].MID_X=529;
  locations[SIDING_SPRING].MID_Y=522;
  locations[SIDING_SPRING].color=(255 << 16) | (255 << 8) | (0);
  strcpy(locations[SIDING_SPRING].name,"Siding Spring,\nAustralia");

  /* SAPIR COLLEGE (wise observatory) */
  locations[SAPIR_COLLEGE].latitude=31.50; 
  locations[SAPIR_COLLEGE].longitude=34.51;
  locations[SAPIR_COLLEGE].height=300;
  locations[SAPIR_COLLEGE].temperature=15;
  locations[SAPIR_COLLEGE].pressure=1000;
  locations[SAPIR_COLLEGE].ang_offset=-6;
  locations[SAPIR_COLLEGE].dist_coefficient=0.55;
  locations[SAPIR_COLLEGE].bad.x1=0;
  locations[SAPIR_COLLEGE].bad.x2=0;
  locations[SAPIR_COLLEGE].bad.y1=0;
  locations[SAPIR_COLLEGE].bad.y2=0;
  locations[SAPIR_COLLEGE].clear_threshold=0.4;

  locations[SAPIR_COLLEGE].MID_X=268;
  locations[SAPIR_COLLEGE].MID_Y=222;
  locations[SAPIR_COLLEGE].color= (0 << 16) | (255 << 8) | (255);
  strcpy(locations[SAPIR_COLLEGE].name,"Sapir College,\nIsrael");

  /* hanle (India) */
  locations[HANLE].latitude=32.779;    //32d46m46s
  locations[HANLE].longitude=78.9641;  //78d57m51s
  locations[HANLE].height=4500;
  locations[HANLE].temperature=10;
  locations[HANLE].pressure=700;
  locations[HANLE].ang_offset=+9;
  locations[HANLE].dist_coefficient=0.55;
  locations[HANLE].bad.x1=0;
  locations[HANLE].bad.x2=0;
  locations[HANLE].bad.y1=0;
  locations[HANLE].bad.y2=0;
  locations[HANLE].clear_threshold=0.4;

  locations[HANLE].MID_X=262;
  locations[HANLE].MID_Y=240;
  locations[HANLE].color= (0 << 16) | (0 << 8) | (255);
  strcpy(locations[HANLE].name,"Hanle,\nIndia");
  
  /* set the planets */
  strcpy(planets[MERCURY].name,"mercury");
  planets[MERCURY].type=0; /* major planet */
  planets[MERCURY].number=MERCURY;
  strcpy(planets[VENUS].name,"venus");
  planets[VENUS].type=0; /* major planet */
  planets[VENUS].number=VENUS;
  strcpy(planets[EARTH].name,"");
  planets[EARTH].type=0; /* major planet */
  planets[EARTH].number=EARTH;
  strcpy(planets[MARS].name,"mars");
  planets[MARS].type=0; /* major planet */
  planets[MARS].number=MARS;
  strcpy(planets[JUPITER].name,"jupiter");
  planets[JUPITER].type=0; /* major planet */
  planets[JUPITER].number=JUPITER;
  strcpy(planets[SATURN].name,"saturn");
  planets[SATURN].type=0; /* major planet */
  planets[SATURN].number=SATURN;
  strcpy(planets[ORANUS].name,"uranus");
  planets[ORANUS].type=0; /* major planet */
  planets[ORANUS].number=ORANUS;
  strcpy(planets[NEPTUN].name,"neptun");
  planets[NEPTUN].type=0; /* major planet */
  planets[NEPTUN].number=NEPTUN;
  strcpy(planets[PLUTO].name,"pluto");
  planets[PLUTO].type=0; /* major planet */
  planets[PLUTO].number=PLUTO;
  strcpy(planets[SUN].name,"sun");
  planets[SUN].type=0; /* major planet */
  planets[SUN].number=SUN;
  strcpy(planets[MOON].name,"moon");
  planets[MOON].type=0; /* major planet */
  planets[MOON].number=MOON;
  /* */
  /* set stars */
  /* */
  CatFile=fopen(catfilename,"r");           /* open file for reading */
  if (!CatFile) return(0);                  /* could not open the file */
  not_eof=fgets(st,500,CatFile);            /* read one line */
  while (not_eof)
  {  strcpy(stars[stars_counter].catalog,"FK5"); /* set the catalog */
     /* star name */
     strncpy(oneval,&st[7],10);
     oneval[10]=0;
     p=&oneval[0];
     while (*p==' ' && p<&oneval[5]) p++;
     strcpy(stars[stars_counter].starname,p);
     /* star's HD number */
     strncpy(oneval,&st[32],7);
     p=&oneval[0];
     while (*p==' ' && p<&oneval[5]) p++;
     stars[stars_counter].starnumber=atol(oneval); 
//     /* star number */
//     strncpy(oneval,&st[1],4);
//     oneval[4]=0;
//     stars[stars_counter].starnumber=atol(oneval);
     /* ra (right acertion) */
     strncpy(oneval,&st[140],2);
     oneval[2]=0;
     value=atof(oneval);                 /* get the hours */
     strncpy(oneval,&st[143],2);
     oneval[2]=0;
     value=value+atof(oneval)/60;        /* get the minutes */
     strncpy(oneval,&st[146],4);
     oneval[4]=0;
     value=value+atof(oneval)/3600;      /* get the seconds */
     stars[stars_counter].ra=value;
     /* dec */
     strncpy(oneval,&st[157],2);
     oneval[2]=0;
     value=atof(oneval);                 /* get the hours */
     strncpy(oneval,&st[160],2);
     oneval[2]=0;
     value=value+atof(oneval)/60;        /* get the minutes */
     strncpy(oneval,&st[163],2);
     oneval[2]=0;
     value=value+atof(oneval)/3600;      /* get the seconds */
     if (st[156]=='-') value=value*-1;   /* consder the sign */
     stars[stars_counter].dec=value;
     /* proper motion a */
     strncpy(oneval,&st[285],6);
     oneval[6]=0;
     value=atof(oneval);
     value=((value/15)/cos((stars[stars_counter].dec*3.14159265)/180))*100;
     stars[stars_counter].promora=value;
     /* proper motion dec */
     strncpy(oneval,&st[296],6);
     oneval[6]=0;
     value=atof(oneval)*100;
     stars[stars_counter].promodec=value;
     /* parallax */
     strncpy(oneval,&st[320],6);
     oneval[6]=0;
     if (oneval[0]==' ') oneval[0]='+';  /* prevent an error if possitive */
     value=atof(oneval);
     if (value>9.99) value=0;  /* on case of -9.999 */
     stars[stars_counter].parallax=value;
     /* radial velocity */
     strncpy(oneval,&st[330],4);
     oneval[4]=0;
     value=atof(oneval);
     stars[stars_counter].radialvelocity=value;
     /* magnitude */
     strncpy(oneval,&st[187],5);
     oneval[5]=0;
     value=atof(oneval);
     stars[stars_counter].magnitude=value;
     /* type */
     strncpy(oneval,&st[254],5);
     oneval[10]=0;
     strcpy(stars[stars_counter].type,oneval);
     /* get the I, R, B magnitudes and calculate the concam magnitude */
     stars[stars_counter].r_magnitude=GetMagnitude(stars[stars_counter].type,stars[stars_counter].magnitude,R_MAGNITUDE);
     stars[stars_counter].i_magnitude=GetMagnitude(stars[stars_counter].type,stars[stars_counter].magnitude,I_MAGNITUDE);
     stars[stars_counter].b_magnitude=GetMagnitude(stars[stars_counter].type,stars[stars_counter].magnitude,B_MAGNITUDE);
     stars[stars_counter].m_concam=GetMagnitude(stars[stars_counter].type,stars[stars_counter].magnitude,CONCAM_MAGNITUDE);
     /* initialize the azimuth and altitude */
     stars[stars_counter].azimuth=0;
     stars[stars_counter].altitude=0;
     /* continue with the loop */
     not_eof=fgets(st,500,CatFile);      /* read the next line */
     stars_counter++;
  }
  fclose(CatFile);
  /* set a sign for the end of the stars */
  strcpy(stars[stars_counter].starname,"");
  /* set the show stars */
  stars_counter=0;
  /* lyra */
  strcpy(showstars[stars_counter].starname,"12Del2Lyr");
  strcpy(showstars[stars_counter++].dispname,"Lyra");

  /* pegasus */
  strcpy(showstars[stars_counter].starname,"84Psi Peg");
  strcpy(showstars[stars_counter++].dispname,"Pegasus");
  /* cassipoia */
  strcpy(showstars[stars_counter].starname,"37Del Cas");
  strcpy(showstars[stars_counter++].dispname,"Cassiopeia");
  /* gruss */
  strcpy(showstars[stars_counter].starname,"Del2Gru");
  strcpy(showstars[stars_counter++].dispname,"Gruss");
  /* psa */
  strcpy(showstars[stars_counter].starname,"17Bet PsA");
  strcpy(showstars[stars_counter++].dispname,"Piscis Austrinus");
  /* capricorn */
  strcpy(showstars[stars_counter].starname,"34Zet Cap");
  strcpy(showstars[stars_counter++].dispname,"Capricorn");
  /* aqurios */
  strcpy(showstars[stars_counter].starname,"73Lam Aqr");
  strcpy(showstars[stars_counter++].dispname,"Aquarius");
  /* sagittarius */
  strcpy(showstars[stars_counter].starname,"34Sig Sgr");
  strcpy(showstars[stars_counter++].dispname,"Sagittarius");
  /* ophiucus */
  strcpy(showstars[stars_counter].starname,"60Bet Oph");
  strcpy(showstars[stars_counter++].dispname,"Ophiuchus");
  /* cygnum */
  strcpy(showstars[stars_counter].starname,"53Eps Cyg");
  strcpy(showstars[stars_counter++].dispname,"Cygnus");
  /* sagitta */
  strcpy(showstars[stars_counter].starname,"12Gam Sge");
  strcpy(showstars[stars_counter++].dispname,"Sagitta");
  /* aquilla */
  strcpy(showstars[stars_counter].starname,"55Eta Aquila");
  strcpy(showstars[stars_counter++].dispname,"Aquila");
  /* hercules */
  strcpy(showstars[stars_counter].starname,"67Pi  Her");
  strcpy(showstars[stars_counter++].dispname,"Hercules");
  /* draco */
  strcpy(showstars[stars_counter].starname,"32Xi  Dra");
  strcpy(showstars[stars_counter++].dispname,"Draco");
  /* umi */
  strcpy(showstars[stars_counter].starname,"16Zet UMi");
  strcpy(showstars[stars_counter++].dispname,"Ursa Minor");
  /* uma */
  strcpy(showstars[stars_counter].starname,"50Alp UMa");
  strcpy(showstars[stars_counter++].dispname,"Ursa Major");
  /* bootes */
  strcpy(showstars[stars_counter].starname,"49Del Boo");
  strcpy(showstars[stars_counter++].dispname,"Bootes");
  /* pisces */
  strcpy(showstars[stars_counter].starname,"110Omi Psc");
  strcpy(showstars[stars_counter++].dispname,"Piscis");
  /* cepheus */
  strcpy(showstars[stars_counter].starname,"32Iot Cep");
  strcpy(showstars[stars_counter++].dispname,"Cepheus");
  /* delphinius */
  strcpy(showstars[stars_counter].starname,"6Bet Del");
  strcpy(showstars[stars_counter++].dispname,"Delphinus");
  /* scorpion */
  strcpy(showstars[stars_counter].starname,"34Ups Sco");
  strcpy(showstars[stars_counter++].dispname,"Scorpio");
  /* crater */
  strcpy(showstars[stars_counter].starname,"Bet CrA");
  strcpy(showstars[stars_counter++].dispname,"Crab");
  /* triangulum */
  strcpy(showstars[stars_counter].starname,"9Gam Tri");
  strcpy(showstars[stars_counter++].dispname,"Triangulum");
  /* pereseus */
  strcpy(showstars[stars_counter].starname,"41Nu  Per");//39Del Per
  strcpy(showstars[stars_counter++].dispname,"Perseus");
  /* cameloparadalis */
  strcpy(showstars[stars_counter].starname,"10Bet Cam");
  strcpy(showstars[stars_counter++].dispname,"Camelopardalis");
  /* serpens */
  strcpy(showstars[stars_counter].starname,"24Alp Ser");
  strcpy(showstars[stars_counter++].dispname,"Serpens");
  /* auriga */
  strcpy(showstars[stars_counter].starname,"29Tau Aur");
  strcpy(showstars[stars_counter++].dispname,"Auriga");
  /* cettus */
  strcpy(showstars[stars_counter].starname,"68Omi Cet");
  strcpy(showstars[stars_counter++].dispname,"Cetus");
  /* andromeda */
  strcpy(showstars[stars_counter].starname,"37Mu  And");
  strcpy(showstars[stars_counter++].dispname,"Andromeda");
  /* phoenix */
  strcpy(showstars[stars_counter].starname,"Bet Phe");
  strcpy(showstars[stars_counter++].dispname,"Pheonix");
  /* fornax */
  strcpy(showstars[stars_counter].starname,"Bet For");
  strcpy(showstars[stars_counter++].dispname,"Fornax");
  /* eridanus */
  strcpy(showstars[stars_counter].starname,"26Pi  Eri");
  strcpy(showstars[stars_counter++].dispname,"Eridanus");
  /* orion */
  strcpy(showstars[stars_counter].starname,"30Psi2Ori");
  strcpy(showstars[stars_counter++].dispname,"Orion");
  /* taurus */
  strcpy(showstars[stars_counter].starname,"74Eps Tau");//78The2Tau
  strcpy(showstars[stars_counter++].dispname,"Taurus");
  /* gemini */
  strcpy(showstars[stars_counter].starname,"55Del Gem");
  strcpy(showstars[stars_counter++].dispname,"Gemini");
  /* canis minor */
  strcpy(showstars[stars_counter].starname,"10Alp CMi");
  strcpy(showstars[stars_counter++].dispname,"Canis Minor");
  /* monoceros */
  strcpy(showstars[stars_counter].starname,"22Del Mon");
  strcpy(showstars[stars_counter++].dispname,"Monoceros");
  /* canis major */
  strcpy(showstars[stars_counter].starname,"24Omi2CMa");
  strcpy(showstars[stars_counter++].dispname,"Canis Major");
  /* lynx */
  strcpy(showstars[stars_counter].starname,"31    Lyn");
  strcpy(showstars[stars_counter++].dispname,"Lynx");
  /* hydra */
  strcpy(showstars[stars_counter].starname,"22The Hya");
  strcpy(showstars[stars_counter++].dispname,"Hydra");
  /* antlia */
  strcpy(showstars[stars_counter].starname,"Alp Ant");
  strcpy(showstars[stars_counter++].dispname,"Antlia");
  /* crt */
  strcpy(showstars[stars_counter].starname,"15Gam Crt");
  strcpy(showstars[stars_counter++].dispname,"Crater");
  /* virgo */
  strcpy(showstars[stars_counter].starname,"79Zet Vir");
  strcpy(showstars[stars_counter++].dispname,"Virgo");
  /* como verices */
  strcpy(showstars[stars_counter].starname,"43Bet Com");
  strcpy(showstars[stars_counter++].dispname,"Coma Berenices");
  /* crv */
  strcpy(showstars[stars_counter].starname,"9Bet Crv");
  strcpy(showstars[stars_counter++].dispname,"Corvus");
  /* centaurious */
  strcpy(showstars[stars_counter].starname,"Nu  Cen");
  strcpy(showstars[stars_counter++].dispname,"Centaurus");
  /* vela */
  strcpy(showstars[stars_counter].starname,"Lam Vel");
  strcpy(showstars[stars_counter++].dispname,"VelA");
  /* puppis */
  strcpy(showstars[stars_counter].starname,"Zet Pup");
  strcpy(showstars[stars_counter++].dispname,"Puppis");
  /* leo */
  strcpy(showstars[stars_counter].starname,"60    Leo");
  strcpy(showstars[stars_counter++].dispname,"Leo");
  /* aries */
  strcpy(showstars[stars_counter].starname,"32Nu  Ari");
  strcpy(showstars[stars_counter++].dispname,"Aries");
  /* lepus */
  strcpy(showstars[stars_counter].starname,"11Alp Lep");
  strcpy(showstars[stars_counter++].dispname,"Lepus");
  
  /****** stars *******/
 
  /* vega */
  strcpy(showstars[stars_counter].starname,"3Alp Lyr");
  strcpy(showstars[stars_counter++].dispname,"vega");
  /* altair */
  strcpy(showstars[stars_counter].starname,"53Alp Aql");
  strcpy(showstars[stars_counter++].dispname,"altair");
  /* deneb */
  strcpy(showstars[stars_counter].starname,"50Alp Cyg");
  strcpy(showstars[stars_counter++].dispname,"deneb");
  /* polaris */
  strcpy(showstars[stars_counter].starname,"1Alp UMi");
  strcpy(showstars[stars_counter++].dispname,"polaris");
  /* antares */
  strcpy(showstars[stars_counter].starname,"21Alp Sco");
  strcpy(showstars[stars_counter++].dispname,"antares");
  /* fomalhaut */
  strcpy(showstars[stars_counter].starname,"24Alp PsA");
  strcpy(showstars[stars_counter++].dispname,"fomalhaut");
  /* shaula */
  strcpy(showstars[stars_counter].starname,"35Lam Sco");
  strcpy(showstars[stars_counter++].dispname,"shaula");
  /* arcturus */
  strcpy(showstars[stars_counter].starname,"16Alp Boo");
  strcpy(showstars[stars_counter++].dispname,"arcturus");
  /* mirach */
  strcpy(showstars[stars_counter].starname,"43Bet And");
  strcpy(showstars[stars_counter++].dispname,"mirach");
  /* mifrak */
  strcpy(showstars[stars_counter].starname,"33Alp Per");
  strcpy(showstars[stars_counter++].dispname,"mifrak");
  /* capella */
  strcpy(showstars[stars_counter].starname,"13Alp Aur");
  strcpy(showstars[stars_counter++].dispname,"capella");
  /* elnath */
  strcpy(showstars[stars_counter].starname,"112Bet Tau");
  strcpy(showstars[stars_counter++].dispname,"elnath");
  /* aldebaran */
  strcpy(showstars[stars_counter].starname,"87Alp Tau");
  strcpy(showstars[stars_counter++].dispname,"aldebaran");
  /* betelgeuse */
  strcpy(showstars[stars_counter].starname,"58Alp Ori");
  strcpy(showstars[stars_counter++].dispname,"betelgeuse");
  /* rigel */
  strcpy(showstars[stars_counter].starname,"19Bet Ori");
  strcpy(showstars[stars_counter++].dispname,"rigel");
  /* sirius */
  strcpy(showstars[stars_counter].starname,"9Alp CMa");
  strcpy(showstars[stars_counter++].dispname,"sirius");
  /* adhara */
  strcpy(showstars[stars_counter].starname,"21Eps CMa");
  strcpy(showstars[stars_counter++].dispname,"adhara");
  /* pollux */
  strcpy(showstars[stars_counter].starname,"78Bet Gem");
  strcpy(showstars[stars_counter++].dispname,"pollux");
  /* castor */
  strcpy(showstars[stars_counter].starname,"66Alp Gem");
  strcpy(showstars[stars_counter++].dispname,"castor");
  /* regulus */
  strcpy(showstars[stars_counter].starname,"32Alp Leo");
  strcpy(showstars[stars_counter++].dispname,"regulus");
  /* gam2vel */
  strcpy(showstars[stars_counter].starname,"Gam2Vel");
  strcpy(showstars[stars_counter++].dispname,"gam2vel");
  /* canopus */
  strcpy(showstars[stars_counter].starname,"Alp Car");
  strcpy(showstars[stars_counter++].dispname,"canopus");
  /* spica */
  strcpy(showstars[stars_counter].starname,"67Alp Vir");
  strcpy(showstars[stars_counter++].dispname,"spica");
  /* alpha centariaus */
  strcpy(showstars[stars_counter].starname,"Alp1Cen");
  strcpy(showstars[stars_counter++].dispname,"alp centau");
  /* miaplacidus */
  strcpy(showstars[stars_counter].starname,"Bet Car");
  strcpy(showstars[stars_counter++].dispname,"miaplacidus");
  /* achernar */
  strcpy(showstars[stars_counter].starname,"Alp Eri");
  strcpy(showstars[stars_counter++].dispname,"achernar");

  
  /***** sky objects *****/
  /* load sky objects from an external file */
  /* the file structure is:                 */
  /* <ra> <dec> <label>                     */

  /* initialize the sky objects. an ra=-1 is means that the entry is  empty */
  stars_counter=0;
  while (stars_counter<SKY_OBJECTS_NUM)   /* initialize the sky objects */
  {  sky_objects[stars_counter].ra=-1;
     sky_objects[stars_counter].dec=-1;
     sky_objects[stars_counter].alt=-1;
     sky_objects[stars_counter].az=-1;
     sky_objects[stars_counter].azalt=0;
     sky_objects[stars_counter].name[0]='\0';
     stars_counter++;
  }
  stars_counter=0;
  if (sky_objects_file_name)
    if (sky_objects_file_name[0]!='\0')
    {  if (!(SkyObjectsFile=fopen(sky_objects_file_name,"r")))
         printf("Can not open file '%s'\n",sky_objects_file_name);
       else
       {
         not_eof=fgets(st,500,SkyObjectsFile);  /* read one line */
         while (not_eof)
         { if (strlen(st)>4)
           {  p=strtok(st," \t\n");
	      if (p && (strcmp(p,"azalt")==0))
              {  sky_objects[stars_counter].azalt=1;
                 p=strtok(NULL," \t\n");
              }
              if (p) value=atof(p);
              sky_objects[stars_counter].ra=value;  /* get the right ascention */
              sky_objects[stars_counter].az=value;
              p=strtok(NULL," \t\n");
              if (p) value=atof(p);
              sky_objects[stars_counter].dec=value; /* get the declination */
              sky_objects[stars_counter].alt=value;
              p=strtok(NULL," \t\n");
              if (p) strcpy(sky_objects[stars_counter].name,p); /* get the label of the sky object */
              stars_counter++;
           }
           not_eof=fgets(st,500,SkyObjectsFile); /* read one line */
         } 
         fclose(SkyObjectsFile);
       }
    }
  return(1);
}
/***********************************************************************/
/* this table holds the information needed for calculating the magnitude 
   R,I,B components needed for calculating the h_concam magnitude.
   The first column is the table (there are 3 different tables in this structure.
   The second column is the type (I, III, IV).
   The third column is the star's class (B2, B5, A0, etc...)
*/ 
double mag_table[3][5][23]=
{
  {   /* the V - R table */
    {-0.15,-0.15,0,-0.05,0.02,0.02,0.03,0.07,0.12,0.21,0.26,0.35,0.45,0.51,0.58,0.67,0.69,0.76,0.85,1.2,1.23,1.34,2.18},      /* I */
    {-0.15,-0.15,0,-0.05,0.02,0.02,0.03,0.07,0.12,0.21,0.26,0.35,0.45,0.51,0.58,0.69,0.70,0.77,0.84,1.2,1.23,1.34,2.18},      /* II */
    {-0.15,-0.15,0,-0.05,0.02,0.02,0.03,0.07,0.12,0.21,0.26,0.35,0.45,0.51,0.58,0.69,0.70,0.77,0.84,1.2,1.23,1.34,2.18},      /* III */
    {-0.15,-0.15,-0.13,-0.10,-0.06,-0.02,0.02,0.08,0.16,0.30,0.35,0.40,0.47,0.50,0.53,0.54,0.58,0.64,0.74,0.99,1.28,1.5,1.8}, /* IV */
    {-0.15,-0.15,-0.13,-0.10,-0.06,-0.02,0.02,0.08,0.16,0.30,0.35,0.40,0.47,0.50,0.53,0.54,0.58,0.64,0.74,0.99,1.28,1.5,1.8}  /* V */
  },
  {   /* the R - I table */
    {-0.32,-0.32,-0.15,-0.15,-0.07,0.00,0.05,0.07,0.13,0.20,0.21,0.23,0.27,0.33,0.40,0.44,0.46,0.48,0.55,0.90,0.94,1.10,1.96},    /* I   */
    {-0.32,-0.32,-0.29,-0.22,-0.16,-0.10,-0.02,0.01,0.06,0.17,0.20,0.24,0.29,0.31,0.48,0.48,0.53,0.58,0.90,0.63,0.94,1.10,1.96},  /* II  */
    {-0.32,-0.32,-0.29,-0.22,-0.16,-0.10,-0.02,0.01,0.06,0.17,0.20,0.24,0.29,0.31,0.48,0.48,0.53,0.58,0.90,0.63,0.94,1.10,1.96},  /* III */
    {-0.32,-0.32,-0.29,-0.22,-0.16,-0.10,-0.02,0.01,0.06,0.17,0.20,0.24,0.29,0.31,0.33,0.35,0.38,0.42,0.48,0.63,0.91,1.19,1.67},  /* IV  */
    {-0.32,-0.32,-0.29,-0.22,-0.16,-0.10,-0.02,0.01,0.06,0.17,0.20,0.24,0.29,0.31,0.33,0.35,0.38,0.42,0.48,0.63,0.91,1.19,1.67}   /* V   */
  },
  {   /* the B - V table */
    {-0.33,-0.27,-0.30,-0.17,-0.10,-0.03,-0.01,0.03,0.09,0.17,0.23,0.32,0.56,0.76,0.87,1.02,1.14,1.25,1.36,1.60,1.67,1.71,1.80},  /* I   */
    {-0.33,-0.31,-0.30,-0.24,-0.17,-0.11,-0.02,0.05,0.15,0.30,0.35,0.44,0.52,0.58,0.63,0.86,0.94,1.00,1.16,1.50,1.56,1.60,1.63},  /* II  */
    {-0.33,-0.31,-0.30,-0.24,-0.17,-0.11,-0.02,0.05,0.15,0.30,0.35,0.44,0.52,0.58,0.63,0.86,0.94,1.00,1.16,1.50,1.56,1.60,1.63},  /* III */
    {-0.33,-0.31,-0.30,-0.24,-0.17,-0.11,-0.02,0.05,0.15,0.30,0.35,0.44,0.52,0.58,0.63,0.68,0.74,0.81,0.91,1.15,1.40,1.49,1.64},  /* IV  */
    {-0.33,-0.31,-0.30,-0.24,-0.17,-0.11,-0.02,0.05,0.15,0.30,0.35,0.44,0.52,0.58,0.63,0.68,0.74,0.81,0.91,1.15,1.40,1.49,1.64}   /* V   */
  }
};
/* ***************************************************************************
                   ********* GetMagnitude **********
   find the I or R magnitude for a star's type from the visual magnitude
   type           = the type of the star (e.g. "KIII")
   v_magnitude    = the visual magnitude of the star (taken from the catalog)
   magnitude_type = the desired type of magnitude (I_MAGNITUDE, R_MAGNITUDE, 
                    B_MAGNITUDE, CONCAM_MAGNITUDE). The magnitude type constants
                    are specified in "calstars.h" header file.
*/
double GetMagnitude(char *type,double v_magnitude,int magnitude_type)
{  int spectral_type_num,star_class_num;
   double V_R,R_I,B_V,mR,mI,mB,mConcam;
   /* find the star's class */
   star_class_num=4;   /* default class is "main" */
   if (strstr(type,"I"))   star_class_num=0;
   if (strstr(type,"II"))  star_class_num=1;
   if (strstr(type,"III")) star_class_num=2;
   if (strstr(type,"V"))   star_class_num=4;
   if (strstr(type,"IV"))  star_class_num=3;
   /* find the star's type */
   spectral_type_num=ST_K5; /* default to a red star (in case type unkown) */
   if (strstr(type,"O")) spectral_type_num=ST_O5;
   if (strstr(type,"B")) spectral_type_num=ST_B0;
   if (strstr(type,"A")) spectral_type_num=ST_A0;
   if (strstr(type,"F")) spectral_type_num=ST_F0;
   if (strstr(type,"G")) spectral_type_num=ST_G0;
   if (strstr(type,"K")) spectral_type_num=ST_K0;
   if (strstr(type,"M")) spectral_type_num=ST_M2;

   if (strstr(type,"O5")) spectral_type_num=ST_O5;
   if (strstr(type,"O9")) spectral_type_num=ST_O9;
   if (strstr(type,"B0")) spectral_type_num=ST_B0;
   if (strstr(type,"B2")) spectral_type_num=ST_B2;
   if (strstr(type,"B5")) spectral_type_num=ST_B5;
   if (strstr(type,"B8")) spectral_type_num=ST_B8;
   if (strstr(type,"A0")) spectral_type_num=ST_A0;
   if (strstr(type,"A2")) spectral_type_num=ST_A2;
   if (strstr(type,"A5")) spectral_type_num=ST_A5;
   if (strstr(type,"F0")) spectral_type_num=ST_F0;
   if (strstr(type,"F2")) spectral_type_num=ST_F2;
   if (strstr(type,"F5")) spectral_type_num=ST_F5;
   if (strstr(type,"F8")) spectral_type_num=ST_F8;
   if (strstr(type,"G0")) spectral_type_num=ST_G0;
   if (strstr(type,"G2")) spectral_type_num=ST_G2;
   if (strstr(type,"G5")) spectral_type_num=ST_G5;
   if (strstr(type,"G8")) spectral_type_num=ST_G8;
   if (strstr(type,"K0")) spectral_type_num=ST_K0;
   if (strstr(type,"K2")) spectral_type_num=ST_K2;
   if (strstr(type,"K5")) spectral_type_num=ST_K5;
   if (strstr(type,"K6")) spectral_type_num=ST_K5;
   if (strstr(type,"K7")) spectral_type_num=ST_K5;
   if (strstr(type,"K8")) spectral_type_num=ST_K5;
   if (strstr(type,"M0")) spectral_type_num=ST_M0;
   if (strstr(type,"M2") || (strstr(type,"M1-2"))) spectral_type_num=ST_M2;
   if (strstr(type,"M5")) spectral_type_num=ST_M5;
   if (strstr(type,"M6")) spectral_type_num=ST_M5;
   if (strstr(type,"M7")) spectral_type_num=ST_M5;
   if (strstr(type,"M8")) spectral_type_num=ST_M5;
   /* calculate the magnitude */
   V_R=mag_table[R_MAGNITUDE][star_class_num][spectral_type_num];
   mR=v_magnitude-V_R;
   if (magnitude_type==R_MAGNITUDE) return(mR);
   R_I=mag_table[I_MAGNITUDE][star_class_num][spectral_type_num];
   mI=mR-R_I;
   if (magnitude_type==I_MAGNITUDE) return(mI);
   B_V=mag_table[B_MAGNITUDE][star_class_num][spectral_type_num];
   mB=B_V+v_magnitude;
   if (magnitude_type==B_MAGNITUDE) return(mB);
   /* calculate the concam magnitude */
   //   mConcam=v_magnitude-2.5*log10(0.7*pow(10,-B_V/2.5)+0.5+1.3*pow(10,V_R/2.5));
   mConcam=v_magnitude-2.5*log10(1.0*pow(10,-B_V/2.5)+1.0*pow(10,V_R/2.5)+0.5*pow(10,(V_R+R_I)/2.5));
   if (mConcam<-5) mConcam=99;
   return(mConcam);
}
/*************************************************************************/
/*                 ************ starat ***************
   find the star which is closest to the location (altitute,azimuth) 
   inputs - x - X coordinate
            y - Y coordinate
            location - the location of the observer where the image was taken
            tjd - julian date when the image was taken
   outputs - the catalog entri of the star that was found to be the closest
             to the x,y coordinates
   The function goes over all the entries in the stars list and calculates
   the location (x,y) of each one. The star that is closest (Euclidean distance)
   to the x,y coordinates is the returned value.
*/
cat_entry *starat(int x,int y,site_info *location,double tjd)
{  long res,star_x,star_y,star_index=0;
   double ra,dec,zd,az,rar,decr,dist,min_dist=100000000;
   cat_entry *min_star;
   while (strcmp(stars[star_index].starname,"")!=0)
   {
     res=topo_star(tjd,&earth,DELTA_T,&stars[star_index],location,&ra,&dec);
     if (res>0) return(NULL);
     equ2hor(tjd,DELTA_T,0,0,location,ra,dec,0,&zd,&az,&rar,&decr);
     zd=90-zd;
     /* calculate the angle and distance using the fuzzy models */
     res=altaz2xy(zd,az,&star_x,&star_y);
     if (res>0)
     {  dist=(x-star_x)*(x-star_x)+(y-star_y)*(y-star_y);
        if (dist<min_dist)
        {  min_dist=dist;
           min_star=&stars[star_index];
        }
     }
     star_index++;
   }
   return(min_star);
}

/* ************************************************************************
        ******************* FindUnknownStars *********************
   This function associates each star point that appears in the image with
   a catalog entry.
   input - star_points - a list of all stars appears in the image.
   When the function is done, each FindUnknownStars(double tjd,site_info *location,star_point *star_points,char *baseline_image_name)star in the image will be associated with a catalog
   entry (or not if the star is "unexpected")  
   before running this function, all "star" field in "star_point" structure
   should be NULL.
   The last star_point should have negative values in x and y fields.
*/
void FindUnknownStars(double tjd,site_info *location,star_point *star_points,char *baseline_image_name)
{  ImageMatrix* baseline_image;
   int star_point_index,baseline_peak_index,planet_index,baseline_peak;
   long res,x,y,stars_num;
   double xx[6],ra,dec,zd,az,rar,decr,dist,min_dist,max_dist;
   char serr[200];
   star_point *baseline_peaks;
   /* load the canonical frame and its peaks */
   baseline_image=new ImageMatrix;
   if (!baseline_image->LoadFits(baseline_image_name)) goto exit_proc;
   baseline_peaks=new star_point[MAX_BASELINE_PEAKS];
   /* calulate the maximum distance for a star from the center of the image */
   max_dist=AltModel270.CalcRules(MAX_DIST_FOR_AUTO_DETECT);
   baseline_image->GetStarsPoints(baseline_peaks,NULL,max_dist);
   /* check the star points to find transients */
   star_point_index=0;
   while (star_points[star_point_index].x>0)
   {  /* if the star is too far from the center - ignore it */
     if (pow(star_points[star_point_index].x-MID_X,2)+pow(star_points[star_point_index].y-MID_Y,2)>max_dist*max_dist)
     {  star_points[star_point_index].star=(cat_entry *)1;
        goto end_loop;
     }
     /* search the bright planets to check if the point is near one of them */
     swe_set_topo(location->latitude,location->longitude,location->height);
     for (planet_index=1;planet_index<=PLANETS_NUM-4;planet_index++) /*calculate all planets but the sun and the moon */
     {  res=swe_calc_ut(tjd,planet_index, SEFLG_TOPOCTR | SEFLG_SWIEPH | SEFLG_SPEED | SEFLG_EQUATORIAL ,xx, serr);
        equ2hor(tjd,DELTA_T,0,0,location,xx[0]/15,xx[1],0,&zd,&az,&rar,&decr);
        res=altaz2xy(90-zd,az,&x,&y);  /* calculate the x,y coordinates */
        if (res==1)  /* only if the star is not beyond the horizon */
        {  dist=sqrt(pow(star_points[star_point_index].x-x,2)+pow(star_points[star_point_index].y-y,2));
	   if (dist<12)
	   {  star_points[star_point_index].star=&stars[planet_index];
	      goto end_loop;  /* the star is too close to a bright planet so it is probably not a "real" object */
	   }
        }
     }

     /* check if the star point is a satelite */

     /* search for the closest star */
     min_dist=1000000.0;
     baseline_peak_index=0;
     while (baseline_peaks[baseline_peak_index].x>-1)
     {  dist=pow(baseline_peaks[baseline_peak_index].x-star_points[star_point_index].x,2)+
	pow(baseline_peaks[baseline_peak_index].y-star_points[star_point_index].y,2);
        if (dist<min_dist)
        {  min_dist=dist;
	   baseline_peak=baseline_peak_index;
        }
        baseline_peak_index++;
     }
     if (min_dist<3)
     {  star_points[star_point_index].star=(cat_entry *)1; /* this star point was found */
        if ((star_points[star_point_index].color-star_points[star_point_index].background)-
           (baseline_peaks[baseline_peak].color-baseline_peaks[baseline_peak].background)>1*baseline_image->AvgColor)
         star_points[star_point_index].star=(cat_entry *)-1; /* this star is very bright */
     }

     end_loop:
     star_point_index++;
   }
 exit_proc:
   /* free the memory */
   baseline_image->FreeImage();
   delete baseline_image;
   delete baseline_peaks;
   baseline_peaks=NULL;
}
/* ***********************************************************************
            *************** FindUnknownStars2 ***************
   same as "FindUnknownStars" but search the closest star to each point 
*/
void FindUnknownStars2(star_point *star_points)
{  int star_point_index,min_star,min_checked_star,a,star_index=0;
   long res,x,y,stars_num;
   double xx[6],ra,dec,zd,az,rar,decr,dist,min_dist,min_checked_dist,max_magnitude,max_dist;
   char serr[200];
   star_point temp_star_point;

   /* count the stars */
   a=0;
   stars_num=0;
   while (star_points[stars_num++].x>=0)
     if (star_points[stars_num].star) a++;
   if ((double)a/(double)stars_num>0.9) return; /* "FindUnkownStars2" has already ran */ 

   /* initialize star ascociation */
   for (star_point_index=0;star_point_index<stars_num;star_point_index++) star_points[star_point_index].star=NULL;

   /* calculate the maximum distance from the center for an "unexpected" star to be notified */
   max_dist=AltModel0.CalcRules(MAX_DIST_FOR_AUTO_DETECT);

   /* initialize the stars "checked" field and calculate the star's positions */
   star_index=0;
   while(stars[star_index].starname[0])
   {  stars[star_index].checked=0;
      topo_star(current_date,&earth,DELTA_T,&stars[star_index],&current_location,&ra,&dec);
      equ2hor(current_date,DELTA_T,0,0,&current_location,ra,dec,0,&zd,&az,&rar,&decr);
      res=altaz2xy(90-zd,az,&x,&y);  /* calculate the x,y coordinates */
      if (res!=1) x=-1;              /* so it will know that it is not within the horizon */
      stars[star_index].x=x;
      stars[star_index].y=y;
      stars[star_index].azimuth=az;
      stars[star_index].altitude=90-zd;
      star_index++;
   }

   /* go over the stars */
   star_point_index=0;
   while (star_points[star_point_index].x>0)
   {  /* if the star is too far from the center of the sky - ignore it */
      if (pow(star_points[star_point_index].x-MID_X,2)+pow(star_points[star_point_index].y-MID_Y,2)>max_dist*max_dist)
      {  star_points[star_point_index].star=(cat_entry *)1; /* so it won't be null */
         goto end_loop;
      }
      /* ignore dim star for auto detection */
      if (star_points[star_point_index].color-star_points[star_point_index].background<AUTO_DETECT_SIGMA*sqrt(star_points[star_point_index].background))
      {  star_points[star_point_index].star=(cat_entry *)1; /* so it won't be null */
      	 goto end_loop;
      }
      /* search the bright planets to check if the point is near one of them */
      swe_set_topo(current_location.latitude,current_location.longitude,current_location.height);
      for (star_index=1;star_index<=PLANETS_NUM-4;star_index++)  /* calculate all planets but the sun and the moon */
      {  res=swe_calc_ut(current_date,star_index, SEFLG_TOPOCTR | SEFLG_SWIEPH | SEFLG_SPEED | SEFLG_EQUATORIAL ,xx, serr);
         equ2hor(current_date,DELTA_T,0,0,&current_location,xx[0]/15,xx[1],0,&zd,&az,&rar,&decr);
         res=altaz2xy(90-zd,az,&x,&y);  /* calculate the x,y coordinates */
         if (res==1)  /* only if the star is not beyond the horizon */
         {  dist=sqrt(pow(star_points[star_point_index].x-x,2)+pow(star_points[star_point_index].y-y,2));
            if (dist<15)
	    {  star_points[star_point_index].star=(cat_entry *)1; /* so this star_point is ascociated with something */
               goto end_loop;
            }
         }
      }
      /* search for the closest star */
      star_index=0;
      min_dist=100000;
      min_checked_dist=10000;
      max_magnitude=MagnitudeModel.CalcRules(STARS_NUM_CO*stars_num,sqrt(pow(star_points[star_point_index].x-MID_X,2)+pow(star_points[star_point_index].y-MID_Y,2)));
//  max_magnitue=MagnitudeModel.CalcRules(star_points[star_point_index].color-star_points[star_point_index].background,pow(star_points[star_point_index].x-MID_X,2)+pow(star_points[star_point_index].y-MID_Y,2)));    
#ifndef FITS
      if (star_points[star_point_index].bright_star==1) max_magnitude=max_magnitude-1.9; /* bright star magnitude */
#endif
      while (stars[star_index].starname[0])
      {  x=stars[star_index].x;
         y=stars[star_index].y;
         /* check the magnitude according to the number of stars */
         if (x>=0 && stars[star_index].m_concam<=max_magnitude)
         {  dist=sqrt(pow(star_points[star_point_index].x-x,2)+pow(star_points[star_point_index].y-y,2));
            if (dist<min_dist && stars[star_index].checked==0)
            {  min_dist=dist;
               min_star=star_index;
            }
            /* find the minimum distance for a star that was checked */
            if (dist<min_checked_dist && stars[star_index].checked==1)
            {  min_checked_dist=dist;
               min_checked_star=star_index;
            }
         }
         star_index++;
      }
      /* find the closest checked star */
      if (min_checked_dist<min_dist && min_dist>MAX_DIST_DIFS)
      {  for (a=0;a<star_point_index;a++)
           if (star_points[a].star==&stars[min_checked_star]) break;
         if (a<star_point_index) /* the star was found */
           if (min_checked_dist<star_points[a].dist)
	   {  temp_star_point=star_points[a];
              star_points[star_point_index].star=&stars[min_checked_star];
              star_points[star_point_index].dist=min_checked_dist;
              star_points[a]=star_points[star_point_index];
              temp_star_point.star=NULL;
              star_points[star_point_index]=temp_star_point;
              continue;  /* do the point again and try to find its second closest star */
           }
      }
#ifdef FITS
      if (min_dist<MAX_DIST_DIFS)
#else
      if (min_dist<6.1 || (min_dist<7 && star_points[star_point_index].bright_star==1))
#endif
      {
        {  star_points[star_point_index].star=&stars[min_star];
           star_points[star_point_index].dist=(long)min_dist;
           stars[min_star].checked=1;
        }
      }
end_loop:
      star_point_index++;
   }
}


/***********************************************************************/
/*               *************    flf_init    **************           */
/* purpose: build the models from the specified files 
   input: data_files_path - the base path of all data files:
                            such as AltData0, AltData90, AltData180, AltData270, AzData
          ext_file - the name of an external file that contains RA,DEC information.
                     This parameter may be NULL.
          error    - a pointer to a null terminated string that can contain an error message
    output: 1 if succeeded, 0 if failed
*/

int flf_init(char *data_files_path,char *ext_file,char *error)
{  char filename[500];
   int res;
   /* get the magnitude data file */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"MagData.txt");
   res=MagnitudeModel.CreateMembershipFunctions(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not create magnitude model from '%s'",filename);
      return(0);
   }

   /* get the cosmic rays data file */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"gamarays.txt");
   res=GamaRaysModel.LoadMembershipFunctions(filename);
   if (res) res=GamaRaysModel.LoadRules(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not open file '%s'",filename);
      return(0);
   }   

   /* get the altitude data file */
#ifdef simple_dist
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AltData");
   res=AltitudeModel.CreateMembershipFunctions(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not create altitude model from '%s'",filename);
      return(0);
   }
#else
   /* create the 4 altitude models */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AltData0");
   res=AltModel0.CreateMembershipFunctions(filename);
   if (res==0)   
   {  if (error) sprintf(error,"Can not create altitude model from '%s'",filename);
      return(0);
   }
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AltData90");
   res=AltModel90.CreateMembershipFunctions(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not create altitude model from '%s'", filename);
      return(0);
   }
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AltData180");
   res=AltModel180.CreateMembershipFunctions(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not create altitude model from '%s'",filename);
      return(0);
   }
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AltData270");
   res=AltModel270.CreateMembershipFunctions(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not create altitude model from '%s'",filename);
      return(0);
   }
#endif
   /* get the azimuth data file */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AzData");
   res=AzimuthModel.CreateMembershipFunctions(filename);
   if (res==0)
   {  if (error) sprintf(error,"Can not create azimuth model from '%s'",filename);
      return(0);
   }
   /* get the distance data file */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"DistData.txt");
 /*  res=DistModel.CreateMembershipFunctions(filename);*/
   if (res==0)
   {  if (error) sprintf(error,"Can not create distance model from '%s'",filename);
      return(0);
   }
   /* get the angel data file */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   strcat(filename,"AngData.txt");
 /*  res=AngModel.CreateMembershipFunctions(filename); */
   if (res==0)
   {  if (error) sprintf(error,"Can not create angel model from '%s'",filename);
      return(0);
   }
   /* load the stars */
   filename[0]='\0';
   if (data_files_path) strcpy(filename,data_files_path);
   //   strcat(filename,"newcat5_6.txt");
   strcat(filename,"newcat4_8.txt");
   res=CreateStars(filename,ext_file);
   if (res==0)
   {  if (error) sprintf(error,"Can not load stars catalog '%s'",filename);
      return(0);
   }
   /* set earth */
   earth.type=0;
   earth.number=3;  /* earth */
   strcpy(earth.name,"earth");

   return(1);
}
/************************************************************************/
/* free all allocated memory */
int flf_cleanup()
{
  return(1);
}
/***********************************************************************
         ************** flf_set_date_location ***************
 set the julian date and the location 
*/
int flf_set_date_location(double tjd,double latitude,double longtitude,double height,double temprature,double pressure)
{  current_date=tjd;
   current_location.latitude=latitude;
   current_location.longitude=longtitude;
   current_location.height=height;
   current_location.temperature=temprature;
   current_location.pressure=pressure;
   return(1);
}
/************************************************************************/
/* initialize the index before start calculating the stars */
int flf_prepare_calc()
{
  star_index=0;
  search_planets=0;
  search_objects=0;
  return(1);
}

/* **********************************************************************
          ******************* flf_get_star *********************
   returns the next star. This function is iterative, so each call to the function
   returns the next star.
   flf_prepare_calc must be called before calling this function for the first
   time.
   inputs - all input are pointer that should hold some value after the
   function is done. star_name - the catalog name of the star, X and Y should 
   unwrap - used when the image is unwrapped to a panormaic view
   hold the star's image coordinates. 
*/
int flf_get_star(char *star_name,long *X,long *Y,long *star_type)
{  long x,y,res,show_star_index;
   double ra,dec,zd,az,rar,decr,dist,ang,dayhour,xx[6];
   char serr[200];
   while (1)
   {  if (search_planets==0 && search_objects==0)
      {  if (strcmp(stars[star_index].starname,"")==0)
         {  search_planets=1;
	    star_index=1;
         }
         else
         {  for (show_star_index=0;show_star_index<SHOW_STARS_NUM;show_star_index++)
              if (strcasecmp(stars[star_index].starname,showstars[show_star_index].starname)==0)
              {  topo_star(current_date,&earth,DELTA_T,&stars[star_index],&current_location,&ra,&dec);
                 equ2hor(current_date,DELTA_T,0,0,&current_location,ra,dec,0,&zd,&az,&rar,&decr);
                 res=altaz2xy(90-zd,az,&x,&y);
                 if (res==1)  /* only if the star is not beyond the horizon */
                 {  if (x>0 && y>0)
                    {  *X=x;
                       *Y=y;
                       if (star_name) strcpy(star_name,showstars[show_star_index].dispname);
                       if (islower(showstars[show_star_index].dispname[0])) *star_type=STAR_TYPE_BRIGHTSTAR;
                       else *star_type=STAR_TYPE_CONSTELLATION;
                       star_index++;
                       return(1);
                    }
               }
            }
            star_index++;
         }
      }
      /* show the planets */
      if (search_planets==1 && search_objects==0)
      {  if (star_index>PLANETS_NUM-4) 
         {  search_objects=1;
            star_index=0;
         }
         else
         {  swe_set_topo(current_location.latitude,current_location.longitude,current_location.height);
            res=swe_calc_ut(current_date,star_index,SEFLG_TOPOCTR | SEFLG_SWIEPH | SEFLG_SPEED | SEFLG_EQUATORIAL,xx,serr);
            equ2hor(current_date,DELTA_T,0,0,&current_location,xx[0]/15,xx[1],0,&zd,&az,&rar,&decr);
            res=altaz2xy(90-zd,az,&x,&y);  /* calculate the x,y coordinates */
            if (res==1)  /* only if the star is not beyond the horizon */
            {  if (x>0 && y>0)
               {  *X=x;
                  *Y=y;
                  if (star_name) strcpy(star_name,planets[star_index].name);
                  *star_type=STAR_TYPE_PLANET;
                  star_index++;
                  return(1);
               }
            }
            star_index++;
         }  
      }
      /* show the objects */
      if (search_objects==1)
      {  if (sky_objects[star_index].ra>-1)
	 {  if (sky_objects[star_index].azalt==0)
            {  ra=sky_objects[star_index].ra;
               dec=sky_objects[star_index].dec;
               equ2hor(current_date,DELTA_T,0,0,&current_location,ra,dec,0,&zd,&az,&rar,&decr);
            }
            else
	    {  az=sky_objects[star_index].az;
	       zd=90-sky_objects[star_index].alt;
	    }
            res=altaz2xy(90-zd,az,&x,&y);
            if (res==1) /* only if the sky object is not beyond the horizon */
            {  *X=x;
               *Y=y;
               if (star_name) strcpy(star_name,sky_objects[star_index].name);
               *star_type=STAR_TYPE_SKY_OBJECT;
               star_index++;
               return(1);
            }
            star_index++;
         }
         else return(0);
      }
   }
}

/****************************************************************************/
/* ************************** flf_write_file ****************************** */
/* purpose: write the photometry data to a text file 
   comments: the output file name is the same file name is the input image 
             (input_image variable) but has a ".txt" extention.
*/
void flf_write_file(star_point *star_points,char *input_image,long width, long height, double exposure_time, short write_stars_files)
{  FILE *text_file;
   char filename[80],s_date[60],*s_time;
   cat_entry *star;
   star_point point;
   long star_point_index,C5c_Bc;
   double tjd;
   strcpy(filename,input_image);
   if (strrchr(filename,'.')) *strrchr(filename,'.')='\0';
   strcat(filename,".html");
   if (!(text_file=fopen(filename,"w"))) 
   {  printf("Can not open target file '%s'\n",filename);
      return;
   }
   fprintf(text_file,"<HTML>\n<HEAD>\n<TITLE>%s</TITLE></HEAD>\n<BODY>\n",input_image);
   fprintf(text_file,"// WOLF %s  &nbsp&nbsp&nbsp Preliminary analyses files compliments to the Night Sky Live project<BR>\n",WOLF_VERSION);
   fprintf(text_file,"//<A HREF=\"../../ph_help.html\">The photometry file columns</A>\n");
   tjd=GetFileDate(input_image);
   GetDate(tjd,s_date);
   fprintf(text_file,"// %s &nbsp&nbsp&nbsp JD:%.5f &nbsp&nbsp&nbsp exposure:%.2f<BR>\n",s_date,tjd,exposure_time);  /* write the date and julian date */
   fprintf(text_file,"// file: %s (%dX%d) <BR>\n//<BR>\n",input_image,width,height);
   fprintf(text_file,"//<TABLE border=1>\n");
   fprintf(text_file,"//<TR><TD>%5s</TD><TD>%9s</TD><TD>%9s</TD><TD>%3s</TD><TD>%4s</TD><TD>%4s</TD><TD>%5s</TD><TD>%5s</TD><TD>%5s</TD><TD>%6s</TD><TD>%5s</TD><TD>%6s</TD></TR>\n","HD","name","C5","B","x","y","az","alt","type","V-mag","C-mag","C5c-Bc");
   FindUnknownStars2(star_points);   /* call this function for accosiating the star_points with the catalog entries */
   /* get the universal date and time */
   strtok(s_date," U");
   s_time=strtok(NULL," U");
   star_point_index=0;
   while (star_points[star_point_index].x>=0)
   {  if (star_points[star_point_index].star!=NULL)
      { star=star_points[star_point_index].star;
        if (long(star)>2)  /* make sure this star point is not just a sign to ignore some star point */
	{  point=star_points[star_point_index];
	   if (point.cloud_opacity>0) C5c_Bc=(int)((point.color-point.background)/point.cloud_opacity);
           else C5c_Bc=0;
	   fprintf(text_file,"<STAR>\n");
	   if (star->magnitude<3.0) fprintf(text_file,"<TR><TD><A HREF=\"HD%d.html\">HD<HD>%d</HD></A></TD>",star->starnumber,star->starnumber);
           else fprintf(text_file,"<TR><TD><HD>HD%d</HD></TD>",star->starnumber);
	   fprintf(text_file,"<TD><NAME>%12s</NAME></TD><TD><c5>%d</c5></TD><TD><BACKGROUND>%d</BACKGROUND></TD><TD><X>%d</X></TD><TD><Y>%d</Y></TD><TD><AZ>%3.2f</AZ></TD><TD><ALT>%2.2f</ALT></TD><TD><TYPE>%5s</TYPE></TD><TD><V_MAG>%5.2f</V_MAG></TD><TD><C_MAG>%5.2f</C_MAG></TD><TD><C5c-Bc>%d</C5c-Bc></TD></TR>\n",star->starname,point.color,point.background,point.x+1,height-point.y,star->azimuth,star->altitude,star->type,star->magnitude,star->m_concam,C5c_Bc);
           fprintf(text_file,"</STAR>\n");
           /* write data for each star in a different file */
	   if (write_stars_files && star->magnitude<3.0)
	   {  FILE *star_file; /* generate individual file for each star */
	      char star_filename[256];
  	      strcpy(star_filename,input_image);
              if (strrchr(star_filename,'/')) 
              {  *strrchr(star_filename,'/')='\0'; /* save the directory */
	         strcat(star_filename,"/");        /* add the '/' */
              }
              else strcpy(star_filename,"");
              sprintf(star_filename,"%sHD%d.html",star_filename,star->starnumber);
	      star_file=fopen(star_filename,"r+");
              if (!star_file)  /* create the file if it does not exist */
	      {  star_file=fopen(star_filename,"w");
	         /* set the top parameters if it is a new file */
//		 fseek(star_file,0L,SEEK_END);
//	         if (ftell(star_file)<24)
		 { fprintf(star_file,"<HTML>\n<HEAD>\n<TITLE>%s</TITLE></HEAD>\n<BODY>\n",star->starname);
                   fprintf(star_file,"// WOLF %s  &nbsp&nbsp&nbsp Preliminary analyses files compliments to the Night Sky Live project<BR>\n",WOLF_VERSION);
                   fprintf(star_file,"// <NAME>%s</NAME> <HD>HD%d</HD><BR>\n",star->starname,star->starnumber);
                   fprintf(star_file,"//  Type:%s  V-mag:%5.2f  I-mag:%5.2f  R-mag:%5.2f  B-mag:%5.2f  C-mag:%5.2f RA:%2.2f  Dec:%2.2f<BR>\n//\n",star->type,star->magnitude,star->i_magnitude,star->r_magnitude,star->b_magnitude,star->m_concam,star->ra,star->dec);
		   fprintf(star_file,"<TABLE border=1>\n");
                   fprintf(star_file,"\n// <TR><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD><TD>%s</TD></TR>\n","date","universal time","julian date","exposure","az","alt","x","y","B","C1-B","C5-B","C9-B","C16-B","C25-B","C5c-Bc");
		 }
	      }
              else /* set the file pointer at the right place in the file */
	      {  fseek(star_file,0L,SEEK_END);
                 fseek(star_file,ftell(star_file)-24,SEEK_SET); /* write before the "</TABLE>..." and of the HTML file */ 
              }
              fprintf(star_file,"<STAR>\n");
              fprintf(star_file,"<TR><TD><DATE>%s</DATE></TD><TD><TIME>%s</TIME></TD><TD><JDT>%.5f</JDT></TD><TD><EXPOSURE>%.2f</EXPOSURE></TD><TD><AZ>%3.2f</AZ></TD><TD><ALT>%2.2f</ALT></TD><TD><X>%d</X></TD><TD><Y>%d</Y></TD><TD><BACKGROUND>%d</BACKGROUND></TD><TD><C1-B>%d</C1-B></TD><TD><C5-B>%d</C5-B></TD><TD><C9-B>%d</C9-B></TD><TD><C16-B>%d</C16-B></TD><TD><C25-B>%d</C25-B></TD><TD><C5c-Bc>%d</C5c-Bc></TD></TR>\n",s_date,s_time,tjd,exposure_time,star->azimuth,star->altitude,point.x+1,height-point.y,point.background,point.C1-point.background,point.C5-point.background,point.C9-point.background,point.C16-point.background,point.C25-point.background,C5c_Bc);
              fprintf(star_file,"</STAR>\n");
              fprintf(star_file,"</TABLE>\n</BODY>\n</HTML>");
	      fclose(star_file);
	   }
        }
      }
      star_point_index++;
    }
    fprintf(text_file,"//</TABLE>\n</BODY>\n</HTML>");
    fclose(text_file);
    star_point_index=0;
}