KJB
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
edge_points_likelihood.h
Go to the documentation of this file.
1 /* $Id: edge_points_likelihood.h 18283 2014-11-25 05:05:59Z ksimek $ */
35 /* =========================================================================== *
36  |
37  | Copyright (c) 1994-2010 by Kobus Barnard (author)
38  |
39  | Personal and educational use of this code is granted, provided that this
40  | header is kept intact, and that the authorship is not misrepresented, that
41  | its use is acknowledged in publications, and relevant papers are cited.
42  |
43  | For other use contact the author (kobus AT cs DOT arizona DOT edu).
44  |
45  | Please note that the code in this file has not necessarily been adequately
46  | tested. Naturally, there is no guarantee of performance, support, or fitness
47  | for any particular task. Nonetheless, I am interested in hearing about
48  | problems that you encounter.
49  |
50  | Author: Luca Del Pero
51  * =========================================================================== */
52 
53 #ifndef KJB_EDGE_POINTS_LIKELIHOOD_H_
54 #define KJB_EDGE_POINTS_LIKELIHOOD_H_
55 
56 #include <list>
57 #include <vector>
58 #include <edge_cpp/line_segment.h>
59 #include <edge_cpp/edge.h>
63 
92 namespace kjb {
93 
98 {
99 public:
100 
126  (
127  const kjb::Edge_set * data_edges,
128  unsigned int num_rows,
129  unsigned int num_cols,
130  unsigned int num_angles,
131  double angle_sigma,
132  double dist_sigma,
133  double max_dist
134  );
135 
137  Correspondence(const Correspondence & c);
138 
141 
150  class Point
151  {
152  public:
153 
155  Point
156  (
157  const kjb::Edge_point & e_pt,
158  unsigned int iedge_pt_num,
159  unsigned int imodel_pt_row,
160  unsigned int imodel_pt_col,
161  unsigned int num_angles,
162  double angle_sigma,
163  double dist_sigma
164  );
165 
167  Point(const Point & p);
168 
170  Point & operator=(const Point & p);
171 
177  {
178  public:
179  bool operator() (const Point* p1, const Point* p2) const;
180  };
181 
182 
187  bool operator< (const Point& p) const;
188 
190  unsigned int edge_pt_row;
191 
192  unsigned int edge_pt_col;
193 
194  double edge_pt_drow;
195 
196  double edge_pt_dcol;
197 
202  unsigned int edge_pt_num;
203 
208  unsigned int model_pt_row;
209 
214  unsigned int model_pt_col;
215 
216  unsigned int model_edge_index;
217 
221  double dtheta;
222 
229  std::vector<double> angles;
230 
237  double angle;
238 
245  std::vector<double> gauss_angles;
246 
250  double gauss_angle;
251 
260  std::vector<double> norm_dists;
261 
269  double norm_dist;
270 
275  std::vector<double> gauss_norm_dists;
276 
282 
288  double grad_dist;
289  };
290 
292  {
293  public:
294 
295  Matched_point( double iangle, double igauss_angle, double inorm_dist, double igauss_norm_dist, double igrad_dist, int imodel_index)
296  : angle(iangle), gauss_angle(igauss_angle), norm_dist(inorm_dist), gauss_norm_dist(igauss_norm_dist),
297  grad_dist(igrad_dist), model_edge_index(imodel_index)
298  {
299 
300  }
301 
303  {
304  angle = 0.0;
305  gauss_angle = 0.0;
306  norm_dist = 0.0;
307  gauss_norm_dist = 0.0;
308  grad_dist = 0.0;
309  model_edge_index = 0;
310  }
311 
313  {
314  this->operator=(mp);
315  }
316 
319  {
320  angle = src.angle;
321  gauss_angle = src.gauss_angle;
322  norm_dist = src.norm_dist;
324  grad_dist = src.grad_dist;
326 
327  return (*this);
328  }
329 
331  {
332  public:
333  bool operator() (const Matched_point* mp1, const Matched_point * mp2) const;
334  };
335 
336 
341  bool operator< (const Matched_point& mp) const;
342 
343  double angle;
344 
345  double gauss_angle;
346 
347  double norm_dist;
348 
350 
351  double grad_dist;
352 
354  };
355 
356 
364  const std::vector< std::vector<const Correspondence::Point *> > &
366  (
367  const Int_matrix & model_map,
368  const std::vector<Model_edge> & model_edges,
369  const std::vector<kjb::Int_vector> & edge_indexes,
370  int edge_counter,
371  int & num_sil_miss,
372  int & num_inn_miss
373  );
374 
376  (
377  const Int_matrix & model_map,
378  const std::vector<Model_edge> & model_edges,
379  const std::vector<kjb::Int_vector> & edge_indexes,
380  std::vector<Correspondence::Matched_point> & matched_points,
381  std::vector< std::vector<const Correspondence::Matched_point *> > & edge_pts_matched_corr,
382  int edge_counter,
383  int & num_sil_miss,
384  int & num_inn_miss,
385  int & num_flagged_miss,
386  int & matched_counter,
387  double inn_prob,
388  double sil_prob
389  );
390 
391  const std::vector< std::vector<const Correspondence::Point*> > &
393  (
394  const kjb::Edge_set& model_edge_set
395  );
396 
400  double get_max_dist() const { return max_dist; };
401 
403  const std::vector< std::vector< std::list<Point> > > & get_model_corr() const {return model_pts_corr;};
404 
405 private:
406 
416  void add_edge_pts_along_line
417  (
418  const kjb::Edge_point & iedge_pt,
419  unsigned int iedge_pt_num,
420  unsigned int num_rows,
421  unsigned int num_cols,
422  unsigned int num_angles,
423  double angle_sigma,
424  double dist_sigma,
425  double max_dist
426  );
427 
437  std::vector< std::vector< std::list<Point> > > model_pts_corr;
438 
445  std::vector< std::vector<const Point*> > edge_pts_corr;
446 
449  double max_dist;
450 
451 };
452 
454 {
455 
456 public:
460  };
461 
463  const kjb::Edge_set * data_edges,
464  int num_angles,
465  unsigned int num_rows,
466  unsigned int num_cols,
467  double angle_sigma,
468  double dist_sigma,
469  double max_dist,
470  double bg_prob,
471  double noise_prob,
472  double silho_miss_prob,
473  double inner_miss_prob,
474  bool idelete_correspondence = true
475  );
476 
481 
483  {
484  if(delete_correspondence)
485  {
486  delete correspondence;
487  }
488  }
489 
494  double operator()(const Edge_set& model_edge_set) const;
495 
501  double old_operator
502  (
503  Int_matrix & model_map,
504  const std::vector<Model_edge> & model_edges,
505  const std::vector<kjb::Int_vector> & external_edge_indexes,
506  int external_edge_counter
507  ) const;
508 
509  double new_operator
510  (
511  Int_matrix & model_map,
512  const std::vector<Model_edge> & model_edges,
513  const std::vector<kjb::Int_vector> & external_edge_indexes,
514  int external_edge_counter
515  ) const;
516 
517  double operator()
518  (
519  Int_matrix & model_map,
520  const std::vector<Model_edge> & model_edges,
521  const std::vector<kjb::Int_vector> & external_edge_indexes,
522  int external_edge_counter
523  ) const;
524 
525  double operator()
526  (
527  Int_matrix & model_map,
528  const std::vector<Model_edge> & model_edges
529  ) const;
530 
532  //const kjb::Int_matrix & get_assign() const { return m_ll_assign; };
533 
535  Correspondence * get_correspondence() { return correspondence; }
536 
544  template <class T>
545  double compute_likelihood(T & model, unsigned int mode = FROM_MAP_AND_EDGES);
546 
555  template <class T, class U>
556  double compute_likelihood(T & model, U & camera, unsigned int mode = FROM_MAP_AND_EDGES);
557 
566  template <class T, class U>
567  double compute_likelihood(T & model, U & camera, Int_matrix & model_map, unsigned int mode = FROM_MAP_AND_EDGES);
568 
577  template <class T, class U, class V>
578  double compute_likelihood(T & model, U & camera, Int_matrix & model_map, V * auxiliary_structure, unsigned int mode = FROM_MAP_AND_EDGES);
579 
580  template <class T, class U, class V>
581  double compute_likelihood
582  (
583  T & model,
584  U & camera,
585  Int_matrix & model_map,
586  V * auxiliary_structure,
587  const std::vector<kjb::Int_vector> & external_edge_indexes,
588  int external_edge_counter,
589  int single_object = -1,
590  unsigned int mode = FROM_MAP_AND_EDGES
591  );
592 
594  void draw_edge_set_using_mask(Image& img);
595 
597  double find_log_max(double dist_sigma, double angle_sigma);
598 
599  inline double get_num_points_ratio()
600  {
601  return num_points_ratio;
602  }
603 
605  {
606  /*std::cout << "Num data points:" << _num_data_point << std::endl;
607  std::cout << "Num miss: " << _num_miss << std::endl;*/
608  return (1.0/(_num_miss + _num_data_point));
609  }
610 
612  {
613  return data_edges;
614  }
615 
617  {
618  return delete_correspondence;
619  }
620 
621  void set_delete_correspondence(bool idelete_correspondence)
622  {
623  delete_correspondence = idelete_correspondence;
624  }
625 
626 
627 private:
628 
630  void reset_edge_mask() const;
631 
634  {
635  return (*this);
636  }
637 
659  //mutable kjb::Int_matrix m_ll_assign;
660 
670  kjb::Int_matrix internal_model_map;
671 
675  const kjb::Edge_set * data_edges;
676 
679  mutable Correspondence * correspondence;
680 
683  double background_prob;
684 
687  double noise_prob;
688 
694  double silhouette_miss_prob;
695 
701  double inner_edge_miss_prob;
702 
704  double num_points_ratio;
705 
706  mutable double _num_miss;
707 
708  double _num_data_point;
709 
711  mutable std::vector<std::vector<bool> > edge_mask;
712 
713  mutable int edge_counter;
714 
715  kjb::Matrix M;
716 
717  int image_size;
718 
719  mutable std::vector<Correspondence::Matched_point> matched_points;
720 
721  mutable std::vector< std::vector<const Correspondence::Matched_point *> > matched_pts;
722 
723  mutable int used_matched_points;
724 
725  bool delete_correspondence;
726 };
727 
741 template <class T>
742 double Independent_edge_points_likelihood::compute_likelihood(T & model, unsigned int mode)
743 {
744  if(mode == FROM_MAP_AND_EDGES)
745  {
746  std::vector<Model_edge> model_edges;
747  model.prepare_model_map(internal_model_map);
748  model.prepare_model_edges(model_edges);
749  return this->operator()(internal_model_map, model_edges);
750  }
751  else if(mode == FROM_EDGE_POINTS)
752  {
753  kjb::Edge_set edge_points;
754  model.prepare_edge_points(edge_points);
755  return this->operator()(edge_points);
756  }
757  else
758  {
759  KJB_THROW_2(Illegal_argument, "Likelihood mode not supported");
760  }
761 }
762 
778 template <class T, class U>
779 double Independent_edge_points_likelihood::compute_likelihood(T & model, U & camera, unsigned int mode)
780 {
781  if(mode == FROM_MAP_AND_EDGES)
782  {
783  std::vector<Model_edge> model_edges;
784  model.prepare_model_map(internal_model_map, camera);
785  model.prepare_model_edges(model_edges, camera);
786  return this->operator()(internal_model_map, model_edges);
787  }
788  else if(mode == FROM_EDGE_POINTS)
789  {
790  kjb::Edge_set edge_points;
791  model.prepare_edge_points(edge_points, camera);
792  return this->operator()(edge_points);
793  }
794  else
795  {
796  KJB_THROW_2(Illegal_argument, "Likelihood mode not supported");
797  }
798 }
799 
800 } //namespace kjb
801 
802 
803 #endif /* KJB_EDGE_POINTS_LIKELIHOOD_H_ */
804 
double norm_dist
Euclidean distance from the model point to the generative approximation of the edge point along...
Definition: edge_points_likelihood.h:269
double grad_dist
Distance between the model point and the edge point along the direction of the edge gradient...
Definition: edge_points_likelihood.h:288
unsigned int model_edge_index
Definition: edge_points_likelihood.h:216
double find_log_max(double dist_sigma, double angle_sigma)
Definition: edge_points_likelihood.cpp:1677
std::vector< double > gauss_norm_dists
Gaussian likelihood of the Euclidean normal distance.
Definition: edge_points_likelihood.h:275
void set_delete_correspondence(bool idelete_correspondence)
Definition: edge_points_likelihood.h:621
Definition: edge_points_likelihood.h:459
boost::bimap< pt::Entity_id, pt::Entity_id > Correspondence
Definition: psi_metrics.h:43
Independent_edge_points_likelihood(const kjb::Edge_set *data_edges, int num_angles, unsigned int num_rows, unsigned int num_cols, double angle_sigma, double dist_sigma, double max_dist, double bg_prob, double noise_prob, double silho_miss_prob, double inner_miss_prob, bool idelete_correspondence=true)
Definition: edge_points_likelihood.cpp:933
Definition: edge_points_likelihood.h:176
This class implements matrices, in the linear-algebra sense, restricted to integer-valued elements...
Definition: l_int_matrix.h:71
bool get_delete_correspondence() const
Definition: edge_points_likelihood.h:616
double dtheta
Size of a bin in the discretized angle space.
Definition: edge_points_likelihood.h:221
Matched_point & operator=(const Matched_point &src)
Assignment operator.
Definition: edge_points_likelihood.h:318
double new_operator(Int_matrix &model_map, const std::vector< Model_edge > &model_edges, const std::vector< kjb::Int_vector > &external_edge_indexes, int external_edge_counter) const
Definition: edge_points_likelihood.cpp:1184
Point & operator=(const Point &p)
Assignment operator.
Definition: edge_points_likelihood.cpp:247
~Independent_edge_points_likelihood()
Definition: edge_points_likelihood.h:482
double angle
Definition: edge_points_likelihood.h:343
Definition: edge_points_likelihood.h:97
double get_num_points_ratio()
Definition: edge_points_likelihood.h:599
Correspondence * get_correspondence()
Returns the assignment matrix.
Definition: edge_points_likelihood.h:535
double grad_dist
Definition: edge_points_likelihood.h:351
double edge_pt_dcol
Definition: edge_points_likelihood.h:196
const std::vector< std::vector< const Correspondence::Point * > > & generate_for_model(const kjb::Edge_set &model_edge_set)
Definition: edge_points_likelihood.cpp:817
double gauss_angle
Definition: edge_points_likelihood.h:345
unsigned int model_pt_col
Column number for the model point corresponding to the edge point.
Definition: edge_points_likelihood.h:214
bool operator()(const Point *p1, const Point *p2) const
Definition: edge_points_likelihood.cpp:45
Definition: edge_points_likelihood.h:453
std::vector< double > norm_dists
Euclidean distance from the model point to the generative approximation of the edge point along...
Definition: edge_points_likelihood.h:260
Definition: edge_points_likelihood.h:150
bool operator()(const Matched_point *mp1, const Matched_point *mp2) const
Definition: edge_points_likelihood.cpp:67
double norm_dist
Definition: edge_points_likelihood.h:347
double gauss_angle
Gaussian likelihood of the angle, once the correspondence is known.
Definition: edge_points_likelihood.h:250
double compute_likelihood(T &model, unsigned int mode=FROM_MAP_AND_EDGES)
Template function to compute the likelihood for a generic model. The input model must be able to gene...
Definition: edge_points_likelihood.h:742
Matched_point(const Matched_point &mp)
Definition: edge_points_likelihood.h:312
double angle
Angle between model point normal and an edge point's gradient, once the correspondence is known...
Definition: edge_points_likelihood.h:237
Declarations for Line segment set classes.
int model_edge_index
Definition: edge_points_likelihood.h:353
Correspondence(const kjb::Edge_set *data_edges, unsigned int num_rows, unsigned int num_cols, unsigned int num_angles, double angle_sigma, double dist_sigma, double max_dist)
Creates a new correspondence between edge points and model points. For efficiency reasons...
Definition: edge_points_likelihood.cpp:300
Matched_point(double iangle, double igauss_angle, double inorm_dist, double igauss_norm_dist, double igrad_dist, int imodel_index)
Definition: edge_points_likelihood.h:295
double get_max_dist() const
Returns the max distance allowed between a model point and edge point for them to be considered match...
Definition: edge_points_likelihood.h:400
void draw_edge_set_using_mask(Image &img)
Definition: edge_points_likelihood.cpp:1659
Matched_point()
Definition: edge_points_likelihood.h:302
const std::vector< std::vector< const Correspondence::Point * > > & generate_for_model_from_map_and_edges(const Int_matrix &model_map, const std::vector< Model_edge > &model_edges, const std::vector< kjb::Int_vector > &edge_indexes, int edge_counter, int &num_sil_miss, int &num_inn_miss)
Generates a correspondence set between the detected edge point and the given model points...
Definition: edge_points_likelihood.cpp:528
unsigned int edge_pt_col
Definition: edge_points_likelihood.h:192
Definition: edge_points_likelihood.h:458
double get_total_components_ratio()
Definition: edge_points_likelihood.h:604
#define KJB_THROW_2(ex, msg)
Definition: l_exception.h:48
double gauss_norm_dist
Definition: edge_points_likelihood.h:349
unsigned int edge_pt_num
Index number of the edge point detected, starting with 0.
Definition: edge_points_likelihood.h:202
std::vector< double > angles
Discretized angles between model point normals and an edge point's gradient.
Definition: edge_points_likelihood.h:229
unsigned int model_pt_row
Row number for the model point corresponding to the edge point.
Definition: edge_points_likelihood.h:208
double old_operator(Int_matrix &model_map, const std::vector< Model_edge > &model_edges, const std::vector< kjb::Int_vector > &external_edge_indexes, int external_edge_counter) const
Calculates the log likelihood of the image edge set given the rendering of the model onto the image p...
Definition: edge_points_likelihood.cpp:1057
std::vector< double > gauss_angles
Gaussian likelihood of the discretized angles angle. This is proportional to the difference in oriena...
Definition: edge_points_likelihood.h:245
Definition: edge.h:48
Likelihood_mode
Definition: edge_points_likelihood.h:457
double operator()(const Edge_set &model_edge_set) const
Calculates the log likelihood of the image edge set (set in the constructor) given the model edges...
Definition: edge_points_likelihood.cpp:1463
Point(const kjb::Edge_point &e_pt, unsigned int iedge_pt_num, unsigned int imodel_pt_row, unsigned int imodel_pt_col, unsigned int num_angles, double angle_sigma, double dist_sigma)
Constructor.
Definition: edge_points_likelihood.cpp:136
bool operator<(const Point &p) const
Compares two Correspondence Points based on the normal distance between model point and the edge poin...
Definition: edge_points_likelihood.cpp:61
double gauss_norm_dist
Gaussian likelihood of the Euclidean normal distance (once the correspondence is known) ...
Definition: edge_points_likelihood.h:281
double edge_pt_drow
Definition: edge_points_likelihood.h:194
Object thrown when an argument to a function is not acceptable.
Definition: l_exception.h:377
Definition: edge.h:233
Definition: edge_points_likelihood.h:330
Definition: edge_points_likelihood.h:291
This class implements matrices, in the linear-algebra sense, with real-valued elements.
Definition: m_matrix.h:94
Wrapped version of the C struct KJB_image.
Definition: i_image.h:76
const std::vector< std::vector< std::list< Point > > > & get_model_corr() const
Gets the correspondences associated to model points.
Definition: edge_points_likelihood.h:403
const kjb::Edge_set * get_data_edges() const
Definition: edge_points_likelihood.h:611
Correspondence & operator=(const Correspondence &c)
Assignment operator.
Definition: edge_points_likelihood.cpp:382
bool operator<(const Matched_point &mp) const
Compares two Correspondence Points based on the normal distance between model point and the edge poin...
Definition: edge_points_likelihood.cpp:83
unsigned int edge_pt_row
Edge point detected in the input image.
Definition: edge_points_likelihood.h:190