Linux Cross Reference
Tina4/src/tools/segment/seg_infr.c

   /**@(#)
   **/
   #include <tina/sys.h>
   #include <tina/sysfuncs.h>
   #include <tina/math.h>
   #include <tina/mathfuncs.h>
   #include <tina/vision.h>
   #include <tina/visionfuncs.h>
   
  #define LEFT_DATA       0
  #define RIGHT_DATA      1
  #define MONO_DATA       2
  
  /**
  
  working image (LEFT, RIGHT, MONO)
  **/
  
  static  image_data = LEFT_DATA;
  
  int     seg_image_data_get(void)
  {
      return (image_data);
  }
  
  void    seg_image_data_set(int new_image_data)
  {
      image_data = new_image_data;
  }
  
  /**
  segment image
  **/
  
  static Imrect *image;
  
  Imrect *seg_image_get(void)
  {
      return (image);
  }
  
  void    seg_image_set(Imrect * newim)
  {
      image = newim;
  }
  
  /**
  list of segment edge strings
  **/
  
  static List *es = NULL;
  
  List   *seg_es_get(void)
  {
      return (es);
  }
  
  void    seg_es_set(List * newes)
  {
      es = newes;
  }
  
  /**
  recursive list of segment geometry
  **/
  
  static List *geom = NULL;
  
  List   *seg_geom_get(void)
  {
      return (geom);
  }
  
  void    seg_geom_set(List * newgeom)
  {
      void    seg_select_geom_set(List * newgeom);
  
      seg_select_geom_set((List *) NULL); /** keeps consistency **/
      (void) reclist_list_free(geom, geom_free, (int)NULL, NULL);
      geom = newgeom;
  }
  
  void    seg_geom_null(void)
  {
      geom = NULL;
  }
  
  /**
  segment edge string index utilities
  **/
  
  static Windex *index = NULL;
  
  void    seg_es_build_index(void)
  {
      wx_free(index, list_rm_links);
      index = es_list_build_wx(es);
  }
  
 List   *seg_es_get_from_index(Vec2 v)
 {
     Ipos    p = {Ipos_id};
     int     i, j;
 
     if (index == NULL)
         return (NULL);
 
     p = wx_get_index(index, v);
     i = ipos_y(p);
     j = ipos_x(p);
     if (i < 0 || i >= index->m || j < 0 || j >= index->n)
         return (NULL);
 
     return (index->index[i][j]);
 }
 
 void    seg_es_index_delete(List * es)
 /* delete edge es from index */
 {
     while (es != NULL)
     {
         wx_delete_entry(index, es->to);
         es = es->next;
     }
 }
 
 void    seg_es_index_replace(List * es, List * es_list)
 {
     while (es != NULL)
     {
         wx_replace_entry(index, es->to, es_list);
         es = es->next;
     }
 }
 
 void    seg_es_index_duplicate(Tstring * es1, Tstring * es2)
 {
     wx_duplicate_entry(index, (void *) es1, (void *) es2, STRING);
 }
 
 /**
 list of selected positions on edge strings
 **/
 
 static List *select_pos = NULL;
 
 List   *seg_select_pos_get(void)
 {
     return (select_pos);
 }
 
 void    seg_select_pos_set(List * newpos)
 {
     list_rm_links(select_pos);
     select_pos = newpos;
 }
 
 /**
 list of selected edge strings
 **/
 
 static List *select_es = NULL;
 
 List   *seg_select_es_get(void)
 {
     return (select_es);
 }
 
 void    seg_select_es_set(List * newes)
 {
     list_rm_links(select_es);
     select_es = newes;
 }
 
 /**
 list of selected geometry
 **/
 
 
 static List *select_geom = NULL;
 
 List   *seg_select_geom_get(void)
 {
     return (select_geom);
 }
 
 void    seg_select_geom_set(List * newgeom)
 {
     list_rm_links(select_geom);
     select_geom = newgeom;
 }
 
 /**
 Low segmentation threshold
 **/
 
 static double lo_thres = 1.0;
 
 double  seg_lo_thres_get(void)
 {
     return (lo_thres);
 }
 
 void    seg_lo_thres_set(double newthres)
 {
     lo_thres = newthres;
 }
 
 /**
 High segmentation threshold
 **/
 
 static double hi_thres = 2.0;
 
 double  seg_hi_thres_get(void)
 {
     return (hi_thres);
 }
 
 void    seg_hi_thres_set(double newthres)
 {
     hi_thres = newthres;
 }
 
 /**
 Maximum divergence at high threshold
 **/
 
 static int max_div = 5;
 
 int     seg_max_div_get(void)
 {
     return (max_div);
 }
 
 void    seg_max_div_set(int newdiv)
 {
     max_div = newdiv;
 }
 
 /**
 Conic confidence threshold
 **/
 
 static double conf_thres = 0.1;
 
 double  seg_conf_thres_get(void)
 {
     return (conf_thres);
 }
 
 void    seg_conf_thres_set(double newthres)
 {
     conf_thres = newthres;
 }
 
 /**
 Plane fit threshold
 **/
 
 static double plane_thres = 2.0;
 
 double  seg_plane_thres_get(void)
 {
     return (plane_thres);
 }
 
 void    seg_plane_thres_set(double newthres)
 {
     plane_thres = newthres;
 }