This file is indexed.

/usr/include/gpiv/gpiv-piv_utils.h is in libgpiv3-dev 0.6.1-3build2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
/* -*- 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, 2005, 2006, 2007, 2008 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:
			 gpiv_null_pivdata
                         gpiv_alloc_pivdata
                         gpiv_check_alloc_pivdata
			 gpiv_free_pivdata
                         gpiv_0_pivdata
                         gpiv_cp_pivdata
                         gpiv_add_dxdy_pivdata
                         gpiv_sum_dxdy_pivdata

                         gpiv_alloc_cov
			 gpiv_free_cov

                         gpiv_piv_mpi_bcast_pivdata

LAST MODIFICATION DATE:  $Id: gpiv-piv_utils.h,v 1.2 2008-09-25 13:19:53 gerber Exp $
 --------------------------------------------------------------------------- */
/**
\file                   gpiv-piv_utils.h
\brief                  utilities module for GpivPivData structure

SOURCES:                lib/piv_utils.c

LAST MODIFICATION DATE:  $Id: gpiv-piv_utils.h,v 1.2 2008-09-25 13:19:53 gerber Exp $
 */

#ifndef __LIBGPIV_PIV_UTILS_H__
#define __LIBGPIV_PIV_UTILS_H__

/**
 *      Sets all elements of piv_data structure to NULL.
 *
 *      @param[in] piv_data     Input PIV data structure
 *      @param[out] piv_data    Output PIV data structure
 *      @return                 void
 */
void
gpiv_null_pivdata			(GpivPivData		*piv_data
					);


/**
 *      Allocates memory for GpivPivData.
 *
 *      @param[in] nx           number of nx  (column-wise data dimension)
 *      @param[in] ny           number of ny  (row-wise data dimension)
 *      @return                 piv_data on success or NULL on failure
 */
GpivPivData *
gpiv_alloc_pivdata			(const guint		nx,
					const guint		ny
					);

/**
 *     Checks if piv_data have been allocated.
 *
 *     @param[in] piv_data     PIV data set to be checked if allocated
 *     @return                 NULL on success or error message on failure
 */
gchar *
gpiv_check_alloc_pivdata		(const GpivPivData      *piv_data
					);

/**
 *      Frees memory for GpivPivData.
 *
 *      @param[in] piv_data     PIV data structure
 *      @param[out] piv_data    NULL pointer to point_x, point_y, dx, dy, snr 
 *                              and peak_no
 *      @return                 void
 */
void 
gpiv_free_pivdata			(GpivPivData		*piv_data
					);



/**
 *      Sets estimators, snr and peak_nr of piv_data to 0 or 0.0. 
 *      The structure will have to be allocated before (with 
 *      gpiv_alloc_pivdata).
 *
 *      @param[in] piv_data     PIV data
 *      @return                 NULL on success or error message on failure
 */
gchar *
gpiv_0_pivdata				(const GpivPivData	*piv_data
					);



/**
 *      Returns a copy of piv_data.  
 *      Piv_data_in will have to be allocated with gpiv_alloc_pivdata and the 
 *      returned datawill have to be freed with gpiv_free_pivdata.
 *
 *      @param[in] piv_data     Input PIV data
 *      @return                 GpivPivData on success or NULL on failure
 */
GpivPivData *
gpiv_cp_pivdata				(const GpivPivData      *piv_data
					);


/**
 *      Overwrites piv_data_out with piv_data_in.
 *      Both PIV data sets will have to be allocated with gpiv_alloc_pivdata
 *      and must be of equal sizes.
 *
 *      @param[in] piv_data_in  Input PIV data
 *      @param[in] piv_data_out Output PIV data
 *      @return                 NULL on success or error message on failure
 */
gchar *
gpiv_ovwrt_pivdata			(const GpivPivData      *piv_data_in,
					const GpivPivData	*piv_data_out
					);



/**
 *      Adds displacements (dx, dy), snr and peak_nr from piv_data_in to 
 *      piv_data_out. Both structures will have to be allocated before 
 *      (with gpiv_alloc_pivdata).
 *
 *      @param[in] piv_data_in          Input PIV data structure
 *      @param[out] piv_data_out        Output PIV data structure
 *      @return                         NULL on success or error message on failure
 */
gchar *
gpiv_add_dxdy_pivdata			(const GpivPivData      *piv_data_in,
					GpivPivData		*piv_data_out
					);



/**
 *      Adds all displacements in order to calculate residuals
 *      The structure will have to be allocated before (with 
 *      gpiv_alloc_pivdata).
 *
 *      @param[in] piv_data     PIV data structure
 *      @param[out] sum         resulting sum
 *      @return                 NULL on success or error message on failure
 */
gchar * 
gpiv_sum_dxdy_pivdata			(const GpivPivData      *piv_data,
					gfloat			*sum
					);



/**
 *      Plots piv data as vectors on screen with gnuplot.
 *
 *      @param[in] title                        title of plot
 *      @param[in] gnuplot_scale                vector scale
 *      @param[in] GNUPLOT_DISPLAY_COLOR        display color of window containing graph
 *      @param[in] GNUPLOT_DISPLAY_SIZE         display size of window containing graph
 *      @param[in] image_par                    image parameters
 *      @param[in] piv_par                      piv evaluation parameters
 *      @param[in] piv_data                     piv data
 *      @return                                 NULL on success or error message on failure
 */
