evCodecSARL.h

Go to the documentation of this file.

/*
 *
 * EVITA: Efficient Visualization of Terascale Datasets
 * Copyright (C) 2000-2016  Team Evita
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 *
 */


#ifndef __evCodecSARL_h
#define __evCodecSARL_h


#include "evCodecEmbedded.h"
#include "evCodecSARLComponentInfo.h"
#include "evDataset.h"

class evPrioritySchedule;
class evSegmentationMap;


#define EVMAX_VECTOR_DIMENSION (sizeof(int)*8 - 2)

class evCodecSARL : public evCodecEmbedded
{
public:
  evCodecSARL(void);
  virtual ~evCodecSARL(void);
  
  virtual const evString GetClassName(void) const
  {
    return(evString("evCodecSARL"));
  }

  virtual int Encode(evBitBuffer &output_buffer,
                     evDataset &dataset,
                     evProgressReporter *progress_reporter = NULL);
  virtual int EncodeHeader(evFile &outfile,
                           evDataset &dataset) const;
  virtual int Decode(evBitBuffer &input_buffer, evDataset &dataset,
                     evProgressReporter *progress_reporter = NULL);
  virtual int DecodeHeader(evFile &infile, evDataset &dataset);
  
protected:
  
private:
  evROIList *Magnitudes;

  QccENTArithmeticModel *ArithmeticModel;
  std::vector<std::vector<std::vector<evCodecSARLComponentInfo> > >
  ComponentInfo;

  evROIList *Coefficients;
  double CurrentPriority;
  evROI *CurrentReconstructed;

  void Initialize(void);
  
  void SetupModel(void);

  int EncodeStart(evBitBuffer &output_buffer,
                  evDataset &dataset,
                  evProgressReporter *progress_reporter = NULL);
  int EncodeStartROI(evBitBuffer &output_buffer,
                     evROI &roi,
                     evProgressReporter *progress_reporter = NULL);
  int EncodeStartROIComponent(evBitBuffer &output_buffer,
                              evROI &coefficients,
                              const unsigned int current_component,
                              evProgressReporter *progress_reporter = NULL);
  int EncodeMask(const evAlphaField &mask,
                 const unsigned int current_scale_start,
                 const unsigned int current_scale_length,
                 evBitBuffer &output_buffer);
  int EncodeNext(evBitBuffer &output_buffer,
                 const evDataset &dataset,
                 evProgressReporter *progress_reporter = NULL);
  int EncodeEnd(evBitBuffer &output_buffer,
                const evDataset &dataset,
                evProgressReporter *progress_reporter = NULL);
  int ExtractSigns(evROI &magnitudes);
  unsigned int SetSign(unsigned int current_sign,
                       const unsigned int vector_component) const;
  unsigned int ClearSign(unsigned int current_sign,
                         const unsigned int vector_component) const;
  unsigned int GetSign(const unsigned int current_sign,
                       const unsigned int vector_component) const;
  unsigned int SetSignificance(const unsigned int map_value) const;
  unsigned int ClearSignificance(const unsigned int map_value) const;
  unsigned int GetSignificance(const unsigned int map_value) const;
  unsigned int SetDifference(const unsigned int map_value) const;
  unsigned int ClearDifference(const unsigned int map_value) const;
  unsigned int GetDifference(const unsigned int map_value) const;
  int EncodeEnhancementLayer(evBitBuffer &output_buffer,
                             evROI *current_magnitudes,
                             const unsigned int current_component,
                             const unsigned int current_scale,
                             const unsigned int current_scale_start,
                             const unsigned int current_scale_length,
                             evProgressReporter *progress_reporter = NULL);
  int EncodeFinishEnhancementLayer(evBitBuffer &output_buffer,
                                   const unsigned int current_roi,
                                   const unsigned int current_tile,
                                   const unsigned int current_component,
                                   const unsigned int current_bitplane,
                                   const unsigned int current_scale,
                                   const double current_priority);
  int EncodeSignificancePass(const double threshold,
                             evROI *current_magnitudes,
                             const unsigned int current_component,
                             const unsigned int current_scale_start,
                             const unsigned int current_scale_length,
                             evBitBuffer &output_buffer);
  int EncodeRefinementPass(const double threshold,
                           evROI *current_magnitudes,
                           const unsigned int current_component,
                           const unsigned int current_scale_start,
                           const unsigned int current_scale_length,
                           evBitBuffer &output_buffer);
  int OutputRun(const unsigned int runlength,
                const unsigned int signs,
                const unsigned int vector_dimension,
                evBitBuffer &output_buffer) const;
  int OutputSymbol(int symbol,
                   evBitBuffer &output_buffer) const;
  
