evROI.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 __evROI_h
#define __evROI_h

#include "evDataObject.h"
#include "evVectorField.h"
#include "evSegmentationMap.h"
#include "evWaveletTransformCollection.h"
#include "evProgressReporter.h"
#include "evVisualizerProp.h"
#include "evBoundingBox.h"
#include "evAlphaField.h"


class evROIList;


class evROI : public evDataObject
{
 public:
  virtual ~evROI(void);
  
  virtual const evString GetClassName(void) const
    {
      return(evString("evROI"));
    }
  
  void Free(void);

  void SetNumComponents(const unsigned int num_components);
  unsigned int GetNumComponents(void) const;
  void SetOrigin(const evAddress &origin);
  evAddress GetOrigin(void) const;
  void SetSize(const evAddress &size);
  evAddress GetSize(void) const;
  
  void SetSize(const unsigned int component,
               const evAddress &size,
               const unsigned int vector_dimension);
  evAddress GetSize(const unsigned int component) const;
  unsigned int GetVectorDimension(const unsigned int component) const;

  unsigned int GetTotalSize(unsigned int component) const;

  int Resize(const unsigned int component,
             const evAddress &size,
             const unsigned int vector_dimension,
             const bool linear = 0);

  static evROI *Create(const evAddress &size,
                       const evAddress &origin,
                       const int grid_type,
                       const unsigned int num_components);
  int CreateComponent(const unsigned int component,
                      const evAddress &size,
                      const unsigned int vector_dimension,
                      const int with_alpha_mask);
  static evROI *Create(const evROI &roi);

  int Copy(const evROI &roi);

  void SetROINumber(const int roi_number);
  unsigned int GetROINumber(void) const;
  void SetTileNumber(const int tile_number);
  unsigned int GetTileNumber(void) const;

  void SetNumScales(const unsigned int component,
                    const unsigned int num_scales);
  unsigned int GetNumScales(const unsigned int component) const;
  evAddress GetBasebandSize(const unsigned int component) const;
  int GetBasebandTotalSize(const unsigned int component) const;
  
  void SetCurrentBitplane(unsigned int current_bitplane);
  unsigned int GetCurrentBitplane(void) const;
  void IncrementCurrentBitplane(void);

  void SetCurrentScale(unsigned int current_scale);
  unsigned int GetCurrentScale(void) const;

  void CalcMaxNumScales(void);
  void SetMaxNumScales(unsigned int max_num_scales);
  unsigned int GetMaxNumScales(void) const;
  
  void SetScaleInfo(const unsigned int component,
                    const evFieldScaleInfo &scale_info);
  evFieldScaleInfo GetScaleInfo(const unsigned int component) const;
  
  void CalcCurrentLOD(const double pixel_size);
  int GetCurrentLOD(void) const;
  int LODResize(const unsigned int component,
                const double pixel_size,
                const bool linear = 0);
  int LODCreateComponent(const unsigned int component,
                         const double pixel_size,
                         const unsigned int vector_dimension,
                         const int with_alpha_mask);
                
  void SetNext(evROI *next);
  void SetPrevious(evROI *previous);
  evROI *GetNext(void) const;
  evROI *GetPrevious(void) const;

  double GetMax(unsigned int component) const;
  double GetMin(unsigned int component) const;
  evVector GetMean(unsigned int component) const;
  int GetHighestBitplane(unsigned int component) const;

  evVector SubtractMean(unsigned int component);
  void AddMean(unsigned int component, const evVector &mean);

  void SetGridType(const int grid_type);
  int GetGridType(void) const;
  //  int HasExplicitGrid(void) const;

  evVectorField *GetComponent(unsigned int component) const;
  evAlphaField *GetAlphaMask(unsigned int component) const;

  evVector GetGrid(const evAddress &grid_coordinates) const;

  void SetVisualizerProp(evVisualizerProp *visualizer_prop);
  evVisualizerProp *GetVisualizerProp(void) const;

  void SetBoundingBox(const evBoundingBox &bounding_box);
  evBoundingBox GetBoundingBox(void) const;
  int CalcBoundingBox(void);
  double CalcGridSpacing(void) const;
  
  int SubtractUniformGrid(const evBoundingBox &bounding_box);
  int AddUniformGrid(const evBoundingBox &bounding_box);

  int Segment(const evSegmentationMap &segmentation_map,
              evROIList &roi_list,
              const unsigned int tile_size,
              evProgressReporter *progress_reporter = NULL) const;
  int Composite(const unsigned int component, evVectorField &field) const;

  int MakeOpaque(const unsigned int component);
  int MakeTransparent(const unsigned int component);
  int IsTransparent(const unsigned int component, const int index) const;
  int IsTransparent(const unsigned int component,
                    const evAddress &address) const;

