GeomUtil.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 MB_GEOM_UTIL_HPP
#define MB_GEOM_UTIL_HPP

#include "moab/CartVect.hpp"
#include <cmath>

namespace moab {

namespace GeomUtil {

bool segment_box_intersect( CartVect box_min,
                            CartVect box_max,
                            const CartVect& seg_pt,
                            const CartVect& seg_unit_dir,
                            double& seg_start, double& seg_end );

bool ray_tri_intersect( const CartVect vertices[3],
                        const CartVect& ray_point,
                        const CartVect& ray_unit_direction,
                        double tolerance,
                        double& t_out,
                        const double* ray_length = 0 );


enum intersection_type {NONE, INTERIOR, NODE0, NODE1, NODE2, EDGE0, EDGE1, EDGE2};
bool plucker_ray_tri_intersect( const CartVect vertices[3],
                                const CartVect& ray_point,
                                const CartVect& ray_unit_direction,
                                double tolerance, /* unused */
                                double& dist_out,
                                const double* nonneg_ray_length = 0,
                                const double* neg_ray_length = 0,
                                const int* orientation = 0,
                                intersection_type* int_type = 0);

bool ray_box_intersect( const CartVect& box_min,
                        const CartVect& box_max,
                        const CartVect& ray_pt,
                        const CartVect& ray_dir,
                        double& t_enter, double& t_exit );

bool box_plane_overlap( const CartVect& plane_normal, 
                        double            plane_coeff,
                        CartVect        box_min_corner, 
                        CartVect        box_max_corner );

bool box_tri_overlap( const CartVect  triangle_corners[3],
                      const CartVect& box_min_corner,
                      const CartVect& box_max_corner,
                      double            tolerance );

bool box_tri_overlap( const CartVect  triangle_corners[3],
                      const CartVect& box_center,
                      const CartVect& box_half_dims );

bool box_point_overlap( const CartVect& box_min_corner,
                        const CartVect& box_max_corner,
                        const CartVect& point,
                        double tolerance );

bool box_elem_overlap( const CartVect *elem_corners,
                       EntityType elem_type,
                       const CartVect& box_center,
                       const CartVect& box_half_dims ); 

bool box_linear_elem_overlap( const CartVect *elem_corners,
                              EntityType elem_type,
                              const CartVect& box_center,
                              const CartVect& box_half_dims ); 

bool box_linear_elem_overlap( const CartVect *elem_corners,
                              EntityType elem_type,
                              const CartVect& box_half_dims ); 

void closest_location_on_box( const CartVect& box_min_corner,
                              const CartVect& box_max_corner,
                              const CartVect& point,
                              CartVect& closest );

void closest_location_on_tri( const CartVect& location,
                              const CartVect* vertices,
                              CartVect& closest_out );

void closest_location_on_polygon( const CartVect& location,
                                  const CartVect* vertices,
                                  int num_vertices,
                                  CartVect& closest_out );

void closest_location_on_tri( const CartVect& location,
                              const CartVect* vertices,
                              double tolerance,
                              CartVect& closest_out,
                              int& closest_topo );

// Finds whether or not a box defined by the center and the half
// width intersects a trilinear hex defined by its eight vertices.
bool box_hex_overlap( const CartVect hexv[8],
                      const CartVect& box_center,
                      const CartVect& box_dims);

// Finds whether or not a box defined by the center and the half
// width intersects a linear tetrahedron defined by its four vertices.
bool box_tet_overlap( const CartVect tet_corners[4],
                      const CartVect& box_center,
                      const CartVect& box_dims);

// tests if 2 boxes overlap within a tolerance
// assume that data is valid, box_min1 << box_max1, and box_min2<< box_max2
// they are overlapping if they are overlapping in all directions
// for example in x direction:
//   box_max2[0] + tolerance < box_min1[0] -- false
bool boxes_overlap( const CartVect & box_min1, const CartVect & box_max1,
    const CartVect & box_min2, const CartVect & box_max2, double tolerance);

// see if boxes formed by 2 lists of "CartVect"s overlap
bool bounding_boxes_overlap (const CartVect * list1, int num1, const CartVect * list2, int num2,
      double tolerance);
//
// point_in_trilinear_hex
// Tests if a point in xyz space is within a hex element defined with
// its eight vertex points forming a trilinear basis function.  Computes
// the natural coordinates with respect to the hex of the xyz point 
// and checks if each are between +/-1.  If anyone is outside the range
// the function returns false, otherwise it returns true.
//
bool point_in_trilinear_hex(const CartVect *hex, 
                            const CartVect& xyz,
                            double etol);

bool nat_coords_trilinear_hex( const CartVect* corner_coords,
                               const CartVect& x,
                               CartVect& xi,
                               double tol );
} // namespace GeomUtil

} // namespace moab

#endif