This question already has answers here:
Closed 5 years ago.
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.
The exact wording of the output is this:
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 ==========
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.
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.
Code:
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
#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_ */
