tlvisEdge_pick.c

Go to the documentation of this file.

/**********
*
*
 * Copyright (c) 2003, Division of Imaging Science and Biomedical Engineering,
 * University of Manchester, UK.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, 
 * are permitted provided that the following conditions are met:
 * 
 *   . Redistributions of source code must retain the above copyright notice, 
 *     this list of conditions and the following disclaimer.
 *    
 *   . Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation 
 *     and/or other materials provided with the distribution.
 * 
 *   . Neither the name of the University of Manchester nor the names of its
 *     contributors may be used to endorse or promote products derived from this 
 *     software without specific prior written permission.
 * 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 * POSSIBILITY OF SUCH DAMAGE.
**********
*
* Program :   TINA
* File    :  $Source: /home/tina/cvs/tina-tools/tinatool/tlvision/tlvisEdge_pick.c,v $
* Date    :  $Date: 2003/10/01 16:02:47 $
* Version :  $Revision: 1.3 $
* CVS Id  :  $Id: tlvisEdge_pick.c,v 1.3 2003/10/01 16:02:47 tony Exp $
*
* Notes   :
*
*
*
*********
*/

#include "tlvisEdge_pick.h"

#if HAVE_CONFIG_H
  #include <config.h>
#endif

#include <tina/sys/sysDef.h>
#include <tina/sys/sysPro.h>
#include <tina/math/mathDef.h>
#include <tina/math/mathPro.h>
#include <tina/geometry/geomDef.h>
#include <tina/geometry/geomPro.h>
#include <tina/image/imgDef.h>
#include <tina/image/imgPro.h>
#include <tina/vision/visDef.h>
#include <tina/vision/visPro.h>

#include <tinatool/draw/drawDef.h>
#include <tinatool/draw/drawPro.h>
#include <tinatool/tlbase/tlbasePro.h>

static int SEARCH_RADIUS = 25;

static void *left_pick_closest_edge(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = left_edges();
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = EDGE;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    return (er_closest(er, r, c, SEARCH_RADIUS, (void *(*) ()) NULL, NULL));
}

static void *left_pick_closest_matchlist(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = left_edges();
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = LIST;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    return (er_closest(er, r, c, SEARCH_RADIUS, edge_sindex_prop_get, (void *) MLIST));
}

static void *left_pick_closest_corr_match(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = left_edges();
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = LIST;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    return (er_closest(er, r, c, SEARCH_RADIUS, edge_prop_get, (void *) MATCH));
}

static void *right_pick_closest_corr_match(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = right_edges();
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = LIST;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    return (er_closest(er, r, c, SEARCH_RADIUS, edge_prop_get, (void *) MATCH));
}

static void *left_pick_closest_string(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = left_edges();
    Edgel  *edge;
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = EDGE;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    edge = er_closest(er, r, c, SEARCH_RADIUS, (void *(*) ()) NULL, NULL);
    if (edge == NULL)
        return (NULL);

    return (prop_get(edge->props, STRING));
}

static void *right_pick_closest_edge(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = right_edges();
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = EDGE;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    return ((void *) er_closest(er, r, c, SEARCH_RADIUS, (void *(*) ()) NULL,
                                NULL));
}

static void *mono_pick_closest_edge(Tv * tv, Ipos pos, int *type)
{
    Imrect *er = mono_edges();
    int     r, c;
    Vec2    v = {Vec2_id};

    *type = EDGE;
    v = tv_backproj2(tv, pos);
    r = tina_int(vec2_y(v));
    c = tina_int(vec2_x(v));
    return ((void *) er_closest(er, r, c, SEARCH_RADIUS, (void *(*) ()) NULL,
                                NULL));
}

void    pick_edge_draw(Tv * tv, Edgel * edge, int type)
{
    if (edge == NULL || type != EDGE)
        return;

    tv_cross2(tv, edge_image_pos(edge), 7);
}

