Box.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGBox_HH_
#define _MGBox_HH_

#include <vector>
#include <assert.h>
#include "mg/Interval.h"

// MGBox.h
// Header for class MGBox.
//

//Forward Declaration
class MGVector;
class MGPosition;
class MGMatrix;
class MGTransf;
class MGStraight;
class MGPlane;
class MGIfstream;
class MGOfstream;


class MG_DLL_DECLR MGBox{

public:

MG_DLL_DECLR friend MGBox operator+(const MGVector& v, const MGBox& b);

MG_DLL_DECLR friend MGBox operator* (double scale, const MGBox&);

MG_DLL_DECLR friend std::ostream& operator<< (std::ostream&, const MGBox&);


MGBox(const MGBox& box2);

explicit MGBox(int dim=0):m_sdim(0), m_range(0){if(dim) get_area(dim);};

MGBox(const MGInterval& xspan, const MGInterval& yspan);

MGBox(const MGInterval& xspan, const MGInterval& yspan, const MGInterval& zspan);

MGBox(const MGPosition& center, double* size);

MGBox(const MGPosition& center, double size=0.);

MGBox(const MGPosition&, const MGPosition&);

MGBox(const MGBox&, const MGPosition&);

MGBox(int dim, const MGInterval*);

MGBox(
  int dim,      
  const MGBox& box, 
  int start1=0, 
  int start2=0  
);

~MGBox();


MGBox& operator= (const MGBox& box2);

const MGInterval& operator[](int i) const {return ref(i);}
const MGInterval& operator()(int i) const {return ref(i);}

MGInterval& operator[](int i){assert(i<sdim());return m_range[i];}
MGInterval& operator()(int i){assert(i<sdim());return m_range[i];}

MGBox operator+ (const MGVector& v) const;

MGBox& operator+= (const MGVector&);

MGBox operator- (const MGVector&) const;

MGBox& operator-= (const MGVector&);

MGBox operator* (double) const;

MGBox operator* (const MGMatrix& ) const;

MGBox operator* (const MGTransf& ) const;

MGBox& operator*= ( double scalar);

MGBox& operator*= (const MGMatrix& );

MGBox& operator*= (const MGTransf& );

MGBox operator/ ( double a) const;

MGBox& operator/= ( double );

MGBox operator| ( const MGBox& ) const;

MGBox& operator|= ( const MGBox& );

MGBox operator& ( const MGBox& ) const;

MGBox& operator &= ( const MGBox& );

bool operator== (const MGBox& box2) const;
bool operator!= (const MGBox& box2) const{return !(*this==box2);}

bool operator >> (const MGPosition&) const;

bool operator>> (const MGBox&) const;

bool operator<< (const MGPosition& pt) const{return !((*this)>>pt);}

bool operator<< (const MGBox& box2) const{return box2>>(*this);}


bool crossing(const MGStraight& sl)const;

bool cutting(const MGPlane& plane)const;

double distance(const MGPosition& P) const;

int dump(MGOfstream& ) const;

int dump_size() const;

void expand();

void expand(double len);

void expand(double* len);

void expand(const MGPosition& P);

bool empty() const;

bool finite() const;

MGPosition high() const;
MGPosition low() const;
MGPosition mid() const;

bool includes_origin()const;

bool includes(const MGPosition& P)const{return operator>>(P);};

bool is_null()const{return m_sdim==0;}

double len() const;

double length()const{return len();};

const MGInterval& ref(int i) const;

int restore(MGIfstream& );

int sdim() const{return m_sdim;};

MGBox& set_high(const MGPosition&);

MGBox& set_low(const MGPosition&);

void set_null();
                                                          
MGINTERVAL_TYPE type(int i) const{
    if(i>=m_sdim) return MGINTERVAL_EMPTY;
    return m_range[i].type();
}

std::vector<MGPosition> vertex() const;

private:
    MGInterval m_rData[3];  
    int m_sdim;         
    MGInterval* m_range;

bool crossing2D(const MGStraight& sl)const;

void get_area(int dim);

void resize(int dim);

};
 // end of BASE group
#endif