evPrioritySchedule.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 __evPrioritySchedule_h
#define __evPrioritySchedule_h


#include "evDataObject.h"
#include "evPriorityScheduleEntry.h"


#define EVBITSTREAMMAP_NODATA -1
#define EVROI_NONESELECTED -1


class evPrioritySchedule : public evDataObject
{
 public:
  evPrioritySchedule(void);
  virtual ~evPrioritySchedule(void);
  
  virtual const evString GetClassName(void) const
    {
      return(evString("evPrioritySchedule"));
    }
  
  void Copy(const evPrioritySchedule &priority_schedule);
  
  void Free(void);
  
  evPriorityScheduleEntry *Find(const evPriorityScheduleEntry &entry,
                                const unsigned int match_mask) const;
  void Remove(evPriorityScheduleEntry *entry);
  void Append(evPriorityScheduleEntry &entry);
  void AppendIfUnique(evPriorityScheduleEntry &entry,
                      const unsigned int match_mask);
  void Insert(evPriorityScheduleEntry *insertion_position,
              evPriorityScheduleEntry &entry);
  int Length(void) const;
  
  int IsEmpty(void) const;
  
  void SortedInsert(evPriorityScheduleEntry &entry);
  void Sort(void);
  
  void FindFilePositions(void);
  
  void SetNumDimensions(const unsigned int num_dimensions);

  int ActivateComponent(const unsigned int component);
  /*
  int MatchAndMoveEntries(evPrioritySchedule &priority_schedule,
                          const evPriorityScheduleEntry &entry_to_match,
                          const unsigned int match_mask);
  */
  int MatchAndMoveEntries(evPrioritySchedule &priority_schedule,
                          const evVector &frustum,
                          const double pixel_size,
                          const bool inside,
                          evPrioritySchedule *deactivation_queue);
  int MatchAndMoveEntries(evPrioritySchedule &priority_schedule,
                          const unsigned int component,
                          const evVector &frustum,
                          const double pixel_size,
                          const bool inside);
  evPriorityScheduleEntry *StartTraversal(void);
  evPriorityScheduleEntry *NextEntry(void);
  evPriorityScheduleEntry *FirstEntry(void) const;
  evPriorityScheduleEntry *LastEntry(void) const;
  
  void NormalizePriorities(void);
  static void NormalizePriorities(evPrioritySchedule &inactive_queue,
                                  evPrioritySchedule &transmission_queue,
                                  evPrioritySchedule &already_sent_queue);
  static void SelectROI(evPrioritySchedule &inactive_queue,
                        evPrioritySchedule &transmission_queue,
                        evPrioritySchedule &already_sent_queue,
                        const int roi);
  
  int Read(const evString filename);
  int Read(evBitBuffer &input_buffer);
  int Write(const evString filename) const;
  int Write(evBitBuffer &output_buffer) const;
  
  void PrintSelf(const int tabbing) const;
  
 protected:
  
 private:
  unsigned int NumDimensions;

  evPriorityScheduleEntry *Start;
  evPriorityScheduleEntry *End;
  evPriorityScheduleEntry *Current;
  
  evPrioritySchedule(const evPrioritySchedule &priority_schedule);
  void Initialize(void);
  int ReadHeader(evFile &infile, int &num_entries);
  int ReadData(evBitBuffer &input_buffer, const int num_entries);
  int WriteHeader(evFile &outfile) const;
  int WriteData(evBitBuffer &output_buffer) const;

  void FindMaxMinPriority(double &max_priority, double &min_priority) const;
  void NormalizePriorities(const double max_priority,
                           const double min_priority);
  void SelectROI(const int roi);
};


inline void evPrioritySchedule::Initialize(void)
{
  this->NumDimensions = 0;

  this->Start = NULL;
  this->End = NULL;
  this->Current = NULL;
}


inline evPrioritySchedule::evPrioritySchedule(void)
{
  this->Initialize();
}


inline evPrioritySchedule::~evPrioritySchedule(void)
{
  this->Free();
}


inline void evPrioritySchedule::Free(void)
{
  evPriorityScheduleEntry *current;
  evPriorityScheduleEntry *next;
  
  current = this->Start;
  while (current != NULL)
    {
      next = current->GetNext();
      delete current;
      current = next;
    }
  
  this->Start = NULL;
  this->End = NULL;
  this->Current = NULL;
}


inline void evPrioritySchedule::SetNumDimensions(const unsigned int
                                                 num_dimensions)
{
  this->NumDimensions = num_dimensions;
}


inline int evPrioritySchedule::IsEmpty(void) const
{
  return(this->Start == NULL);
}
  

inline evPriorityScheduleEntry *evPrioritySchedule::StartTraversal(void)
{
  this->Current = this->Start;
  return(this->Current);
}


inline evPriorityScheduleEntry *evPrioritySchedule::NextEntry(void)
{
  if (this->Current == NULL)
    return(this->StartTraversal());
  
  this->Current = this->Current->GetNext();
  return(this->Current);
}


inline evPriorityScheduleEntry *evPrioritySchedule::FirstEntry(void) const
{
  return(this->Start);
}


inline evPriorityScheduleEntry *evPrioritySchedule::LastEntry(void) const
{
  return(this->End);
}


inline void evPrioritySchedule::NormalizePriorities(void)
{
  double min_priority;
  double max_priority;
  
  this->FindMaxMinPriority(max_priority, min_priority);

  this->NormalizePriorities(max_priority, min_priority);
}


#endif