~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

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

Version: ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /**@(#)
  2 **/
  3 #include <stdio.h>
  4 #include <tina/sys.h>
  5 #include <tina/sysfuncs.h>
  6 #include <tina/math.h>
  7 #include <tina/mathfuncs.h>
  8 #include <tina/vision.h>
  9 #include <tina/visionfuncs.h>
 10 #include <tina/tv.h>
 11 #include <tina/tvfuncs.h>
 12 #include <tina/toolsfuncs.h>
 13 #include <tina/tw_Xfuncs.h>
 14 #include <tina/draw.h>
 15 #include <tina/drawfuncs.h>
 16 #include <tina/toolsfuncs.h>
 17 
 18 #define INIT_SAMPLE 12
 19 
 20 #define LEFT_DATA       0
 21 #define RIGHT_DATA      1
 22 #define MONO_DATA       2
 23 
 24 #define IMAGE_MASK      1
 25 #define ES_MASK         2
 26 #define GEOM_MASK       4
 27 
 28 
 29 /* EXTERNS  */
 30 extern void tw_show_tool();
 31 extern void *tw_tool();
 32 extern void *tw_fglobal();
 33 extern void *tw_iglobal();
 34 extern void *tw_ivalue();
 35 
 36 /**
 37 Tv selection
 38 **/
 39 
 40 static void tv_choice_proc(int value)
 41 {
 42     switch (value)
 43     {
 44         case 0:
 45         tv_set_next(seg_tv());
 46     }
 47 }
 48 
 49 /**
 50 Tv pick function selection
 51 **/
 52 
 53 static void pick_choice_proc(Tv_pick(*func) ( /* ??? */ ))
 54 {
 55     Tv     *tv = seg_tv();
 56 
 57     tv_set_pick(tv, (*func) ());
 58     (void) tv_set_activity(tv, PICK);
 59 }
 60 
 61 /**
 62 display check options
 63 **/
 64 
 65 static void display_check_proc(int value)
 66 {
 67     seg_set_image_on((value & IMAGE_MASK) ? true : false);
 68     seg_set_es_on((value & ES_MASK) ? true : false);
 69     seg_set_geom_on((value & GEOM_MASK) ? true : false);
 70 }
 71 
 72 /**
 73 parameter dialog
 74 **/
 75 
 76 static int curve_sample = 5;
 77 static double z_scale = 10.0;
 78 
 79 static void param_dialog(void)
 80 {
 81     static void *dialog = NULL;
 82 
 83     if (dialog)
 84     {
 85         tw_show_dialog(dialog);
 86         return;
 87     }
 88     dialog = tw_dialog("Segment Params");
 89     (void) tw_fvalue("Lo fit thres: ", seg_lo_thres_get, seg_lo_thres_set, 16);
 90     tw_newrow();
 91     (void) tw_fvalue("Hi fit thres: ", seg_hi_thres_get, seg_hi_thres_set, 16);
 92     tw_newrow();
 93     (void) tw_ivalue("Max div     : ", seg_max_div_get, seg_max_div_set, 16);
 94     tw_newrow();
 95     (void) tw_fvalue("Conf thres  : ", seg_conf_thres_get, seg_conf_thres_set, 16);
 96     tw_newrow();
 97     (void) tw_ivalue("Conic sample: ", conic_sample_get, conic_sample_set, 16);
 98     tw_newrow();
 99     (void) tw_fvalue("Conic var   : ", conic_var_get, conic_var_set, 16);
100     tw_newrow();
101     (void) tw_ivalue("Conic iter  : ", conic_iter_get, conic_iter_set, 16);
102     tw_newrow();
103     (void) tw_fvalue("Plane thres : ", seg_plane_thres_get, seg_plane_thres_set, 16);
104     tw_newrow();
105     (void) tw_iglobal("Curve Sample: ", &curve_sample, 16);
106     tw_newrow();
107     (void) tw_fglobal("Terr z scale: ", &z_scale, 16);
108     tw_end_dialog();
109 }
110 
111 /**
112 conic filter selection
113 **/
114 
115 static double (*con_fit_func) ();
116 
117 static void filter_choice_proc(int value)
118 {
119     switch (value)
120     {
121         case 0:
122         con_fit_func = NULL;
123         break;
124     case 1:
125         con_fit_func = conic_nlsq;
126         break;
127     case 2:
128         con_fit_func = conic_ekf;
129         break;
130     case 3:
131         con_fit_func = conic_bckf;
132         break;
133     }
134     conic_filter_set(con_fit_func);
135 }
136 
137 /**
138 linear approximation choice
139 **/
140 
141 static int linear_approx = 1;
142 
143 static void poly_choice_proc(int value)
144 {
145     switch (value)
146     {
147         case 0:
148         linear_approx = 1;
149         break;
150     case 1:
151         linear_approx = 0;
152         break;
153     }
154 }
155 
156 /**
157 local curvature computation choice
158 **/
159 
160 #define LOCAL_CURVE    0
161 #define EXTND_CURVE    1
162 
163 static int local_curvature = LOCAL_CURVE;
164 
165 static void curvature_choice_proc(int value)
166 {
167     local_curvature = value;
168 }
169 
170 /**
171 initialise geometry to nil
172 **/
173 
174 static void init_proc(void)
175 {
176     List   *geom = threed_geom_get();
177 
178     threed_geom_null();
179     geom = reclist_list_free(geom, geom_free, CONIC3, NULL);
180     threed_geom_set(geom);
181     seg_geom_set((List *) NULL);
182 }
183 
184 /**
185 get image and edge strings from appropriate place
186 **/
187 
188 static void get_data_proc(void)
189 {
190     Imrect *er;
191     Imrect *mono_edges();
192     Imrect *left_edges();
193     Imrect *right_edges();
194     Imrect *im;
195     Imrect *mono_image();
196     Imrect *left_image();
197     Imrect *right_image();
198     List   *es;
199     List   *seg_es_get();
200 
201     switch (seg_image_data_get())
202     {
203     case LEFT_DATA:
204         er = left_edges();
205         im = left_image();
206         break;
207     case RIGHT_DATA:
208         er = right_edges();
209         im = right_image();
210         break;
211     case MONO_DATA:
212         er = mono_edges();
213         im = mono_image();
214         break;
215     default:
216         er = im = NULL;
217     }
218 
219     seg_image_set((im == NULL) ? NULL : im_copy(im));
220 
221     if (er == NULL)
222         return;
223     es = (List *) prop_get(er->props, STRING);
224     if (es == NULL)
225         return;
226     seg_es_set(list_copy(es, (void *(*) ()) str_clone, NULL));  /* store copy of strings */
227     seg_es_build_index();
228 }
229 
230 /**
231 (1 2 1) mask smoothing of selected strings
232 **/
233 
234 static void smooth_proc(void)
235 {
236     List   *p;
237     Tv     *tv = seg_tv();
238 
239     p = seg_select_es_get();
240 
241     if (p == NULL || p->type != STRING)
242         return;
243 
244     for (; p != NULL; p = p->next)
245     {
246         Tstring *str = (Tstring *) p->to;
247 
248         str_smooth(str, 1);
249         tv_save_draw(tv);
250         tv_set_color(tv, salmon);
251         tv_string2(tv, str);
252         tv_reset_draw(tv);
253     }
254 }
255 
256 /**
257 adds image location to rectified geometry for graphics use
258 **/
259 
260 void    seg_add_image_location(List * reclist)
261 /* a recursive list of very recent 2D geometry */
262 {
263     Mat3    rect = {Mat3_id};
264     Parcam *pcam;
265 
266     if (seg_image_data_get() == MONO_DATA ||
267         edge_edges_rectified_get() == false)
268         return;
269 
270     if ((pcam = pcam_get()) == NULL)
271         return;
272 
273     rect = (seg_image_data_get() == LEFT_DATA) ? pcam->derect1 : pcam->derect2;
274 
275     reclist_list_apply(reclist, geom_add_image_pos_prop, (int)NULL, (void *) &rect);
276 }
277 
278 /**
279 Approximate by conics all selected strings
280 **/
281 
282 static void conic_proc(void)
283 {
284     List   *p;
285     Conic  *conic;
286     List   *conics = NULL;
287     Tv     *tv = seg_tv();
288 
289     p = seg_select_es_get();
290 
291     if (p == NULL || p->type != STRING)
292         return;
293 
294     for (; p != NULL; p = p->next)
295     {
296         Tstring *str = (Tstring *) p->to;
297 
298         tv_set_color(tv, gold);
299         conic = conic_ellipse_fit(str->start, str->end, 0.2);
300         conic->props = proplist_add(conic->props, (void *) str,
301                                     STRING, (void (*) ()) NULL);
302         conics = ref_addtostart(conics, (void *) conic, CONIC2);
303     }
304 
305     seg_add_image_location(conics);
306     reclist_list_draw(seg_tv(), conics, (int)NULL, geom_col_draw, NULL);
307     conics = ref_addtostart(seg_geom_get(), (void *) conics, LIST);
308     seg_geom_null();
309     seg_geom_set(conics);
310 }
311 
312 /**
313 Approximate by splines all selected strings
314 **/
315 
316 static void spline_proc(void)
317 {
318     List   *p;
319     Tstring *spline;
320     Tv     *tv = seg_tv();
321 
322     p = seg_select_es_get();
323 
324     if (p == NULL || p->type != STRING)
325         return;
326 
327     for (; p != NULL; p = p->next)
328     {
329         Tstring *str = (Tstring *) p->to;
330 
331         tv_set_color(tv, baby_pink);
332         spline = str_ics2(str, curve_sample, 1.0, (double *) NULL, (double *) NULL);
333         draw_string_vec2(tv, spline);
334     }
335 }
336 
337 /**
338 apply conic filter to conic
339 **/
340 
341 static void apply_conic_filter(Conic * conic)
342 {
343     Tstring *str;
344 
345     str = (Tstring *) prop_get(conic->props, STRING);
346     if ((str = (Tstring *) prop_get(conic->props, STRING)) != NULL)
347         conic_filter(conic, str->start, str->end);
348 }
349 
350 static void conic_seg_proc(void)
351 {
352     List   *conics = NULL;
353 
354     conics = conic_strings(seg_select_es_get(), INIT_SAMPLE, seg_lo_thres_get(), seg_hi_thres_get(), seg_max_div_get());
355 
356     seg_add_image_location(conics);
357     reclist_list_draw(seg_tv(), conics, (int)NULL, geom_col_draw, NULL);
358     seg_geom_set(conics);
359 }
360 
361 static void circ_seg_proc(void)
362 {
363     List   *conics = NULL;
364 
365     conics = conic_circ_strings(seg_select_es_get(), INIT_SAMPLE,
366                                 seg_lo_thres_get(), seg_hi_thres_get(),
367                                 seg_max_div_get());
368 
369     seg_add_image_location(conics);
370     reclist_list_draw(seg_tv(), conics, (int)NULL, geom_col_draw, NULL);
371     seg_geom_set(conics);
372 }
373 
374 static void poly_proc(void)
375 {
376     List   *p;
377     List   *lines = NULL;
378 
379     p = seg_select_es_get();
380 
381     if (p == NULL || p->type != STRING)
382         return;
383 
384     for (; p != NULL; p = p->next)
385     {
386         Tstring *str = (Tstring *) p->to;
387 
388         if (linear_approx)
389             str = linear_string(str, seg_lo_thres_get());
390         else
391             str = poly_string(str, seg_lo_thres_get());
392         if (str != NULL)
393             lines = ref_addtostart(lines, (void *) str, STRING);
394     }
395     seg_add_image_location(lines);
396     reclist_list_draw(seg_tv(), lines, (int)NULL, geom_col_draw, NULL);
397     seg_geom_set(lines);
398 }
399 
400 static void poly_conic_seg_proc(void)
401 {
402     int     sample = INIT_SAMPLE;
403     int     max_div = seg_max_div_get();
404     double  lo_thres = seg_lo_thres_get();
405     double  hi_thres = seg_hi_thres_get();
406     List   *p = seg_select_es_get();
407     List   *geom = NULL;
408 
409 
410     if (p == NULL || p->type != STRING)
411         return;
412 
413     for (; p != NULL; p = p->next)
414     {
415         Tstring *str = (Tstring *) p->to;
416 
417         if (linear_approx)
418             str = linear_string(str, lo_thres);
419         else
420             str = poly_string(str, lo_thres);
421         poly_string_find_conics(str, sample, lo_thres, hi_thres, max_div);
422         if (str != NULL)
423             geom = ref_addtostart(geom, (void *) str, STRING);
424     }
425     if (con_fit_func != NULL)
426         reclist_list_apply(geom, apply_conic_filter, CONIC2, NULL);
427 
428     seg_add_image_location(geom);
429     reclist_list_draw(seg_tv(), geom, (int)NULL, geom_col_draw, NULL);
430     seg_geom_set(geom);
431 }
432 
433 static void geom3_proc(void)
434 {
435     List   *geom = seg_select_geom_get();
436     double  fit_thres = seg_plane_thres_get();
437 
438     geom = reclist_list_update(geom, geom3_from_geom2, (int)NULL, (void *) &fit_thres);
439     threed_geom_set(geom);
440 }
441 
442 static void candidates_proc(void)
443 {
444     List   *geom;
445     List   *allgeom;
446 
447 
448     geom = seg_select_geom_get();
449     allgeom = seg_geom_get();
450 
451     if (geom == NULL || geom->type != CONIC2)
452         return;
453 
454     geom = conic_compatible((Conic *) geom->to, allgeom, seg_lo_thres_get(),
455                             seg_hi_thres_get(), seg_max_div_get());
456 
457     tv_set_color(seg_tv(), cyan);
458     reclist_list_draw(seg_tv(), geom, (int)NULL, geom_draw, NULL);
459     list_rm_links(geom);
460 }
461 
462 static void conic_join_proc(void)
463 {
464     List   *geom;
465     List   *allgeom;
466     List   *ptr;
467 
468     geom = seg_select_geom_get();
469     allgeom = seg_geom_get();
470 
471     for (ptr = geom; ptr != NULL; ptr = ptr->next)
472         allgeom = reclist_list_rm_entry(allgeom, ptr->to, (void (*) ()) NULL);
473 
474     geom = list_copy(geom, (void *(*) ()) NULL, NULL);
475     geom = conic_join(geom, (Imregion *) NULL, seg_conf_thres_get(),
476                       seg_lo_thres_get(), seg_hi_thres_get(),
477                       seg_max_div_get());
478 
479     seg_add_image_location(geom);
480     allgeom = list_append(geom, allgeom);
481     seg_geom_null();
482     seg_geom_set(allgeom);
483     seg_select_geom_set((List *) NULL);
484     tv_repaint(seg_tv());
485 }
486 
487 static Windex *index = NULL;
488 
489 static void build_geom_index_proc(void)
490 {
491     Windex *geom_mid_point_index_build();
492 
493     wx_free(index, list_rm_links);
494     index = geom_mid_point_index_build(seg_geom_get(), (Imregion *) NULL);
495 }
496 
497 static void index_disp_conf(Tv * tv, Conic * conic, Conic_stat * stats, Windex * index, char **mask, Ipos p, double conf)
498 {
499     int     i, ii, j, jj;
500     Vec2    v = {Vec2_id};
501     Vec2    v1 = {Vec2_id};
502     Vec2    v2 = {Vec2_id};
503     double  t;
504 
505     i = ipos_y(p);
506     j = ipos_x(p);
507 
508     if (wx_in_index(index, i, j) == false || mask[i][j])
509         return;
510 
511     mask[i][j] = 1;
512 
513     v = wx_get_mid_pos2(index, p);
514     t = conic_param(conic, v);
515     if (t < conic->t1)
516     {
517         if (t + TWOPI < conic->t2)
518             return;
519     } else if (t < conic->t2)
520         return;
521 
522     v1 = wx_get_pos2(index, p);
523     v2 = wx_get_pos2(index, ipos(j + 1, i + 1));
524 
525     if (conic_chi2(v, conic, stats) < conf &&
526         conic_chi2(v1, conic, stats) < conf &&
527         conic_chi2(v2, conic, stats) < conf &&
528         conic_chi2(wx_get_pos2(index, ipos(j, i + 1)), conic, stats) < conf &&
529         conic_chi2(wx_get_pos2(index, ipos(j + 1, i)), conic, stats) < conf)
530     {
531         v = conic_point(conic, t);      /* closest point on conic */
532 
533         /* does the conic NOT pass through this grid point */
534         if (!BETWEEN(vec2_x(v), vec2_x(v1), vec2_x(v2)) ||
535             !BETWEEN(vec2_y(v), vec2_y(v1), vec2_y(v2)))
536             return;
537     }
538     tv_rect2(tv, v1, v2);
539     tv_flush(tv);
540 
541     for (ii = -1; ii <= 1; ++ii)
542         for (jj = -1; jj <= 1; ++jj)
543             if (ii != 0 || jj != 0)
544             {
545                 p = ipos(j + jj, i + ii);
546                 index_disp_conf(tv, conic, stats, index, mask, p, conf);
547             }
548 }
549 
550 static void index_conf_proc(void)
551 {
552     List   *geom = seg_select_geom_get();
553     char  **mask;
554     Conic  *conic;
555     Conic_stat *stats;
556     Tv     *tv = seg_tv();
557     Vec2    v = {Vec2_id};
558 
559     if (index == NULL || geom == NULL || geom->type != CONIC2)
560         return;
561 
562     conic = (Conic *) geom->to;
563     stats = (Conic_stat *) prop_get(conic->props, STATS);
564 
565     if (stats == NULL)
566         return;
567 
568     tv_set_color(tv, red);
569     mask = carray_alloc(0, 0, index->m, index->n);
570     v = conic_point(conic, PI + (conic->t1 + conic->t2) * 0.5);
571     index_disp_conf(tv, conic, stats, index, mask,
572                     wx_get_index(index, v), seg_conf_thres_get());
573     v = conic_point(conic, conic->t1 - 0.1);
574     index_disp_conf(tv, conic, stats, index, mask,
575                     wx_get_index(index, v), seg_conf_thres_get());
576     v = conic_point(conic, conic->t2 + 0.1);
577     index_disp_conf(tv, conic, stats, index, mask,
578                     wx_get_index(index, v), seg_conf_thres_get());
579     carray_free(mask, 0, 0, index->m, index->n);
580 }
581 
582 static void access_index_proc(void)
583 {
584     List   *temp;
585     List   *test_geom;
586     List   *geom = seg_select_geom_get();
587     char  **mask;
588     Conic  *conic;
589     Conic_stat *stats;
590     double  conf;
591     Vec2    v = {Vec2_id};
592     Ipos    p = {Ipos_id};
593 
594     if (index == NULL || geom == NULL || geom->type != CONIC2)
595         return;
596 
597     conic = (Conic *) geom->to;
598     stats = (Conic_stat *) prop_get(conic->props, STATS);
599 
600     if (stats == NULL)
601         return;
602 
603     conf = seg_conf_thres_get();
604 
605     mask = carray_alloc(0, 0, index->m, index->n);
606     v = conic_point(conic, PI + (conic->t1 + conic->t2) * 0.5);
607     p = wx_get_index(index, v);
608     test_geom = geom_from_index(conic, stats, index, mask, p, conf);
609     v = conic_point(conic, conic->t1 - 0.1);
610     p = wx_get_index(index, v);
611     temp = geom_from_index(conic, stats, index, mask, p, conf);
612     test_geom = list_append(temp, test_geom);
613     v = conic_point(conic, conic->t2 + 0.1);
614     p = wx_get_index(index, v);
615     temp = geom_from_index(conic, stats, index, mask, p, conf);
616     test_geom = list_append(temp, test_geom);
617     tv_set_color(seg_tv(), cyan);
618 
619     reclist_list_draw(seg_tv(), test_geom, (int)NULL, geom_draw, NULL);
620     list_rm_links(test_geom);
621     carray_free(mask, 0, 0, index->m, index->n);
622 }
623 
624 #if 0
625 static void invar_surf_proc(void)
626 {
627     List   *p;
628     Terrain_data *surf;
629 
630     p = seg_select_es_get();
631 
632     if (p == NULL || p->type != STRING)
633         return;
634 
635     switch (local_curvature)
636     {
637     case LOCAL_CURVE:
638         surf = curv_invar_surf_dds((Tstring *) p->to, curve_sample, 10, z_scale);
639         break;
640     case EXTND_CURVE:
641         surf = curv_invar_surf((Tstring *) p->to, curve_sample, 10, z_scale);
642         break;
643     }
644     stack_push((void *) surf, TERRAIN, terrain_data_free);
645 }
646 #endif
647 #if 0
648 static void local_curve_proc(void)
649 {
650     List   *p;
651     List   *es;
652 
653     p = seg_select_pos_get();
654 
655     if (p == NULL || p->type != EDGE)
656         return;
657 
658     es = seg_es_get();          /* list of edge strings */
659 
660 
661     while (p != NULL)
662     {
663         Tstring *s;
664         List *d;
665         float   c=0.0;
666 
667         s = str_list_get_by_ref(es, p->to);
668         d = str_link_get_by_ref(s, p->to);
669 
670         switch (local_curvature)
671         {
672         case LOCAL_CURVE:
673             c = dds_curvature(d, curve_sample);
674             break;
675         case EXTND_CURVE:
676             c = es_curvature(s, d, 0.4, (float) curve_sample, 25.0);
677             break;
678         }
679         format("curvature %f \n", c);
680         p = p->next;
681     }
682 }
683 #endif
684 #if 0
685 static void invar_range_proc(void)
686 {
687     List   *p;
688     List   *es;
689     Tstring *s1, *s2;
690     List *d1;
691     List *d2;
692 
693     p = seg_select_pos_get();
694 
695     if (p == NULL || p->next == NULL || p->type != EDGE)
696         return;
697 
698     es = seg_es_get();          /* list of edge strings */
699     s1 = str_list_get_by_ref(es, p->to);
700     d1 = str_link_get_by_ref(s1, p->to);
701 
702     if (s1 == NULL || d1 == NULL)
703         return;
704 
705     while (p->next != NULL)
706     {
707         float   low, up;
708 
709         p = p->next;
710         s2 = str_list_get_by_ref(es, p->to);
711         d2 = str_link_get_by_ref(s2, p->to);
712 
713         if (s2 == NULL || d2 == NULL)
714             continue;
715 
716         switch (local_curvature)
717         {
718         case LOCAL_CURVE:
719             curv_invar_ratio_range_dds(s1, d1, s2, d2, curve_sample, &low, &up);
720             break;
721         case EXTND_CURVE:
722             curv_invar_ratio_range(s1, d1, s2, d2, curve_sample, &low, &up);
723             break;
724         }
725         format("invar range %f to %f \n", low, up);
726     }
727 }
728 #endif
729 
730 static void select_strings_proc(void)
731 {
732     seg_select_es_set(list_copy(seg_es_get(), (void *(*) ()) str_clone,
733                                 NULL));
734 }
735 
736 static void select_geom_proc(void)
737 {
738     seg_select_geom_set(reclist_list_flat(seg_geom_get(), (void *(*) ()) NULL,
739                         (int)NULL, NULL));
740 }
741 
742 void    seg_tool(int x, int y)
743 {
744     static void *tool = NULL;
745 
746     if (tool)
747     {
748         tw_show_tool(tool);
749         return;
750     }
751     tool = tw_tool("Segment Tool", x, y);
752 
753     tw_menubar("Pick: ",
754                "point",
755                "null", pick_choice_proc, null_pick,
756                "curv", pick_choice_proc, seg_pick_curvature,
757                "etest", pick_choice_proc, seg_pick_etest,
758                "segment", pick_choice_proc, seg_pick_segment,
759                "select", pick_choice_proc, seg_pick_select_pos,
760                NULL,
761                "string",
762                "null", pick_choice_proc, null_pick,
763                "choose", pick_choice_proc, seg_pick_choose,
764                "delete", pick_choice_proc, seg_pick_delete,
765                "combine", pick_choice_proc, seg_pick_combine,
766                "select", pick_choice_proc, seg_pick_select_es,
767                NULL,
768                "geom",
769                "null", pick_choice_proc, null_pick,
770                "draw whole", pick_choice_proc, seg_pick_draw_whole,
771            "draw string", pick_choice_proc, seg_pick_draw_geom_string,
772                "print", pick_choice_proc, seg_pick_geom_print,
773 #ifndef lint                    /* lint fails on > 49 arguments */
774                "join", pick_choice_proc, seg_pick_geom_join,
775                "select", pick_choice_proc, seg_pick_select_geom,
776 #endif                          /* lint */
777                NULL,
778                NULL);
779     tw_newrow();
780 
781     tw_choice("Tv ", tv_choice_proc, 0, "segment", NULL);
782     tw_newrow();
783     tw_check("Display ", display_check_proc, 7,
784              "image", "strings", "geom", NULL);
785     tw_newrow();
786     tw_choice("Image ", seg_image_data_set, 0,
787               "left", "right", "mono ", NULL);
788     tw_choice("Line fit ", poly_choice_proc, 0,
789               "linear", "poly", NULL);
790     tw_newrow();
791     tw_choice("Conic fit", filter_choice_proc, 0,
792               "5pt", "nlsq", "ekf", "bckf", NULL);
793     tw_newrow();
794     tw_choice("Curve fit", curvature_choice_proc, 0,
795               "local", "extended", NULL);
796     tw_newrow();
797     tw_button("Segment Params", param_dialog, NULL);
798     tw_newrow();
799     (void) tw_label("manipulation");
800     tw_newrow();
801     tw_button("init geom", init_proc, NULL);
802     tw_button("get data", get_data_proc, NULL);
803     tw_button("select all strings", select_strings_proc, NULL);
804     tw_button("select all geom", select_geom_proc, NULL);
805     tw_newrow();
806     (void) tw_label("segmentation");
807     tw_newrow();
808     tw_button("poly", poly_proc, NULL);
809     tw_button("circ", circ_seg_proc, NULL);
810     tw_button("conic", conic_seg_proc, NULL);
811     tw_button("poly/conic", poly_conic_seg_proc, NULL);
812     tw_button("join", conic_join_proc, NULL);
813     tw_newrow();
814     (void) tw_label("confidence");
815     tw_newrow();
816     tw_button("index build", build_geom_index_proc, NULL);
817     tw_button("index access", access_index_proc, NULL);
818     tw_button("index conf", index_conf_proc, NULL);
819     tw_button("candidates", candidates_proc, NULL);
820     tw_newrow();
821     (void) tw_label("fitting");
822     tw_newrow();
823     tw_button("smooth", smooth_proc, NULL);
824     tw_button("conic", conic_proc, NULL);
825     tw_button("spline", spline_proc, NULL);
826     tw_button("proj3", geom3_proc, NULL);
827     tw_newrow();
828 
829     tw_end_tool();
830 }
831 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.