OrientedBoxTreeTool.hpp

Go to the documentation of this file.

/*
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 * 
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Coroporation, the U.S. Government
 * retains certain rights in this software.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 */

#ifndef MOAB_ORIENTED_BOX_TREE_TOOL_HPP
#define MOAB_ORIENTED_BOX_TREE_TOOL_HPP

#include "moab/Forward.hpp"

#include <iosfwd>
#include <list>
#include <vector>

namespace moab {

class Range;
class OrientedBox;
class StatData;
class CartVect;

class OrientedBoxTreeTool
{
  public:
  
    struct Settings {
      public:
        Settings();              
        int max_leaf_entities;   
        int max_depth;           



        double worst_split_ratio;
        double best_split_ratio;
        unsigned int set_options;
        bool valid() const;
    };
  
    OrientedBoxTreeTool( Interface* i, 
                           const char* tag_name = 0,
                           bool destroy_created_trees = false ) ;
  
    ~OrientedBoxTreeTool();
  
    ErrorCode build( const Range& entities, 
                       EntityHandle& set_handle_out,
                       const Settings* settings = 0 );
     
    ErrorCode join_trees( const Range& tree_roots,
                            EntityHandle& root_set_out,
                            const Settings* settings = 0 );


    class TrvStats{ 
      public:

        const std::vector< unsigned >& nodes_visited() const
        { return nodes_visited_count; }
        const std::vector< unsigned >& leaves_visited() const
        { return leaves_visited_count; }
        const std::vector< unsigned >& traversals_ended() const 
        { return traversals_ended_count; }        
        unsigned int ray_tri_tests() const
        { return ray_tri_tests_count; }
        void reset();
        void print( std::ostream& str ) const ;

        TrvStats() : ray_tri_tests_count(0) {}

      private: 
      
        std::vector< unsigned > nodes_visited_count;
        std::vector< unsigned > leaves_visited_count;
        std::vector< unsigned > traversals_ended_count;
        unsigned int ray_tri_tests_count;

        void increment( unsigned depth );
        void increment_leaf( unsigned depth );
        void end_traversal( unsigned depth );

      friend class OrientedBoxTreeTool;

    };


    ErrorCode ray_intersect_triangles( std::vector<double>& distances_out,
                                         std::vector<EntityHandle>& facets_out,
                                         EntityHandle root_set,
                                         double tolerance,
                                         const double ray_point[3],
                                         const double unit_ray_dir[3],
                                         const double* ray_length = 0,
                                         TrvStats* accum = 0 );
    
    ErrorCode ray_intersect_boxes( Range& boxes_out,
                                     EntityHandle root_set,
                                     double tolerance,
                                     const double ray_point[3],
                                     const double unit_ray_dir[3],
                                     const double* ray_length = 0,
                                     TrvStats* accum = 0 );

    ErrorCode ray_intersect_triangles( 
                          std::vector<double>& intersection_distances_out,
                          std::vector<EntityHandle>& intersection_facets_out,
                          const Range& leaf_boxes_containing_tris,
                          double tolerance,
                          const double ray_point[3],
                          const double unit_ray_dir[3],
                          const double* ray_length = 0, 
                          unsigned int* raytri_test_count = 0);
                          

    ErrorCode ray_intersect_sets( std::vector<double>&       distances_out,
                                  std::vector<EntityHandle>& sets_out,
                                  std::vector<EntityHandle>& facets_out,
                                  EntityHandle               root_set,
                                  double                     tolerance,
                                  int                        min_tolerace_intersections,
                                  const double               ray_point[3],
                                  const double               unit_ray_dir[3],
                                  const double*              nonneg_ray_len = 0,
                                  TrvStats*                  accum          = 0,
                                  const double*              neg_ray_len    = 0,
                                  const EntityHandle*        geom_vol       = 0,
                                  const Tag*                 sense_tag      = 0,
                                  const int*                 desired_orient = 0,
                                  const std::vector<EntityHandle>* prev_facets = 0 );
    
    ErrorCode closest_to_location( const double* point,
                                     EntityHandle tree_root,
                                     double* point_out,
                                     EntityHandle& facet_out,
                                     EntityHandle* set_out = 0, 
                                     TrvStats* accum = 0 );
                                     
    ErrorCode closest_to_location( const double* point,
                                     EntityHandle tree_root,
                                     double tolerance,
                                     std::vector<EntityHandle>& facets_out,
                                     std::vector<EntityHandle>* sets_out = 0, 
                                     TrvStats* accum = 0 );
    
    ErrorCode sphere_intersect_triangles( const double* center,
                                        double radius,
                                        EntityHandle tree_root,
                                        std::vector<EntityHandle>& facets_out,
                                        std::vector<EntityHandle>* sets_out = 0, 
                                        TrvStats* accum = 0 );
    
    ErrorCode box( EntityHandle node_set,
                     double center[3],
                     double axis1[3],
                     double axis2[3],
                     double axis3[3] );
                         
    ErrorCode delete_tree( EntityHandle root_set );

    void print( EntityHandle tree_root_set, 
                std::ostream& stream,
                bool list_contents = false,
                const char* id_tag_name = 0 );
                
    ErrorCode stats( EntityHandle tree_root_set, std::ostream& stream );
  
  ErrorCode stats( EntityHandle set, 
                     unsigned &entities_in_tree,
                     double &root_volume,
                     double &tot_node_volume,
                     double &tot_to_root_volume,
                     unsigned &tree_height,
                     unsigned &node_count,
                     unsigned &num_leaves);
  
    class Op {
      public:

        virtual ErrorCode visit( EntityHandle node,
                                 int depth,
                 bool& descend ) = 0;
       
        virtual ErrorCode leaf( EntityHandle node ) = 0;

        virtual ~Op(); // probably isn't necessary in this case, and
                       // does nothing, but lots of compilers warn if
                       // virtual function but no virtual destructor.
    };
    
    ErrorCode preorder_traverse( EntityHandle root_set,
                                   Op& operation, 
                                   TrvStats* accum = 0 );
  
    Interface* get_moab_instance() const { return instance; }
  
    struct SetData;
    
    ErrorCode box( EntityHandle node_set,
                     OrientedBox& box );
  private:
  
    ErrorCode build_tree( const Range& entities, 
                            EntityHandle& set, 
                            int depth,
                            const Settings& settings );
  
    ErrorCode build_sets( std::list<SetData>& sets,
                            EntityHandle& node_set,
                            int depth,
                            const Settings& settings );

    ErrorCode recursive_stats( OrientedBoxTreeTool* tool,
                                    Interface* instance,
                                    EntityHandle set,
                                    int depth,
                                    StatData& data,
                                    unsigned& count_out,
                                    CartVect& dimensions_out );
  
    Interface* instance;
    Tag tagHandle;
 
    bool cleanUpTrees;
    std::vector<EntityHandle> createdTrees;
};

} // namespace moab 

#endif