  int RasterScan(const unsigned int component, evROI &roi) const;
  int InverseRasterScan(const unsigned int component, evROI &roi) const;
  int InverseRasterScan(evROI &roi) const;
  int ForwardTransform(const unsigned int component,
                       const evWaveletTransform &wavelet_transform);
  int ForwardTransform(const evWaveletTransformCollection
                       &wavelet_transform_collection);
  int InverseTransform(const unsigned int component,
                       const evWaveletTransform &wavelet_transform);

  int ExtractSubband(const unsigned int subband, evROI &roi) const;
  int PreserveBaseband(void);

  virtual void PrintSelf(const int tabbing) const;
  static evString GridTypeName(const int grid_type);
  static int GridTypeName(const evString &grid_type_name);
  //  static int HasExplicitGrid(const int grid_type);

 protected:
  
 private:
  void Initialize(void);
  evROI(void);

  unsigned int ROINumber;
  unsigned int TileNumber;

  unsigned int NumDimensions;
  evAddress Origin;
  evAddress Size;
  evBoundingBox BoundingBox;

  unsigned int CurrentBitplane;
  unsigned int CurrentScale;
  
  unsigned int MaxNumScales;
  int CurrentLOD;
  
  int GridType;

  unsigned int NumComponents;

  std::vector<evVectorField *> Components;
  std::vector<unsigned int> VectorDimension;
  std::vector<evFieldScaleInfo> ScaleInfo;
  std::vector<evAlphaField *> AlphaMask;

  evROI *Previous;
  evROI *Next;

  evVisualizerProp *VisualizerProp;

  evVector CodecMean;
  int CodecHighestBitplane;
  evVector CodecThreshold;

  int SegmentROI(const unsigned int roi_number,
                 const evSegmentationMap &segmentation_map,
                 evROIList &roi_list,
                 const unsigned int tile_size) const;
  int SegmentTile(const unsigned int roi_number,
                  const unsigned int tile_number,
                  const evAddress &origin,
                  const evAddress &size,
                  const evSegmentationMap &segmentation_map,
                  evROIList &roi_list) const;
  void SegmentTileCopyInfo(const evROI &roi,
                           const evAddress &address1,
                           const evAddress &address2,
                           const unsigned int previous_inside);
};


inline void evROI::SetNumComponents(const unsigned int num_components)
{
  this->NumComponents = num_components;

  if (this->Components.size())
    {
      for (unsigned int component = 0; component < this->Components.size();
           component++)
        delete this->Components[component];
      this->Components = std::vector<evVectorField *>();
    }
  
  this->Components.resize(num_components, NULL);
  
  if (this->AlphaMask.size())
    {
      for (unsigned int component = 0; component < this->AlphaMask.size();
           component++)
        delete this->AlphaMask[component];
      this->AlphaMask = std::vector<evAlphaField *>();
    }
  
  this->AlphaMask.resize(num_components, NULL);

  if (this->VectorDimension.size())
    this->VectorDimension = std::vector<unsigned int>();

  this->VectorDimension.resize(num_components, 0);

  if (this->ScaleInfo.size())
    this->ScaleInfo = std::vector<evFieldScaleInfo>();

  this->ScaleInfo.resize(num_components, evFieldScaleInfo());
}


inline unsigned int evROI::GetNumComponents(void) const
{
  return(this->NumComponents);
}


inline void evROI::SetOrigin(const evAddress &origin)
{
  this->Origin = origin;
}


inline evAddress evROI::GetOrigin(void) const
{
  return(this->Origin);
}


inline void evROI::SetSize(const evAddress &size)
{
  this->Size = size;
  this->NumDimensions = size.GetNumDimensions();
}


inline evAddress evROI::GetSize(void) const
{
  return(this->Size);
}


inline void evROI::SetSize(const unsigned int component,
                           const evAddress &size,
                           const unsigned int vector_dimension)
{
  if (component >= this->NumComponents)
    return;
  
  if (this->Components[component] == NULL)
    return;

  this->Components[component]->SetSize(size, vector_dimension);
  this->VectorDimension[component] = vector_dimension;

  if (this->AlphaMask[component] == NULL)
    return;

  this->AlphaMask[component]->SetSize(size);
}


inline evAddress evROI::GetSize(const unsigned int component) const
{
  evAddress size;

  if (this->Components[component] != NULL)
    size = this->Components[component]->GetSize();

  return(size);
}


inline unsigned int evROI::GetVectorDimension(const unsigned int component)
  const
{
  unsigned int vector_dimension = 0;
  if (component < this->NumComponents)
    vector_dimension = this->VectorDimension[component];

  return(vector_dimension);
}


