GammaLib 2.0.0
Loading...
Searching...
No Matches
GFitsImageByte.cpp
Go to the documentation of this file.
1/***************************************************************************
2 * GFitsImageByte.cpp - FITS Byte image class *
3 * ----------------------------------------------------------------------- *
4 * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 * ----------------------------------------------------------------------- *
6 * *
7 * This program is free software: you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation, either version 3 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19 * *
20 ***************************************************************************/
21/**
22 * @file GFitsImageByte.cpp
23 * @brief FITS byte image class implementation
24 * @author Juergen Knoedlseder
25 */
26
27/* __ Includes ___________________________________________________________ */
28#ifdef HAVE_CONFIG_H
29#include <config.h>
30#endif
31#include "GException.hpp"
32#include "GFitsCfitsio.hpp"
33#include "GFitsImageByte.hpp"
34
35/* __ Method name definitions ____________________________________________ */
36
37/* __ Macros _____________________________________________________________ */
38#define G_BITPIX 8 //!< Defines the number of bits per pixel
39
40/* __ Coding definitions _________________________________________________ */
41
42/* __ Debug definitions __________________________________________________ */
43
44
45
46/*==========================================================================
47 = =
48 = Constructors/destructors =
49 = =
50 ==========================================================================*/
51
52/***********************************************************************//**
53 * @brief Void constructor
54 ***************************************************************************/
56{
57 // Initialise class members
59
60 // Return
61 return;
62}
63
64
65/***********************************************************************//**
66 * @brief 1D image constructor
67 *
68 * @param[in] nx Number of pixels.
69 * @param[in] pixels Optional pointer to image pixel array
70 *
71 * Construct 1D instance by specifying the number of pixels in the image.
72 ***************************************************************************/
73GFitsImageByte::GFitsImageByte(const int& nx, const unsigned char* pixels) :
75{
76 // Initialise class members
78
79 // Construct data
81
82 // Return
83 return;
84}
85
86
87/***********************************************************************//**
88 * @brief 2D image constructor
89 *
90 * @param[in] nx Number of pixels in first dimension.
91 * @param[in] ny Number of pixels in second dimension.
92 * @param[in] pixels Optional pointer to image pixel array
93 *
94 * Construct 2D image by specifying the number of pixels in each dimension.
95 ***************************************************************************/
96GFitsImageByte::GFitsImageByte(const int& nx, const int& ny,
97 const unsigned char* pixels) :
98 GFitsImage(G_BITPIX, nx, ny)
99{
100 // Initialise class members
101 init_members();
102
103 // Construct data
105
106 // Return
107 return;
108}
109
110
111/***********************************************************************//**
112 * @brief 3D image constructor
113 *
114 * @param[in] nx Number of pixels in first dimension.
115 * @param[in] ny Number of pixels in second dimension.
116 * @param[in] nz Number of pixels in third dimension.
117 * @param[in] pixels Optional pointer to image pixel array
118 *
119 * Construct 3D image by specifying the number of pixels in each dimension.
120 ***************************************************************************/
121GFitsImageByte::GFitsImageByte(const int& nx, const int& ny, const int& nz,
122 const unsigned char* pixels) :
123 GFitsImage(G_BITPIX, nx, ny, nz)
124{
125 // Initialise class members
126 init_members();
127
128 // Construct data
130
131 // Return
132 return;
133}
134
135
136/***********************************************************************//**
137 * @brief 4D image constructor
138 *
139 * @param[in] nx Number of pixels in first dimension.
140 * @param[in] ny Number of pixels in second dimension.
141 * @param[in] nz Number of pixels in third dimension.
142 * @param[in] nt Number of pixels in forth dimension.
143 * @param[in] pixels Optional pointer to image pixel array
144 *
145 * Construct 4D image by specifying the number of pixels in each dimension.
146 ***************************************************************************/
147GFitsImageByte::GFitsImageByte(const int& nx, const int& ny, const int& nz,
148 const int& nt, const unsigned char* pixels) :
149 GFitsImage(G_BITPIX, nx, ny, nz, nt)
150{
151 // Initialise class members
152 init_members();
153
154 // Construct data
156
157 // Return
158 return;
159}
160
161
162/***********************************************************************//**
163 * @brief Pixel array constructor
164 *
165 * @param[in] naxes Vector of number of pixels in each dimension.
166 * @param[in] pixels Optional pointer to image pixel array
167 *
168 * Construct instance of GFitsImageByte by specifying the image dimension and
169 * the number of pixels in each dimension.
170 ***************************************************************************/
171GFitsImageByte::GFitsImageByte(const std::vector<int>& naxes,
172 const unsigned char* pixels) :
173 GFitsImage(G_BITPIX, naxes)
174{
175 // Initialise class members
176 init_members();
177
178 // Construct data
180
181 // Return
182 return;
183}
184
185
186/***********************************************************************//**
187 * @brief Type conversion constructor
188 *
189 * @param[in] image FITS image.
190 *
191 * This constructor performs the conversion of any image type into a byte
192 * image.
193 ***************************************************************************/
195 GFitsImage(image)
196{
197 // Initialise class members
198 init_members();
199
200 // Copy pixels
201 if (m_num_pixels > 0) {
202 m_pixels = new unsigned char[m_num_pixels];
203 for (int i = 0; i < m_num_pixels; ++i) {
204 m_pixels[i] = (unsigned char)image.pixel(i);
205 }
206 }
207
208 // Set number of bits per pixel
210
211 // Update header card
212 card("BITPIX").value(G_BITPIX);
213
214 // Return
215 return;
216}
217
218
219/***********************************************************************//**
220 * @brief Copy constructor
221 *
222 * @param[in] image FITS image.
223 ***************************************************************************/
225 GFitsImage(image)
226{
227 // Initialise class members
228 init_members();
229
230 // Copy members
231 copy_members(image);
232
233 // Return
234 return;
235}
236
237
238/***********************************************************************//**
239 * @brief Destructor
240 ***************************************************************************/
242{
243 // Free members
244 free_members();
245
246 // Return
247 return;
248}
249
250
251/*==========================================================================
252 = =
253 = Operators =
254 = =
255 ==========================================================================*/
256
257/***********************************************************************//**
258 * @brief Assignment operator
259 *
260 * @param[in] image FITS image.
261 * @return FITS image.
262 ***************************************************************************/
264{
265 // Execute only if object is not identical
266 if (this != &image) {
267
268 // Copy base class members
269 this->GFitsImage::operator=(image);
270
271 // Free members
272 free_members();
273
274 // Initialise private members
275 init_members();
276
277 // Copy members
278 copy_members(image);
279
280 } // endif: object was not identical
281
282 // Return this object
283 return *this;
284}
285
286
287/***********************************************************************//**
288 * @brief Image pixel access operator
289 *
290 * @param[in] ix Pixel index (starting from 0).
291 *
292 * Provides access to an image pixel. No range checking is performed.
293 * Use the at(ix) method if range checking is required.
294 ***************************************************************************/
295unsigned char& GFitsImageByte::operator()(const int& ix)
296{
297 // If image pixels are not available then fetch them now
298 load_data();
299
300 // Return image pixel
301 return m_pixels[ix];
302}
303
304
305/***********************************************************************//**
306 * @brief 2D image pixel access operator
307 *
308 * @param[in] ix Pixel index in first dimension (starting from 0).
309 * @param[in] iy Pixel index in second dimension (starting from 0).
310 *
311 * Provides access to a pixel of a 2D image. No range checking or image
312 * dimension verification is performed. Use the at(ix,iy) method if range
313 * checking and image dimension verification is required.
314 ***************************************************************************/
315unsigned char& GFitsImageByte::operator()(const int& ix, const int& iy)
316{
317 // If image pixels are not available then allocate them now
318 load_data();
319
320 // Calculate pixel offset
321 int offset = ix + iy * m_naxes[0];
322
323 // Return image pixel
324 return m_pixels[offset];
325}
326
327
328/***********************************************************************//**
329 * @brief 3D image pixel access operator
330 *
331 * @param[in] ix Pixel index in first dimension (starting from 0).
332 * @param[in] iy Pixel index in second dimension (starting from 0).
333 * @param[in] iz Pixel index in third dimension (starting from 0).
334 *
335 * Provides access to a pixel of a 3D image. No range checking or image
336 * dimension verification is performed. Use the at(ix,iy) method if range
337 * checking and image dimension verification is required.
338 ***************************************************************************/
339unsigned char& GFitsImageByte::operator()(const int& ix, const int& iy,
340 const int& iz)
341{
342 // If image pixels are not available then allocate them now
343 load_data();
344
345 // Calculate pixel offset
346 int offset = ix + m_naxes[0] * (iy + iz * m_naxes[1]);
347
348 // Return image pixel
349 return m_pixels[offset];
350}
351
352
353/***********************************************************************//**
354 * @brief 4D image pixel access operator
355 *
356 * @param[in] ix Pixel index in first dimension (starting from 0).
357 * @param[in] iy Pixel index in second dimension (starting from 0).
358 * @param[in] iz Pixel index in third dimension (starting from 0).
359 * @param[in] it Pixel index in forth dimension (starting from 0).
360 *
361 * Provides access to a pixel of a 4D image. No range checking or image
362 * dimension verification is performed. Use the at(ix,iy) method if range
363 * checking and image dimension verification is required.
364 ***************************************************************************/
365unsigned char& GFitsImageByte::operator()(const int& ix, const int& iy,
366 const int& iz, const int& it)
367{
368 // If image pixels are not available then allocate them now
369 load_data();
370
371 // Calculate pixel offset
372 int offset = ix + m_naxes[0] * (iy + m_naxes[1] * (iz + it * m_naxes[2]));
373
374 // Return image pixel
375 return m_pixels[offset];
376}
377
378
379/***********************************************************************//**
380 * @brief Image pixel access operator (const variant)
381 *
382 * @param[in] ix Pixel index (starting from 0).
383 *
384 * Provides access to an image pixel. No range checking is performed.
385 * Use the at(ix) method if range checking is required.
386 ***************************************************************************/
387const unsigned char& GFitsImageByte::operator()(const int& ix) const
388{
389 // If image pixels are not available then fetch them now
390 load_data();
391
392 // Return image pixel
393 return m_pixels[ix];
394}
395
396
397/***********************************************************************//**
398 * @brief 2D image pixel access operator (const variant)
399 *
400 * @param[in] ix Pixel index in first dimension (starting from 0).
401 * @param[in] iy Pixel index in second dimension (starting from 0).
402 *
403 * Provides access to a pixel of a 2D image. No range checking or image
404 * dimension verification is performed. Use the at(ix,iy) method if range
405 * checking and image dimension verification is required.
406 ***************************************************************************/
407const unsigned char& GFitsImageByte::operator()(const int& ix, const int& iy) const
408{
409 // If image pixels are not available then allocate them now
410 load_data();
411
412 // Calculate pixel offset
413 int offset = ix + iy * m_naxes[0];
414
415 // Return image pixel
416 return m_pixels[offset];
417}
418
419
420/***********************************************************************//**
421 * @brief 3D image pixel access operator (const variant)
422 *
423 * @param[in] ix Pixel index in first dimension (starting from 0).
424 * @param[in] iy Pixel index in second dimension (starting from 0).
425 * @param[in] iz Pixel index in third dimension (starting from 0).
426 *
427 * Provides access to a pixel of a 3D image. No range checking or image
428 * dimension verification is performed. Use the at(ix,iy) method if range
429 * checking and image dimension verification is required.
430 ***************************************************************************/
431const unsigned char& GFitsImageByte::operator()(const int& ix, const int& iy,
432 const int& iz) const
433{
434 // If image pixels are not available then allocate them now
435 load_data();
436
437 // Calculate pixel offset
438 int offset = ix + m_naxes[0] * (iy + iz * m_naxes[1]);
439
440 // Return image pixel
441 return m_pixels[offset];
442}
443
444
445/***********************************************************************//**
446 * @brief 4D image pixel access operator (const variant)
447 *
448 * @param[in] ix Pixel index in first dimension (starting from 0).
449 * @param[in] iy Pixel index in second dimension (starting from 0).
450 * @param[in] iz Pixel index in third dimension (starting from 0).
451 * @param[in] it Pixel index in forth dimension (starting from 0).
452 *
453 * Provides access to a pixel of a 4D image. No range checking or image
454 * dimension verification is performed. Use the at(ix,iy) method if range
455 * checking and image dimension verification is required.
456 ***************************************************************************/
457const unsigned char& GFitsImageByte::operator()(const int& ix, const int& iy,
458 const int& iz, const int& it) const
459{
460 // If image pixels are not available then allocate them now
461 load_data();
462
463 // Calculate pixel offset
464 int offset = ix + m_naxes[0] * (iy + m_naxes[1] * (iz + it * m_naxes[2]));
465
466 // Return image pixel
467 return m_pixels[offset];
468}
469
470
471/*==========================================================================
472 = =
473 = Public methods =
474 = =
475 ==========================================================================*/
476
477/***********************************************************************//**
478 * @brief Clear instance
479 *
480 * This method properly resets the object to an initial state.
481 ***************************************************************************/
483{
484 // Free class members (base and derived classes, derived class first)
485 free_members();
488
489 // Initialise members
492 init_members();
493
494 // Return
495 return;
496}
497
498
499/***********************************************************************//**
500 * @brief Clone FITS image
501 *
502 * Cloning provides a copy of the FITS file. Cloning is used to allocate
503 * derived classes into a base class pointer.
504 ***************************************************************************/
506{
507 // Clone this image
508 return new GFitsImageByte(*this);
509}
510
511
512/***********************************************************************//**
513 * @brief Image pixel access operator
514 *
515 * @param[in] ix Pixel index (starting from 0).
516 *
517 * Provides access to a pixel of an image including range checking. Note that
518 * this method does not necessarily restrict do 1D images but generally
519 * applies to all image dimensions.
520 ***************************************************************************/
521unsigned char& GFitsImageByte::at(const int& ix)
522{
523 // If image pixels are not available then allocate them now
524 load_data();
525
526 // Return image pixel
527 return (m_pixels[offset(ix)]);
528}
529
530
531/***********************************************************************//**
532 * @brief 2D image pixel access operator
533 *
534 * @param[in] ix Pixel index in first dimension (starting from 0).
535 * @param[in] iy Pixel index in second dimension (starting from 0).
536 *
537 * Provides access to a pixel of an image including range checking.
538 ***************************************************************************/
539unsigned char& GFitsImageByte::at(const int& ix, const int& iy)
540{
541 // If image pixels are not available then allocate them now
542 load_data();
543
544 // Return image pixel
545 return (m_pixels[offset(ix,iy)]);
546}
547
548
549/***********************************************************************//**
550 * @brief 3D image pixel access operator
551 *
552 * @param[in] ix Pixel index in first dimension (starting from 0).
553 * @param[in] iy Pixel index in second dimension (starting from 0).
554 * @param[in] iz Pixel index in third dimension (starting from 0).
555 *
556 * Provides access to a pixel of an image including range checking.
557 ***************************************************************************/
558unsigned char& GFitsImageByte::at(const int& ix, const int& iy, const int& iz)
559{
560 // If image pixels are not available then allocate them now
561 load_data();
562
563 // Return image pixel
564 return (m_pixels[offset(ix,iy,iz)]);
565}
566
567
568/***********************************************************************//**
569 * @brief 4D image pixel access operator
570 *
571 * @param[in] ix Pixel index in first dimension (starting from 0).
572 * @param[in] iy Pixel index in second dimension (starting from 0).
573 * @param[in] iz Pixel index in third dimension (starting from 0).
574 * @param[in] it Pixel index in forth dimension (starting from 0).
575 *
576 * Provides access to a pixel of an image including range checking.
577 ***************************************************************************/
578unsigned char& GFitsImageByte::at(const int& ix, const int& iy, const int& iz,
579 const int& it)
580{
581 // If image pixels are not available then allocate them now
582 load_data();
583
584 // Return image pixel
585 return (m_pixels[offset(ix,iy,iz,it)]);
586}
587
588
589/***********************************************************************//**
590 * @brief Image pixel access operator (const variant)
591 *
592 * @param[in] ix Pixel index (starting from 0).
593 *
594 * Provides access to a pixel of an image including range checking.
595 ***************************************************************************/
596const unsigned char& GFitsImageByte::at(const int& ix) const
597{
598 // If image pixels are not available then allocate them now
599 load_data();
600
601 // Return image pixel
602 return (m_pixels[offset(ix)]);
603}
604
605
606/***********************************************************************//**
607 * @brief 2D image pixel access operator (const variant)
608 *
609 * @param[in] ix Pixel index in first dimension (starting from 0).
610 * @param[in] iy Pixel index in second dimension (starting from 0).
611 *
612 * Provides access to a pixel of an image including range checking.
613 ***************************************************************************/
614const unsigned char& GFitsImageByte::at(const int& ix, const int& iy) const
615{
616 // If image pixels are not available then allocate them now
617 load_data();
618
619 // Return image pixel
620 return (m_pixels[offset(ix,iy)]);
621}
622
623
624/***********************************************************************//**
625 * @brief 3D image pixel access operator (const variant)
626 *
627 * @param[in] ix Pixel index in first dimension (starting from 0).
628 * @param[in] iy Pixel index in second dimension (starting from 0).
629 * @param[in] iz Pixel index in third dimension (starting from 0).
630 *
631 * Provides access to a pixel of an image including range checking.
632 ***************************************************************************/
633const unsigned char& GFitsImageByte::at(const int& ix, const int& iy,
634 const int& iz) const
635{
636 // If image pixels are not available then allocate them now
637 load_data();
638
639 // Return image pixel
640 return (m_pixels[offset(ix,iy,iz)]);
641}
642
643
644/***********************************************************************//**
645 * @brief 4D image pixel access operator (const variant)
646 *
647 * @param[in] ix Pixel index in first dimension (starting from 0).
648 * @param[in] iy Pixel index in second dimension (starting from 0).
649 * @param[in] iz Pixel index in third dimension (starting from 0).
650 * @param[in] it Pixel index in forth dimension (starting from 0).
651 *
652 * Provides access to a pixel of an image including range checking.
653 ***************************************************************************/
654const unsigned char& GFitsImageByte::at(const int& ix, const int& iy,
655 const int& iz, const int& it) const
656{
657 // If image pixels are not available then allocate them now
658 load_data();
659
660 // Return image pixel
661 return (m_pixels[offset(ix,iy,iz,it)]);
662}
663
664
665/***********************************************************************//**
666 * @brief Return value of image pixel
667 *
668 * @param[in] ix Pixel index (starting from 0).
669 *
670 * Returns the value of an image pixel as double precision floating point
671 * value. This method performs range checking.
672 ***************************************************************************/
673double GFitsImageByte::pixel(const int& ix) const
674{
675 // Return pixel value
676 return (double(this->at(ix)));
677}
678
679
680/***********************************************************************//**
681 * @brief Return value of image pixel (2D version)
682 *
683 * @param[in] ix Pixel index in first dimension (starting from 0).
684 * @param[in] iy Pixel index in second dimension (starting from 0).
685 *
686 * Returns the value of an image pixel as double precision floating point
687 * value. This method performs range checking.
688 ***************************************************************************/
689double GFitsImageByte::pixel(const int& ix, const int& iy) const
690{
691 // Return pixel value
692 return (double(this->at(ix,iy)));
693}
694
695
696/***********************************************************************//**
697 * @brief Return value of image pixel (3D version)
698 *
699 * @param[in] ix Pixel index in first dimension (starting from 0).
700 * @param[in] iy Pixel index in second dimension (starting from 0).
701 * @param[in] iz Pixel index in third dimension (starting from 0).
702 *
703 * Returns the value of an image pixel as double precision floating point
704 * value. This method performs range checking.
705 ***************************************************************************/
706double GFitsImageByte::pixel(const int& ix, const int& iy, const int& iz) const
707{
708 // Return pixel value
709 return (double(this->at(ix,iy,iz)));
710}
711
712
713/***********************************************************************//**
714 * @brief Return value of image pixel (4D version)
715 *
716 * @param[in] ix Pixel index in first dimension (starting from 0).
717 * @param[in] iy Pixel index in second dimension (starting from 0).
718 * @param[in] iz Pixel index in third dimension (starting from 0).
719 * @param[in] it Pixel index in forth dimension (starting from 0).
720 *
721 * Returns the value of an image pixel as double precision floating point
722 * value. This method performs range checking.
723 ***************************************************************************/
724double GFitsImageByte::pixel(const int& ix, const int& iy, const int& iz,
725 const int& it) const
726{
727 // Return pixel value
728 return (double(this->at(ix,iy,iz,it)));
729}
730
731
732/***********************************************************************//**
733 * @brief Return pointer to image pixel
734 ***************************************************************************/
736{
737 // If image pixels are not available then allocate them now
738 load_data();
739
740 // Return
741 return m_pixels;
742}
743
744
745/***********************************************************************//**
746 * @brief Return image type
747 ***************************************************************************/
748int GFitsImageByte::type(void) const
749{
750 // Return type
751 return __TBYTE;
752}
753
754
755/*==========================================================================
756 = =
757 = Private methods =
758 = =
759 ==========================================================================*/
760
761/***********************************************************************//**
762 * @brief Initialise class members
763 ***************************************************************************/
765{
766 // Initialise members
768 m_pixels = NULL;
769 m_nulval = NULL;
770
771 // Return
772 return;
773}
774
775
776/***********************************************************************//**
777 * @brief Copy class members
778 *
779 * @param image FITS image to copy
780 *
781 * Copy class members. If the pixel array is linked the pointer to the array
782 * is copied. Otherwise a copy of the image pixels will be created.
783 ***************************************************************************/
785{
786 // Fetch column data if not yet fetched. The casting circumvents the
787 // const correctness
788 bool not_loaded = (image.m_pixels == NULL);
789 if (not_loaded) {
790 const_cast<GFitsImageByte*>(&image)->fetch_data();
791 }
792
793 // Copy pixels
794 if (m_num_pixels > 0 && image.m_pixels != NULL) {
795 m_pixels = new unsigned char[m_num_pixels];
796 for (int i = 0; i < m_num_pixels; ++i) {
797 m_pixels[i] = image.m_pixels[i];
798 }
799 }
800
801 // Copy NULL value
802 alloc_nulval(image.m_nulval);
803
804 // Small memory option: release column if it was fetch above
805 #if defined(G_SMALL_MEMORY)
806 if (not_loaded) {
807 const_cast<GFitsImageByte*>(&image)->release_data();
808 }
809 #endif
810
811 // Return
812 return;
813}
814
815
816/***********************************************************************//**
817 * @brief Delete class members
818 ***************************************************************************/
820{
821 // Free memory
822 if (m_pixels != NULL) delete [] m_pixels;
823 if (m_nulval != NULL) delete m_nulval;
824
825 // Mark memory as free
826 m_pixels = NULL;
827 m_nulval = NULL;
828
829 // Return
830 return;
831}
832
833
834/***********************************************************************//**
835 * @brief Allocate data
836 ***************************************************************************/
838{
839 // Release any existing data
840 release_data();
841
842 // Allocate new data
843 if (m_num_pixels > 0) {
844 m_pixels = new unsigned char[m_num_pixels];
845 }
846
847 // Return
848 return;
849}
850
851
852/***********************************************************************//**
853 * @brief Initialise data
854 ***************************************************************************/
856{
857 // Initialise data if they exist
858 if (m_pixels != NULL) {
859 for (int i = 0; i < m_num_pixels; ++i) {
860 m_pixels[i] = 0;
861 }
862 }
863
864 // Return
865 return;
866}
867
868
869/***********************************************************************//**
870 * @brief Release data
871 ***************************************************************************/
873{
874 // Free any existing memory
875 if (m_pixels != NULL) delete [] m_pixels;
876
877 // Mark pointer as free
878 m_pixels = NULL;
879
880 // Return
881 return;
882}
883
884
885/***********************************************************************//**
886 * @brief Construct data from array
887 *
888 * @param[in] pixels Optional pointer to pixel array.
889 *
890 * Initialise pixel data from an optional pixel array. If the pointer is
891 * NULL the image is simply initialised. This method supports all
892 * constructors.
893 ***************************************************************************/
894void GFitsImageByte::construct_data(const unsigned char* pixels)
895{
896 // If there are pixels then allocate array
897 if (m_num_pixels > 0) {
898
899 // Allocate data
900 alloc_data();
901
902 // If no pixel array has been specified then simply initialise data
903 if (pixels == NULL) {
904 init_data();
905 }
906
907 // ... otherwise copy pixels
908 else {
909 for (int i = 0; i < m_num_pixels; ++i) {
910 m_pixels[i] = pixels[i];
911 }
912 }
913
914 } // endif: there are pixels in image
915
916 // Return
917 return;
918}
919
920
921/***********************************************************************//**
922 * @brief Load data
923 *
924 * Load the image data if no pixels have been allocated.
925 ***************************************************************************/
927{
928 // If image pixels are not available then fetch them now.
929 if (m_pixels == NULL) {
930 const_cast<GFitsImageByte*>(this)->fetch_data();
931 }
932
933 // Return
934 return;
935}
936
937
938/***********************************************************************//**
939 * @brief Allocates nul value
940 *
941 * @param[in] value Nul value.
942 ***************************************************************************/
943void GFitsImageByte::alloc_nulval(const void* value)
944{
945 // Free any existing memory
946 if (m_nulval != NULL) delete m_nulval;
947
948 // Mark pointer as free
949 m_nulval = NULL;
950
951 // If we have valid value, allocate and set nul value
952 if (value != NULL) {
953 m_nulval = new unsigned char;
954 *m_nulval = *((unsigned char*)value);
955 }
956
957 // Return
958 return;
959}
Exception handler interface definition.
CFITSIO interface header.
#define __TBYTE
#define G_BITPIX
Defines the number of bits per pixel.
FITS Byte image class definition.
void free_members(void)
Delete class members.
Definition GFitsHDU.cpp:505
void init_members(void)
Initialise class members.
Definition GFitsHDU.cpp:462
GFitsHeaderCard & card(const int &cardno)
Return header card.
Definition GFitsHDU.hpp:259
void value(const std::string &value)
Set string value of header card.
FITS Byte image class.
void free_members(void)
Delete class members.
void * pixels(void)
Return pointer to image pixel.
double pixel(const int &ix) const
Return value of image pixel.
virtual ~GFitsImageByte(void)
Destructor.
void release_data(void)
Release data.
int type(void) const
Return image type.
unsigned char & operator()(const int &ix)
Image pixel access operator.
void load_data(void) const
Load data.
unsigned char * m_nulval
NULL value.
void clear(void)
Clear instance.
void alloc_data(void)
Allocate data.
void init_data(void)
Initialise data.
unsigned char & at(const int &ix)
Image pixel access operator.
GFitsImageByte(void)
Void constructor.
void copy_members(const GFitsImageByte &image)
Copy class members.
GFitsImageByte * clone(void) const
Clone FITS image.
void init_members(void)
Initialise class members.
GFitsImageByte & operator=(const GFitsImageByte &image)
Assignment operator.
void alloc_nulval(const void *value)
Allocates nul value.
unsigned char * m_pixels
Pixels.
void construct_data(const unsigned char *pixels)
Construct data from array.
Abstract FITS image base class.
virtual double pixel(const int &ix) const =0
int offset(const int &ix) const
Return pixel offset.
void free_members(void)
Delete class members.
void fetch_data(void)
Fetch image pixels.
long * m_naxes
Number of pixels in each dimension.
int m_bitpix
Number of Bits/pixel.
int m_num_pixels
Number of image pixels.
GFitsImage & operator=(const GFitsImage &image)
Assignment operator.
void init_members(void)
Initialise class members.