Linux Cross Reference
Tina6/tina-libs/tina/sys/sysLst_match.c

   /**********
    * 
    * 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-libs/tina/sys/sysLst_match.c,v $
   * Date    :  $Date: 2003/09/22 16:09:02 $
   * Version :  $Revision: 1.6 $
   * CVS Id  :  $Id: sysLst_match.c,v 1.6 2003/09/22 16:09:02 tony Exp $
   *
   * Author  :  Legacy TINA
  */
  /** 
   * @file A genericly defined matching structure for storing correspondence between any two
   * data strucutres.
   * 
   * @brief typedef struct match { int type; int label; float weight; void *to1;
   * void *to2; struct list *props; } Match;
   *
   *********
  */
  
  #include "sysLst_match.h"
  
  #if HAVE_CONFIG_H
    #include <config.h>
  #endif
  
  #include <stdio.h>
  
  #if STDC_HEADERS
  #  include  <string.h>
  #elif __GNUC__
  void *memcpy();
  void *memset();
  #else
  char *memcpy();
  char *memset();
  #endif
  
  #ifdef _PCC
  #include <memory.h>
  #endif
  
  #include <tina/sys/sys_LstDef.h>
  #include <tina/sys/sys_MemDef.h>
  #include <tina/sys/sysLst_prop.h>
  #include <tina/sys/sysLst_list.h>
  #include <tina/sys/sysMem_ralloc.h>
  
  
  /* static variable for unique match label generation */
  static int label = 0;           /* static data! */
  
  /* allocate match structure body of specified type */
  Match  *match_alloc(int type)
  {
      Match  *match = ts_ralloc(Match);
  
      match->type = type;
      match->label = label++;
      match->weight = (float)1.0;
      match->to1 = match->to2 = NULL;
      match->props = NULL;
      return (match);
  }
  
  /* allocate match structure and make it reference generic pointers of
   * specified type
  * 
  * note that the match structure is for matches between things of the same
  * tyoe */
 Match  *match_make(void *ptr1, void *ptr2, int type)
 {
     Match  *match = ts_ralloc(Match);
 
     match->type = type;
     match->label = label++;
     match->weight = (float)1.0;
     match->to1 = ptr1;
     match->to2 = ptr2;
     match->props = NULL;
     return (match);
 }
 
 /* copy the match data structure and make a copy of its property list
  * 
  * changes to the properties will be shared */
 Match  *match_copy(Match * match)
 {
     Match  *copy;
 
     if (match == NULL)
         return (NULL);
 
     copy = ts_ralloc(Match);
     (void) memcpy((char *) copy, (char *) match, sizeof(Match));
     copy->props = proplist_copy(match->props);
     return (copy);
 }
 
 /* find the mostr strongly weighted match in a list */
 double  mlist_strongest(List * mlist, double (*cost_func) ( /* ??? */ ))
 {
     double  maxs = 0;
 
     while (mlist != NULL)
     {
         Match  *m = (Match *) mlist->to;
         double  s;
 
         s = (cost_func == NULL) ? m->weight : cost_func(m);
 
         if (s > maxs)
             maxs = s;
         mlist = mlist->next;
     }
     return (maxs);
 }
 
 /* check if to2 is referenced as a ->to2 of any element of the match
  * list */
 Bool    mlist_to2_exists(List * mlist, void *to2)
 {
     List   *ptr;
 
     for (ptr = mlist; ptr != NULL; ptr = ptr->next)
         if (((Match *) ptr->to)->to2 == to2)
             return (true);
     return (false);
 }
 
 /* generate a list of the second reference (->to2) of a match list */
 List   *mlist_to2_list(List * mlist)
 {
     List   *mptr;
     List   *list = NULL;
 
     for (mptr = mlist; mptr != NULL; mptr = mptr->next)
     {
         Match  *m = (Match *) mptr->to;
 
         list = ref_addtostart(list, (void *) m->to2, m->type);
     }
     return (list_reverse(list));
 }
 
 void    match_free(Match * match)
 {
     if (match == NULL)
         return;
     proplist_freelist(match->props);
     match->props = NULL;
     rfree((void *) match);
 }
 
 void    match_copy_free(Match * match)
 /* don't free up the proplist as this was not allocated 
    NAT 22/12/99 */
 {
     if (match == NULL)
         return;
     list_rm_links(match->props);
     match->props = NULL;
     rfree((void *) match);
 }
 
 void    mlist_free(List * mlist)
 /* list of matches */
 {
     list_rm(mlist, match_free);
 }