Errore LNK2019: Simbolo esterno non risolto in Visual Studio

Question

Ho scaricato questo codice C++ dal sito Web SBIG per controllare (scattare e salvare le foto) la fotocamera (modello ST-401ME) che ho acquistato da loro. Ho un programma Matlab che deve chiamarlo così sto provando a compilare (con Visual Studio) questo codice con le sue intestazioni e librerie in un eseguibile. Tuttavia, quando provo ottengo l'errore di cui sopra. Solo per notare ho aggiunto i file che contengono le librerie al percorso della directory.

La formulazione esatta della uscita è questa:

1>------ Build started: Project: CaptureImage, Configuration: Debug Win32 ------ 
1>Compiling... 
1>main.cpp 
1>Linking... 
1>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>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>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>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>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>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>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>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>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>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>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>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>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>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>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>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>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>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>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>I:\My Documents\Visual Studio 2008\Projects\CaptureImage\Debug\CaptureImage.exe : fatal error LNK1120: 19 unresolved externals 
1>Build log was saved at "file://i:\My Documents\Visual Studio 2008\Projects\CaptureImage\CaptureImage\Debug\BuildLog.htm" 
1>CaptureImage - 20 error(s), 0 warning(s) 
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== 

penso che questo abbia a che fare con il collegamento delle librerie. Non ho mai imparato come farlo in Visual Studio, e non aiuta che la classe che ho frequentato al college sia stata 5 anni fa, quindi ricordo a malapena qualcosa.

A causa della lunghezza del codice, eseguirò solo le parti in cui si verificano gli errori. Se vuoi saperne di più (come il principale) fammelo sapere.

Codice:

csbigcam.cpp

#include "lpardrv.h" 
#include "sbigudrv.h" 
#include "csbigcam.h" 
#include "csbigimg.h" 
#include <string> 
#include <math.h> 

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 &nWidth, int &nHeight) 
{ 
    GetCCDInfoResults0 gcir; 
    GetCCDInfoParams gcip; 
    unsigned short vertNBinning; 
    unsigned short rm; 

    // Get the image dimensions 
    vertNBinning = m_uReadoutMode >> 8; 
    if (vertNBinning == 0) 
     vertNBinning = 1; 
    rm = m_uReadoutMode & 0xFF; 
    gcip.request = (m_eActiveCCD == CCD_IMAGING ? CCD_INFO_IMAGING : CCD_INFO_TRACKING); 
    if (SBIGUnivDrvCommand(CC_GET_CCD_INFO, &gcip, &gcir) != CE_NO_ERROR) 
     return m_eLastError; 
    if (rm >= gcir.readoutModes) 
     return CE_BAD_PARAMETER; 
    nWidth = gcir.readoutInfo[rm].width; 
    if (rm >=3 && rm <= 5) 
     nHeight = gcir.readoutInfo[rm-3].height/vertNBinning; 
    else 
     nHeight = gcir.readoutInfo[rm].height/vertNBinning; 
    return CE_NO_ERROR; 
} 

. 
. 
. 

csbigcam.h

#ifndef _CSBIGCAM_ 
#define _CSBIGCAM_ 

#ifndef _PARDRV_ 
#include "sbigudrv.h" 
#endif 

#ifndef _CSBIGIMG_ 
#include "csbigimg.h" 
#endif 

