Libpiv API documentation

 Search for 

gpiv-utils_alloc.h

Go to the documentation of this file.

/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 c-style: "K&R" -*- */

/*
   libgpiv - library for Particle Image Velocimetry

   Copyright (C) 2007 Gerber van der Graaf

   This file is part of libgpiv.

   Libgpiv is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  




-------------------------------------------------------------------------------
LIBRARY:                 libgpiv:
EXTERNAL FUNCTIONS:
                         check_img_exist

                         gpiv_scan_iph,
                         gpiv_scan_iph_nl,
                         gpiv_fscan_iph, 
                         gpiv_scan_cph, 
                         gpiv_fscan_cph, 
                         gpiv_scan_fph, 
                         gpiv_fscan_fph, 
                         gpiv_scan_sph, 
                         gpiv_fscan_sph, 
                         gpiv_sort_3,


                         gpiv_matrix, 
                         gpiv_free_matrix
                         gpiv_matrix_index 
                         gpiv_free_matrix_index
                         gpiv_ucmatrix, 
                         gpiv_free_ucmatrix
                         gpiv_matrix_guint16
                         gpiv_free_matrix_guint16
                         gpiv_imatrix, 
                         gpiv_free_imatrix
                         gpiv_double_matrix
                         gpiv_free_double_matrix
                         gpiv_fftw_real_matrix
                         gpiv_free_fftw_real_matrix

                         gpiv_vector,
                         gpiv_free_vector, 
                         gpiv_vector_index,
                         gpiv_free_vector_index, 

                         gpiv_dvector,
                         gpiv_free_dvector, 
                         gpiv_dvector_index,
                         gpiv_free_dvector_index, 

                         gpiv_nulvector,
                         gpiv_free_nulvector,
                         gpiv_nulvector_index,
                         gpiv_free_nulvector_index, 

                         gpiv_ulvector,
                         gpiv_free_ulvector, 
                         gpiv_ulvector_index,
                         gpiv_free_ulvector_index, 

                         gpiv_ivector,
                         gpiv_free_ivector, 
                         gpiv_ivector_index,
                         gpiv_free_ivector_index
                         gpiv_gbolvector
                         gpiv_free_gbolvector


LAST MODIFICATION DATE:  $Id: $
 --------------------------------------------------------------------------- */
#ifndef __L_UTILS_H__
#define __L_UTILS_H__

gfloat **
gpiv_matrix                             (long                   nr,
                                        long                    nc
                                        );



void 
gpiv_free_matrix                        (gfloat                 **m
                                        );



gfloat **
gpiv_matrix_index                       (const long             nrl,
                                         const long             nrh,
                                         const long             ncl,
                                         const long             nch
                                         );



void 
gpiv_free_matrix_index                  (gfloat                 **m,
                                        const long              nrl,
                                        const long              nrh,
                                        const long              ncl,
                                        const long              nch
                                        );



guchar **
gpiv_ucmatrix                           (const long             nr,
                                        const long              nc
                                        );



void 
gpiv_free_ucmatrix                      (guchar                 **m
                                        );



guint8 **
gpiv_matrix_guint8                      (const long             nr, 
                                        const long              nc
                                        );



void 
gpiv_free_matrix_guint8                 (guint8                 **m
                                        );


guint16 **
gpiv_matrix_guint16                     (const long             nr, 
                                        const long              nc
                                        );



void 
gpiv_free_matrix_guint16                (guint16                **m
                                        );



gint **
gpiv_imatrix_index                      (const long             nrl,
                                        const long              nrh,
                                        const long              ncl,
                                        const long              nch
                                        );



void 
gpiv_free_imatrix_index                 (gint                   **m, 
                                        const long              nrl, 
                                        const long              nrh, 
                                        const long              ncl, 
                                        const long              nch
                                        );



gint **
gpiv_imatrix                            (const long             nr,
                                        const long              nc
                                        );



void 
gpiv_free_imatrix                       (gint                   **m
                                        );



double **
gpiv_double_matrix                      (const glong            nr, 
                                        const glong             nc 
                                        );



void 
gpiv_free_double_matrix                 (double                 **m
                                        );


#ifndef USE_FFTW3

fftw_real **
gpiv_fftw_real_matrix                   (glong                  nr, 
                                        glong                   nc 
                                        );



void 
gpiv_free_fftw_real_matrix              (fftw_real              **m
                                        );

#endif /* USE_FFTW3 */


fftw_complex **
gpiv_fftw_complex_matrix                (const long             nr, 
                                        const long              nc 
                                        );



void 
gpiv_free_fftw_complex_matrix           (fftw_complex           **m
                                        );


gfloat *
gpiv_vector                             (const long             nl
                                        );



void 
gpiv_free_vector                        (gfloat                 *vector
                                        );



gfloat *
gpiv_vector_index                       (const long             nl,
                                        const long              nh
                                        );



void 
gpiv_free_vector_index                  (gfloat                 *vector,
                                        const long              nl,
                                        const long              nh
                                        );



gdouble *
gpiv_dvector                            (const glong            nl
                                        );



void
gpiv_free_dvector                       (gdouble                *vector
                                        );



gdouble *
gpiv_dvector_index                      (const long             nl, 
                                        const long              nh
                                        );



void
gpiv_free_dvector_index                 (gdouble                *vector, 
                                        const long              nl, 
                                        const long              nh
                                        );



long *
gpiv_nulvector                          (long                   nl
                                        );



void 
gpiv_free_nulvector                     (long                   *vector
                                        );



long *
gpiv_nulvector_index                    (const long             nl,
                                        const long              nh
                                        );



void 
gpiv_free_nulvector_index               (long                   *vector,
                                        const long              nl,
                                        const long              nh
                                        );



unsigned long *
gpiv_ulvector                           (const long             nl
                                        );



void 
gpiv_free_ulvector                      (unsigned long          *vector
                                        );



unsigned long *
gpiv_ulvector_index                     (const long             nl,
                                        const long              nh
                                         );



void 
gpiv_free_ulvector_index                (unsigned long          *vector,
                                        const long              nl,
                                        const long              nh
                                        );



gint *
gpiv_ivector                            (const long             nl
                                        );



void 
gpiv_free_ivector                       (gint                   *vector
                                        );



gint *
gpiv_ivector_index                      (const long             nl,
                                        const long              nh
                                        );



void 
gpiv_free_ivector_index                 (gint                   *vector,
                                        const long              nl,
                                        const long              nh
                                        );



gboolean *
gpiv_gbolvector                         (const glong            nl
                                        );



void 
gpiv_free_gbolvector                    (gboolean               *vector
                                        );



#endif /* __L_UTILS_H__ */

---