static void draw_matchable(Tv * tv, void *ptr, int type)
{
  Point2 *point;

  switch (type)
    {
    case CORNER:
      tv_cross2(tv, ((Edgel *) ptr)->pos, 7);
      break;
    case EDGE:
      point = (Point2 *)prop_get(((Edgel *)ptr)->props, POINT2);
      tv_pixel2(tv, point->p);
      break;
    case STRING:
      tv_edge_string(tv, (Tstring *) ptr);
      break;
    }
}

void    pick_mlist_draw(Tv * tv, List * mlist, int type)
{
    List   *lptr;
    Match  *match;

    if (mlist == NULL || type != LIST)
        return;

    for (lptr = mlist; lptr != NULL; lptr = lptr->next)
    {
        match = (Match *) lptr->to;
        draw_matchable(tv, match->to1, match->type);
    }
}

void    pick_corr_match_draw(Tv * tv1, Match * match, int type)
{
  Tv     *tv2 = NULL;
  int     old_color;

  if (tv1 == left_tv())
    tv2 = right_tv();

  if (tv1 == right_tv())
    tv2 = left_tv();

  if (match == NULL || tv1 == NULL || tv2 == NULL)
    return;

  old_color = tv_get_color(tv2);
  tv_set_color(tv2, green);

  draw_matchable(tv2, match->to2, EDGE);

  tv_set_color(tv2, old_color);

  old_color = tv_get_color(tv1);
  tv_set_color(tv1, green);

  draw_matchable(tv1, match->to1, EDGE);

  tv_set_color(tv1, old_color);
}

void    stereo_match_list_draw(List * mlist)
{
    Tv     *tvl = left_tv();
    Tv     *tvr = right_tv();
    List   *lptr;
    Match  *match;

    if (mlist == NULL)
        return;

    for (lptr = mlist; lptr != NULL; lptr = lptr->next)
    {
        match = (Match *) lptr->to;
        draw_matchable(tvl, match->to1, match->type);
        draw_matchable(tvr, match->to2, match->type);
    }
}

void    stereo_corr_match_draw(Tv * tv1, Match * match, int num)
{
  Tv     *tv2 = NULL;
  Edgel  *edge1, *edge2;
  Vec2    pos;
  Point2 *point;
  char    numstr[10];
  int     old_color;

  sprintf(numstr, "%d", num);

  if (tv1 == left_tv())
    tv2 = right_tv();

  if (tv1 == right_tv())
    tv2 = left_tv();

  if (match == NULL || tv1 == NULL || tv2 == NULL)
    return;

  old_color = tv_get_color(tv2);
  tv_set_color(tv2, green);

  edge2 = (Edgel *)match->to2;
  draw_matchable(tv2, (void *)edge2, EDGE);

  point = (Point2 *)prop_get(edge2->props, POINT2);
  pos = point->p;
  vec2_x(pos) = (float)tina_int(vec2_x(pos));
  vec2_y(pos) = (float)tina_int(vec2_y(pos)) + 0.5;
  tv_cltext2(tv2, numstr, pos);

  tv_set_color(tv2, old_color);

  old_color = tv_get_color(tv1);
  tv_set_color(tv1, green);

  edge1 = (Edgel *)match->to1;
  draw_matchable(tv1, (void *)edge1, EDGE);

  point = (Point2 *)prop_get(edge1->props, POINT2);
  pos = point->p;
  vec2_x(pos) = (float)tina_int(vec2_x(pos));
  vec2_y(pos) = (float)tina_int(vec2_y(pos)) + 0.5;
  tv_cltext2(tv1, numstr, pos);

  tv_set_color(tv1, old_color);
}

static void match_string_draw(Tstring * es)
{
    List *ptr;
    List *end;

    if (es == NULL)
        return;

    end = es->end;
    for (ptr = es->start;; ptr = ptr->next)
    {
        Tstring *sub = prop_get(((Edgel *) (ptr->to))->props, SINDEX);

        stereo_match_list_draw((List *) prop_get(sub->props, MLIST));
        ptr = sub->end;
        if (ptr == end)
            break;
    }
}

