gr_find_shapes.h

Go to the documentation of this file.

/* $Id$ */
/* =========================================================================== *
|
|  Copyright (c) 1994-2008 by Kobus Barnard (author).
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT cs DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
| Authors:
|     Emily Hartley
|
* =========================================================================== */

#ifndef KJB_FIND_SHAPES_H
#define KJB_FIND_SHAPES_H

#include <gr_cpp/gr_polymesh_plane.h>
#include <gr_cpp/gr_polygon.h>
#include <gr_cpp/gr_right_triangle_pair.h>
#include <m_cpp/m_int_vector.h>
#include <g_cpp/g_cylinder.h>
#include <g_cpp/g_cylinder_section.h>
#include <g_cpp/g_circle.h>
#include <vector>

namespace kjb {

void get_plane_parameters
(
    const Vector& normal, 
    const Vector& point_on_plane, 
    Vector&       plane_params
);

void get_plane_parameters
(
    const Vector& pt1, 
    const Vector& pt2, 
    const Vector& pt3, 
    Vector&       plane_params
); 

bool check_if_faces_are_coplanar
(
    const Vector& plane1_params, 
    const Vector& plane2_params, 
    double        tolerance, 
    double        distTolerance=1.0
);

bool check_if_4_points_are_coplanar
(
    const Vector& p1, 
    const Vector& p2, 
    const Vector& p3, 
    const Vector& p4, 
    double        tolerance
);

double get_angle_between_two_vectors
(
    const Vector& plane1_params, 
    const Vector& plane2_params
) throw (Illegal_argument, KJB_error);


void find_planes(const Polymesh& p, std::vector<Polymesh_Plane>& plane);

void render_planes
(
    const Polymesh&                    p, 
    const std::vector<Polymesh_Plane>& planes
);

void find_all_circles_in_polymesh
(
    Polymesh&                          p, 
    std::vector<Circle_in_3d>&         circles, 
    std::vector<std::vector<Vector> >& points
);


void find_right_triangles
(
    const std::vector<kjb::Polygon>& faces, 
    Int_vector&                      mask
);

void find_rectangles
(
    const std::vector<kjb::Polygon>&  faces, 
    const Int_vector&                 mask, 
    const Polymesh&                   p, 
    std::vector<Right_Triangle_Pair>& rectangles
);

void create_rectangle_mask
(
    const Polymesh&                         p, 
    const std::vector<Right_Triangle_Pair>& rectangles, 
    Int_vector&                             rectMask
);

void find_adjacent_rectangles
(
    const Polymesh&                         p, 
    const Int_vector&                       cylMask, 
    const Int_vector&                       rectMask, 
    const std::vector<Right_Triangle_Pair>& rectangles, 
    int                                     startIndex, 
    int                                     rectIndex, 
    int                                     prevAdjFace, 
    double                                  width, 
    double                                  lengthTolerance, 
    double&                                 smallestAngle, 
    double&                                 largestAngle, 
    double&                                 sumAngles, 
    std::vector<int>&                       cyl_indices, 
    Vector&                                 edge_pt1, 
    Vector&                                 edge_pt2, 
    Vector&                                 edge_pt1_adj, 
    Vector&                                 edge_pt_adj
);

void find_cylinders
(
    const Polymesh&                         p, 
    const std::vector<Right_Triangle_Pair>& rectangles, 
    std::vector<std::vector<int> >&         cyl_indices, 
    std::vector<double>&                    cylSumAngles, 
    std::vector<std::vector<Vector> >&      cylEdgePoints
);


void find_top_and_bottom_points_of_cylinder
(
    const Polymesh&                         p, 
    const Int_vector&                       rectMask, 
    const std::vector<Right_Triangle_Pair>& rectangles, 
    const std::vector<int>&                 cyl_indices, 
    std::vector<Vector>&                    top_points, 
    std::vector<Vector>&                    bottom_points
);

void find_centroid_of_3d_points
(
    const std::vector<Vector>& points, 
    Vector&                    centroid
);

void fit_plane_to_3d_points
(
    const std::vector<Vector>& points, 
    const Vector&              centroid, 
    Vector&                    plane_params
);

void project_points_onto_plane
(
    std::vector<Vector>& points, 
    const Vector&        plane_params, 
    const Vector&        centroid, 
    std::vector<Vector>& projected_points
);

/*
 * @brief Maps a 3D plane to the X-Y plane.
 */
void translate_3d_plane_to_xy_plane
(
    const std::vector<Vector>& points, 
    const Vector&              plane_params, 
    std::vector<Vector>&       translated_points, 
    std::vector<Matrix>&       transformMatrices
);

/*
 * @brief Using the transformMatrices from translate_3d_plane_to_xy_plane(), 
 * maps a point on the X-Y plane back onto the original 3D plane.
 */
void translate_xy_point_to_3d_plane
(
    const Vector&              point, 
    const std::vector<Matrix>& transformMatrices, 
    Vector&                    translated_point
);

void fit_cylinder
(
    const Polymesh&                         p, 
    const Int_vector&                       rectMask, 
    const std::vector<Right_Triangle_Pair>& rectangles, 
    const std::vector<int>&                 cyl_indices, 
    double                                  cylAngle, 
    const std::vector<Vector>&              cylEdgePoints, 
    Cylinder_section&                       cyl
);



void find_cylinders_to_render_and_fit
(
    char*                           faceFile, 
    char*                           cylFile, 
    const Polymesh&                 p,
    std::vector<Polymesh_Plane>&    plane, 
    std::vector<Cylinder_section>&  cyl
);

void find_cylinders_to_render
(
    const Polymesh&              p, 
    std::vector<Polymesh_Plane>& plane
);

void find_rectangles_to_render
(
    const Polymesh&              p, 
    std::vector<Polymesh_Plane>& plane
);

void find_right_triangles_to_render
(
    const Polymesh&              p, 
    std::vector<Polymesh_Plane>& plane
);

void find_adjacent_right_triangles_to_render
(
    const Polymesh&              p, 
    std::vector<Polymesh_Plane>& plane
);

}

#endif