inline unsigned int evROI::GetTotalSize(unsigned int component) const
{
  if (component < this->NumComponents)
    return(this->Components[component]->GetSize().Product());
  return(0);
}


inline evROI *evROI::Create(const evROI &roi)
{
  evROI *new_roi = evROI::Create(roi.Size,
                                 roi.Origin,
                                 roi.GridType,
                                 roi.NumComponents);
  
  new_roi->Copy(roi);
  return(new_roi);
}


inline void evROI::SetROINumber(const int roi_number)
{
  this->ROINumber = roi_number;
}


inline unsigned int evROI::GetROINumber(void) const
{
  return(this->ROINumber);
}


inline void evROI::SetTileNumber(const int tile_number)
{
  this->TileNumber = tile_number;
}


inline unsigned int evROI::GetTileNumber(void) const
{
  return(this->TileNumber);
}


inline void evROI::SetNumScales(const unsigned int component,
                                const unsigned int num_scales)
{
  if (this->Components[component] != NULL)
    this->Components[component]->SetNumScales(num_scales);
  if (this->AlphaMask[component] != NULL)
    this->AlphaMask[component]->SetNumScales(num_scales);
}


inline unsigned int evROI::GetNumScales(const unsigned int component) const
{
  return(this->Components[component]->GetNumScales());
}


inline int evROI::GetBasebandTotalSize(const unsigned int component) const
{
  return(this->GetBasebandSize(component).Product());
}


inline void evROI::CalcMaxNumScales(void)
{
  evVector lower_bound = this->BoundingBox.GetLowerBound();
  evVector upper_bound = this->BoundingBox.GetUpperBound();
  evVector diff = upper_bound - lower_bound;

  for (unsigned int i = 0; i < diff.Dimension(); i++)
    diff[i] =
      std::max(((int)(std::ceil(std::log(diff[i] + 1) * M_LOG2E) - 1)), 0);
  
  this->SetMaxNumScales((unsigned int)diff.Min());
}


inline void evROI::SetCurrentBitplane(unsigned int current_bitplane)
{
  this->CurrentBitplane = current_bitplane;
}


inline unsigned int evROI::GetCurrentBitplane(void) const
{
  return(this->CurrentBitplane);
}


inline void evROI::IncrementCurrentBitplane(void)
{
  this->CurrentBitplane++;
}


inline void evROI::SetCurrentScale(unsigned int current_scale)
{
  this->CurrentScale = current_scale;
}


inline unsigned int evROI::GetCurrentScale(void) const
{
  return(this->CurrentScale);
}


inline void evROI::SetMaxNumScales(unsigned int max_num_scales)
{
  this->MaxNumScales = max_num_scales;
}


inline unsigned int evROI::GetMaxNumScales(void) const
{
  return(this->MaxNumScales);
}


inline void evROI::SetScaleInfo(const unsigned int component,
                                const evFieldScaleInfo &scale_info)
{
  if (component < this->NumComponents)
    this->ScaleInfo[component] = scale_info;
}


inline evFieldScaleInfo evROI::GetScaleInfo(const unsigned int component) const
{
  return(this->ScaleInfo[component]);
}


inline int evROI::GetCurrentLOD(void) const
{
  return(this->CurrentLOD);
}


inline void evROI::SetNext(evROI *next)
{
  this->Next = next;
}


inline void evROI::SetPrevious(evROI *previous)
{
  this->Previous = previous;
}


inline evROI *evROI::GetNext(void) const
{
  return(this->Next);
}


inline evROI *evROI::GetPrevious(void) const
{
  return(this->Previous);
}


inline void evROI::SetGridType(const int grid_type)
{
  this->GridType = grid_type;
}


inline int evROI::GetGridType(void) const
{
  return(this->GridType);
}


/*
inline int evROI::HasExplicitGrid(void) const
{
  return(this->HasExplicitGrid(this->GridType));
}
*/


inline evVectorField *evROI::GetComponent(unsigned int component) const
{
  if (component >= this->NumComponents)
    return(NULL);

  return(this->Components[component]);
}


inline evAlphaField *evROI::GetAlphaMask(unsigned int component) const
{
  return(this->AlphaMask[component]);
}


inline void evROI::SetVisualizerProp(evVisualizerProp *visualizer_prop)
{
  this->VisualizerProp = visualizer_prop;
}


inline evVisualizerProp *evROI::GetVisualizerProp(void) const
{
  return(this->VisualizerProp);
}


inline void evROI::SetBoundingBox(const evBoundingBox &bounding_box)
{
  this->BoundingBox = bounding_box;
}


inline evBoundingBox evROI::GetBoundingBox(void) const
{
  return(this->BoundingBox);
}


#endif