static void picklist_match_string_draw(Tv * tv, List * picklist)
{
    List   *p;
    Tv     *tvl = left_tv();
    Tv     *tvr = right_tv();

    tv_save_draw(tvl);
    tv_save_draw(tvr);
    tv_set_color(tvl, yellow);
    tv_set_color(tvr, yellow);
    for (p = picklist; p != NULL; p = p->next)
        match_string_draw((Tstring *) p->to);
    tv_reset_draw(tvl);
    tv_reset_draw(tvr);
}

static void print_edges(Tv * tv, List * picklist)
{
    List   *p;

    for (p = picklist; p != NULL; p = p->next)
        edge_format((Edgel *) p->to);
}

/*
static void print_es(tv, picklist)
Tv     *tv;
List   *picklist;
{
    List   *p;

    for (p = picklist; p != NULL; p = p->next) {
        Tstring *es = prop_get(((Edgel *) (p->to))->props, SINDEX);

        str_apply_func(es, edge_format);
    }
}
*/

static void print_matchlist(Tv * tv, List * picklist)
{
    List   *p;

    for (p = picklist; p != NULL; p = p->next)
    {
        stereo_match_list_draw((List *) p->to);
        em_list_format((List *) p->to);
    }
}

static void print_corr_match(Tv * tv, List * picklist)
{
  List   *p, *other_p;
  int     num = 1;
  Bool    repeated_pick;

  for (p = picklist; p != NULL; p = p->next)
    {
      repeated_pick = false;

      /* check for the same edge being picked more than once */
      for (other_p = p->next; other_p != NULL; other_p = other_p->next)
        if (other_p->to == p->to)
          repeated_pick = true;
      
      if (repeated_pick)
        continue;

      stereo_corr_match_draw(tv, (Match *)p->to, num);
      num++;
    }
}

Tv_pick left_edge_print(void)
{
    return (pick_define(
                        PICK_NAME, "edge",
                        PICK_CLOSEST, left_pick_closest_edge,
                        PICK_DRAW, pick_edge_draw,
                        PICK_FUNC, print_edges,
                        NULL));
}

Tv_pick right_edge_print(void)
{
    return (pick_define(
                        PICK_NAME, "edge",
                        PICK_CLOSEST, right_pick_closest_edge,
                        PICK_DRAW, pick_edge_draw,
                        PICK_FUNC, print_edges,
                        NULL));
}

Tv_pick mono_print(void)
{
    return (pick_define(
                        PICK_NAME, "edge",
                        PICK_CLOSEST, mono_pick_closest_edge,
                        PICK_DRAW, pick_edge_draw,
                        PICK_FUNC, print_edges,
                        NULL));
}

Tv_pick left_edge_matches(void)
{
    return (pick_define(
                        PICK_NAME, "edge match",
                        PICK_CLOSEST, left_pick_closest_matchlist,
                        PICK_DRAW, pick_mlist_draw,
                        PICK_FUNC, print_matchlist,
                        PICK_REPAINT, false,
                        NULL));
}

Tv_pick left_edge_corr_matches(void)
{
    return (pick_define(
                        PICK_NAME, "corr match",
                        PICK_CLOSEST, left_pick_closest_corr_match,
                        PICK_DRAW, pick_corr_match_draw,
                        PICK_FUNC, print_corr_match,
                        PICK_REPAINT, false,
                        NULL));
}

Tv_pick right_edge_corr_matches(void)
{
    return (pick_define(
                        PICK_NAME, "corr match",
                        PICK_CLOSEST, right_pick_closest_corr_match,
                        PICK_DRAW, pick_corr_match_draw,
                        PICK_FUNC, print_corr_match,
                        PICK_REPAINT, false,
                        NULL));
}

Tv_pick left_string_matches(void)
{
    return (pick_define(
                        PICK_NAME, "string match",
                        PICK_CLOSEST, left_pick_closest_string,
                        PICK_DRAW, tv_edge_string,
                        PICK_FUNC, picklist_match_string_draw,
                        PICK_REPAINT, false,
                        NULL));
}

---