#include <string> 
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 &nLeft, int &nTop, int &nWidth, int &nHeight); 
    PAR_ERROR GetReadoutInfo(double &pixelWidth, double &pixelHeight, double &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 &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 &grabState, double &percentComplete); 

    // Low-Level Exposure Related Commands 
    PAR_ERROR StartExposure(SHUTTER_COMMAND shutterState); 
    PAR_ERROR EndExposure(void); 
    PAR_ERROR IsExposureComplete(MY_LOGICAL &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 &ccdTemp); 
    PAR_ERROR SetTemperatureRegulation(MY_LOGICAL enable, double setpoint); 
    PAR_ERROR QueryTemperatureStatus(MY_LOGICAL &enabled, double &ccdTemp, 
     double &setpointTemp, double &percentTE); 

    // Control Related Commands 
    PAR_ERROR ActivateRelay(CAMERA_RELAY relay, double time); 
    PAR_ERROR IsRelayActive(CAMERA_RELAY relay, MY_LOGICAL &active); 
    PAR_ERROR AOTipTilt(AOTipTiltParams attp); 
    PAR_ERROR CFWCommand(CFWParams cfwp, CFWResults &cfwr); 

    // General Purpose Commands 
    PAR_ERROR EstablishLink(void); 
    string GetCameraTypeString(void); 
    PAR_ERROR GetFullFrame(int &nWidth, int &nHeight); 
    PAR_ERROR GetFormattedCameraInfo(string &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 &position, CFW_STATUS &status); 
    PAR_ERROR GetCFWMaxPosition(CFW_POSITION &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_ */ 

csbigimg.ccp

012.351.641,061 mila

#include "lpardrv.h" 
#include "csbigimg.h" 
#include <stdio.h> 
#include <string.h> 
#include <string> 

/* 
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(), "", &status); 
     first = FALSE; 

     if (fits_write_history(fptr,msg,&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(&fptr, pFullPath, READONLY, &status)) 
{ 
    do {  // Allow to break out 
     // get and check the dimensions 
     if (fits_get_img_param(fptr, 2, &bitpix, &naxis, naxes, &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, &status)) break; 

     // try and read the SBIG keys 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_OBJ], s, NULL, &status)) SetFITSObject(s); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_SCOPE], s, NULL, &status)) SetFITSTelescope(s); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_INST], s, NULL, &status)) SetCameraModel(s); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_OBS], s, NULL, &status)) SetObserver(s); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_DATEOBS], s, NULL, &status)) { 
         if (sscanf(s,"%4d-%2d-%2dT%2d.%2d.%2d", &obs.tm_year, &obs.tm_mon, &obs.tm_mday, 
            &obs.tm_hour, &obs.tm_min, &obs.tm_sec) == 6) { 
          obs.tm_year -= 1900; obs.tm_mon -= 1; 
          memcpy(&m_sDecodedImageStartTime, &obs, sizeof(struct tm)); 
         } 
        } 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_EXP], &d, NULL, &status)) SetExposureTime(d); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_CCDT], &d, NULL, &status)) SetCCDTemperature(d); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_PIXX], &d, NULL, &status)) SetPixelWidth(d/1000.0); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_PIXY], &d, NULL, &status)) SetPixelHeight(d/1000.0); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_BINX], &l, NULL, &status) && 
         !fits_read_key_lng(fptr, FITS_KEYS[FK_BINY], &l2, NULL, &status)) SetBinning((unsigned short)l, (unsigned short)l2); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_ORGX], &l, NULL, &status) && 
         !fits_read_key_lng(fptr, FITS_KEYS[FK_ORGY], &l2, NULL, &status)) SetSubFrame((unsigned short)l, (unsigned short)l2); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_EGAIN], &d, NULL, &status))  SetEGain(d); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_FL], &d, NULL, &status)) SetFocalLength(d/25.4); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_APTD], &d, NULL, &status)) SetApertureDiameter(d/25.4); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_APTA], &d, NULL, &status)) SetApertureArea(d/25.4/25.4); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_BLACK], &l, NULL, &status)) SetBackground(l); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_WHITE], &l, NULL, &status)) SetRange(l - GetBackground()); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_PED], &l, NULL, &status)) SetPedestal((unsigned short)(l+100)); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_MAX], &l, NULL, &status)) SetSaturationLevel((unsigned short)l); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_SWA], s, NULL, &status)) SetSoftware(s); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_FILT], s, NULL, &status)) SetFilter(s); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_SNAP], &l, NULL, &status)) SetNumberExposures((unsigned short)l); 
                          SetEachExposure(GetExposureTime()/l); 
     status = 0; if (!fits_read_key_lng(fptr, FITS_KEYS[FK_RES], &l, NULL, &status)) SetReadoutMode((unsigned short)l); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_EXPST], s, NULL, &status) && sscanf(s,"%lX", &l) == 1) SetExposureState((unsigned short)l); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_RESP], &d, NULL, &status)) SetResponseFactor(d); 
     status = 0; if (!fits_read_key_str(fptr, FITS_KEYS[FK_NOTE], s, NULL, &status))  SetImageNote(s); 
     status = 0; if (!fits_read_key_dbl(fptr, FITS_KEYS[FK_TRAK], &d, NULL, &status)) SetTrackExposure(d); 
     status = 0; 

     // read and filter out the parsed keywords 
     fits_get_hdu_num(fptr, &hdupos); /* Get the current HDU position */ 
     for (; !status; hdupos++) /* Main loop through each extension */ 
     { 
      fits_get_hdrspace(fptr, &nkeys, NULL, &status); /* get # of keywords */ 
      for (ii = 1; ii <= nkeys; ii++) { /* Read and print each keywords */ 
       if (fits_read_record(fptr, ii, card, &status)) break; 
       for (jj=0; jj<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, &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, &status); 
} 

if (err == SBFE_NO_ERROR && status) 
    err = SBFE_FORMAT_ERROR; 
if (err != SBFE_NO_ERROR) 
    DeleteImageData(); 
return(err); 
} 
#endif 

csbigimg.h

#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 <time.h> 
    #include <string> 

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 &nLeft, int &nTop); 
    void   SetBinning(unsigned short nHoriz, unsigned short nVert); 
    void   GetBinning(unsigned short &nHoriz, unsigned short &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 &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 &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_ */ 

Answer 1

Quando hai tutto #included, un simbolo esterno non risolto è spesso un mancante * o & nella dichiarazione o la definizione di una funzione.

Answer 2

Stavo ricevendo questo errore dopo aver aggiunto i file di inclusione e il collegamento della libreria. Era perché la lib era costruita con non unicode e la mia applicazione era unicode. Abbinarli li ha riparati.