  int DecodeStart(evBitBuffer &input_buffer,
                  evDataset &dataset);
  int DecodeNext(evBitBuffer &input_buffer,
                 evDataset &dataset);
  int DecodeStartROIComponent(evBitBuffer &input_buffer,
                              const evDataset &dataset,
                              const unsigned int current_roi,
                              const unsigned int current_tile,
                              const unsigned int current_component,
                              const evBoundingBox &current_bounding_box);
  int DecodeMask(evAlphaField &mask,
                 const unsigned int current_scale_start,
                 const unsigned int current_scale_length,
                 evBitBuffer &input_buffer);
  int DecodeEnhancementLayer(evBitBuffer &input_buffer,
                             const unsigned int current_roi,
                             const unsigned int current_tile,
                             const unsigned int current_component,
                             const unsigned int current_bitplane,
                             const unsigned int current_scale);
  int DecodeSignificancePass(const double threshold,
                             evROI *current_magnitudes,
                             const unsigned int current_component,
                             const unsigned int current_scale_start,
                             const unsigned int current_scale_length,
                             evBitBuffer &input_buffer);
  int DecodeRefinementPass(const double threshold,
                           evROI *current_magnitudes,
                           const unsigned int current_component,
                           const unsigned int current_scale_start,
                           const unsigned int current_scale_length,
                           evBitBuffer &input_buffer);
  int InputRun(int &runlength,
               unsigned int &signs,
               const unsigned int vector_dimension,
               evBitBuffer &input_buffer) const;
  int InputSymbol(int &symbol,
                  evBitBuffer &input_buffer) const;
  int ApplySigns(const evROI &magnitudes,
                 evROI &coefficients,
                 const unsigned int current_roi,
                 const unsigned int current_tile,
                 const unsigned int current_component);
  int CopyMask(const evROI &magnitudes,
               evROI &coefficients,
               const unsigned int current_component);
  int DecodeReconstruct(evDataset &dataset);
  int DecodeReconstructROI(const unsigned int current_roi,
                           const unsigned int current_tile,
                           const unsigned int current_component);
  
  int DeactivateROI(const evPriorityScheduleEntry &entry);

  int DecodeAuxiliaryFiles(const evDataset &dataset);

  int ProcessLevelOfDetail(void);

};


inline unsigned int evCodecSARL::SetSign(const unsigned int map_value,
                                         const unsigned int vector_component)
  const
{
  return(map_value | (1 << vector_component));
}


inline unsigned int evCodecSARL::ClearSign(const unsigned int map_value,
                                           const unsigned int vector_component)
  const
{
  return(map_value & (~(1 << vector_component)));
}


inline unsigned int evCodecSARL::GetSign(const unsigned int map_value,
                                         const unsigned int vector_component)
  const
{
  return((map_value >> vector_component) & 1);
}


inline unsigned int evCodecSARL::SetSignificance(const unsigned int map_value)
     const
{
  return(map_value | (1 << EVMAX_VECTOR_DIMENSION));
}


inline unsigned int evCodecSARL::ClearSignificance(const unsigned int
                                                   map_value) const
{
  return(map_value & (~(1 << EVMAX_VECTOR_DIMENSION)));
}


inline unsigned int evCodecSARL::GetSignificance(const unsigned int map_value)
     const
{
  return((map_value >> EVMAX_VECTOR_DIMENSION) & 1);
}


inline unsigned int evCodecSARL::SetDifference(const unsigned int map_value)
     const
{
  return(map_value | (1 << (EVMAX_VECTOR_DIMENSION + 1)));
}


inline unsigned int evCodecSARL::ClearDifference(const unsigned int map_value)
     const
{
  return(map_value & (~(1 << (EVMAX_VECTOR_DIMENSION + 1))));
}


inline unsigned int evCodecSARL::GetDifference(const unsigned int map_value)
     const
{
  return((map_value >> (EVMAX_VECTOR_DIMENSION + 1)) & 1);
}


#endif