SiExtents.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
#ifndef _SpExtents_h_Included_
#define _SpExtents_h_Included_
 
#if _MSC_VER >= 1000
#pragma once
#endif
 
#include "Si/SiSpatialIndex.h"
 
namespace OdSi
{
 
  class ODSI_API Extent3d : public OdGeExtents3d, public OdSiShape
  {
  public:
    virtual bool contains( const OdGeExtents3d& extents, bool planar = false, const OdGeTol& tol = OdGeContext::gTol) const
    {
      if ( planar ) 
      {
        ODA_ASSERT ( extents.minPoint().z == 0 && extents.maxPoint().z == 0 );
      }
      return OdGeExtents3d::contains( extents, tol );
    }
 
    virtual bool intersects( const OdGeExtents3d& extents, bool planar = false, const OdGeTol& tol = OdGeContext::gTol) const
    {
      if ( planar == false )
        return !isDisjoint( extents, tol );
      else
      {
        return !( extents.minPoint().x > (maxPoint().x + tol.equalPoint())
          || extents.minPoint().y > (maxPoint().y + tol.equalPoint())
          || minPoint().x > (extents.maxPoint().x + tol.equalPoint()) 
          || minPoint().y > (extents.maxPoint().y + tol.equalPoint()));
      }
    }
 
    enum IntersectResult 
    { 
      left    = 0,     // Coordinate is to the *left* of the *extents*.
      upon    = 1,     // Coordinate is *upon* the *extents*.
      right   = 2      // Coordinate is to the *right* of the *extents*.
    };
    
    
#ifndef SWIG
 
    IntersectResult intersects( double coordinate, int dimension, double tol = OdGeContext::gTol.equalPoint() ) const
    {
      if ( m_min[dimension] > (coordinate + tol) ) return right;
      if ( m_max[dimension] < (coordinate - tol) ) return left;
      return upon;
    }
#endif
 
    void makeHalf( int dimension, bool moveRight )
    {
      if ( moveRight )
        m_max[dimension] = ( m_min[dimension] + m_max[dimension]) / 2;
      else 
        m_min[dimension] = ( m_min[dimension] + m_max[dimension]) / 2;
    }
 
    void makeDouble( int dimension, bool moveRight )
    {
      if ( moveRight )
        m_max[dimension] += ( m_max[dimension] - m_min[dimension] );
      else 
        m_min[dimension] -= ( m_max[dimension] - m_min[dimension] );
    }
    void makeCube( bool planar )
    {
      if ( m_min.isEqualTo( m_max ) ) return;
      double ext = odmax( m_max.x - m_min.x, m_max.y - m_min.y );
      if ( !planar ) ext = odmax( m_max.z - m_min.z, ext );
      m_max.x = m_min.x + ext;
      m_max.y = m_min.y + ext;
      if ( !planar ) m_max.z = m_min.z + ext;
    }
    
    Extent3d() {}
    Extent3d( const OdGePoint3d& min, const OdGePoint3d& max )
      : OdGeExtents3d( min, max ) {}
    Extent3d( const OdGeExtents3d& source ) : OdGeExtents3d( source ) {}
    Extent3d( const OdGeExtents2d& source ) 
      : OdGeExtents3d( OdGePoint3d( source.minPoint().x, source.minPoint().y, 0 ), 
      OdGePoint3d( source.maxPoint().x, source.maxPoint().y, 0 )) {}
  };
}
#endif