gchar *
gpiv_piv_gnuplot			(const gchar            *title, 
					const gfloat		gnuplot_scale,
					const gchar		*GNUPLOT_DISPLAY_COLOR, 
					const guint		GNUPLOT_DISPLAY_SIZE,
					const GpivImagePar	*image_par, 
					const GpivPivPar	*piv_par,
					const GpivPivData	*piv_data
					);



/**
 *      Allocates memory for GpivCov.
 *
 *      @param[in] int_size0     size of zere-padded interrogation area
 *      @param[in] x_corr        two frame image / cross correlation
 *      @return                  covariance on success or NULL on failure
 */
GpivCov *
gpiv_alloc_cov				(const guint            int_size0,
					const gboolean		x_corr
					);

/**
 *      Frees memory for GpivCov.
 *
 *      @param[in] cov          Covariance structure
 *      @return                 void
 */
void 
gpiv_free_cov				(GpivCov		*cov
					);


/*
 * Some MPI routines
 */
#ifdef ENABLE_MPI

/**
 *      Scatters PivData structure for parallel processing with MPI
 *      using MPI_Scatter().
 *      Except of pd->nx and pd->ny, which should broadcasted in forward
 *      in order to allocate memory.)
 *
 *      @param[in] pd PIV       data to be scattered
 *      @param[in] nprocs       number of processes
 *      @param[out] pd_scat     scattered piv data
 *      @return                 void
 */
void
gpiv_piv_mpi_scatter_pivdata 		(GpivPivData 		*pd, 
                              		GpivPivData 		*pd_scat, 
                              		guint 			nprocs
                              		);

/**
 *     Gathers PivData structure for parallel processing with MPI
 *     using MPI_Gather().
 *     Counterpart of gpiv_piv_mpi_scatter_pivdata
 *
 *      @param[in] pd_scat      scattered piv data
 *      @param[out] pd          PIV data to be gathered
 *      @return                 void
 */
void 
gpiv_piv_mpi_gather_pivdata 		(GpivPivData 		*pd_scat, 
                             		GpivPivData 		*pd, 
                             		guint 			nprocs
					);

/**
 *      Calculates number of data counts[] for scatterv rows of data
 *
 *      @param[in] nx           number of x-data (columns)
 *      @param[in] ny           number of y-data (rows)
 *      @return                 pointer to gint array representing counts[]
 */
gint * 
gpiv_piv_mpi_compute_counts		(const guint 		nx, 
                            		const guint 		ny
					);

/**
 *      Calculates displacements array displs[] for scatterv rows of data
 *
 *      @param[in] counts       array containing number of data to be scattered to each node
 *      @param[in] nx           number of x-data (columns)
 *      @param[in] ny           number of x-data (rows)
 *      @return                 pointer to gint array representing displs[]
 */
gint * 
gpiv_piv_mpi_compute_displs		(gint 			*counts, 
                            		const guint 		nx, 
                            		const guint 		ny
					);

/**
 *      Scatters PivData structure to variable arrays for parallel processing 
 *      with MPI using MPI_Scatterv().
 *      Except of pd->nx and pd->ny, which should broadcasted in forward
 *      in order to allocate memory.)
 *
 *      @param[in] pd           PIV data to be scattered
 *      @param[out] pd_scat     scattered piv data
 *      @param[in] counts       array containing number of data to be scattered 
 *                              to each node, obtained with gpiv_piv_mpi_compute_counts()
 *      @param[in] displs       array containing displacement to each node, , obtained 
 *                              with gpiv_piv_mpi_compute_displs()
 *      @return                 void
 */
void
gpiv_piv_mpi_scatterv_pivdata 		(GpivPivData 		*pd, 
                               		GpivPivData 		*pd_scat, 
                               		gint 			*counts,
                               		gint 			*displs
					);

/**
 *      Gathers PivData structure to variable arrays for parallel processing 
 *      with MPI using MPI_Gatherv().
 *      Except of pd->nx and pd->ny, which should broadcasted in forward
 *      in order to allocate memory.)
 *
 *      @param[in] pd_scat      scattered PIV data
 *      @param[out] pd          PIV data to be gathered
 *      @param[in] counts       array containing number of data to be scattered 
 *                              to each node, obtained with gpiv_piv_mpi_compute_counts()
 *      @param[in] displs       array containing displacement to each node, , obtained 
 *                              with gpiv_piv_mpi_compute_displs()
 *      @return                 void
 */
void 
gpiv_piv_mpi_gatherv_pivdata 		(GpivPivData 		*pd_scat, 
                              		GpivPivData 		*pd, 
                              		gint 			*counts,
                              		gint 			*displs
					);

/**
 *      Broadcasts PivData structure to variable arrays for parallel processing 
 *      with MPI using MPI_Bcast().
 *      Except of pd->nx and pd->ny, which should broadcasted in forward
 *      in order to allocate memory.)
 *
 *      @param[out] pd          PIV data to be broadcasted
 *      @return                 void
 */
void 
gpiv_piv_mpi_bcast_pivdata 		(GpivPivData 		*pd
					);

#endif /* ENABLE_MPI */
#endif /* __LIBGPIV_PIV_UTILS_H__ */