title: Error LNK2019: Unresolved External Symbol in Visual Studio
body: <p>I've downloaded this C++ code from the SBIG website in order to control (take pictures and save them) the camera (model ST-401ME) which I purchased from them. I have a Matlab program which needs to call this so I'm trying to compile (with Visual Studio) this code with its headers and libraries into an executable. However, when I try I get the above mentioned error. Just to note I have added the files which contain the libraries to the directory path.</p>
  
  <p>The exact wording of the output is this:</p>
  
  <pre><code>1&gt;------ Build started: Project: CaptureImage, Configuration: Debug Win32 ------
  1&gt;Compiling...
  1&gt;main.cpp
  1&gt;Linking...
  1&gt;csbigcam.obj : error LNK2019: unresolved external symbol _SBIGUnivDrvCommand@12 referenced in function "public: enum PAR_ERROR __thiscall CSBIGCam::SBIGUnivDrvCommand(short,void *,void *)" (?SBIGUnivDrvCommand@CSBIGCam@@QAE?AW4PAR_ERROR@@FPAX0@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffclos referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffprec referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffpky referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffuky referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffppr referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffcrim referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffinit referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::SaveFITS(char const *)" (?SaveFITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffphis referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::History2FITS(struct fitsfile *)" (?History2FITS@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PAUfitsfile@@@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffmrhd referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffgrec referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffghsp referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffghdn referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffgkyj referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffgkyd referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffgkys referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffgpxv referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffgipr referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;csbigimg.obj : error LNK2019: unresolved external symbol _ffopen referenced in function "public: enum SBIG_FILE_ERROR __thiscall CSBIGImg::ReadFITSImage(char const *)" (?ReadFITSImage@CSBIGImg@@QAE?AW4SBIG_FILE_ERROR@@PBD@Z)
  1&gt;I:\My Documents\Visual Studio 2008\Projects\CaptureImage\Debug\CaptureImage.exe : fatal error LNK1120: 19 unresolved externals
  1&gt;Build log was saved at "file://i:\My Documents\Visual Studio 2008\Projects\CaptureImage\CaptureImage\Debug\BuildLog.htm"
  1&gt;CaptureImage - 20 error(s), 0 warning(s)
  ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
  </code></pre>
  
  <p>I think this has to do with linking the libraries. I never learned how to do that in Visual Studio, and It doesn't help that the class I took in college was 5 years ago so I barely remember anything.</p>
  
  <p>Because of the length of the code I'll only poast the parts where the errors occur. If you want more of it (like the main) just let me know.</p>
  
  <p><strong>Code:</strong></p>
  
  <p><em>csbigcam.cpp</em></p>
  
  <pre><code>#include "lpardrv.h"
  #include "sbigudrv.h"
  #include "csbigcam.h"
  #include "csbigimg.h"
  #include &lt;string&gt;
  #include &lt;math.h&gt;
  
  using namespace std;
  
  #ifndef INVALID_HANDLE_VALUE
  #define INVALID_HANDLE_VALUE -1
  #endif
  
  #define VERSION_STR     "1.2"   /* version of this class */
  
  /*
  
   Temperature Conversion Constants
   Defined in the SBIG Universal Driver Documentation
  
  */
  #define T0      25.0
  #define R0       3.0
  #define DT_CCD  25.0
  #define DT_AMB  45.0
  #define RR_CCD   2.57
  #define RR_AMB   7.791
  #define RB_CCD  10.0
  #define RB_AMB   3.0
  #define MAX_AD  4096
  
  .
  .
  .
  
  PAR_ERROR CSBIGCam::GetFullFrame(int &amp;nWidth, int &amp;nHeight)
  {
      GetCCDInfoResults0 gcir;
      GetCCDInfoParams gcip;
      unsigned short vertNBinning;
      unsigned short rm;
  
      // Get the image dimensions
      vertNBinning = m_uReadoutMode &gt;&gt; 8;
      if ( vertNBinning == 0 )
          vertNBinning = 1;
      rm = m_uReadoutMode &amp; 0xFF;
      gcip.request = (m_eActiveCCD == CCD_IMAGING ? CCD_INFO_IMAGING : CCD_INFO_TRACKING);
      if ( SBIGUnivDrvCommand(CC_GET_CCD_INFO, &amp;gcip, &amp;gcir) != CE_NO_ERROR )
          return m_eLastError;
      if ( rm &gt;= gcir.readoutModes )
          return CE_BAD_PARAMETER;
      nWidth = gcir.readoutInfo[rm].width;
      if ( rm &gt;=3 &amp;&amp; rm &lt;= 5 )
          nHeight = gcir.readoutInfo[rm-3].height / vertNBinning;
      else
          nHeight = gcir.readoutInfo[rm].height / vertNBinning;
      return CE_NO_ERROR;
  }
  
  .
  .
  .
  </code></pre>
  
  <p><em>csbigcam.h</em></p>
  
  <pre><code>#ifndef _CSBIGCAM_
  #define _CSBIGCAM_
  
  #ifndef _PARDRV_
   #include "sbigudrv.h"
  #endif
  
  #ifndef _CSBIGIMG_
   #include "csbigimg.h"
  #endif
  
  #include &lt;string&gt;
  using namespace std;
  
  typedef enum {RELAY_XPLUS, RELAY_XMINUS, RELAY_YPLUS, RELAY_YMINUS } CAMERA_RELAY;
  typedef enum {SBDF_LIGHT_ONLY, SBDF_DARK_ONLY, SBDF_DARK_ALSO } SBIG_DARK_FRAME;
  typedef enum {GS_IDLE, GS_DAWN, GS_EXPOSING_DARK, GS_DIGITIZING_DARK, GS_EXPOSING_LIGHT,
      GS_DIGITIZING_LIGHT, GS_DUSK } GRAB_STATE;
  
  class CSBIGCam {
  private:
      PAR_ERROR m_eLastError;
      PAR_COMMAND m_eLastCommand;
      short m_nDrvHandle;
      CAMERA_TYPE m_eCameraType;
      CCD_REQUEST m_eActiveCCD;
      double m_dExposureTime;
      unsigned short m_uReadoutMode;
      ABG_STATE7 m_eABGState;
      int m_nSubFrameLeft, m_nSubFrameTop, m_nSubFrameWidth, m_nSubFrameHeight;
      GRAB_STATE m_eGrabState;
      double m_dGrabPercent;
      CFW_MODEL_SELECT m_eCFWModel;
      CFW_ERROR m_eCFWError;
      struct {
          unsigned short vertNBinning, hBin, vBin;
          unsigned short rm;
          int left, top, width, height;
      } m_sGrabInfo;
  
  public:
      // Constructors/Destructors
      CSBIGCam();
      CSBIGCam(OpenDeviceParams odp);
      CSBIGCam(SBIG_DEVICE_TYPE dev);
      ~CSBIGCam();
      void Init();
  
      // Error Reporting Routines
      PAR_ERROR GetError();
      string GetErrorString();
      string GetErrorString(PAR_ERROR err);
      PAR_COMMAND GetCommand();
  
      // Accessor Functions
      double GetExposureTime(void) { return m_dExposureTime; }
      void SetExposureTime(double exp) { m_dExposureTime = exp; }
      CCD_REQUEST GetActiveCCD(void) { return m_eActiveCCD; }
      void SetActiveCCD(CCD_REQUEST ccd) { m_eActiveCCD = ccd; }
      unsigned short GetReadoutMode(void) { return m_uReadoutMode; }
      void SetReadoutMode(unsigned short rm) { m_uReadoutMode = rm; }
      CAMERA_TYPE GetCameraType(void) { return m_eCameraType; }
      ABG_STATE7 GetABGState(void) { return m_eABGState; }
      void SetABGState(ABG_STATE7 abgState) { m_eABGState = abgState; }
      void SetSubFrame(int nLeft, int nTop, int nWidth, int nHeight);
      void GetSubFrame(int &amp;nLeft, int &amp;nTop, int &amp;nWidth, int &amp;nHeight);
      PAR_ERROR GetReadoutInfo(double &amp;pixelWidth, double &amp;pixelHeight, double &amp;eGain);
  
      // Driver/Device Routines
      PAR_ERROR OpenDriver();
      PAR_ERROR CloseDriver();
      PAR_ERROR OpenDevice(OpenDeviceParams odp);
      PAR_ERROR CloseDevice();
      PAR_ERROR GetDriverInfo(DRIVER_REQUEST request, GetDriverInfoResults0 &amp;gdir);
  
      // High-Level Exposure Related Commands
      PAR_ERROR GrabSetup(CSBIGImg *pImg, SBIG_DARK_FRAME dark);
      PAR_ERROR GrabMain(CSBIGImg *pImg, SBIG_DARK_FRAME dark);
      PAR_ERROR GrabImage(CSBIGImg *pImg, SBIG_DARK_FRAME dark);
      void GetGrabState(GRAB_STATE &amp;grabState, double &amp;percentComplete);
  
      // Low-Level Exposure Related Commands
      PAR_ERROR StartExposure(SHUTTER_COMMAND shutterState);
      PAR_ERROR EndExposure(void);
      PAR_ERROR IsExposureComplete(MY_LOGICAL &amp;complete);
      PAR_ERROR StartReadout(StartReadoutParams srp);
      PAR_ERROR EndReadout(void);
      PAR_ERROR ReadoutLine(ReadoutLineParams rlp, MY_LOGICAL darkSubtract, unsigned short *dest);
      PAR_ERROR DumpLines(unsigned short noLines);
  
      //Temperature Related Commands
      PAR_ERROR GetCCDTemperature(double &amp;ccdTemp);
      PAR_ERROR SetTemperatureRegulation(MY_LOGICAL enable, double setpoint);
      PAR_ERROR QueryTemperatureStatus(MY_LOGICAL &amp;enabled, double &amp;ccdTemp,
          double &amp;setpointTemp, double &amp;percentTE);
  
      // Control Related Commands
      PAR_ERROR ActivateRelay(CAMERA_RELAY relay, double time);
      PAR_ERROR IsRelayActive(CAMERA_RELAY relay, MY_LOGICAL &amp;active);
      PAR_ERROR AOTipTilt(AOTipTiltParams attp);
      PAR_ERROR CFWCommand(CFWParams cfwp, CFWResults &amp;cfwr);
  
      // General Purpose Commands
      PAR_ERROR EstablishLink(void);
      string GetCameraTypeString(void);
      PAR_ERROR GetFullFrame(int &amp;nWidth, int &amp;nHeight);
      PAR_ERROR GetFormattedCameraInfo(string &amp;ciStr, MY_LOGICAL htmlFormat = TRUE);
  
      // Utility functions
      MY_LOGICAL CheckLink(void);
      unsigned short DegreesCToAD(double degC, MY_LOGICAL ccd = TRUE);
      double ADToDegreesC(unsigned short ad, MY_LOGICAL ccd = TRUE);
  
      //CFW Functions
      CFW_MODEL_SELECT GetCFWModel(void) { return m_eCFWModel; }
      PAR_ERROR SetCFWModel(CFW_MODEL_SELECT cfwModel, CFW_COM_PORT comPort = CFWPORT_COM1);
      PAR_ERROR SetCFWPosition(CFW_POSITION position);
      PAR_ERROR GetCFWPositionAndStatus(CFW_POSITION &amp;position, CFW_STATUS &amp;status);
      PAR_ERROR GetCFWMaxPosition(CFW_POSITION &amp;position);
      CFW_ERROR GetCFWError(void) { return m_eCFWError; }
      string GetCFWErrorString(CFW_ERROR err);
      string GetCFWErrorString(void);
  
      // Allows access directly to driver
      PAR_ERROR SBIGUnivDrvCommand(short command, void *Params, void *Results);
  };
  
  #endif /* #ifndef _CSBIGCAM_ */
  </code></pre>
  
  <p><em>csbigimg.ccp</em></p>
  
  <pre><code>#include "lpardrv.h"
  #include "csbigimg.h"
  #include &lt;stdio.h&gt;
  #include &lt;string.h&gt;
  #include &lt;string&gt;
  
  /*
   Local Constants
  */
  #if TARGET == ENV_MACOSX
      #define LONGLONG long long
  #endif
  #define FILE_VERSION    3       /* current header version written */
  #define DATA_VERSION    1       /* current data version written */
  #define HEADER_LEN      2048
  #define VERSION_STR     "1.2"   /* version of this class */
  static const char   *HEADER_KEYWORDS[] =
  {
      "File_version = ",
      "Data_version = ",
      "Exposure = ",
      "Focal_length = ",
      "Aperture = ",
      "Response_factor = ",
      "Note = ",
      "Background = ",
      "Range = ",
      "Height = ",
      "Width = ",
      "Date = ",
      "Time = ",
      "Exposure_state = ",
      "Temperature = ",
      "Number_exposures = ",
      "Each_exposure = ",
      "History = ",
      "Observer = ",
      "X_pixel_size = ",
      "Y_pixel_size = ",
      "Pedestal = ",
      "E_gain = ",
      "User_1 = ",
      "User_2 = ",
      "User_3 = ",
      "User_4 = ",
      "Filter = ",
      "Readout_mode = ",
      "Track_time = ",
      "Sat_level = ",
      "End"
  };
  typedef enum
  {
      HH_FILE_VERSION,
      HH_DATA_VERSION,
      HH_EXPOSURE,
      HH_FOCAL_LENGTH,
      HH_APERTURE,
      HH_RESPONSE_FACTOR,
      HH_NOTE,
      HH_BACKGROUND,
      HH_RANGE,
      HH_HEIGHT,
      HH_WIDTH,
      HH_DATE,
      HH_TIME,
      HH_EXPOSURE_STATE,
      HH_TEMPERATURE,
      HH_NUMBER_EXPOSURES,
      HH_EACH_EXPOSURE,
      HH_HISTORY,
      HH_OBSERVER,
      HH_X_PIXEL_SIZE,
      HH_Y_PIXEL_SIZE,
      HH_PEDESTAL,
      HH_E_GAIN,
      HH_USER_1,
      HH_USER_2,
      HH_USER_3,
      HH_USER_4,
      HH_FILTER,
      HH_READOUT_MODE,
      HH_TRACK_TIME,
      HH_SAT_LEVEL,
      HH_END
  } SBIG_HEADER_HEADING;
  
  .
  .
  .
  
  #if INCLUDE_FITSIO
              /* save file in FITS format */
              res = SaveFITS(pFullPath);
  #else
  
  .
  .
  .
  
  SBIG_FILE_ERROR CSBIGImg::History2FITS(fitsfile *fptr)
  {
      int         status = 0;
      const char  *msg, *p;
      char        c, *cp = (char*)m_cHistory.c_str();
      int         index;
      MY_LOGICAL  first = TRUE;
  
      while (*cp) {
          c = *cp++;
          if ( (p=strchr(HISTORY_CHARS, c)) != NULL ) {
              index = (p - HISTORY_CHARS)/sizeof(const char);
              msg = HISTORY_PHRASES[index];
          } else if ( c == '0' )
              continue;
          else
              msg = "???";
  
          if ( first )
              fits_write_key(fptr, TSTRING, "SWMODIFY", (void *)m_cSoftware.c_str(), "", &amp;status);
          first = FALSE;
  
          if (fits_write_history(fptr,msg,&amp;status)) {
              return SBFE_FITS_HEADER_ERROR;
          }
      }
      return SBFE_NO_ERROR;
  }
  
  .
  .
  .
  
  SBIG_FILE_ERROR CSBIGImg::ReadFITSImage(char const *pFullPath)
  {
  SBIG_FILE_ERROR err = SBFE_FORMAT_ERROR;
  fitsfile *fptr;         /* FITS file pointer, defined in fitsio.h */
  char card[FLEN_CARD];   /* Standard string lengths defined in fitsio.h */
  int status = 0;         /* CFITSIO status value MUST be initialized to zero! */
  int hdupos, nkeys, ii, jj;
  int bitpix, naxis;
  long naxes[2] = {1,1}, fpixel[2] = {1,1};
  unsigned short *uip;
  long l, l2;
  double d;
  char s[80];
  MY_LOGICAL first = TRUE;
  struct tm obs;
  
  if (!fits_open_file(&amp;fptr, pFullPath, READONLY, &amp;status))
  {
      do {        // Allow to break out
          // get and check the dimensions
          if ( fits_get_img_param(fptr, 2, &amp;bitpix, &amp;naxis, naxes, &amp;status) ) break;
          if ( bitpix != 16 || naxis != 2 ) break;
  
          // allocate the buffer
          err = SBFE_MEMORY_ERROR;
          if ( !AllocateImageBuffer(naxes[1], naxes[0]) ) break;
          uip = GetImagePointer();
  
          // read the image data
          err = SBFE_READ_ERROR;
          if ( fits_read_pix(fptr, TUSHORT, fpixel, naxes[0]*naxes[1], NULL, uip, NULL, &amp;status) ) break;
  
          // try and read the SBIG keys
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_OBJ], s, NULL, &amp;status) )    SetFITSObject(s);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_SCOPE], s, NULL, &amp;status) )  SetFITSTelescope(s);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_INST], s, NULL, &amp;status) )   SetCameraModel(s);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_OBS], s, NULL, &amp;status) )    SetObserver(s);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_DATEOBS], s, NULL, &amp;status) ) {
                          if ( sscanf(s,"%4d-%2d-%2dT%2d.%2d.%2d", &amp;obs.tm_year, &amp;obs.tm_mon, &amp;obs.tm_mday,
                                      &amp;obs.tm_hour, &amp;obs.tm_min, &amp;obs.tm_sec) == 6 ) {
                              obs.tm_year -= 1900; obs.tm_mon -= 1;
                              memcpy(&amp;m_sDecodedImageStartTime, &amp;obs, sizeof(struct tm));
                          }
                      }
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_EXP], &amp;d, NULL, &amp;status) )   SetExposureTime(d);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_CCDT], &amp;d, NULL, &amp;status) )  SetCCDTemperature(d);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_PIXX], &amp;d, NULL, &amp;status) )  SetPixelWidth(d/1000.0);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_PIXY], &amp;d, NULL, &amp;status) )  SetPixelHeight(d/1000.0);
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_BINX], &amp;l, NULL, &amp;status) &amp;&amp;
                           !fits_read_key_lng(fptr, FITS_KEYS[FK_BINY], &amp;l2, NULL, &amp;status) ) SetBinning((unsigned short)l, (unsigned short)l2);
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_ORGX], &amp;l, NULL, &amp;status) &amp;&amp;
                           !fits_read_key_lng(fptr, FITS_KEYS[FK_ORGY], &amp;l2, NULL, &amp;status) ) SetSubFrame((unsigned short)l, (unsigned short)l2);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_EGAIN], &amp;d, NULL, &amp;status) )     SetEGain(d);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_FL], &amp;d, NULL, &amp;status) )    SetFocalLength(d/25.4);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_APTD], &amp;d, NULL, &amp;status) )  SetApertureDiameter(d/25.4);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_APTA], &amp;d, NULL, &amp;status) )  SetApertureArea(d/25.4/25.4);
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_BLACK], &amp;l, NULL, &amp;status) ) SetBackground(l);
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_WHITE], &amp;l, NULL, &amp;status) ) SetRange(l - GetBackground());
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_PED], &amp;l, NULL, &amp;status) )   SetPedestal((unsigned short)(l+100));
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_MAX], &amp;l, NULL, &amp;status) )   SetSaturationLevel((unsigned short)l);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_SWA],  s, NULL, &amp;status) )   SetSoftware(s);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_FILT],  s, NULL, &amp;status) )  SetFilter(s);
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_SNAP], &amp;l, NULL, &amp;status) )  SetNumberExposures((unsigned short)l);
                                                                                              SetEachExposure(GetExposureTime()/l);
          status = 0; if ( !fits_read_key_lng(fptr, FITS_KEYS[FK_RES], &amp;l, NULL, &amp;status) )   SetReadoutMode((unsigned short)l);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_EXPST],  s, NULL, &amp;status) &amp;&amp; sscanf(s,"%lX", &amp;l) == 1 ) SetExposureState((unsigned short)l);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_RESP], &amp;d, NULL, &amp;status) )  SetResponseFactor(d);
          status = 0; if ( !fits_read_key_str(fptr, FITS_KEYS[FK_NOTE],  s, NULL, &amp;status) )      SetImageNote(s);
          status = 0; if ( !fits_read_key_dbl(fptr, FITS_KEYS[FK_TRAK], &amp;d, NULL, &amp;status) )  SetTrackExposure(d);
          status = 0;
  
          // read and filter out the parsed keywords
          fits_get_hdu_num(fptr, &amp;hdupos);  /* Get the current HDU position */
          for (; !status; hdupos++)  /* Main loop through each extension */
          {
              fits_get_hdrspace(fptr, &amp;nkeys, NULL, &amp;status); /* get # of keywords */
              for (ii = 1; ii &lt;= nkeys; ii++) { /* Read and print each keywords */
                  if (fits_read_record(fptr, ii, card, &amp;status)) break;
                  for (jj=0; jj&lt;FK_NEXT; jj++) {
                      l = strlen(FITS_KEYS[jj]);
                      if ( strncmp(card, FITS_KEYS[jj], l) == 0 ) break;
                  }
                  if ( jj == FK_NEXT ) {
                      if ( !first ) m_cAdditionalFITSKeys += "\r";
                      m_cAdditionalFITSKeys += card ;
                      first = FALSE;
                  }
              }
              fits_movrel_hdu(fptr, 1, NULL, &amp;status);  /* try to move to next HDU */
          }
          if (status == END_OF_FILE)  status = 0; /* Reset after normal error */
          if ( status ) break;            
  
          // got here so there was no error
          err = SBFE_NO_ERROR;
          m_nDefaultImageFormat = SBIF_FITS;
      } while ( FALSE );
      fits_close_file(fptr, &amp;status);
  }
  
  if (err == SBFE_NO_ERROR &amp;&amp; status)
      err = SBFE_FORMAT_ERROR;
  if ( err != SBFE_NO_ERROR )
      DeleteImageData();
  return(err);
  }
  #endif
  </code></pre>
  
  <p><em>csbigimg.h</em></p>
  
  <pre><code>#ifndef _CSBIGIMG_
      #define _CSBIGIMG_
  /*
    Compile Time Options
  */
      #define INCLUDE_FITSIO  1       /* set to 1 to compile and link with FITSIO Library */
  
      #ifndef _LPARDRV_
          #include "lpardrv.h"
      #endif
      #include &lt;time.h&gt;
      #include &lt;string&gt;
  
  using namespace std;
  
      #if INCLUDE_FITSIO
          #include "fitsio.h"
      #endif  /* INCLUDE_FITSIO */
  
  #ifndef PI
      #define PI  3.1415926535
  #endif
  
  /*
   Exposure State Field Defines
  */
      #define ES_ABG_MASK             0x0003
      #define ES_ABG_UNKNOWN          0x0000
      #define ES_ABG_LOW              0x0001
      #define ES_ABG_CLOCKED          0x0002
      #define ES_ABG_MID              0x0003
  
      #define ES_ABG_RATE_MASK        0x00C0
      #define ES_ABG_RATE_FIXED       0x0000
      #define ES_ABG_RATE_LOW         0x0040
      #define ES_ABG_RATE_MED         0x0080
      #define ES_ABG_RATE_HI          0x00C0
  
      #define ES_DCS_MASK             0x000c
      #define ES_DCS_UNKNOWN          0x0000
      #define ES_DCS_ENABLED          0x0004
      #define ES_DCS_DISABLED         0x0008
  
      #define ES_DCR_MASK             0x0030
      #define ES_DCR_UNKNOWN          0x0000
      #define ES_DCR_ENABLED          0x0010
      #define ES_DCR_DISABLED         0x0020
  
      #define ES_AUTOBIAS_MASK        0x0100
      #define ES_AUTOBIAS_ENABLED     0x0100
      #define ES_AUTOBIAS_DISABLED    0x0000
  
  typedef enum { SBIF_COMPRESSED,
                 SBIF_UNCOMPRESSED,
                 SBIF_FITS,
                 SBIF_DEFAULT } SBIG_IMAGE_FORMAT;
  typedef enum
  {
      SBFE_NO_ERROR,
      SBFE_OPEN_ERROR,
      SBRE_CLOSE_ERROR,
      SBFE_READ_ERROR,
      SBFE_WRITE_ERROR,
      SBFE_FORMAT_ERROR,
      SBFE_MEMORY_ERROR,
      SBFE_FITS_HEADER_ERROR,
      SBFE_WRONG_SIZE,
      SBFE_NEXT_ERROR
  } SBIG_FILE_ERROR;
  
  class CSBIGImg
  {
  /* */
  private:
      int                 m_nHeight, m_nWidth;            // image size in pixels
      int                 m_nSubFrameTop, m_nSubFrameLeft;// for partial frames the top-left pixel
      unsigned short      *m_pImage;                      // pointer to image data
      double              m_dCCDTemperature;              // CCD Temp at start of exposure
      double              m_dExposureTime;                // Exposure time in seconds
      double              m_dTrackExposure;               // Exposure when tracking
      double              m_dEachExposure;                // Snapshot time in seconds
      double              m_dFocalLength;                 // Lens/Telescope Focal Length in inches
      double              m_dApertureArea;                // Lens/Telescope Aperture Are in Sq-Inches
      double              m_dResponseFactor;              // Magnitude Calibration Factor
      double              m_dPixelHeight, m_dPixelWidth;  // Pixel Dimensions in mm
      double              m_dEGain;                       // Electronic Gain, e-/ADU
      long                m_lBackground, m_lRange;        // Display Background and Range
      unsigned short      m_uNumberExposures;             // Number of exposures co-added
      unsigned short      m_uSaturationLevel;             // Pixels at this level are saturated
      unsigned short      m_uPedestal;                    // Image Pedestal
      unsigned short      m_uExposureState;               // Exposure State
      unsigned short      m_uReadoutMode;                 // Camera Readout Mode use to acquire image
      unsigned short      m_uHorizontalBinning;           // Binning used in X
      unsigned short      m_uVerticalBinning;             // Binning used in Y
      string              m_cImageNote;                   // Note attached to image
      string              m_cObserver;                    // Observer name
      string              m_cHistory;                     // Image History string of modification chars
      string              m_cFilter;                      // Filter name imaged through
      string              m_cSoftware;                    // Software App Name and Version
      string              m_cCameraModel;                 // Model of camera used to acquire image
      int                 m_isCompressed;                 // clc
      MY_LOGICAL          m_bImageModified;               // True when modified and not saved
      SBIG_IMAGE_FORMAT   m_nDefaultImageFormat;          // default image format for Saves
      struct tm           m_sDecodedImageStartTime;       // Decoded time light exposure started
      MY_LOGICAL          m_bImageCanClose;               // TRUE when image can be closed, FALSE if owned by
                                                          //  a CSBIGCam object and acquiring data
  
  /* */
  public:
      /* Constructors/Destructor */
      CSBIGImg(void);
      CSBIGImg(int height, int width);
      ~               CSBIGImg(void);
  
      void            Init(void);
      void            DeleteImageData(void);
  .
  .
  .
      /* More Accessor Functions */
      void            SetImageStartTime(void);
      void            SetImageStartTime(time_t startTime);
      void            SetImageStartTime(int mon, int dd, int yy, int hr, int min, int sec);
      void            SetImageStartTime(struct tm *pStartTime);
      void            SetSubFrame(int nLeft, int nTop);
      void            GetSubFrame(int &amp;nLeft, int &amp;nTop);
      void            SetBinning(unsigned short nHoriz, unsigned short nVert);
      void            GetBinning(unsigned short &amp;nHoriz, unsigned short &amp;nVert);
      void            AddHistory(string str);
  
      /* File IO Routines */
      SBIG_FILE_ERROR SaveImage(const char *pFullPath, SBIG_IMAGE_FORMAT fmt = SBIF_DEFAULT);
      SBIG_FILE_ERROR OpenImage(const char *pFullPath);
  
      /* Utility Functions */
      MY_LOGICAL      AllocateImageBuffer(int height, int width);
      void            CreateSBIGHeader(char *pHeader, MY_LOGICAL isCompressed);
      MY_LOGICAL      ParseHeader(char *pHeader, MY_LOGICAL &amp;isCompressed);
      SBIG_FILE_ERROR SaveCompressedImage(const char *pFullPath, char *pHeader);
      SBIG_FILE_ERROR ReadCompressedImage(FILE *fh);
      SBIG_FILE_ERROR SaveUncompressedImage(const char *pFullPath, char *pHeader);
      SBIG_FILE_ERROR ReadUncompressedImage(FILE *fh);    
      int             CompressSBIGData(unsigned char *pCmpData, int imgRow);
      void            IntelCopyBytes(unsigned char *pRevData, int imgRow);
      void            AutoBackgroundAndRange(void);
      string          GetFileErrorString(SBIG_FILE_ERROR err);
      unsigned short  GetAveragePixelValue(void);
      unsigned short  GetAveragePixelValue(int left, int top, int width, int height);
      void            GetFormattedImageInfo(string &amp;iiStr, MY_LOGICAL htmlFormat = TRUE);
  
      /* Image Processing Funcions */
      void            VerticalFlip(void);
      void            HorizontalFlip(void);
      SBIG_FILE_ERROR DarkSubtract(CSBIGImg *pImg);
      SBIG_FILE_ERROR FlatField(CSBIGImg *pImg);
  
      /* Color Image Processing */
      void            RemoveBayerColor(void);
  
  #if INCLUDE_FITSIO
  private:
      string          m_cFITSObject;                      // Name of object in FITS header
      string          m_cFITSTelescope;                   // Name of telescope in FITS header
      double          m_dApertureDiameter;     // Diameter of telescope
      string          m_cAdditionalFITSKeys;              // additional FITS keywords
  
  public:
      /* FITS Accessor functions */
      void        SetFITSObject(string str)       { m_cFITSObject = str; }
      string      GetFITSObject(void)             { return m_cFITSObject;}
      void        SetFITSTelescope(string str)    { m_cFITSTelescope = str; }
      string      GetFITSTelescope(void)          { return m_cFITSTelescope;}
      void        SetApertureDiameter(double ap)  { m_dApertureDiameter = ap; }
      double      GetApertureDiameter(void)       { return m_dApertureDiameter; }
      void        SetAdditionalFITSKeys(string str) { m_cAdditionalFITSKeys = str; }
      string      GetAdditionalFITSKeys(void)     { return m_cAdditionalFITSKeys; }
  
      /* FITS file format utilities */
      SBIG_FILE_ERROR SaveFITS(const char *pFullPath);
      SBIG_FILE_ERROR History2FITS(fitsfile *fptr);
      SBIG_FILE_ERROR ReadFITSImage(const char *pFullPath);
  #endif
  };
  
  #endif /* #ifndef _CSBIGIMG_ */
  </code></pre>