+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

bounding_shape.cc

Go to the documentation of this file.

// -*-c++-*-
//---------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file  bounding_shape.cc
 *
 * The Bounding_Shape class models the collision parameters of a
 * three-dimensionsl object. It is to be used in collision detection
 * algorithms.
 *
 * <br>@b Designer(s):  Hari Das Nayar, Issa Nesnas
 * <br>@b Author(s):    Hari Das Nayar
 * <br>@b Date:         August 4, 2005
 *
 * <b>Software License:</b><br>
 * <code> http://claraty.jpl.nasa.gov/license/open_src/  or 
 *        file: license/open_src.txt </code> 
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology<br>
 *
 * $Revision: 1.7 $
 */
//-----------------------------------------------------------------------------

#include "claraty/bounding_shape.h"

using namespace std;

namespace claraty {

//-------------------------------------------------------------------------
//---------------------<< Bounding_Shape Class >>--------------------------
//-------------------------------------------------------------------------
/**
 * Default constructor
 *
 * @ingroup mech_model_pkg
 */
Bounding_Shape::Bounding_Shape()
  : _name("root"), 
    _parent_name(""), 
    _is_container(false), 
    _is_aligned(false), 
    _ignore_collisions(false), 
    _tol(0.0)
{
}

//----------------------------------------------------------------------------
/**
 * Copy constructor
 *
 * @param[in] bounding_shape  Reference to the bounding shape to be copied.
 *
 * @ingroup bounding_shape_pkg
 */

Bounding_Shape::Bounding_Shape(const Bounding_Shape & bounding_shape)
{
  _name              = bounding_shape._name;
  _parent_name       = bounding_shape._parent_name;
  _is_container      = bounding_shape._is_container;
  _is_aligned        = bounding_shape._is_aligned;
  _ignore_collisions = bounding_shape._ignore_collisions;
  _tol               = bounding_shape._tol;

  _transform         = bounding_shape._transform;
  _three_d_object    = bounding_shape._three_d_object;
}


//----------------------------------------------------------------------------
/**
 * Destructor for a Bounding_Shape object.
 *
 * @ingroup bounding_shape_pkg
 */
Bounding_Shape::~Bounding_Shape()
{
}

//----------------------------------------------------------------------------
/**
 * Set name parameter 
 *
 * @param[in]  name The name of the bounding shape.
 * @return     void
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set_name(std::string name)
{
  _name = name;
}

//----------------------------------------------------------------------------
/**
 * Get name parameter of the bouding shape.
 *
 * @return Bounding shape name
 *
 * @ingroup bounding_shape_pkg
 */

std::string 
Bounding_Shape::get_name()
{
  return _name;
}

//----------------------------------------------------------------------------
/**
 * Set parent name parameter 
 *
 * @param[in] parent_name The name of the parent.
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set_parent_name(std::string parent_name)
{
  _parent_name = parent_name;
}

//----------------------------------------------------------------------------
/**
 * Get parent name parameter 
 *
 * @return enum type
 *
 * @ingroup bounding_shape_pkg
 */
std::string 
Bounding_Shape::get_parent_name()
{
  return _parent_name;
}

//----------------------------------------------------------------------------
/**
 * Set containment parameter 
 *
 * @param[in] containment
 *
 * @return enum type
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set_containment(bool containment)
{
  _is_container = containment;
}

//----------------------------------------------------------------------------
/**
 * Get containment parameter 
 *
 * @return A boolean if _is_containiner returns true.
 *
 * @ingroup bounding_shape_pkg
 */
bool 
Bounding_Shape::get_containment()
{
  return _is_container;
}

//----------------------------------------------------------------------------
/**
 * Set alignment parameter 
 *
 * @param[in] alignment
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set_alignment(bool alignment)
{
  _is_aligned = alignment;
}

//----------------------------------------------------------------------------
/**
 * Get alignment parameter 
 *
 * @return booliean indicating alignment.
 *
 * @ingroup bounding_shape_pkg
 */
bool 
Bounding_Shape::get_alignment()
{
  return _is_aligned;
}

//----------------------------------------------------------------------------
/**
 * Set collision parameter 
 *
 * @param[in] collision Set boolean value.
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set_collision(bool collision)
{
  _ignore_collisions = collision;
}

//----------------------------------------------------------------------------
/**
 * Get collision parameter 
 *
 * @return Collision boolean.
 *
 * @ingroup bounding_shape_pkg
 */
bool 
Bounding_Shape::get_collision()
{
  return _ignore_collisions;
}

//----------------------------------------------------------------------------
/**
 * Set tollerance parameter 
 *
 * @param[in] tolerance
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set_tolerance(double tolerance)
{
  _tol = tolerance;
}

//----------------------------------------------------------------------------
/**
 * Get tollerance parameter 
 *
 * @return Tolerance.
 *
 * @ingroup bounding_shape_pkg
 */
double & 
Bounding_Shape::get_tolerance()
{
  return _tol;
}

//----------------------------------------------------------------------------
/**
 * Set transform
 *
 * @param[in] transform
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set(Transform & transform)
{
  _transform = transform;
}

//----------------------------------------------------------------------------
/**
 * Get transform
 *
 * @return Transform.
 *
 * @ingroup bounding_shape_pkg
 */
Transform & 
Bounding_Shape::get_transform()
{
  return _transform;
}

//----------------------------------------------------------------------------
/**
 * Set shape object
 *
 * @param[in] three_d_object
 *
 * @ingroup bounding_shape_pkg
 */
void 
Bounding_Shape::set(N_3D_Object & three_d_object)
{
  _three_d_object = three_d_object;
}
//----------------------------------------------------------------------------
/**
 * Get shape object
 *
 * @return Shape
 *
 * @ingroup bounding_shape_pkg
 */
N_3D_Object & 
Bounding_Shape::get_3d_object()
{
  return _three_d_object;
}

//----------------------------------------------------------------------------
/**
 * Output to ostream
 *
 * @param[out] os  ostream to put output on
 * @param[in]  bounding_shape  Bounding_Shape object to be output
 * @return ostream with output on it
 *
 * @ingroup mechanism_model_io_pkg
 */
std::ostream& operator<< (std::ostream& os, Bounding_Shape & bounding_shape)
{
  std::string spacing = "";
  std::string child_spacing = "";
  spacing.append(XML_Out::get_indentation_space(), ' ');
  child_spacing.append(XML_Out::get_indentation_space()
                       + XML_Out::get_tab_space(), ' ');

  os << spacing;
  os << "<Bounding_Shape ";
  os << "name = \""     << bounding_shape.get_name() << "\" ";
  os << "parent = \""   << bounding_shape.get_parent_name() << "\" ";
  os << "is_container = \""
     << (bounding_shape.get_containment()   ?  "true" : "false")  << "\" ";;
  os << "is_aligned = \""
     << (bounding_shape.get_alignment() ? "true" : "false")  << "\" ";;
  os << "ignore_collisions = \""
     << (bounding_shape.get_collision()   ?  "true" : "false")  << "\" ";;
  os << "tol = \"" << bounding_shape.get_tolerance() << "\" ";
  os << ">\n";

#ifdef DEBUG
  cout << "In Bounding_Shape, about to output transform_io" << endl;
#endif
  os << child_spacing;
  os << "<Transform>\n";
  XML_Out::increment_indentation_level();
  XML_Out::increment_indentation_level();
  os << XML_Out::enable << bounding_shape.get_transform() << XML_Out::disable;
  XML_Out::decrement_indentation_level();
  XML_Out::decrement_indentation_level();
  os << child_spacing;
  os << "</Transform>\n";
  
#ifdef DEBUG
  cout << "In Bounding_Shape, about to output bounding_shape_io" << endl;
#endif
  XML_Out::increment_indentation_level();
  os << bounding_shape.get_3d_object();
  XML_Out::decrement_indentation_level();

  os << spacing;
  os << "</Bounding_Shape> \n";

  return os;

}

//-------------------------------------------------------------------------
//----------------<< Composite_Bounding_Shape Class >>---------------------
//-------------------------------------------------------------------------
//----------------------------------------------------------------------------
/**
 * Insert a bounding_shape object to the bounding_shape tree
 *
 * @param[in] bounding_shape Shape to be inserted into the tree.
 *
 * @ingroup bounding_shape_pkg
 */
void 
Composite_Bounding_Shape::insert(Bounding_Shape * bounding_shape)
{
  bool attached_new_node = false;

  Tree<Bounding_Shape>::Pre_Order_Iterator p_shape_tree_itr
    = _bounding_shape_tree.begin_pre_order();
  Tree<Bounding_Shape>::Pre_Order_Iterator p_end_shape_tree_itr
    = _bounding_shape_tree.end_pre_order();
  for (; p_shape_tree_itr < p_end_shape_tree_itr; ++p_shape_tree_itr)
    {
      if (p_shape_tree_itr->get_name() == bounding_shape->get_parent_name())
        {
          _bounding_shape_tree.append_child(p_shape_tree_itr, bounding_shape);
          attached_new_node = true;
          break;
        }
    }
  if ((!attached_new_node)||
      (bounding_shape->get_parent_name().length() == 0))
    // If parent name wasn't found or name string length is zero, attach to root
    {
      Tree<Bounding_Shape>::Pre_Order_Iterator p_shape_tree_itr
        = _bounding_shape_tree.begin_pre_order();
      _bounding_shape_tree.append_child(p_shape_tree_itr, bounding_shape);
      attached_new_node = true;
    }
}
//----------------------------------------------------------------------------
/**
 * Insert a bounding_shape object at the root of the bounding_shape tree
 *
 * @param[in] bounding_shape Object to be inserted at the root of the tree.
 *
 * @ingroup bounding_shape_pkg
 */
void 
Composite_Bounding_Shape::insert_at_root(Bounding_Shape * bounding_shape)
{
  Tree<Bounding_Shape>::Pre_Order_Iterator p_shape_tree_itr
    = _bounding_shape_tree.begin_pre_order();
  _bounding_shape_tree.append_child(p_shape_tree_itr, bounding_shape);
}

//----------------------------------------------------------------------------
/**
 * Copy of the tree to this bounding_shape tree
 *
 * @param[in] composite_bounding_shape
 *
 * @ingroup bounding_shape_pkg
 */
void 
Composite_Bounding_Shape::copy(Composite_Bounding_Shape & composite_bounding_shape)
{
  _bounding_shape_tree.copy(composite_bounding_shape._bounding_shape_tree);
}

//----------------------------------------------------------------------------
/**
 * Return true if tree is empty, false if not
 *
 * @return True if tree is empty and false if it is not empty.
 *
 * @ingroup bounding_shape_pkg
 */
bool 
Composite_Bounding_Shape::empty()
{
  return _bounding_shape_tree.empty();
}
//----------------------------------------------------------------------------
/**
 * Clear the tree
 *
 * @ingroup bounding_shape_pkg
 */
void 
Composite_Bounding_Shape::clear_tree()
{
  return _bounding_shape_tree.clear_tree();
}
//----------------------------------------------------------------------------
/**
 * Get the tree
 *
 * @return The tree.
 *
 * @ingroup bounding_shape_pkg
 */
Tree<Bounding_Shape> & 
Composite_Bounding_Shape::get_shape_tree()
{
  return _bounding_shape_tree;
}
//----------------------------------------------------------------------------
/**
 * Output to ostream
 *
 * @param[out] os  ostream to put output on.
 * @param[in]  composite_bounding_shape The object to be output.
 * @return ostream with output on it.
 *
 * @ingroup mechanism_model_io_pkg
 */
std::ostream& operator<< (std::ostream& os,
                          Composite_Bounding_Shape & composite_bounding_shape)
{
  Tree<Bounding_Shape>::Pre_Order_Iterator p_shape_tree_itr
    = composite_bounding_shape.get_shape_tree().begin_pre_order();
  Tree<Bounding_Shape>::Pre_Order_Iterator p_end_shape_tree_itr
    = composite_bounding_shape.get_shape_tree().end_pre_order();
  
  ++p_shape_tree_itr; // Skip the root object of the object tree
  
  for (; p_shape_tree_itr < p_end_shape_tree_itr; ++p_shape_tree_itr)
    {
      os << *p_shape_tree_itr;
    }
  return os;
}
//----------------------------------------------------------------------------
/**
 * Return the top-level bounding_shape object in the composite
 *
 * @return ostream with the level bounding shape.
 *
 * @ingroup mechanism_model_io_pkg
 */
Bounding_Shape & Composite_Bounding_Shape::_get_top_level_bounding_shape()
{
  Tree<Bounding_Shape>::Pre_Order_Iterator p_shape_tree_itr
    = get_shape_tree().begin_pre_order();

  ++p_shape_tree_itr;
  return *p_shape_tree_itr;

}//----------------------------------------------------------------------------


} // namespace claraty

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635