planar_object_recognizer.h

Go to the documentation of this file.

/*
Copyright 2005, 2006 Computer Vision Lab, 
Ecole Polytechnique Federale de Lausanne (EPFL), Switzerland. 
All rights reserved.

This file is part of BazAR.

BazAR is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

BazAR is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
BazAR; if not, write to the Free Software Foundation, Inc., 51 Franklin
Street, Fifth Floor, Boston, MA 02110-1301, USA 
*/
#ifndef PLANAR_OBJECT_RECOGNIZER_H
#define PLANAR_OBJECT_RECOGNIZER_H

#include <keypoints/keypoint.h>
#include <keypoints/yape.h>
#include <starter.h>
#include "affine_image_generator.h"
#include "object_view.h"
#include "image_classification_forest.h"
#include "image_object_point_match.h"




static const int hard_max_detected_pts = 5000;

class planar_object_recognizer
{
public:
  planar_object_recognizer();

  planar_object_recognizer(string directory_name);

  ~planar_object_recognizer(void);

  bool build_with_cache(string filename, int max_point_number_on_model,
                        int patch_size, int yape_radius, 
                        int tree_number, int nbLev,
                        LEARNPROGRESSION LearnProgress=0);

  bool build(IplImage *model_image,
                  int max_point_number_on_model, int patch_size,
                  int yape_radius, int tree_number, int nbLev, 
                  LEARNPROGRESSION LearnProgress=0, int *roi=0);


  void use_bins_when_creating_model_points(void) { use_bins_for_model_points = true; } 
  void dont_use_bins_when_creating_model_points(void) { use_bins_for_model_points = false; }

  void use_bins_when_detecting_input_image_points(void) { use_bins_for_input_image = true; } 
  void dont_use_bins_when_detecting_input_image_points(void) { use_bins_for_input_image = false; }

  void set_noise_level(int noise_level);

  void set_use_random_background(bool use_random_background);

  void set_range_variation_for_theta(float min_theta, float max_theta);
  void set_range_variation_for_phi(float min_phi, float max_phi);

  void independent_scaling(float min_lambda1, float max_lambda1, float min_lambda2, float max_lambda2);
  void constrained_scaling(float min_lambda1, float max_lambda1, 
                           float min_lambda2, float max_lambda2,
                           float min_l1_l2, float max_l1_l2);

  void use_orientation_correction(void);
  void dont_use_orientation_correction(void);

  void set_max_depth(int p_max_depth) { max_depth = p_max_depth; }

  void set_sample_number_for_refining(int sample_number) { sample_number_for_refining = sample_number; }
  int sample_number_for_refining;

  void learn(int max_point_number_on_model, 
             int patch_size, int yape_radius, 
             int tree_number, int nbLev=5, 
             LEARNPROGRESSION LearnProgress=0);

  void save(string directory_name);

  bool load(string directory_name);

  bool detect(IplImage * input_image);

  void set_max_detected_pts(int max);


  void detect_points(IplImage * input_image);
  void preprocess_points(void);
  void match_points(bool fill_match_struct = true);
  bool estimate_affine_transformation(void);
  bool estimate_homographic_transformation_linear_method(void);
  bool estimate_homographic_transformation_nonlinear_method(void);

  object_keypoint * model_points;
  int model_point_number;

  keypoint *detected_points;
  int detected_point_number;
  image_class_example *detected_point_views;

  float * match_probabilities[hard_max_detected_pts];
  image_object_point_match matches[hard_max_detected_pts];
  int match_number;

  bool object_is_detected;
  affinity * affine_motion;
  homography * H;
  ls_minimizer2 * homography_estimator;
  float detected_u_corner1, detected_v_corner1;
  float detected_u_corner2, detected_v_corner2;
  float detected_u_corner3, detected_v_corner3;
  float detected_u_corner4, detected_v_corner4;

  pyr_yape * point_detector;

  IplImage * create_result_image(IplImage * input_image, 
    bool p_draw_points, bool p_draw_matches, 
    bool p_draw_object, bool p_draw_model_image,
    int line_width = 2);

  void debug_model_point(int p_index_of_model_point_to_debug) 
  { index_of_model_point_to_debug = p_index_of_model_point_to_debug; }

  void save_one_image_per_match(IplImage * input_image, const char * matches_dir);
  void save_one_image_per_match_model_to_input(IplImage * input_image, const char * matches_dir);
  void save_one_image_per_match_input_to_model(IplImage * input_image, const char * matches_dir);


  void initialize(void);

  affine_image_generator new_images_generator;

  object_view * object_input_view;

  pair<object_keypoint, int> * search_for_existing_model_point(vector< pair<object_keypoint, int> > * tmp_model_points,
    float cu, float cv, int scale);
  void detect_most_stable_model_points(int max_point_number_on_model, 
                                       int patch_size, int view_number, 
                                       double min_view_rate, 
                                       LEARNPROGRESSION LearnProgress=0);
  void save_image_of_model_points(int patch_size, char * filename = 0);

  image_classification_forest * forest;

  // For position estimation:
  int compute_support_for_affine_transformation(affinity * A);
  bool three_random_correspondences(int * n1, int * n2, int * n3);
  bool valid(affinity * A);

  int max_detected_pts;
  int max_depth;

  void default_settings(void);
  bool use_bins_for_model_points;
  bool use_bins_for_input_image;
  int index_of_model_point_to_debug;

  int views_number; 

  double min_view_rate;

  double keypoint_distance_threshold;

  float match_score_threshold;

  float ransac_dist_threshold;

  float non_linear_refine_threshold;

  int max_ransac_iterations;

  int ransac_stop_support;


  void save_patch_before_and_after_correction(IplImage * image,
                                              int u, int v, int patch_size,
                                              image_class_example * pv,
                                              int point_index, 
                                              int call_number);
  void concat_model_and_input_images(IplImage * input_image, bool p_draw_model_image = true);
  void draw_points(int line_width = 1);
  void draw_model_points(int line_width = 1);
  void draw_input_image_points(int line_width = 1);
  void draw_matches(int line_width = 2);
  void draw_inlier_matches(int line_width = 1);
  void draw_model(void);
  IplImage * model_and_input_images;
  int x0, y0; // up left corner of modelImage in modelInputImage
  int u_input_image, v_input_image; // up left corner of inputImage in modelInputImage

  void check_target_size(IplImage *image);
};

#endif // PLANAR_OBJECT_RECOGNIZER_H