Image_Line.hh

Go to the documentation of this file.

/*  HiRISE Image Line
 
PIRL CVS ID: Image_Line.hh,v 1.37 2020/02/14 01:17:18 schaller Exp
 
Copyright (C) 2004-2020 Arizona Board of Regents on behalf of the Lunar and
Planetary Laboratory at the University of Arizona.
 
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
*/
#ifndef _HiRISE_Image_Line_
#define _HiRISE_Image_Line_
 
//  UA::HiRISE
#include    "Data_Component.hh"
#include    "LUT.hh"
 
#if defined (INCLUDE_PVL)
//  idaeim::PVL
#include    "PVL.hh"
#endif
 
#include    <iostream>
#include    <string>
 
namespace UA
{
namespace HiRISE
{
//  Forward references.
class Line_Cache;
 
/*******************************************************************************
    Image_Line
*/
class Image_Line
:   public Data_Component
{
public:
/*==============================================================================
    Constants:
*/
static const char* const
    ID;
 
static const char* const
    NAME;
 
enum Elements
    {
    //  Line header Elements:
    Sync,
    Channel,
    Line_Number,
 
    //  Pixel Elements:
    Buffer_Pixels,
    Image_Pixels,
    Black_Pixels,
    Virtual_Pixels,
 
    //  The total number of Elements:
    Total_Elements
    };
 
static const char*
    NAMES[];
 
static const unsigned int
    LINE_HEADER_BYTES;
static const unsigned int
    BUFFER_PIXELS_COUNT;
static const unsigned int
    BLACK_PIXELS_COUNT;
static const unsigned int
    MAX_VIRTUAL_PIXELS_COUNT;
 
static const unsigned int
    MAX_PIXELS_PER_LINE;
 
static const unsigned int
    DEFAULT_CALIBRATION_LINES;
 
static const Index
    MAX_COMPONENT_BYTES;
 
static const Index
    OFFSETS_TEMPLATE[];
 
static const Index
    ARRAY_COUNTS_TEMPLATE[][2];
 
static const u_int_32
    SYNC;
 
static const u_int_8
    SYNC_3;
 
static const u_int_8
    SYNC_2;
 
static const u_int_8
    SYNC_1_BIT_MASK;
 
static const u_int_8
    CHANNEL_BIT_MASK;
 
static const u_int_32
    LINE_NUMBER_MASK;
 
enum Sync_Type
    {
    No_Sync_Type,
    Line_Header_Sync_Type,
    FELICS_Sync_Type
    };
 
static const char*
    Sync_Type_Names[];
 
static const unsigned int
    DEFAULT_WIDTH;
 
/*==============================================================================
    Class (static) data:
*/
static unsigned int
    Calibration_Lines;
 
/*==============================================================================
    Constructors
*/
Image_Line ();
 
Image_Line
    (
    unsigned int    bytes_per_pixel,
    unsigned int    total_pixels,
    unsigned int    total_lines = 0,
    unsigned int    channel_number = CCD_UNKNOWN,
    std::istream*   stream = NULL
    );
 
Image_Line (const Image_Line& component, bool duplicate = true);
 
Image_Line& operator= (const Image_Line& component);
 
virtual ~Image_Line ();
 
/*==============================================================================
    Accessors
*/
/*  Identification:
*/
std::string id () const;
 
const char* name () const;
 
/*------------------------------------------------------------------------------
    Line header
*/
u_int_32 sync () const;
 
Image_Line& sync (u_int_32 value);
 
u_int_32 channel () const;
 
Image_Line& channel (u_int_32 channel_number);
 
u_int_32 expected_channel () const
    {return Channel_Number;}
 
Image_Line& expected_channel (u_int_32 channel_number)
    {Channel_Number = channel_number; return *this;}
 
u_int_32 line_number () const;
 
Image_Line& line_number (u_int_32 line);
 
bool bad_line () const;
 
Image_Line& bad_line (bool state);
 
std::string bad_line_description () const;
 
/*------------------------------------------------------------------------------
    Pixels
*/
Pixel_type pixel (Index index) const;
 
Pixel_type operator[] (Index index) const;
 
void pixel (Index index, Pixel_type value);
 
Pixel_type buffer_pixel (Index index) const;
 
void buffer_pixel (Index index, Pixel_type value);
 
Pixel_type image_pixel (Index index) const;
 
void image_pixel (Index index, Pixel_type value);
 
Pixel_type black_pixel (Index index) const;
 
void black_pixel (Index index, Pixel_type value);
 
Pixel_type virtual_pixel (Index index) const;
 
void virtual_pixel (Index index, Pixel_type value);
 
/*------------------------------------------------------------------------------
    Structure
*/
unsigned int pixel_count () const
    {return Pixels_per_Line;}
 
Image_Line& pixel_count (unsigned int total_pixels);
 
unsigned int pixel_bytes () const;
 
Image_Line& pixel_bytes (unsigned int bytes_per_pixel);
 
unsigned int total_lines () const
    {return Total_Lines;}
 
Image_Line& total_lines (unsigned int lines);
 
static unsigned int calibration_lines ()
    {return Calibration_Lines;}
 
static void calibration_lines (unsigned int lines);
 
void mirror ();
 
Image_Line& lookup (const LUT& lut);
 
Image_Line& pukool (Pixel_type *table);
 
/*==============================================================================
    Cache
*/
std::istream& source () const;
 
Image_Line& source (std::istream& stream);
 
bool next ();
 
unsigned int count () const;
 
unsigned long long bytes_read () const;
 
unsigned long long source_bytes () const;
 
bool compressed_data () const;
 
unsigned long long compressed_bytes () const;
 
unsigned long long decompressed_bytes () const;
 
Line_Cache* cache ()
    {return Data_Cache;}
 
bool synchronization_lost ();
 
/*==============================================================================
    Printing
*/
std::ostream& print
    (std::ostream& stream = std::cout, bool verbose = false) const;
 
unsigned int width () const
    {return Width;}
 
Image_Line& width (unsigned int groups)
    {Width = groups; return *this;}
 
#if defined (INCLUDE_PVL)
/*==============================================================================
    PVL
*/
idaeim::PVL::Aggregate* PVL () const;
 
idaeim::PVL::Aggregate* PVL_description () const;
 
#endif  // defined (INCLUDE_PVL)
 
/*==============================================================================
    Validation
*/
bool is_valid () const;
 
/*==============================================================================
    Functions
*/
static bool is_sync (void* data_at);
 
static Sync_Type next_sync (std::istream& stream);
 
protected:
/*==============================================================================
    Data
*/
unsigned int
    Pixels_per_Line;
 
unsigned int
    Bytes_per_Pixel;
 
unsigned int
    Total_Lines;
 
unsigned int
    Channel_Number;
 
Line_Cache
    *Data_Cache;
 
/*..............................................................................
    List formatting
*/
unsigned int
    Width;
 
};  //  class Image_Line
 
}   //  namespace HiRISE
}   //  namespace UA
#endif