Linux Cross Reference
TINA5/tina-libs/tina/medical/medSroi_io.c

   /**********
    *
    * This file is part of the TINA Open Source Image Analysis Environment
    * henceforth known as TINA
    *
    * TINA is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as
    * published by the Free Software Foundation.
    *
   * TINA is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with TINA; if not, write to the Free Software Foundation, Inc.,
   * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *
   **********
   *
   * Program :    TINA
   * File    :  $Source: /home/tina/cvs/tina-libs/tina/medical/medSroi_io.c,v $
   * Date    :  $Date: 2004/03/10 14:56:22 $
   * Version :  $Revision: 1.7 $
   * CVS Id  :  $Id: medSroi_io.c,v 1.7 2004/03/10 14:56:22 neil Exp $
   *
   * Author  : Legacy TINA
   *
  */
  /**
   * @file 
   * @brief Functions for reading and writing SROI and ASM model data
   * Can only read one file at a time due to the use of static variables.
   *
   *********
   */
  
  #if HAVE_CONFIG_H
  #   include <config.h>
  #endif
  
  
  #include <tina/medical/med_SroiDef.h>
  #include <tina/medical/medSroi_alloc.h>
  
  #include <math.h>
  #include <string.h>
  #include <tina/math/mathDef.h>
  #include <tina/math/mathPro.h>
  #include <tina/image/imgDef.h>
  #include <tina/image/imgPro.h>
  
  #include "med_SroiDef.h"
  #include "medSroi_io.h"
  
  
  /*
   * Local variables
   */
  
  static FILE *blfp = NULL;
  static int   blcount = 0;
  static int   bltotal = 0;
  
  
  static int get_int(FILE * f)
  {
    int n = 0;
  
    fscanf(f, "%d", &n);
    return n;
  }
  
  static float get_float(FILE * f)
  {
    float x = 0.0;
  
    fscanf(f, "%f", &x);
    return x;
  }
  
  static double get_ledouble(FILE * f)
  {
    double x = 0.0;
  
    fscanf(f, "%le", &x);
    return x;
  }
  
  static double get_lfdouble(FILE * f)
  {
    double x = 0.0;
  
    fscanf(f, "%lf", &x);
    return x;
  }
  
  void dvector_printf(FILE * f, Vector * vec)
  {
   double *el = (double *) vec->data;
   int i, n = vec->n;
 
   fprintf(f, "double ");
   fprintf(f, "%d ", n);
   for (i = 0; i < n; i++)
     fprintf(f, "%f ", el[i]);
 }
 
 void dvector_scanf(FILE * f, Vector * vec)
 {
 
   double *el = (double *) vec->data;
   int i;
   char type[64];
 
   fscanf(f, "%s", type);
   if (strcmp(type, "double") != 0)
   {
     error("Wrong data type in file", non_fatal);
     return;
   }
   vec->n = get_int(f);
   for (i = 0; i < vec->n; i++)
     el[i] = get_lfdouble(f);
 }
 
 
 void dmatrix_scanf(FILE * f, Matrix * mat)
 {
   double **el = mat->el.double_v;
   int i, j;
   char dtype[64], mtype[64];
 
   fscanf(f, "%s", dtype);
   if (strcmp(dtype, "double") != 0)
   {
     error("Wrong data type in file", non_fatal);
     return;
   }
   switch (mat->shape)
   {
   case matrix_full:
     fscanf(f, "%s", mtype);
     if (strcmp(mtype, "full") != 0)
     {
       error("Wrong matrix shape in file", non_fatal);
       return;
     }
     mat->m = get_int(f);
     mat->n = get_int(f);
     for (i = 0; i < mat->m; ++i)
       for (j = 0; j < mat->n; ++j)
         el[i][j] = get_lfdouble(f);
     break;
   case matrix_lower:
     fscanf(f, "%s", mtype);
     if (strcmp(mtype, "lower") != 0)
     {
       error("Wrong matrix shape in file", non_fatal);
       return;
     }
     mat->m = get_int(f);
     mat->n = get_int(f);
     for (i = 0; i < mat->m; ++i)
       for (j = 0; j < i; ++j)
         el[i][j] = get_lfdouble(f);
     break;
   case matrix_upper:
     fscanf(f, "%s", mtype);
     if (strcmp(mtype, "upper") != 0)
     {
       error("Wrong matrix shape in file", non_fatal);
       return;
     }
     mat->m = get_int(f);
     mat->n = get_int(f);
     for (i = 0; i < mat->m; ++i)
       for (j = i; j < mat->m; ++j)
         el[i][j] = get_lfdouble(f);
     break;
   case matrix_symmetric:
     fscanf(f, "%s", mtype);
     if (strcmp(mtype, "symmetric") != 0)
     {
       error("Wrong matrix shape in file", non_fatal);
       return;
     }
     mat->m = get_int(f);
     mat->n = get_int(f);
     for (i = 0; i < mat->m; ++i)
       for (j = 0; j <= i; ++j)
         el[i][j] = get_lfdouble(f);
     break;
   default:
     error("Wrong matrix shape in file", non_fatal);
     return;
   }
 }
 
 void output_model(char *fname, Model *model)
 {
   char temps[256];
   FILE *fp;
   int i, j;
   float **p;
   double **el;
   
   if (model == NULL)
     return;
 
   if ((fp = fopen(fname, "wt")) == NULL)
   {
     string_append(temps, "can't open file", fname, 0);
     error(temps, non_fatal);
     return;
   }
   el = model->m->el.double_v;
   p = model->profile->el.float_v;
 
   fprintf(fp, "%d ", model->r);
   fprintf(fp, "%d ", model->c);
   fprintf(fp, "%d ", model->o);
   fprintf(fp, "%e ", model->tx);
   fprintf(fp, "%e ", model->ty);
   fprintf(fp, "%e ", model->s);
   fprintf(fp, "%e ", model->theta);
   fprintf(fp, "%d ", model->vsize);
   fprintf(fp, "\n");
 
   for (i = 0; i < model->r; i++)
   {
     for (j = 0; j < model->c; j++)
       fprintf(fp, "%e ", el[i][j]);
     fprintf(fp, "\n");
   }
   for (i = 0; i < model->c; i++)
   {
     for (j = 0; j < 2 * model->vsize - 1; j++)
       fprintf(fp, "%f ", p[i][j]);
     fprintf(fp, "\n");
   }
   fflush(fp);
   fclose(fp);
 }
 
 
 
 Model *input_model(char *fname, Model *model)
 {
   FILE *fp;
   int i, j, r, c, o, vsize;
   float **p;
   double **el, tx, ty, s, theta;
   char temps[256];
 
   if ((fp = fopen(fname, "r")) == NULL)
   {
     string_append(temps, "can't open file", fname, 0);
     error(temps, non_fatal);
     return (NULL);
   }
   r = get_int(fp);
   c = get_int(fp);
   o = get_int(fp);
   tx = get_ledouble(fp);
   ty = get_ledouble(fp);
   s = get_ledouble(fp);
   theta = get_ledouble(fp);
   vsize = get_int(fp);
 
   if (model == NULL || model->c != c || model->o != o || 
        model-> r != r || model->vsize != vsize)
   {
     if ((model = model_alloc(r, c, o, vsize)) == NULL)
 /* warning, memory should have been deleted here NAT */
       return (NULL);
   }
 
   el = model->m->el.double_v;
   p = model->profile->el.float_v;
 
 /* these are either already correct or were set in model alloc NAT 
   model->r = r;
   model->c = c;
   model->o = o;
   model->vsize = vsize;
 */
   model->tx = tx;
   model->ty = ty;
   model->s = s;
   model->theta = theta;
 
   for (i = 0; i < model->r; i++)
     for (j = 0; j < model->c; j++)
       el[i][j] = get_ledouble(fp);
   for (i = 0; i < model->c; i++)
     for (j = 0; j < 2 * model->vsize - 1; j++)
       p[i][j] = get_float(fp);
 
   fclose(fp);
   return(model);
 }
 
 
 int   sroi_open_buildlist(char *fname)
 {
   char  temp[512];
 
   if ((fname == NULL) || (blfp = fopen(fname, "r")) == NULL)
   {
     sprintf(temp, "sroi_open_buildlist: build list %s not found", fname);
     error(temp, warning);
     return(0);
   }
 
   bltotal = blcount = 0;
   while (fscanf(blfp, "%s", temp) != EOF)
     bltotal++;
   rewind(blfp);
   
   return(bltotal);    
 }
 
 
 int  sroi_getnext_build(char *fname)
 {
   int  status;
 
   if (fname == NULL || blfp == NULL)
     return(0);
 
   status = fscanf(blfp, "%s", fname);
   if (status == 0 || status == EOF)
   {
     if (blcount != bltotal)
       return(0);
     else
       return(-1);
   }
 
   return(1); 
 }
 
 
 void  sroi_close_buildlist(void)
 {
   if (blfp == NULL)
     return;
  
   fclose(blfp);
   blfp = NULL;
 
   return;
 }