evBoundingBox.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 __evBoundingBox_h
#define __evBoundingBox_h


#include "evField.h"
#include "evAddress.h"


class evBoundingBox : public evDataObject
{
public:
  evBoundingBox(void);
  evBoundingBox(const unsigned int num_dimensions);
  evBoundingBox(const evBoundingBox &bounding_box);
  virtual ~evBoundingBox(void);
  
  virtual const evString GetClassName(void) const
  {
    return(evString("evBoundingBox"));
  }
  
  void SetLowerBound(const evVector &lower_bound);
  evVector GetLowerBound(void) const;

  void SetUpperBound(const evVector &upper_bound);
  evVector GetUpperBound(void) const;

  void SetBounds(const evVector &lower_bound,
                 const evVector &upper_bound);

  evBoundingBox operator = (const evBoundingBox &bounding_box);

  evVector CalcUniformGrid(const evAddress &grid_coordinates,
                           const evAddress &size) const;

  double CalcPixelSize(const evAddress &size) const;

  int InsideViewFrustum(const evVector &frustum) const;

  void PrintSelf(const int tabbing) const;

protected:
  
private:
  evVector LowerBound;
  evVector UpperBound;
};


inline evBoundingBox::evBoundingBox(void)
{
}


inline evBoundingBox::evBoundingBox(const unsigned int num_dimensions) :
  LowerBound(num_dimensions), UpperBound(num_dimensions)
{
}


inline evBoundingBox::evBoundingBox(const evBoundingBox &bounding_box)
{
  this->LowerBound = bounding_box.LowerBound;
  this->UpperBound = bounding_box.UpperBound;
}


inline evBoundingBox::~evBoundingBox(void)
{
}


inline void evBoundingBox::SetLowerBound(const evVector &lower_bound)
{
  this->LowerBound = lower_bound;
}


inline evVector evBoundingBox::GetLowerBound(void) const
{
  return(this->LowerBound);
}


inline void evBoundingBox::SetUpperBound(const evVector &upper_bound)
{
  this->UpperBound = upper_bound;
}


inline evVector evBoundingBox::GetUpperBound(void) const
{
  return(this->UpperBound);
}


inline void evBoundingBox::SetBounds(const evVector &lower_bound,
                                     const evVector &upper_bound)
{
  this->SetLowerBound(lower_bound);
  this->SetUpperBound(upper_bound);
}


inline evBoundingBox evBoundingBox::operator = (const evBoundingBox
                                                &bounding_box)
{
  this->LowerBound = bounding_box.LowerBound;
  this->UpperBound = bounding_box.UpperBound;

  return(*this);
}


inline evVector evBoundingBox::CalcUniformGrid(const evAddress
                                               &grid_coordinates,
                                               const evAddress &size) const
{
  unsigned int num_dimensions = this->LowerBound.Dimension();

  evVector uniform_grid(num_dimensions);

  for (unsigned int component = 0; component < num_dimensions;
       component++)
    uniform_grid[component] =
      (this->UpperBound[component] - this->LowerBound[component]) *
      ((double)grid_coordinates[component] / (size[component] - 1)) +
      this->LowerBound[component];
  return(uniform_grid);
}


inline double evBoundingBox::CalcPixelSize(const evAddress &size) const
{
  double pixel_size = -MAXDOUBLE;

  unsigned int num_dimensions = this->LowerBound.Dimension();

  for (unsigned int component = 0; component < num_dimensions;
       component++)
    if (size[component] > 1)
      pixel_size = std::max(pixel_size,
                            std::fabs(this->UpperBound[component] -
                                      this->LowerBound[component]) /
                            (size[component] - 1));

  return(pixel_size);
}


inline void evBoundingBox::PrintSelf(const int tabbing) const
{
  evPrintWithTab(tabbing, "Lower Bound: ");
  this->LowerBound.PrintSelf(EVPRINT_NOFORMAT);
  printf("\n");
  evPrintWithTab(tabbing, "Upper Bound: ");
  this->UpperBound.PrintSelf(EVPRINT_NOFORMAT);
  printf("\n");
}


inline int evBoundingBox::InsideViewFrustum(const evVector &frustum)
     const
{
  evVector diagonal = this->UpperBound - this->LowerBound;
  evVector center = (diagonal / 2.0) + this->LowerBound;
  double radius = diagonal.Norm() / 2;

  if (center.Dimension() >= 3)
    for (unsigned int plane = 0; plane < 6; plane++)
      {
        double distance =
          frustum[plane * 4 + 0] * center[0] +
          frustum[plane * 4 + 1] * center[1] +
          frustum[plane * 4 + 2] * center[2] +
          frustum[plane * 4 + 3];
        if (distance < -radius)
          return(0);
      }
  else
    for (unsigned int plane = 0; plane < 4; plane++)
      {
        double distance =
          frustum[plane * 4 + 0] * center[0] +
          frustum[plane * 4 + 1] * center[1] +
          frustum[plane * 4 + 3];
        if (distance < -radius)
          return(0);
      }

  return(1);
}


#endif