forked from algebrato/PenguinSBIG
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcsbigimg.cpp
2116 lines (1825 loc) · 59.5 KB
/
csbigimg.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
csbigimg.cpp - SBIG Image Class
1. This software (c)2004-2010 Santa Barbara Instrument Group.
2. This free software is provided as an example of how
to communicate with SBIG cameras. It is provided AS-IS
without any guarantees by SBIG of suitability for a
particular purpose and without any guarantee to be
bug-free. If you use it you agree to these terms and
agree to do so at your own risk.
3. Any distribution of this source code to include these
terms.
Revision History
Date Modification
=========================================================
1/26/04 Initial release
1/9/05 Added OpenImage() and ParseHeader() methods
for reading SBIG Compressed and Uncompressed
images.
Added missing Get/SetFilter() and
Get/SetSoftware() functions
Added AutoBackgroundAndRange() method
1/10/05 Added VerticalFlip() and HorizontalFlip()
Changed way we keep track of image start time
by using a struct tm instead of a time_t since
reading headers is now required
1/11/05 Added SaveFITS() routine. Saves files in FITS
format using the CFITSIO library. CLC.
1/12/05 Added History2FITS() routine. Generates a FITS
HISTORY card for each history element. CLC.
1/14/05 Removed debug printf's from SaveFITS() routine.
AllocateImageBuffer allocated 2x as much memory as
needed (looks like a cut & paste error from C code).
Fixed. CLC.
1/17/05 Added the Get/SetSubFrame() methods for specifying
top-left corner of partial frames
Added the Get/SetBinning() methods for specifying
the binning used to acquire the image
2/18/05 Fixed bugs in ParseHeader() that would fail or bomb
on old headers
4/9/06 Added GetFormattedImageInfo() method
Bumped version to 1.2
Fixed a few bugs in ParseSBIGHeader()
Made back and range parameters long instead of
unsigned short to allow broader range
Added the DarkSubtract() and FlatField()
mehtods
Added the GetAveragePixelValue() methods
Added the GetFileErrorString() method
Added the ability to read FITS images via the
OpenImage() method through the new
ReadFITSImage() method.
9/21/06 Integrated Mac and PC Versions into release
version 1.2
4/19/10 Integrated Mac and PC Versions.
Fixed a bug parsing the optional header entries
at the end of the header that could cause a crash.
Added support for the STX and ST-8300 Cameras.
Bumped Version to 1.30.
10/17/11 Fixed a bug parsing the SBIG Header where CCDSoft
was not setting a blank Observer to the required "-"
Bumped Version to 1.31
*/
#include "lpardrv.h"
#include "csbigimg.h"
#include <stdio.h>
#include <string.h>
#include <string>
/*
Local Constants
*/
#if TARGET == ENV_MACOSX || TARGET == ENV_LINUX
#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.31" /* 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;
static const char *FILE_ERROR_STRINGS[] = {
"No File Error",
"Error Opening Image File",
"Error Closing Image File",
"Error Reading Image File",
"Error Writing Image File",
"Invalid Image File Format",
"Insufficient Memory",
"FITS Header Error",
"Image is the Wrong Size",
};
static const char HISTORY_CHARS[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvw";
static const char *HISTORY_PHRASES[] =
{
"Unknown Modification", "Image Co-Addition", "Scale ADU Values","Crop Image",
"Dark Subtraction", "Remove Cool Pixels", "Flat Field", "Smooth Pixels",
"Sharpen Pixels", "Pseudo Flat Field", "Quantize ADU Values", "Remove Warm Pixels",
"Flip Horizontally", "Flip Vertically", "Zoom In", "Further Additional Modifications",
"Log Scale ADU Values", "Combine Pixels", "Auto Dark Subtraction", "Replicate Pixels",
"Clip ADU Values", "Compress Dynamic Range", "RGB Merge Version 2",
"RGB Merge Version 3", "Translate Image", "Invert ADU Values", "Sharpen Pixels Asymmetrically",
"Expand Dynamic Range", "Modernize", "Resample Pixel Size", "Average Images",
"Add/Subtract ADU Constant", "Multiply/Divide ADU by Constant",
"Enlarge Image", "Reduce Image",
"Repair Column", "Adaptive Dark Subtraction", "Make Pseudo 3-D Image",
"Auto Dark Subtraction with Hot Pixel Removal","Dark Subtraction with Hot Pixel Removal",
"LR Deconvolve Image","Spatial Median Filter", "Set ADU Saturation Level",
"DDP Image", "Rotate Image", "Fix TDI Background", "ME CCD Spike Removal",
"Fix Bloomed Stars", "Remove Image Gradient",
"Extract RGB", "Extract Luminance", "Rotate Clockwise", "Rotate Counter-Clockwise",
"Median Combine 3 Images", "Rotate 180�", "Raw Single Shot Color"
};
static void stripcontrols(char *s)
{
char c;
while ( (c = *s) != 0 ) {
if ( iscntrl(c) || !isascii(c) )
*s = 0x20;
s++;
}
}
/*
CSBIGImg:
Standard constructor. Init member variables.
*/
CSBIGImg::CSBIGImg(void)
{
Init();
}
/*
CSBIGImg:
Alternate constructor. Try to allocate the image buffer.
*/
CSBIGImg::CSBIGImg(int height, int width)
{
Init();
AllocateImageBuffer(height, width);
}
/*
~CSBIGImg:
Deallocate the image buffer.
*/
CSBIGImg::~CSBIGImg(void)
{
DeleteImageData();
}
/*
Init:
Initialize the member variables with reasonable default values.
*/
void CSBIGImg::Init(void)
{
/*~~~~~~~~~~~*/
string s1, s2;
time_t tm;
/*~~~~~~~~~~~*/
m_nHeight = m_nWidth = 0;
m_pImage = NULL;
tm = time(NULL);
SetImageStartTime(tm);
m_dCCDTemperature = 25.0;
m_dExposureTime = m_dEachExposure = 1.0;
m_dTrackExposure = 0.0;
m_dFocalLength = 80.0;
m_dApertureArea = PI * 4.0 * 4.0;
m_dResponseFactor = 2000.0;
m_dPixelHeight = m_dPixelWidth = 0.009;
m_dEGain = 2.3;
m_lBackground = 0;
m_lRange = 65535;
m_uNumberExposures = 1;
m_uSaturationLevel = 65535;
m_uPedestal = 0;
m_uExposureState = ES_ABG_LOW | ES_ABG_RATE_FIXED | ES_DCS_ENABLED | ES_DCR_DISABLED | ES_AUTOBIAS_ENABLED;
m_uReadoutMode = 0;
m_cImageNote = "";
m_cObserver = "Image acquired with CSBIGImg";
m_cHistory = "";
m_cFilter = "None";
s1 = "CSBIGImg Ver ";
s2 = VERSION_STR;
m_cSoftware = s1 + s2;
m_cCameraModel = "ST-7";
m_bImageModified = TRUE;
m_nDefaultImageFormat = SBIF_UNCOMPRESSED;
m_nSubFrameTop = m_nSubFrameLeft = 0;
m_uHorizontalBinning = m_uVerticalBinning = 1;
m_bImageCanClose = TRUE;
#if INCLUDE_FITSIO
m_cFITSObject = "";
m_cFITSTelescope = "";
m_dApertureDiameter = 4.0;
m_cAdditionalFITSKeys = "";
#endif
}
/* */
void CSBIGImg::DeleteImageData(void)
{
if (m_pImage)
delete m_pImage;
m_pImage = NULL;
}
/*
SetImageStartTime:
This set of overloaded functions records the time the
image started. Each is defined separately below:
SetImageStartTime(void)
Set to the current time.
SetImageStartTime(struct tm *pStartTime)
SetImageStartTime(time_t startTime)
SetImageStartTime(int mm, int dd, int yy, int hr, int min, int sec)
Set to the passed time in it's individual format.
*/
void CSBIGImg::SetImageStartTime(void)
{
SetImageStartTime(time(NULL));
}
void CSBIGImg::SetImageStartTime(struct tm* pStartTime)
{
memcpy(&m_sDecodedImageStartTime, pStartTime, sizeof(struct tm));
}
void CSBIGImg::SetImageStartTime(time_t startTime)
{
struct tm *pTm;
pTm = gmtime(&startTime);
memcpy(&m_sDecodedImageStartTime, pTm, sizeof(struct tm));
}
void CSBIGImg::SetImageStartTime(int mm, int dd, int yy, int hr, int min, int sec)
{
m_sDecodedImageStartTime.tm_mon = mm - 1; // month in struct tm is 0 - 11, not 1 - 12
m_sDecodedImageStartTime.tm_mday = dd;
m_sDecodedImageStartTime.tm_year = yy - 1900; // year is zero based in 1900
m_sDecodedImageStartTime.tm_hour = hr;
m_sDecodedImageStartTime.tm_min = min;
m_sDecodedImageStartTime.tm_sec = sec;
}
/*
GetSubFrame:
SetSubFrame:
For partial frame images these contain the coordinate
of the upper-left most pixel.
*/
void CSBIGImg::SetSubFrame(int nLeft, int nTop)
{
m_nSubFrameLeft = nLeft;
m_nSubFrameTop = nTop;
}
void CSBIGImg::GetSubFrame(int &nLeft, int &nTop)
{
nLeft = m_nSubFrameLeft;
nTop = m_nSubFrameTop;
}
/*
GetBinning:
SetBinning:
These contain the binning used to
acquire the image.
*/
void CSBIGImg::SetBinning(unsigned short uHoriz, unsigned short uVert)
{
m_uHorizontalBinning = uHoriz;
m_uVerticalBinning = uVert;
}
void CSBIGImg::GetBinning(unsigned short &uHoriz, unsigned short &uVert)
{
uHoriz = m_uHorizontalBinning;
uVert = m_uVerticalBinning;
}
/*
AddHistory:
Add the passed char to the history string and if it's
only the '0' char in the string remove it.
*/
void CSBIGImg::AddHistory(string str)
{
if ( m_cHistory.length() == 1 && m_cHistory[0] == '0' )
m_cHistory = str;
else
m_cHistory += str;
}
/*
SaveImage:
Save the image in passed path and format.
Returns any file errors that occur.
*/
SBIG_FILE_ERROR CSBIGImg::SaveImage(const char *pFullPath, SBIG_IMAGE_FORMAT fmt /* = SBIF_DEFAULT */ )
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
char header[HEADER_LEN];
SBIG_FILE_ERROR res;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if (fmt == SBIF_DEFAULT)
fmt = m_nDefaultImageFormat;
switch (fmt) {
case SBIF_COMPRESSED:
res = SaveCompressedImage(pFullPath, header);
break;
case SBIF_UNCOMPRESSED:
res = SaveUncompressedImage(pFullPath, header);
break;
case SBIF_FITS:
#if INCLUDE_FITSIO
/* save file in FITS format */
res = SaveFITS(pFullPath);
#else
return SBFE_FORMAT_ERROR;
#endif
break;
default:
res = SBFE_FORMAT_ERROR;
break;
}
if (res == SBFE_NO_ERROR) {
SetImageModified(FALSE);
m_nDefaultImageFormat = fmt;
}
return res;
}
/*
SaveCompressedImage:
Create and write the image header then compress and write each
row in the image.
*/
SBIG_FILE_ERROR CSBIGImg::SaveCompressedImage(const char *pFullPath, char *pHeader)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
SBIG_FILE_ERROR res;
FILE *fp;
int i, cmpWidth;
unsigned char *pCmpData;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
CreateSBIGHeader(pHeader, TRUE);
res = SBFE_MEMORY_ERROR;
pCmpData = new unsigned char[m_nWidth * 2 + 2];
if (pCmpData) {
res = SBFE_OPEN_ERROR;
if ((fp = fopen(pFullPath, "wb")) != 0) {
res = SBFE_WRITE_ERROR;
if (fwrite(pHeader, HEADER_LEN, 1, fp) == 1) {
for (i = 0; i < m_nHeight; i++) {
cmpWidth = CompressSBIGData(pCmpData, i);
if (fwrite(pCmpData, 1, cmpWidth, fp) != (size_t) cmpWidth)
break;
}
if (i == m_nHeight)
res = SBFE_NO_ERROR;
fclose(fp);
}
}
delete pCmpData;
}
return res;
}
/*
SaveUncompressedImage:
Create and write the image header then write the image
data. We save the image as unsigned shorts but since this
can run on machines with different byte order make the
file byte order comply with the Intel byte order (low
byte first).
*/
SBIG_FILE_ERROR CSBIGImg::SaveUncompressedImage(const char *pFullPath, char *pHeader)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
FILE *fp;
SBIG_FILE_ERROR res;
int i;
unsigned char *pRevData;
unsigned short byteTest = 0x1234;
MY_LOGICAL reverseBytes;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
CreateSBIGHeader(pHeader, FALSE);
res = SBFE_OPEN_ERROR;
if ((fp = fopen(pFullPath, "wb")) != 0) {
res = SBFE_WRITE_ERROR;
if (fwrite(pHeader, HEADER_LEN, 1, fp) == 1) {
reverseBytes = *((unsigned char *) &byteTest) != 0x34;
if (reverseBytes) {
pRevData = new unsigned char[m_nWidth * 2];
if (pRevData) {
for (i = 0; i < m_nHeight; i++) {
IntelCopyBytes(pRevData, i);
if (fwrite(pRevData, 2 * m_nWidth, 1, fp) != 1)
break;
}
delete pRevData;
if (i == m_nHeight)
res = SBFE_NO_ERROR;
}
else
res = SBFE_MEMORY_ERROR;
}
else {
if (fwrite(m_pImage, 2 * m_nWidth, m_nHeight, fp) == (size_t) m_nHeight)
res = SBFE_NO_ERROR;
}
}
fclose(fp);
}
return res;
}
/*
OpenImage:
Open the image in the passed path.
Returns any file errors that occur.
*/
SBIG_FILE_ERROR CSBIGImg::OpenImage(const char *pFullPath)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
char header[HEADER_LEN];
FILE *fh;
SBIG_FILE_ERROR res;
MY_LOGICAL isCompressed;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if ((fh = fopen(pFullPath, "rb")) == NULL)
return SBFE_OPEN_ERROR;
else {
do { // allow break out
// read and pars header
res = SBFE_FORMAT_ERROR;
if (fread(header, 1, HEADER_LEN, fh) != HEADER_LEN)
break;
if (!ParseHeader(header, isCompressed))
break;
// allocate image buffer
res = SBFE_MEMORY_ERROR;
if (!AllocateImageBuffer(m_nHeight, m_nWidth))
break;
if (isCompressed)
res = ReadCompressedImage(fh);
else
res = ReadUncompressedImage(fh);
if (res != SBFE_NO_ERROR) {
delete m_pImage;
m_pImage = NULL;
}
} while (FALSE);
}
fclose(fh);
#if INCLUDE_FITSIO
// see if could be a FITS file
if ( res == SBFE_FORMAT_ERROR )
res = ReadFITSImage(pFullPath);
#endif
if (res == SBFE_NO_ERROR) {
SetImageModified(FALSE);
if ( m_nDefaultImageFormat != SBIF_FITS )
m_nDefaultImageFormat = isCompressed ? SBIF_COMPRESSED : SBIF_UNCOMPRESSED;
}
return res;
}
/*
ReadCompressedImage:
Read from the file and uncompress a compressed image.
*/
SBIG_FILE_ERROR CSBIGImg::ReadCompressedImage(FILE *fh)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
SBIG_FILE_ERROR res;
int i, j;
unsigned char *pcb = NULL, *pc, code;
unsigned short *pVid, vid;
unsigned short delta;
unsigned short len;
unsigned short byteTest = 0x1234;
MY_LOGICAL reverseBytes;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
// compressed images save shorts in Intel order but since we want
// this code to work on a PPC based Mac as well we might have to
// reverse the bytes in the shorts
reverseBytes = *((unsigned char *) &byteTest) != 0x34;
// read compressed image data
do { // allow break out
// allocate a row buffer
res = SBFE_MEMORY_ERROR;
pcb = new unsigned char[2 * m_nWidth];
if (pcb == NULL)
break;
// read each row in turn
res = SBFE_FORMAT_ERROR;
for (i = 0; i < m_nHeight;) {
// read the first 2 bytes which are the length of the compressed data
pVid = m_pImage + (long)i * m_nWidth;
if (fread(pcb, sizeof(unsigned short), 1, fh) != 1)
break;
if ( reverseBytes )
len = (unsigned short)(pcb[0]) + ((unsigned short)pcb[1] << 8);
else
len = *((unsigned short *)pcb);
// check the length for invalid or uncompressed
if (len > 2 * m_nWidth)
break; // row too long for compressed data
else if (len < m_nWidth + 1)
break; // row too short for compressed data
else if (len == 2 * m_nWidth) {
// see if an uncompressed row
if (fread(pVid, 2, m_nWidth, fh) != (size_t) m_nWidth)
break;
if ( reverseBytes ) {
for(j=0; j<m_nWidth; j++) {
vid = pVid[j];
vid = (vid >> 8) + (vid << 8);
pVid[j] = vid;
}
}
i++; // goto next row
}
else {
// compressed data, read the rest of the line
if (fread(pcb, 1, len, fh) != (size_t) len)
break;
pc = pcb;
vid = *pc++; // first pixel is 2 bytes, lsb first
vid += (*pc++) << 8;
len -= 2;
*pVid++ = vid;
for (j = 1; j < m_nWidth && len > 0; j++) {
code = *pc++;
len--;
if (code == 0x80) {
// 0x80 means pixel in next 2 bytes
if (len < 2)
break; // whoops, buffer underflow, format error
vid = *pc++; // ls byte first
vid += (*pc++) << 8;
len -= 2;
}
else {
// byte read is an 8 bit signed delta
delta = code;
if (code & 0x80)
delta += 0xFF00; // sign extend
vid += delta;
}
*pVid++ = vid;
}
if (j != m_nWidth || len != 0)
break; // again a format error
i++; // goto next row
} // compressed row
if (i == m_nHeight) // made it through without error
res = SBFE_NO_ERROR;
} // for i=0 to height
} while (FALSE);
if (pcb)
delete pcb;
return res;
}
/*
ReadUncompressedImage:
Read an uncompressed image which is written as
an array of unsigned shorts in Intel byte order
(low byte first). If after reading the data the
byte order needs to be reversed do so.
*/
SBIG_FILE_ERROR CSBIGImg::ReadUncompressedImage(FILE *fh)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
SBIG_FILE_ERROR res;
int i;
unsigned short *pVid;
unsigned short byteTest = 0x1234;
MY_LOGICAL reverseBytes;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
// read uncompressed data which is a simple binary image
if (fread(m_pImage, 2 * m_nWidth, m_nHeight, fh) != (size_t) m_nHeight)
res = SBFE_FORMAT_ERROR;
else {
reverseBytes = *((unsigned char *) &byteTest) != 0x34;
if (reverseBytes) {
for (i=0; i<m_nHeight; i++) {
pVid = m_pImage + (long)i*m_nWidth;
IntelCopyBytes((unsigned char *)pVid, i);
}
}
res = SBFE_NO_ERROR;
}
return res;
}
/*
AllocateImageBuffer:
Delete any existing buffer then try to allocate one of the
given size. Returns TRUE if successful.
*/
MY_LOGICAL CSBIGImg::AllocateImageBuffer(int height, int width)
{
if (m_pImage)
delete m_pImage;
m_nHeight = m_nWidth = 0;
if (height > 0 && width > 0) {
m_pImage = new unsigned short[(long)height * width];
if (m_pImage) {
m_nHeight = height;
m_nWidth = width;
}
memset(m_pImage, 0, 2L * m_nHeight * m_nWidth);
}
return m_pImage != NULL;
}
/* */
void CSBIGImg::CreateSBIGHeader(char *pHeader, MY_LOGICAL isCompressed)
{
/*~~~~~~~~~~~~~*/
char *p;
struct tm *plt;
/*~~~~~~~~~~~~~*/
plt = &m_sDecodedImageStartTime;
memset(pHeader, 0, HEADER_LEN);
p = pHeader;
p += sprintf(p, "SBIG %sImage\n\r", isCompressed ? "Compressed " : "");
p += sprintf(p, "%s%d\n\r", HEADER_KEYWORDS[HH_FILE_VERSION], FILE_VERSION);
p += sprintf(p, "%s%d\n\r", HEADER_KEYWORDS[HH_DATA_VERSION], DATA_VERSION);
p += sprintf(p,
"%s%ld\n\r",
HEADER_KEYWORDS[HH_EXPOSURE],
m_dExposureTime < 0.01 ? 1 : (long)(m_dExposureTime * 100.0 + 0.5));
p += sprintf(p, "%s%1.3lf\n\r", HEADER_KEYWORDS[HH_FOCAL_LENGTH], m_dFocalLength);
p += sprintf(p, "%s%1.4lf\n\r", HEADER_KEYWORDS[HH_APERTURE], m_dApertureArea);
p += sprintf(p, "%s%1.3lf\n\r", HEADER_KEYWORDS[HH_RESPONSE_FACTOR], m_dResponseFactor);
p += sprintf(p, "%s%s\n\r", HEADER_KEYWORDS[HH_NOTE], m_cImageNote.length() == 0 ? "-" :
m_cImageNote.length() > 70 ? m_cImageNote.substr(0, 70).c_str() : m_cImageNote.c_str());
p += sprintf(p, "%s%ld\n\r", HEADER_KEYWORDS[HH_BACKGROUND], m_lBackground);
p += sprintf(p, "%s%ld\n\r", HEADER_KEYWORDS[HH_RANGE], m_lRange);
p += sprintf(p, "%s%d\n\r", HEADER_KEYWORDS[HH_HEIGHT], m_nHeight);
p += sprintf(p, "%s%d\n\r", HEADER_KEYWORDS[HH_WIDTH], m_nWidth);
p += sprintf(p,
"%s%02d/%02d/%02d\n\r",
HEADER_KEYWORDS[HH_DATE],
plt->tm_mon + 1,
plt->tm_mday,
plt->tm_year % 100);
p += sprintf(p, "%s%02d:%02d:%02d\n\r", HEADER_KEYWORDS[HH_TIME], plt->tm_hour, plt->tm_min, plt->tm_sec);
p += sprintf(p, "%s%u\n\r", HEADER_KEYWORDS[HH_EXPOSURE_STATE], m_uExposureState);
p += sprintf(p, "%s%1.2lf\n\r", HEADER_KEYWORDS[HH_TEMPERATURE], m_dCCDTemperature);
p += sprintf(p, "%s%d\n\r", HEADER_KEYWORDS[HH_NUMBER_EXPOSURES], m_uNumberExposures);
p += sprintf(p,
"%s%ld\n\r",
HEADER_KEYWORDS[HH_EACH_EXPOSURE],
m_dEachExposure < 0.01 ? 1 : (long)(m_dEachExposure * 100.0 + 0.5));
p += sprintf(p, "%s%s\n\r", HEADER_KEYWORDS[HH_HISTORY], m_cHistory.length() == 0 ? "-" : m_cHistory.c_str());
p += sprintf(p, "%s%s\n\r", HEADER_KEYWORDS[HH_OBSERVER], m_cObserver.length() == 0 ? "-" :
m_cObserver.length() > 30 ? m_cObserver.substr(0,30).c_str() : m_cObserver.c_str());
p += sprintf(p, "%s%1.4lf\n\r", HEADER_KEYWORDS[HH_X_PIXEL_SIZE], m_dPixelWidth);
p += sprintf(p, "%s%1.4lf\n\r", HEADER_KEYWORDS[HH_Y_PIXEL_SIZE], m_dPixelHeight);
p += sprintf(p, "%s%u\n\r", HEADER_KEYWORDS[HH_PEDESTAL], m_uPedestal);
p += sprintf(p, "%s%1.2lf\n\r", HEADER_KEYWORDS[HH_E_GAIN], m_dEGain);
/* create user parameters */
p += sprintf(p, "%s%s\n\r", HEADER_KEYWORDS[HH_USER_1], m_cSoftware.length() == 0 ? "-" :
m_cSoftware.length() > 70 ? m_cSoftware.substr(0,70).c_str() : m_cSoftware.c_str());
p += sprintf(p,
"%s%s\n\r",
HEADER_KEYWORDS[HH_USER_2],
m_cCameraModel.length() == 0 ? "-" : m_cCameraModel.c_str());
p += sprintf(p,
"%sExposure = %1.3lf, Each_exposure = %1.3lf\n\r",
HEADER_KEYWORDS[HH_USER_3],
m_dExposureTime,
m_dEachExposure);
p += sprintf(p, "%s%s%d\n\r",HEADER_KEYWORDS[HH_USER_4], "Y2KYear = ", plt->tm_year + 1900);
/* create filter string */
p += sprintf(p, "%s%s\n\r", HEADER_KEYWORDS[HH_FILTER], m_cFilter.length() == 0 ? "-" : m_cFilter.c_str());
/* create readout mode */
p += sprintf(p, "%s%u\n\r", HEADER_KEYWORDS[HH_READOUT_MODE], m_uReadoutMode);
/* create track time */
p += sprintf(p,
"%s%ld\n\r",
HEADER_KEYWORDS[HH_TRACK_TIME],
m_dTrackExposure < 0.01 ? 0 : (long)(m_dTrackExposure * 100.0 + 0.5));
/* create saturation level */
p += sprintf(p, "%s%u\n\r", HEADER_KEYWORDS[HH_SAT_LEVEL], m_uSaturationLevel);
p += sprintf(p, "%s\n\r%c", HEADER_KEYWORDS[HH_END], 0x1a);
}
/* */
MY_LOGICAL CSBIGImg::ParseHeader(char *pHeader, MY_LOGICAL &isCompressed)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
char *p, *p1;
char const *ph;
MY_LOGICAL res = FALSE;
int i, mm, dd, yy, hh, ss;
double d, d2;
char s[80], model[80];
long l;
unsigned int u;
struct tm tm;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
p = pHeader;
ph = "Start of Header";
do
{ // allow break to exit this loop
// get the first line in the header
if (sscanf(p, "%79[^\n]", s) < 1)
break;
// First word is either the Camera Model or "SBIG"
// detect the optional camera model starting the first line
SetCameraModel("ST-7"); // init to default
if (sscanf(s, "%s", model) < 1)
break;
if (strcmp(model, "SBIG") != 0)
SetCameraModel(model);
// If the image is compressed the next word will be "Compressed"
isCompressed = FALSE;
if (strcmp(s + strlen(model) + 1, "Compressed Image") == 0)
isCompressed = TRUE;
else if (strcmp(s + strlen(model) + 1, "Image") != 0)
break;
// Get File Version
ph = HEADER_KEYWORDS[HH_FILE_VERSION];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%d", &i) != 1 || i<0 || i > FILE_VERSION)
break;
// Get Data Version
ph = HEADER_KEYWORDS[HH_DATA_VERSION];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%d", &i) != 1 || i != DATA_VERSION)
break;
// Get Exposure
ph = HEADER_KEYWORDS[HH_EXPOSURE];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%ld", &l) != 1)
break;
if (l < 1)
l = 1;
SetExposureTime((double)l / 100.0);
// Get Focal Length
ph = HEADER_KEYWORDS[HH_FOCAL_LENGTH];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%lf", &d) != 1)
break;
if (d < 0.001)
d = 0.001;
SetFocalLength(d);
// Get Aperture
ph = HEADER_KEYWORDS[HH_APERTURE];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%lf", &d) != 1)
break;
if (d < 0.001)
d = 0.001;
SetApertureArea(d);
// Get Response Factor
ph = HEADER_KEYWORDS[HH_RESPONSE_FACTOR];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%lf", &d) != 1)
break;
if (d < 0.001)
d = 0.001;
SetResponseFactor(d);
// Get Note
ph = HEADER_KEYWORDS[HH_NOTE];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%70[^\n]", s) != 1)
break;
if (strlen(s) == 1 && s[0] == '-')
s[0] = 0;
stripcontrols(s);
SetImageNote(s);
// Get Background
ph = HEADER_KEYWORDS[HH_BACKGROUND];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%ld", &l) != 1)
break;
SetBackground(l);
// Get Range
ph = HEADER_KEYWORDS[HH_RANGE];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%ld", &l) != 1)
break;
SetRange(l < 1 ? 1 : l);
// Get Height
ph = HEADER_KEYWORDS[HH_HEIGHT];
if ((p = strstr(p, ph)) == NULL)
break;
if (sscanf(p += strlen(ph), "%d", &m_nHeight) != 1)
break;
// Get Width
ph = HEADER_KEYWORDS[HH_WIDTH];
if ((p = strstr(p, ph)) == NULL)