Libpiv API documentation

 Search for 

gpiv-imgproc.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) 2002, 2003, 2004 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.  

-------------------------------------------------------------------------------
FILENAME:               imgproc.h
LIBRARY:                libgpiv:
EXTERNAL FUNCTIONS:
SOURCE:                 imgproc_par.c
                        gpiv_imgproc_default_parameters
                        gpiv_imgproc_fscan_parameters
                        gpiv_imgproc_read_parameters 
                        gpiv_imgproc_check_parameters
                        gpiv_imgproc_test_parameters
                        gpiv_imgproc_print_parameters
                        gpiv_imgproc_fprint_parameters
                        gpiv_imgproc_cp_parameters

SOURCE:                 imgproc.c
                        gpiv_imgproc_mktestimg
                        gpiv_imgproc_subtractimg
                        gpiv_imgproc_smooth
                        gpiv_imgproc_highlow
                        gpiv_imgproc_clip
                        gpiv_imgproc_getbit
                        gpiv_imgproc_fft
                        gpiv_imgproc_lowpass
                        gpiv_imgproc_highpass
                        gpiv_imgproc_correlate
                        gpiv_imgproc_convolve

-----------------------------------------------------------------------------*/
#ifndef __LIBGPIV_IMGPROC_H__
#define __LIBGPIV_IMGPROC_H__

#define GPIV_IMGPROCPAR_MAX__THRESHOLD 255
#define GPIV_IMGPROCPAR_MAX__WINDOW 50

#define GPIV_IMGPROCPAR_KEY "IMGPROC"       
enum GpivImgFilter {
    GPIV_IMGFI_MKTESTIMG,       
    GPIV_IMGFI_SUBACK,          
    GPIV_IMGFI_SMOOTH,          
    GPIV_IMGFI_HILO,            
    GPIV_IMGFI_CLIP,            
    GPIV_IMGFI_FFT,             
    GPIV_IMGFI_INVFFT,          
    GPIV_IMGFI_CORR,            
    GPIV_IMGFI_CONV,            
    GPIV_IMGFI_LOWPASS,         
    GPIV_IMGFI_HIGHPASS,        
    GPIV_IMGFI_GETBIT,  
};

enum GpivImgSmoothOperator {
    GPIV_IMGOP_EQUAL,    
    GPIV_IMGOP_SUBTRACT, 
    GPIV_IMGOP_ADD,      
    GPIV_IMGOP_MULTIPLY, 
    GPIV_IMGOP_DIVIDE    
};


typedef struct __GpivImageProcPar GpivImageProcPar;

struct __GpivImageProcPar {
    guint bit;                  
    gboolean bit__set;          
    guint first_dir;            
    gboolean first_dir__set;    
    guint last_dir;             
    gboolean last_dir__set;     
    gboolean  dir_prefix;       
    gboolean dir_prefix__set;   
    guint first_file;           
    gboolean first_file__set;   
    guint last_file;            
    gboolean last_file__set;    
    gboolean file_prefix;       
    gboolean file_prefix__set;  
    enum GpivImgFilter filter;  
    gboolean filter__set;       
    enum GpivImgSmoothOperator smooth_operator; 
    gboolean smooth_operator__set;              
    guint window;               
    gboolean window__set;       
    guint threshold;            
    gboolean threshold__set;    
};



/*
 * image processing parameters
 */



void
gpiv_imgproc_default_parameters         (GpivImageProcPar       *imgproc_par_default,
                                        const gboolean         force
                                        );



void
gpiv_imgproc_read_parameters            (FILE                   *fp_h, 
                                        GpivImageProcPar        *image_proc_par, 
                                        const gboolean          print_par
                                        );



gchar *
gpiv_imgproc_check_parameters_read      (GpivImageProcPar       *image_proc_par,
                                        const GpivImageProcPar  *image_proc_par_default
                                        );



gchar *
gpiv_imgproc_test_parameters            (const GpivImageProcPar *image_proc_par
                                        );



void
gpiv_imgproc_print_parameters           (FILE                   *fp, 
                                        const GpivImageProcPar  *image_proc_par
                                        );


GpivImageProcPar *
gpiv_imgproc_cp_parameters              (const GpivImageProcPar *imgproc_par
                                        );


GpivImage *
gpiv_imgproc_mktestimg          (const GpivImagePar             *image_par,
                                const GpivImageProcPar          *image_proc_par
                                );


gchar *
gpiv_imgproc_subtractimg        (const GpivImage                *image_in,
                                 GpivImage                      *image_out
                                 );


gchar *
gpiv_imgproc_smooth             (GpivImage                      *image, 
                                const GpivImageProcPar          *image_proc_par
                                );


gchar *
gpiv_imgproc_highpass           (GpivImage                      *image, 
                                const GpivImageProcPar          *image_proc_par
                                );


gchar *
gpiv_imgproc_highlow            (GpivImage                      *image,
                                const GpivImageProcPar          *image_proc_par
                                );


gchar *
gpiv_imgproc_clip               (GpivImage                      *image,
                                const GpivImageProcPar          *image_proc_par
                                );


gchar *
gpiv_imgproc_getbit             (GpivImage                      *image,
                                const GpivImageProcPar          *image_proc_par
                                );


gchar *
gpiv_imgproc_fft                        (GpivImage              *image,
                                        const GpivImageProcPar  *image_proc_par
                                        );


#ifndef USE_FFTW3

gchar *
gpiv_imgproc_lowpass                    (GpivImagePar           image_par, 
                                        GpivImageProcPar        image_proc_par,
                                        guint16                 **img
                                        );



gchar *
gpiv_imgproc_correlate                  (GpivImagePar           image_par, 
                                        GpivImageProcPar        image_proc_par,
                                        guint16                 **img1_in, 
                                        guint16                 **img2_in, 
                                        guint16*                **img_out
                                        );



gchar *
gpiv_imgproc_convolve           (GpivImagePar                   image_par, 
                                GpivImageProcPar                image_proc_par,
                                 guint16                        **img1_in, 
                                 guint16                        **img2_in, 
                                 guint16*                       **img_out
                                 );

#endif /* USE_FFTW3 */


gchar *
gpiv_imgproc_deform             (GpivImage                      *image,
                                const GpivPivData               *piv_data
                                );


#endif /* __LIBGPIV_IMGPROC_H__ */

---