;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; LUSH Lisp Universal Shell
;;;   Copyright (C) 2002 Leon Bottou, Yann Le Cun, AT&T Corp, NECI.
;;; Includes parts of TL3:
;;;   Copyright (C) 1987-1999 Leon Bottou and Neuristique.
;;; Includes selected parts of SN3.2:
;;;   Copyright (C) 1991-2001 AT&T Corp.
;;;
;;; Includes information derived from the GSL (Gnu Scientific Library)
;;;   header files which are copyrighted and distributed under the GPL
;;;   by their respective authors.
;;;
;;; This program 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 of the License, 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, USA
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(libload "opencv/cv-config")



#? *** aux_structure

;; Functions to allocate structures used in OpenCV
;; and to get their size. There are also functions to
;; access the fields of various structures.
;; The naming convention is <(getp_field_type typeptr)>.
;; This returns a pointer to the field <field> of the
;; object of type <type> pointed to by <typeptr>.



;; dummy function that adds OpenCV C header files in C file
(eval `(de dummy_aux_structure () ,cv-cpheader-cmd ()))

#? * (dummy_aux_structure)
#? * (getp_data_cvmat <thispointer>)
#? * (getp_step_cvmat <thispointer>)
#? * (getp_cols_cvmat <thispointer>)
#? * (getp_rows_cvmat <thispointer>)
#? * (getp_type_cvmat <thispointer>)
#? * (alloc_cvmat)
#? * (memsize_cvmat)
#? * (getp_height_cvrect <thispointer>)
#? * (getp_width_cvrect <thispointer>)
#? * (getp_y_cvrect <thispointer>)
#? * (getp_x_cvrect <thispointer>)
#? * (alloc_cvrect)
#? * (memsize_cvrect)
#? * (getp_y_cvpoint <thispointer>)
#? * (getp_x_cvpoint <thispointer>)
#? * (alloc_cvpoint)
#? * (memsize_cvpoint)
#? * (getp_height_cvsize <thispointer>)
#? * (getp_width_cvsize <thispointer>)
#? * (alloc_cvsize)
#? * (memsize_cvsize)
#? * (getp_epsilon_cvtermcriteria <thispointer>)
#? * (getp_max_iter_cvtermcriteria <thispointer>)
#? * (getp_type_cvtermcriteria <thispointer>)
#? * (alloc_cvtermcriteria)
#? * (memsize_cvtermcriteria)
#? * (getp_y_cvpoint2d32f <thispointer>)
#? * (getp_x_cvpoint2d32f <thispointer>)
#? * (alloc_cvpoint2d32f)
#? * (memsize_cvpoint2d32f)
#? * (getp_z_cvpoint3d32f <thispointer>)
#? * (getp_y_cvpoint3d32f <thispointer>)
#? * (getp_x_cvpoint3d32f <thispointer>)
#? * (alloc_cvpoint3d32f)
#? * (memsize_cvpoint3d32f)
#? * (getp_y_cvpoint2d64d <thispointer>)
#? * (getp_x_cvpoint2d64d <thispointer>)
#? * (alloc_cvpoint2d64d)
#? * (memsize_cvpoint2d64d)
#? * (getp_z_cvpoint3d64d <thispointer>)
#? * (getp_y_cvpoint3d64d <thispointer>)
#? * (getp_x_cvpoint3d64d <thispointer>)
#? * (alloc_cvpoint3d64d)
#? * (memsize_cvpoint3d64d)
#? * (getp_height_cvsize2d32f <thispointer>)
#? * (getp_width_cvsize2d32f <thispointer>)
#? * (alloc_cvsize2d32f)
#? * (memsize_cvsize2d32f)
#? * (getp_angle_cvbox2d <thispointer>)
#? * (getp_size_cvbox2d <thispointer>)
#? * (getp_center_cvbox2d <thispointer>)
#? * (alloc_cvbox2d)
#? * (memsize_cvbox2d)
#? * (getp_end_index_cvslice <thispointer>)
#? * (getp_start_index_cvslice <thispointer>)
#? * (alloc_cvslice)
#? * (memsize_cvslice)
#? * (getp_val_cvscalar <thispointer>)
#? * (alloc_cvscalar)
#? * (memsize_cvscalar)
#? * (getp_rect_cvconnectedcomp <thispointer>)
#? * (getp_value_cvconnectedcomp <thispointer>)
#? * (getp_area_cvconnectedcomp <thispointer>)
#? * (alloc_cvconnectedcomp)
#? * (memsize_cvconnectedcomp)
#? * (getp_bins_cvhistogram <thispointer>)
#? * (getp_thresh_cvhistogram <thispointer>)
#? * (getp_thresh2_cvhistogram <thispointer>)
#? * (getp_mat_cvhistogram <thispointer>)
#? * (getp_type_cvhistogram <thispointer>)
#? * (getp_header_size_cvhistogram <thispointer>)
#? * (alloc_cvhistogram)
#? * (memsize_cvhistogram)
#? * (getp_next_cvmemblock <thispointer>)
#? * (getp_prev_cvmemblock <thispointer>)
#? * (alloc_cvmemblock)
#? * (memsize_cvmemblock)
#? * (getp_free_space_cvmemstorage <thispointer>)
#? * (getp_block_size_cvmemstorage <thispointer>)
#? * (getp_parent_cvmemstorage <thispointer>)
#? * (getp_top_cvmemstorage <thispointer>)
#? * (getp_bottom_cvmemstorage <thispointer>)
#? * (alloc_cvmemstorage)
#? * (memsize_cvmemstorage)
#? * (getp_free_space_cvmemstoragepos <thispointer>)
#? * (getp_top_cvmemstoragepos <thispointer>)
#? * (alloc_cvmemstoragepos)
#? * (memsize_cvmemstoragepos)
#? * (getp_data_cvseqblock <thispointer>)
#? * (getp_count_cvseqblock <thispointer>)
#? * (getp_start_index_cvseqblock <thispointer>)
#? * (getp_next_cvseqblock <thispointer>)
#? * (getp_prev_cvseqblock <thispointer>)
#? * (alloc_cvseqblock)
#? * (memsize_cvseqblock)
#? * (getp_first_cvseq <thispointer>)
#? * (getp_free_blocks_cvseq <thispointer>)
#? * (getp_storage_cvseq <thispointer>)
#? * (getp_delta_elems_cvseq <thispointer>)
#? * (getp_ptr_cvseq <thispointer>)
#? * (getp_block_max_cvseq <thispointer>)
#? * (getp_elem_size_cvseq <thispointer>)
#? * (getp_total_cvseq <thispointer>)
#? * (getp_flags_cvseq <thispointer>)
#? * (getp_v_next_cvseq <thispointer>)
#? * (getp_v_prev_cvseq <thispointer>)
#? * (getp_h_next_cvseq <thispointer>)
#? * (getp_h_prev_cvseq <thispointer>)
#? * (getp_header_size_cvseq <thispointer>)
#? * (alloc_cvseq)
#? * (memsize_cvseq)
#? * (alloc_cvsetelem)
#? * (memsize_cvsetelem)
#? * (getp_free_elems_cvset <thispointer>)
#? * (getp_first_cvset <thispointer>)
#? * (getp_free_blocks_cvset <thispointer>)
#? * (getp_storage_cvset <thispointer>)
#? * (getp_delta_elems_cvset <thispointer>)
#? * (getp_ptr_cvset <thispointer>)
#? * (getp_block_max_cvset <thispointer>)
#? * (getp_elem_size_cvset <thispointer>)
#? * (getp_total_cvset <thispointer>)
#? * (getp_flags_cvset <thispointer>)
#? * (getp_v_next_cvset <thispointer>)
#? * (getp_v_prev_cvset <thispointer>)
#? * (getp_h_next_cvset <thispointer>)
#? * (getp_h_prev_cvset <thispointer>)
#? * (getp_header_size_cvset <thispointer>)
#? * (alloc_cvset)
#? * (memsize_cvset)
#? * (getp_vtx_cvgraphedge <thispointer>)
#? * (getp_next_cvgraphedge <thispointer>)
#? * (getp_flags_cvgraphedge <thispointer>)
#? * (alloc_cvgraphedge)
#? * (memsize_cvgraphedge)
#? * (getp_first_cvgraphvtx <thispointer>)
#? * (getp_flags_cvgraphvtx <thispointer>)
#? * (alloc_cvgraphvtx)
#? * (memsize_cvgraphvtx)
#? * (getp_ptr_cvgraphvtx2d <thispointer>)
#? * (getp_first_cvgraphvtx2d <thispointer>)
#? * (getp_flags_cvgraphvtx2d <thispointer>)
#? * (alloc_cvgraphvtx2d)
#? * (memsize_cvgraphvtx2d)
#? * (getp_edges_cvgraph <thispointer>)
#? * (getp_free_elems_cvgraph <thispointer>)
#? * (getp_first_cvgraph <thispointer>)
#? * (getp_free_blocks_cvgraph <thispointer>)
#? * (getp_storage_cvgraph <thispointer>)
#? * (getp_delta_elems_cvgraph <thispointer>)
#? * (getp_ptr_cvgraph <thispointer>)
#? * (getp_block_max_cvgraph <thispointer>)
#? * (getp_elem_size_cvgraph <thispointer>)
#? * (getp_total_cvgraph <thispointer>)
#? * (getp_flags_cvgraph <thispointer>)
#? * (getp_v_next_cvgraph <thispointer>)
#? * (getp_v_prev_cvgraph <thispointer>)
#? * (getp_h_next_cvgraph <thispointer>)
#? * (getp_h_prev_cvgraph <thispointer>)
#? * (getp_header_size_cvgraph <thispointer>)
#? * (alloc_cvgraph)
#? * (memsize_cvgraph)
#? * (getp_origin_cvchain <thispointer>)
#? * (getp_first_cvchain <thispointer>)
#? * (getp_free_blocks_cvchain <thispointer>)
#? * (getp_storage_cvchain <thispointer>)
#? * (getp_delta_elems_cvchain <thispointer>)
#? * (getp_ptr_cvchain <thispointer>)
#? * (getp_block_max_cvchain <thispointer>)
#? * (getp_elem_size_cvchain <thispointer>)
#? * (getp_total_cvchain <thispointer>)
#? * (getp_flags_cvchain <thispointer>)
#? * (getp_v_next_cvchain <thispointer>)
#? * (getp_v_prev_cvchain <thispointer>)
#? * (getp_h_next_cvchain <thispointer>)
#? * (getp_h_prev_cvchain <thispointer>)
#? * (getp_header_size_cvchain <thispointer>)
#? * (alloc_cvchain)
#? * (memsize_cvchain)
#? * (getp_rect_cvcontour <thispointer>)
#? * (getp_first_cvcontour <thispointer>)
#? * (getp_free_blocks_cvcontour <thispointer>)
#? * (getp_storage_cvcontour <thispointer>)
#? * (getp_delta_elems_cvcontour <thispointer>)
#? * (getp_ptr_cvcontour <thispointer>)
#? * (getp_block_max_cvcontour <thispointer>)
#? * (getp_elem_size_cvcontour <thispointer>)
#? * (getp_total_cvcontour <thispointer>)
#? * (getp_flags_cvcontour <thispointer>)
#? * (getp_v_next_cvcontour <thispointer>)
#? * (getp_v_prev_cvcontour <thispointer>)
#? * (getp_h_next_cvcontour <thispointer>)
#? * (getp_h_prev_cvcontour <thispointer>)
#? * (getp_header_size_cvcontour <thispointer>)
#? * (alloc_cvcontour)
#? * (memsize_cvcontour)
#? * (getp_block_max_cvseqwriter <thispointer>)
#? * (getp_block_min_cvseqwriter <thispointer>)
#? * (getp_ptr_cvseqwriter <thispointer>)
#? * (getp_block_cvseqwriter <thispointer>)
#? * (getp_seq_cvseqwriter <thispointer>)
#? * (getp_header_size_cvseqwriter <thispointer>)
#? * (alloc_cvseqwriter)
#? * (memsize_cvseqwriter)
#? * (getp_prev_elem_cvseqreader <thispointer>)
#? * (getp_delta_index_cvseqreader <thispointer>)
#? * (getp_block_min_cvseqreader <thispointer>)
#? * (getp_block_max_cvseqreader <thispointer>)
#? * (getp_ptr_cvseqreader <thispointer>)
#? * (getp_block_cvseqreader <thispointer>)
#? * (getp_seq_cvseqreader <thispointer>)
#? * (getp_header_size_cvseqreader <thispointer>)
#? * (alloc_cvseqreader)
#? * (memsize_cvseqreader)
#? * (getp_m_cvmatrix3 <thispointer>)
#? * (alloc_cvmatrix3)
#? * (memsize_cvmatrix3)
#? * (getp_inv_sqrt_m00_cvmoments <thispointer>)
#? * (getp_mu03_cvmoments <thispointer>)
#? * (getp_mu12_cvmoments <thispointer>)
#? * (getp_mu21_cvmoments <thispointer>)
#? * (getp_mu30_cvmoments <thispointer>)
#? * (getp_mu02_cvmoments <thispointer>)
#? * (getp_mu11_cvmoments <thispointer>)
#? * (getp_mu20_cvmoments <thispointer>)
#? * (getp_m03_cvmoments <thispointer>)
#? * (getp_m12_cvmoments <thispointer>)
#? * (getp_m21_cvmoments <thispointer>)
#? * (getp_m30_cvmoments <thispointer>)
#? * (getp_m02_cvmoments <thispointer>)
#? * (getp_m11_cvmoments <thispointer>)
#? * (getp_m20_cvmoments <thispointer>)
#? * (getp_m01_cvmoments <thispointer>)
#? * (getp_m10_cvmoments <thispointer>)
#? * (getp_m00_cvmoments <thispointer>)
#? * (alloc_cvmoments)
#? * (memsize_cvmoments)
#? * (getp_hu7_cvhumoments <thispointer>)
#? * (getp_hu6_cvhumoments <thispointer>)
#? * (getp_hu5_cvhumoments <thispointer>)
#? * (getp_hu4_cvhumoments <thispointer>)
#? * (getp_hu3_cvhumoments <thispointer>)
#? * (getp_hu2_cvhumoments <thispointer>)
#? * (getp_hu1_cvhumoments <thispointer>)
#? * (alloc_cvhumoments)
#? * (memsize_cvhumoments)
#? * (getp_dx_cvfont <thispointer>)
#? * (getp_thickness_cvfont <thispointer>)
#? * (getp_shear_cvfont <thispointer>)
#? * (getp_font_face_cvfont <thispointer>)
#? * (getp_ascii_cvfont <thispointer>)
#? * (getp_greek_cvfont <thispointer>)
#? * (alloc_cvfont)
#? * (memsize_cvfont)
#? * (getp_minus_step_cvlineiterator <thispointer>)
#? * (getp_plus_step_cvlineiterator <thispointer>)
#? * (getp_minus_delta_cvlineiterator <thispointer>)
#? * (getp_plus_delta_cvlineiterator <thispointer>)
#? * (getp_err_cvlineiterator <thispointer>)
#? * (getp_ptr_cvlineiterator <thispointer>)
#? * (alloc_cvlineiterator)
#? * (memsize_cvlineiterator)
#? * (getp_param_cvrandstate <thispointer>)
#? * (getp_state_cvrandstate <thispointer>)
#? * (alloc_cvrandstate)
#? * (memsize_cvrandstate)
#? * (getp_next_cvquadedge2d <thispointer>)
#? * (getp_pt_cvquadedge2d <thispointer>)
#? * (alloc_cvquadedge2d)
#? * (memsize_cvquadedge2d)
#? * (getp_pt_cvsubdiv2dpoint <thispointer>)
#? * (getp_first_cvsubdiv2dpoint <thispointer>)
#? * (getp_flags_cvsubdiv2dpoint <thispointer>)
#? * (alloc_cvsubdiv2dpoint)
#? * (memsize_cvsubdiv2dpoint)
#? * (getp_bottomright_cvsubdiv2d <thispointer>)
#? * (getp_topleft_cvsubdiv2d <thispointer>)
#? * (getp_recent_edge_cvsubdiv2d <thispointer>)
#? * (getp_is_geometry_valid_cvsubdiv2d <thispointer>)
#? * (getp_quad_edges_cvsubdiv2d <thispointer>)
#? * (getp_edges_cvsubdiv2d <thispointer>)
#? * (getp_free_elems_cvsubdiv2d <thispointer>)
#? * (getp_first_cvsubdiv2d <thispointer>)
#? * (getp_free_blocks_cvsubdiv2d <thispointer>)
#? * (getp_storage_cvsubdiv2d <thispointer>)
#? * (getp_delta_elems_cvsubdiv2d <thispointer>)
#? * (getp_ptr_cvsubdiv2d <thispointer>)
#? * (getp_block_max_cvsubdiv2d <thispointer>)
#? * (getp_elem_size_cvsubdiv2d <thispointer>)
#? * (getp_total_cvsubdiv2d <thispointer>)
#? * (getp_flags_cvsubdiv2d <thispointer>)
#? * (getp_v_next_cvsubdiv2d <thispointer>)
#? * (getp_v_prev_cvsubdiv2d <thispointer>)
#? * (getp_h_next_cvsubdiv2d <thispointer>)
#? * (getp_h_prev_cvsubdiv2d <thispointer>)
#? * (getp_header_size_cvsubdiv2d <thispointer>)
#? * (alloc_cvsubdiv2d)
#? * (memsize_cvsubdiv2d)
#? * (getp_deltas_cvchainptreader <thispointer>)
#? * (getp_pt_cvchainptreader <thispointer>)
#? * (getp_code_cvchainptreader <thispointer>)
#? * (getp_prev_elem_cvchainptreader <thispointer>)
#? * (getp_delta_index_cvchainptreader <thispointer>)
#? * (getp_block_min_cvchainptreader <thispointer>)
#? * (getp_block_max_cvchainptreader <thispointer>)
#? * (getp_ptr_cvchainptreader <thispointer>)
#? * (getp_block_cvchainptreader <thispointer>)
#? * (getp_seq_cvchainptreader <thispointer>)
#? * (getp_header_size_cvchainptreader <thispointer>)
#? * (alloc_cvchainptreader)
#? * (memsize_cvchainptreader)
#? * (getp_p2_cvcontourtree <thispointer>)
#? * (getp_p1_cvcontourtree <thispointer>)
#? * (getp_first_cvcontourtree <thispointer>)
#? * (getp_free_blocks_cvcontourtree <thispointer>)
#? * (getp_storage_cvcontourtree <thispointer>)
#? * (getp_delta_elems_cvcontourtree <thispointer>)
#? * (getp_ptr_cvcontourtree <thispointer>)
#? * (getp_block_max_cvcontourtree <thispointer>)
#? * (getp_elem_size_cvcontourtree <thispointer>)
#? * (getp_total_cvcontourtree <thispointer>)
#? * (getp_flags_cvcontourtree <thispointer>)
#? * (getp_v_next_cvcontourtree <thispointer>)
#? * (getp_v_prev_cvcontourtree <thispointer>)
#? * (getp_h_next_cvcontourtree <thispointer>)
#? * (getp_h_prev_cvcontourtree <thispointer>)
#? * (getp_header_size_cvcontourtree <thispointer>)
#? * (alloc_cvcontourtree)
#? * (memsize_cvcontourtree)
#? * (getp_depth_cvconvexitydefect <thispointer>)
#? * (getp_depth_point_cvconvexitydefect <thispointer>)
#? * (getp_end_cvconvexitydefect <thispointer>)
#? * (getp_start_cvconvexitydefect <thispointer>)
#? * (alloc_cvconvexitydefect)
#? * (memsize_cvconvexitydefect)
;; #? * (getp_weight_cvehmmstate <thispointer>)
;; #? * (getp_log_var_val_cvehmmstate <thispointer>)
;; #? * (getp_inv_var_cvehmmstate <thispointer>)
;; #? * (getp_mu_cvehmmstate <thispointer>)
;; #? * (getp_num_mix_cvehmmstate <thispointer>)
;; #? * (alloc_cvehmmstate)
;; #? * (memsize_cvehmmstate)
;; #? * (getp_u_cvehmm <thispointer>)
;; #? * (getp_obsprob_cvehmm <thispointer>)
;; #? * (getp_transp_cvehmm <thispointer>)
;; #? * (getp_num_states_cvehmm <thispointer>)
;; #? * (getp_level_cvehmm <thispointer>)
;; #? * (alloc_cvehmm)
;; #? * (memsize_cvehmm)
#? * (getp_mix_cvimgobsinfo <thispointer>)
#? * (getp_state_cvimgobsinfo <thispointer>)
#? * (getp_obs_cvimgobsinfo <thispointer>)
#? * (getp_obs_size_cvimgobsinfo <thispointer>)
#? * (getp_obs_y_cvimgobsinfo <thispointer>)
#? * (getp_obs_x_cvimgobsinfo <thispointer>)
#? * (alloc_cvimgobsinfo)
#? * (memsize_cvimgobsinfo)
#? * (getp_rands_cvcondensation <thispointer>)
#? * (getp_randomsample_cvcondensation <thispointer>)
#? * (getp_temp_cvcondensation <thispointer>)
#? * (getp_flcumulative_cvcondensation <thispointer>)
#? * (getp_flconfidence_cvcondensation <thispointer>)
#? * (getp_flnewsamples_cvcondensation <thispointer>)
#? * (getp_flsamples_cvcondensation <thispointer>)
#? * (getp_samplesnum_cvcondensation <thispointer>)
#? * (getp_state_cvcondensation <thispointer>)
#? * (getp_dynammatr_cvcondensation <thispointer>)
#? * (getp_dp_cvcondensation <thispointer>)
#? * (getp_mp_cvcondensation <thispointer>)
#? * (alloc_cvcondensation)
#? * (memsize_cvcondensation)
#? * (getp_temp2_cvkalman <thispointer>)
#? * (getp_temp1_cvkalman <thispointer>)
#? * (getp_postererrorcovariance_cvkalman <thispointer>)
#? * (getp_priorerrorcovariance_cvkalman <thispointer>)
#? * (getp_kalmgainmatr_cvkalman <thispointer>)
#? * (getp_pncovariance_cvkalman <thispointer>)
#? * (getp_mncovariance_cvkalman <thispointer>)
#? * (getp_measurementmatr_cvkalman <thispointer>)
#? * (getp_dynammatr_cvkalman <thispointer>)
#? * (getp_priorstate_cvkalman <thispointer>)
#? * (getp_posterstate_cvkalman <thispointer>)
#? * (getp_dp_cvkalman <thispointer>)
#? * (getp_mp_cvkalman <thispointer>)
#? * (alloc_cvkalman)
#? * (memsize_cvkalman)
#? * (getp_imagedataorigin_iplimage <thispointer>)
#? * (getp_borderconst_iplimage <thispointer>)
#? * (getp_bordermode_iplimage <thispointer>)
#? * (getp_widthstep_iplimage <thispointer>)
#? * (getp_imagedata_iplimage <thispointer>)
#? * (getp_imagesize_iplimage <thispointer>)
#? * (getp_tileinfo_iplimage <thispointer>)
#? * (getp_imageid_iplimage <thispointer>)
#? * (getp_maskroi_iplimage <thispointer>)
#? * (getp_roi_iplimage <thispointer>)
#? * (getp_height_iplimage <thispointer>)
#? * (getp_width_iplimage <thispointer>)
#? * (getp_align_iplimage <thispointer>)
#? * (getp_origin_iplimage <thispointer>)
#? * (getp_dataorder_iplimage <thispointer>)
#? * (getp_channelseq_iplimage <thispointer>)
#? * (getp_colormodel_iplimage <thispointer>)
#? * (getp_depth_iplimage <thispointer>)
#? * (getp_alphachannel_iplimage <thispointer>)
#? * (getp_nchannels_iplimage <thispointer>)
#? * (getp_id_iplimage <thispointer>)
#? * (getp_nsize_iplimage <thispointer>)
#? * (alloc_iplimage)
#? * (memsize_iplimage)
#? * (getp_nshiftr_iplconvkernel <thispointer>)
#? * (getp_values_iplconvkernel <thispointer>)
#? * (getp_anchory_iplconvkernel <thispointer>)
#? * (getp_anchorx_iplconvkernel <thispointer>)
#? * (getp_nrows_iplconvkernel <thispointer>)
#? * (getp_ncols_iplconvkernel <thispointer>)
#? * (alloc_iplconvkernel)
#? * (memsize_iplconvkernel)
#? * (getp_values_iplconvkernelfp <thispointer>)
#? * (getp_anchory_iplconvkernelfp <thispointer>)
#? * (getp_anchorx_iplconvkernelfp <thispointer>)
#? * (getp_nrows_iplconvkernelfp <thispointer>)
#? * (getp_ncols_iplconvkernelfp <thispointer>)
#? * (alloc_iplconvkernelfp)
#? * (memsize_iplconvkernelfp)
#? * (getp_step_arr_cvpixelposition8u <thispointer>)
#? * (getp_step_cvpixelposition8u <thispointer>)
#? * (getp_height_cvpixelposition8u <thispointer>)
#? * (getp_width_cvpixelposition8u <thispointer>)
#? * (getp_x_cvpixelposition8u <thispointer>)
#? * (getp_bottomline_cvpixelposition8u <thispointer>)
#? * (getp_topline_cvpixelposition8u <thispointer>)
#? * (getp_currline_cvpixelposition8u <thispointer>)
#? * (alloc_cvpixelposition8u)
#? * (memsize_cvpixelposition8u)
#? * (getp_step_arr_cvpixelposition8s <thispointer>)
#? * (getp_step_cvpixelposition8s <thispointer>)
#? * (getp_height_cvpixelposition8s <thispointer>)
#? * (getp_width_cvpixelposition8s <thispointer>)
#? * (getp_x_cvpixelposition8s <thispointer>)
#? * (getp_bottomline_cvpixelposition8s <thispointer>)
#? * (getp_topline_cvpixelposition8s <thispointer>)
#? * (getp_currline_cvpixelposition8s <thispointer>)
#? * (alloc_cvpixelposition8s)
#? * (memsize_cvpixelposition8s)
#? * (getp_step_arr_cvpixelposition32f <thispointer>)
#? * (getp_step_cvpixelposition32f <thispointer>)
#? * (getp_height_cvpixelposition32f <thispointer>)
#? * (getp_width_cvpixelposition32f <thispointer>)
#? * (getp_x_cvpixelposition32f <thispointer>)
#? * (getp_bottomline_cvpixelposition32f <thispointer>)
#? * (getp_topline_cvpixelposition32f <thispointer>)
#? * (getp_currline_cvpixelposition32f <thispointer>)
#? * (alloc_cvpixelposition32f)
#? * (memsize_cvpixelposition32f)

;; ********************************************************






(de getp_data_CvMat ( thispointer )
    ((-gptr- "CvMat *") thispointer)
    (gptr #{ &(($thispointer)->data) #} ))

(de getp_step_CvMat ( thispointer )
    ((-gptr- "CvMat *") thispointer)
    (gptr #{ &(($thispointer)->step) #} ))

(de getp_cols_CvMat ( thispointer )
    ((-gptr- "CvMat *") thispointer)
    (gptr #{ &(($thispointer)->cols) #} ))

(de getp_rows_CvMat ( thispointer )
    ((-gptr- "CvMat *") thispointer)
    (gptr #{ &(($thispointer)->rows) #} ))

(de getp_type_CvMat ( thispointer )
    ((-gptr- "CvMat *") thispointer)
    (gptr #{ &(($thispointer)->type) #} ))


(de alloc_CvMat ()
    (gptr #{ malloc(sizeof(CvMat)) #}))

(de memsize_CvMat ()
    (int #{ sizeof(CvMat) #} ))




(de getp_height_CvRect ( thispointer )
    ((-gptr- "CvRect *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_CvRect ( thispointer )
    ((-gptr- "CvRect *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de getp_y_CvRect ( thispointer )
    ((-gptr- "CvRect *") thispointer)
    (gptr #{ &(($thispointer)->y) #} ))

(de getp_x_CvRect ( thispointer )
    ((-gptr- "CvRect *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de alloc_CvRect ()
    (gptr #{ malloc(sizeof(CvRect)) #}))

(de memsize_CvRect ()
    (int #{ sizeof(CvRect) #} ))



(de getp_y_CvPoint ( thispointer )
    ((-gptr- "CvPoint *") thispointer)
    (gptr #{ &(($thispointer)->y) #} ))

(de getp_x_CvPoint ( thispointer )
    ((-gptr- "CvPoint *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de alloc_CvPoint ()
    (gptr #{ malloc(sizeof(CvPoint)) #}))

(de memsize_CvPoint ()
    (int #{ sizeof(CvPoint) #} ))



(de getp_height_CvSize ( thispointer )
    ((-gptr- "CvSize *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_CvSize ( thispointer )
    ((-gptr- "CvSize *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de alloc_CvSize ()
    (gptr #{ malloc(sizeof(CvSize)) #}))

(de memsize_CvSize ()
    (int #{ sizeof(CvSize) #} ))



(de getp_epsilon_CvTermCriteria ( thispointer )
    ((-gptr- "CvTermCriteria *") thispointer)
    (gptr #{ &(($thispointer)->epsilon) #} ))

(de getp_max_iter_CvTermCriteria ( thispointer )
    ((-gptr- "CvTermCriteria *") thispointer)
    (gptr #{ &(($thispointer)->max_iter) #} ))

(de getp_type_CvTermCriteria ( thispointer )
    ((-gptr- "CvTermCriteria *") thispointer)
    (gptr #{ &(($thispointer)->type) #} ))

(de alloc_CvTermCriteria ()
    (gptr #{ malloc(sizeof(CvTermCriteria)) #}))

(de memsize_CvTermCriteria ()
    (int #{ sizeof(CvTermCriteria) #} ))




(de getp_y_CvPoint2D32f ( thispointer )
    ((-gptr- "CvPoint2D32f *") thispointer)
    (gptr #{ &(($thispointer)->y) #} ))

(de getp_x_CvPoint2D32f ( thispointer )
    ((-gptr- "CvPoint2D32f *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de alloc_CvPoint2D32f ()
    (gptr #{ malloc(sizeof(CvPoint2D32f)) #}))

(de memsize_CvPoint2D32f ()
    (int #{ sizeof(CvPoint2D32f) #} ))



(de getp_z_CvPoint3D32f ( thispointer )
    ((-gptr- "CvPoint3D32f *") thispointer)
    (gptr #{ &(($thispointer)->z) #} ))

(de getp_y_CvPoint3D32f ( thispointer )
    ((-gptr- "CvPoint3D32f *") thispointer)
    (gptr #{ &(($thispointer)->y) #} ))

(de getp_x_CvPoint3D32f ( thispointer )
    ((-gptr- "CvPoint3D32f *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de alloc_CvPoint3D32f ()
    (gptr #{ malloc(sizeof(CvPoint3D32f)) #}))

(de memsize_CvPoint3D32f ()
    (int #{ sizeof(CvPoint3D32f) #} ))



(de getp_y_CvPoint2D64d ( thispointer )
    ((-gptr- "CvPoint2D64d *") thispointer)
    (gptr #{ &(($thispointer)->y) #} ))

(de getp_x_CvPoint2D64d ( thispointer )
    ((-gptr- "CvPoint2D64d *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de alloc_CvPoint2D64d ()
    (gptr #{ malloc(sizeof(CvPoint2D64d)) #}))

(de memsize_CvPoint2D64d ()
    (int #{ sizeof(CvPoint2D64d) #} ))



(de getp_z_CvPoint3D64d ( thispointer )
    ((-gptr- "CvPoint3D64d *") thispointer)
    (gptr #{ &(($thispointer)->z) #} ))

(de getp_y_CvPoint3D64d ( thispointer )
    ((-gptr- "CvPoint3D64d *") thispointer)
    (gptr #{ &(($thispointer)->y) #} ))

(de getp_x_CvPoint3D64d ( thispointer )
    ((-gptr- "CvPoint3D64d *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de alloc_CvPoint3D64d ()
    (gptr #{ malloc(sizeof(CvPoint3D64d)) #}))

(de memsize_CvPoint3D64d ()
    (int #{ sizeof(CvPoint3D64d) #} ))



(de getp_height_CvSize2D32f ( thispointer )
    ((-gptr- "CvSize2D32f *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_CvSize2D32f ( thispointer )
    ((-gptr- "CvSize2D32f *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de alloc_CvSize2D32f ()
    (gptr #{ malloc(sizeof(CvSize2D32f)) #}))

(de memsize_CvSize2D32f ()
    (int #{ sizeof(CvSize2D32f) #} ))



(de getp_angle_CvBox2D ( thispointer )
    ((-gptr- "CvBox2D *") thispointer)
    (gptr #{ &(($thispointer)->angle) #} ))

(de getp_size_CvBox2D ( thispointer )
    ((-gptr- "CvBox2D *") thispointer)
    (gptr #{ &(($thispointer)->size) #} ))

(de getp_center_CvBox2D ( thispointer )
    ((-gptr- "CvBox2D *") thispointer)
    (gptr #{ &(($thispointer)->center) #} ))

(de alloc_CvBox2D ()
    (gptr #{ malloc(sizeof(CvBox2D)) #}))

(de memsize_CvBox2D ()
    (int #{ sizeof(CvBox2D) #} ))



(de getp_end_index_CvSlice ( thispointer )
    ((-gptr- "CvSlice *") thispointer)
    (gptr #{ &(($thispointer)->end_index) #} ))

(de getp_start_index_CvSlice ( thispointer )
    ((-gptr- "CvSlice *") thispointer)
    (gptr #{ &(($thispointer)->start_index) #} ))

(de alloc_CvSlice ()
    (gptr #{ malloc(sizeof(CvSlice)) #}))

(de memsize_CvSlice ()
    (int #{ sizeof(CvSlice) #} ))



(de getp_val_CvScalar ( thispointer )
    ((-gptr- "CvScalar *") thispointer)
    (gptr #{ ($thispointer)->val #} ))

(de alloc_CvScalar ()
    (gptr #{ malloc(sizeof(CvScalar)) #}))

(de memsize_CvScalar ()
    (int #{ sizeof(CvScalar) #} ))






(de getp_rect_CvConnectedComp ( thispointer )
    ((-gptr- "CvConnectedComp *") thispointer)
    (gptr #{ &(($thispointer)->rect) #} ))

(de getp_value_CvConnectedComp ( thispointer )
    ((-gptr- "CvConnectedComp *") thispointer)
    (gptr #{ &(($thispointer)->value) #} ))

(de getp_area_CvConnectedComp ( thispointer )
    ((-gptr- "CvConnectedComp *") thispointer)
    (gptr #{ &(($thispointer)->area) #} ))

(de alloc_CvConnectedComp ()
    (gptr #{ malloc(sizeof(CvConnectedComp)) #}))

(de memsize_CvConnectedComp ()
    (int #{ sizeof(CvConnectedComp) #} ))




(de getp_type_CvHistogram ( thispointer )
    ((-gptr- "CvHistogram *") thispointer)
    (gptr #{ ($thispointer)->type #} ))

(de getp_bins_CvHistogram ( thispointer )
    ((-gptr- "CvHistogram *") thispointer)
    (gptr #{ &(($thispointer)->bins) #} ))

(de getp_thresh_CvHistogram ( thispointer )
    ((-gptr- "CvHistogram *") thispointer)
    (gptr #{ &(($thispointer)->thresh) #} ))

(de getp_thresh2_CvHistogram ( thispointer )
    ((-gptr- "CvHistogram *") thispointer)
    (gptr #{ &(($thispointer)->thresh2) #} ))

(de getp_mat_CvHistogram ( thispointer )
    ((-gptr- "CvHistogram *") thispointer)
    (gptr #{ &(($thispointer)->mat) #} ))

(de alloc_CvHistogram ()
    (gptr #{ malloc(sizeof(CvHistogram)) #}))

(de memsize_CvHistogram ()
    (int #{ sizeof(CvHistogram) #} ))





(de getp_next_CvMemBlock ( thispointer )
    ((-gptr- "CvMemBlock *") thispointer)
    (gptr #{ &(($thispointer)->next) #} ))

(de getp_prev_CvMemBlock ( thispointer )
    ((-gptr- "CvMemBlock *") thispointer)
    (gptr #{ &(($thispointer)->prev) #} ))

(de alloc_CvMemBlock ()
    (gptr #{ malloc(sizeof(CvMemBlock)) #}))

(de memsize_CvMemBlock ()
    (int #{ sizeof(CvMemBlock) #} ))




(de getp_free_space_CvMemStorage ( thispointer )
    ((-gptr- "CvMemStorage *") thispointer)
    (gptr #{ &(($thispointer)->free_space) #} ))

(de getp_block_size_CvMemStorage ( thispointer )
    ((-gptr- "CvMemStorage *") thispointer)
    (gptr #{ &(($thispointer)->block_size) #} ))

(de getp_parent_CvMemStorage ( thispointer )
    ((-gptr- "CvMemStorage *") thispointer)
    (gptr #{ &(($thispointer)->parent) #} ))

(de getp_top_CvMemStorage ( thispointer )
    ((-gptr- "CvMemStorage *") thispointer)
    (gptr #{ &(($thispointer)->top) #} ))

(de getp_bottom_CvMemStorage ( thispointer )
    ((-gptr- "CvMemStorage *") thispointer)
    (gptr #{ &(($thispointer)->bottom) #} ))

(de alloc_CvMemStorage ()
    (gptr #{ malloc(sizeof(CvMemStorage)) #}))

(de memsize_CvMemStorage ()
    (int #{ sizeof(CvMemStorage) #} ))




(de getp_free_space_CvMemStoragePos ( thispointer )
    ((-gptr- "CvMemStoragePos *") thispointer)
    (gptr #{ &(($thispointer)->free_space) #} ))

(de getp_top_CvMemStoragePos ( thispointer )
    ((-gptr- "CvMemStoragePos *") thispointer)
    (gptr #{ &(($thispointer)->top) #} ))

(de alloc_CvMemStoragePos ()
    (gptr #{ malloc(sizeof(CvMemStoragePos)) #}))

(de memsize_CvMemStoragePos ()
    (int #{ sizeof(CvMemStoragePos) #} ))






(de getp_data_CvSeqBlock ( thispointer )
    ((-gptr- "CvSeqBlock *") thispointer)
    (gptr #{ &(($thispointer)->data) #} ))

(de getp_count_CvSeqBlock ( thispointer )
    ((-gptr- "CvSeqBlock *") thispointer)
    (gptr #{ &(($thispointer)->count) #} ))

(de getp_start_index_CvSeqBlock ( thispointer )
    ((-gptr- "CvSeqBlock *") thispointer)
    (gptr #{ &(($thispointer)->start_index) #} ))

(de getp_next_CvSeqBlock ( thispointer )
    ((-gptr- "CvSeqBlock *") thispointer)
    (gptr #{ &(($thispointer)->next) #} ))

(de getp_prev_CvSeqBlock ( thispointer )
    ((-gptr- "CvSeqBlock *") thispointer)
    (gptr #{ &(($thispointer)->prev) #} ))

(de alloc_CvSeqBlock ()
    (gptr #{ malloc(sizeof(CvSeqBlock)) #}))

(de memsize_CvSeqBlock ()
    (int #{ sizeof(CvSeqBlock) #} ))






(de getp_first_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvSeq ( thispointer )
    ((-gptr- "CvSeq *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvSeq ()
    (gptr #{ malloc(sizeof(CvSeq)) #}))

(de memsize_CvSeq ()
    (int #{ sizeof(CvSeq) #} ))






(de getp_elem_type_CvSetElem ( thispointer )
    ((-gptr- "CvSetElem *") thispointer)
    (gptr #{ &(($thispointer)->elem_type) #} ))

(de getp_flags_CvSetElem ( thispointer )
    ((-gptr- "CvSetElem *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de alloc_CvSetElem ()
    (gptr #{ malloc(sizeof(CvSetElem)) #}))

(de memsize_CvSetElem ()
    (int #{ sizeof(CvSetElem) #} ))




(de getp_free_elems_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->free_elems) #} ))

(de getp_first_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvSet ( thispointer )
    ((-gptr- "CvSet *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvSet ()
    (gptr #{ malloc(sizeof(CvSet)) #}))

(de memsize_CvSet ()
    (int #{ sizeof(CvSet) #} ))



    



(de getp_vtx_CvGraphEdge ( thispointer )
    ((-gptr- "CvGraphEdge *") thispointer)
    (gptr #{ ($thispointer)->vtx #} ))

(de getp_next_CvGraphEdge ( thispointer )
    ((-gptr- "CvGraphEdge *") thispointer)
    (gptr #{ ($thispointer)->next #} ))

(de getp_flags_CvGraphEdge ( thispointer )
    ((-gptr- "CvGraphEdge *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de alloc_CvGraphEdge ()
    (gptr #{ malloc(sizeof(CvGraphEdge)) #}))

(de memsize_CvGraphEdge ()
    (int #{ sizeof(CvGraphEdge) #} ))





(de getp_first_CvGraphVtx ( thispointer )
    ((-gptr- "CvGraphVtx *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_flags_CvGraphVtx ( thispointer )
    ((-gptr- "CvGraphVtx *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de alloc_CvGraphVtx ()
    (gptr #{ malloc(sizeof(CvGraphVtx)) #}))

(de memsize_CvGraphVtx ()
    (int #{ sizeof(CvGraphVtx) #} ))





(de getp_ptr_CvGraphVtx2D ( thispointer )
    ((-gptr- "CvGraphVtx2D *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_first_CvGraphVtx2D ( thispointer )
    ((-gptr- "CvGraphVtx2D *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_flags_CvGraphVtx2D ( thispointer )
    ((-gptr- "CvGraphVtx2D *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de alloc_CvGraphVtx2D ()
    (gptr #{ malloc(sizeof(CvGraphVtx2D)) #}))

(de memsize_CvGraphVtx2D ()
    (int #{ sizeof(CvGraphVtx2D) #} ))






(de getp_edges_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->edges) #} ))

(de getp_free_elems_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->free_elems) #} ))

(de getp_first_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvGraph ( thispointer )
    ((-gptr- "CvGraph *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvGraph ()
    (gptr #{ malloc(sizeof(CvGraph)) #}))

(de memsize_CvGraph ()
    (int #{ sizeof(CvGraph) #} ))





(de getp_origin_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->origin) #} ))

(de getp_first_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvChain ( thispointer )
    ((-gptr- "CvChain *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvChain ()
    (gptr #{ malloc(sizeof(CvChain)) #}))

(de memsize_CvChain ()
    (int #{ sizeof(CvChain) #} ))






(de getp_rect_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->rect) #} ))

(de getp_first_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvContour ( thispointer )
    ((-gptr- "CvContour *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvContour ()
    (gptr #{ malloc(sizeof(CvContour)) #}))

(de memsize_CvContour ()
    (int #{ sizeof(CvContour) #} ))






(de getp_block_max_CvSeqWriter ( thispointer )
    ((-gptr- "CvSeqWriter *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_block_min_CvSeqWriter ( thispointer )
    ((-gptr- "CvSeqWriter *") thispointer)
    (gptr #{ &(($thispointer)->block_min) #} ))

(de getp_ptr_CvSeqWriter ( thispointer )
    ((-gptr- "CvSeqWriter *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_CvSeqWriter ( thispointer )
    ((-gptr- "CvSeqWriter *") thispointer)
    (gptr #{ &(($thispointer)->block) #} ))

(de getp_seq_CvSeqWriter ( thispointer )
    ((-gptr- "CvSeqWriter *") thispointer)
    (gptr #{ &(($thispointer)->seq) #} ))

(de getp_header_size_CvSeqWriter ( thispointer )
    ((-gptr- "CvSeqWriter *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvSeqWriter ()
    (gptr #{ malloc(sizeof(CvSeqWriter)) #}))

(de memsize_CvSeqWriter ()
    (int #{ sizeof(CvSeqWriter) #} ))







(de getp_prev_elem_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->prev_elem) #} ))

(de getp_delta_index_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->delta_index) #} ))

(de getp_block_min_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->block_min) #} ))

(de getp_block_max_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_ptr_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->block) #} ))

(de getp_seq_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->seq) #} ))

(de getp_header_size_CvSeqReader ( thispointer )
    ((-gptr- "CvSeqReader *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvSeqReader ()
    (gptr #{ malloc(sizeof(CvSeqReader)) #}))

(de memsize_CvSeqReader ()
    (int #{ sizeof(CvSeqReader) #} ))





(de getp_m_CvMatrix3 ( thispointer )
    ((-gptr- "CvMatrix3 *") thispointer)
    (gptr #{ ($thispointer)->m #} ))

(de alloc_CvMatrix3 ()
    (gptr #{ malloc(sizeof(CvMatrix3)) #}))

(de memsize_CvMatrix3 ()
    (int #{ sizeof(CvMatrix3) #} ))

 



(de getp_inv_sqrt_m00_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->inv_sqrt_m00) #} ))

(de getp_mu03_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu03) #} ))

(de getp_mu12_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu12) #} ))

(de getp_mu21_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu21) #} ))

(de getp_mu30_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu30) #} ))

(de getp_mu02_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu02) #} ))

(de getp_mu11_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu11) #} ))

(de getp_mu20_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->mu20) #} ))

(de getp_m03_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m03) #} ))

(de getp_m12_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m12) #} ))

(de getp_m21_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m21) #} ))

(de getp_m30_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m30) #} ))

(de getp_m02_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m02) #} ))

(de getp_m11_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m11) #} ))

(de getp_m20_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m20) #} ))

(de getp_m01_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m01) #} ))

(de getp_m10_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m10) #} ))

(de getp_m00_CvMoments ( thispointer )
    ((-gptr- "CvMoments *") thispointer)
    (gptr #{ &(($thispointer)->m00) #} ))

(de alloc_CvMoments ()
    (gptr #{ malloc(sizeof(CvMoments)) #}))

(de memsize_CvMoments ()
    (int #{ sizeof(CvMoments) #} ))




(de getp_hu7_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu7) #} ))

(de getp_hu6_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu6) #} ))

(de getp_hu5_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu5) #} ))

(de getp_hu4_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu4) #} ))

(de getp_hu3_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu3) #} ))

(de getp_hu2_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu2) #} ))

(de getp_hu1_CvHuMoments ( thispointer )
    ((-gptr- "CvHuMoments *") thispointer)
    (gptr #{ &(($thispointer)->hu1) #} ))

(de alloc_CvHuMoments ()
    (gptr #{ malloc(sizeof(CvHuMoments)) #}))

(de memsize_CvHuMoments ()
    (int #{ sizeof(CvHuMoments) #} ))




(de getp_dx_CvFont ( thispointer )
    ((-gptr- "CvFont *") thispointer)
    (gptr #{ &(($thispointer)->dx) #} ))

(de getp_ascii_CvFont ( thispointer )
    ((-gptr- "CvFont *") thispointer)
    (gptr #{ &(($thispointer)->ascii) #} ))

(de getp_greek_CvFont ( thispointer )
    ((-gptr- "CvFont *") thispointer)
    (gptr #{ &(($thispointer)->ascii) #} ))

(de getp_font_face_CvFont ( thispointer )
    ((-gptr- "CvFont *") thispointer)
    (gptr #{ &(($thispointer)->font_face) #} ))

(de getp_thickness_CvFont ( thispointer )
    ((-gptr- "CvFont *") thispointer)
    (gptr #{ &(($thispointer)->thickness) #} ))

(de getp_shear_CvFont ( thispointer )
    ((-gptr- "CvFont *") thispointer)
    (gptr #{ &(($thispointer)->shear) #} ))

(de alloc_CvFont ()
    (gptr #{ malloc(sizeof(CvFont)) #}))

(de memsize_CvFont ()
    (int #{ sizeof(CvFont) #} ))




(de getp_minus_step_CvLineIterator ( thispointer )
    ((-gptr- "CvLineIterator *") thispointer)
    (gptr #{ &(($thispointer)->minus_step) #} ))

(de getp_plus_step_CvLineIterator ( thispointer )
    ((-gptr- "CvLineIterator *") thispointer)
    (gptr #{ &(($thispointer)->plus_step) #} ))

(de getp_minus_delta_CvLineIterator ( thispointer )
    ((-gptr- "CvLineIterator *") thispointer)
    (gptr #{ &(($thispointer)->minus_delta) #} ))

(de getp_plus_delta_CvLineIterator ( thispointer )
    ((-gptr- "CvLineIterator *") thispointer)
    (gptr #{ &(($thispointer)->plus_delta) #} ))

(de getp_err_CvLineIterator ( thispointer )
    ((-gptr- "CvLineIterator *") thispointer)
    (gptr #{ &(($thispointer)->err) #} ))

(de getp_ptr_CvLineIterator ( thispointer )
    ((-gptr- "CvLineIterator *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de alloc_CvLineIterator ()
    (gptr #{ malloc(sizeof(CvLineIterator)) #}))

(de memsize_CvLineIterator ()
    (int #{ sizeof(CvLineIterator) #} ))




(de getp_param_CvRandState ( thispointer )
    ((-gptr- "CvRandState *") thispointer)
    (gptr #{ ($thispointer)->param #} ))

(de getp_state_CvRandState ( thispointer )
    ((-gptr- "CvRandState *") thispointer)
    (gptr #{ &(($thispointer)->state) #} ))

(de alloc_CvRandState ()
    (gptr #{ malloc(sizeof(CvRandState)) #}))

(de memsize_CvRandState ()
    (int #{ sizeof(CvRandState) #} ))





(de getp_next_CvQuadEdge2D ( thispointer )
    ((-gptr- "CvQuadEdge2D *") thispointer)
    (gptr #{ ($thispointer)->next #} ))

(de getp_pt_CvQuadEdge2D ( thispointer )
    ((-gptr- "CvQuadEdge2D *") thispointer)
    (gptr #{ ($thispointer)->pt #} ))

(de alloc_CvQuadEdge2D ()
    (gptr #{ malloc(sizeof(CvQuadEdge2D)) #}))

(de memsize_CvQuadEdge2D ()
    (int #{ sizeof(CvQuadEdge2D) #} ))





(de getp_pt_CvSubdiv2DPoint ( thispointer )
    ((-gptr- "CvSubdiv2DPoint *") thispointer)
    (gptr #{ &(($thispointer)->pt) #} ))

(de getp_first_CvSubdiv2DPoint ( thispointer )
    ((-gptr- "CvSubdiv2DPoint *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_flags_CvSubdiv2DPoint ( thispointer )
    ((-gptr- "CvSubdiv2DPoint *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de alloc_CvSubdiv2DPoint ()
    (gptr #{ malloc(sizeof(CvSubdiv2DPoint)) #}))

(de memsize_CvSubdiv2DPoint ()
    (int #{ sizeof(CvSubdiv2DPoint) #} ))



    


(de getp_bottomright_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->bottomright) #} ))

(de getp_topleft_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->topleft) #} ))

(de getp_recent_edge_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->recent_edge) #} ))

(de getp_is_geometry_valid_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->is_geometry_valid) #} ))

(de getp_quad_edges_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->quad_edges) #} ))

(de getp_edges_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->edges) #} ))

(de getp_free_elems_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->free_elems) #} ))

(de getp_first_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvSubdiv2D ( thispointer )
    ((-gptr- "CvSubdiv2D *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvSubdiv2D ()
    (gptr #{ malloc(sizeof(CvSubdiv2D)) #}))

(de memsize_CvSubdiv2D ()
    (int #{ sizeof(CvSubdiv2D) #} ))





(de getp_deltas_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ ($thispointer)->deltas #} ))

(de getp_pt_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->pt) #} ))

(de getp_code_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->code) #} ))

(de getp_prev_elem_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->prev_elem) #} ))

(de getp_delta_index_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->delta_index) #} ))

(de getp_block_min_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->block_min) #} ))

(de getp_block_max_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_ptr_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->block) #} ))

(de getp_seq_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->seq) #} ))

(de getp_header_size_CvChainPtReader ( thispointer )
    ((-gptr- "CvChainPtReader *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvChainPtReader ()
    (gptr #{ malloc(sizeof(CvChainPtReader)) #}))

(de memsize_CvChainPtReader ()
    (int #{ sizeof(CvChainPtReader) #} ))




(de getp_p2_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->p2) #} ))

(de getp_p1_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->p1) #} ))

(de getp_first_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->first) #} ))

(de getp_free_blocks_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->free_blocks) #} ))

(de getp_storage_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->storage) #} ))

(de getp_delta_elems_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->delta_elems) #} ))

(de getp_ptr_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->ptr) #} ))

(de getp_block_max_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->block_max) #} ))

(de getp_elem_size_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->elem_size) #} ))

(de getp_total_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->total) #} ))

(de getp_flags_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->flags) #} ))

(de getp_v_next_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->v_next) #} ))

(de getp_v_prev_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->v_prev) #} ))

(de getp_h_next_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->h_next) #} ))

(de getp_h_prev_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->h_prev) #} ))

(de getp_header_size_CvContourTree ( thispointer )
    ((-gptr- "CvContourTree *") thispointer)
    (gptr #{ &(($thispointer)->header_size) #} ))

(de alloc_CvContourTree ()
    (gptr #{ malloc(sizeof(CvContourTree)) #}))

(de memsize_CvContourTree ()
    (int #{ sizeof(CvContourTree) #} ))




(de getp_depth_CvConvexityDefect ( thispointer )
    ((-gptr- "CvConvexityDefect *") thispointer)
    (gptr #{ &(($thispointer)->depth) #} ))

(de getp_depth_point_CvConvexityDefect ( thispointer )
    ((-gptr- "CvConvexityDefect *") thispointer)
    (gptr #{ &(($thispointer)->depth_point) #} ))

(de getp_end_CvConvexityDefect ( thispointer )
    ((-gptr- "CvConvexityDefect *") thispointer)
    (gptr #{ &(($thispointer)->end) #} ))

(de getp_start_CvConvexityDefect ( thispointer )
    ((-gptr- "CvConvexityDefect *") thispointer)
    (gptr #{ &(($thispointer)->start) #} ))

(de alloc_CvConvexityDefect ()
    (gptr #{ malloc(sizeof(CvConvexityDefect)) #}))

(de memsize_CvConvexityDefect ()
    (int #{ sizeof(CvConvexityDefect) #} ))




(de getp_RandS_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->RandS) #} ))

(de getp_RandomSample_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->RandomSample) #} ))

(de getp_Temp_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->Temp) #} ))

(de getp_flCumulative_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->flCumulative) #} ))

(de getp_flConfidence_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->flConfidence) #} ))

(de getp_flNewSamples_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->flNewSamples) #} ))

(de getp_flSamples_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->flSamples) #} ))

(de getp_SamplesNum_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->SamplesNum) #} ))

(de getp_State_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->State) #} ))

(de getp_DynamMatr_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->DynamMatr) #} ))

(de getp_DP_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->DP) #} ))

(de getp_MP_CvConDensation ( thispointer )
    ((-gptr- "CvConDensation *") thispointer)
    (gptr #{ &(($thispointer)->MP) #} ))

(de alloc_CvConDensation ()
    (gptr #{ malloc(sizeof(CvConDensation)) #}))

(de memsize_CvConDensation ()
    (int #{ sizeof(CvConDensation) #} ))




(de getp_Temp2_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->Temp2) #} ))

(de getp_Temp1_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->Temp1) #} ))

(de getp_PosterErrorCovariance_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->PosterErrorCovariance) #} ))

(de getp_PriorErrorCovariance_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->PriorErrorCovariance) #} ))

(de getp_KalmGainMatr_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->KalmGainMatr) #} ))

(de getp_PNCovariance_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->PNCovariance) #} ))

(de getp_MNCovariance_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->MNCovariance) #} ))

(de getp_MeasurementMatr_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->MeasurementMatr) #} ))

(de getp_DynamMatr_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->DynamMatr) #} ))

(de getp_PriorState_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->PriorState) #} ))

(de getp_PosterState_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->PosterState) #} ))

(de getp_DP_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->DP) #} ))

(de getp_MP_CvKalman ( thispointer )
    ((-gptr- "CvKalman *") thispointer)
    (gptr #{ &(($thispointer)->MP) #} ))

(de alloc_CvKalman ()
    (gptr #{ malloc(sizeof(CvKalman)) #}))

(de memsize_CvKalman ()
    (int #{ sizeof(CvKalman) #} ))






(de getp_imageDataOrigin_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->imageDataOrigin) #} ))

(de getp_BorderConst_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ ($thispointer)->BorderConst #} ))

(de getp_BorderMode_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ ($thispointer)->BorderMode #} ))

(de getp_widthStep_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->widthStep) #} ))

(de getp_imageData_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->imageData) #} ))

(de getp_imageSize_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->imageSize) #} ))

(de getp_tileInfo_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->tileInfo) #} ))

(de getp_imageId_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->imageId) #} ))

(de getp_maskROI_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->maskROI) #} ))

(de getp_roi_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->roi) #} ))

(de getp_height_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de getp_align_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->align) #} ))

(de getp_origin_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->origin) #} ))

(de getp_dataOrder_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->dataOrder) #} ))

(de getp_channelSeq_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ ($thispointer)->channelSeq #} ))

(de getp_colorModel_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ ($thispointer)->colorModel #} ))

(de getp_depth_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->depth) #} ))

(de getp_alphaChannel_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->alphaChannel) #} ))

(de getp_nChannels_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->nChannels) #} ))

(de getp_ID_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->ID) #} ))

(de getp_nSize_IplImage ( thispointer )
    ((-gptr- "IplImage *") thispointer)
    (gptr #{ &(($thispointer)->nSize) #} ))

(de alloc_IplImage ()
    (gptr #{ malloc(sizeof(IplImage)) #}))

(de memsize_IplImage ()
    (int #{ sizeof(IplImage) #} ))





(de getp_height_IplROI ( thispointer )
    ((-gptr- "IplROI *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_IplROI ( thispointer )
    ((-gptr- "IplROI *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de getp_yOffset_IplROI ( thispointer )
    ((-gptr- "IplROI *") thispointer)
    (gptr #{ &(($thispointer)->yOffset) #} ))

(de getp_xOffset_IplROI ( thispointer )
    ((-gptr- "IplROI *") thispointer)
    (gptr #{ &(($thispointer)->xOffset) #} ))

(de getp_coi_IplROI ( thispointer )
    ((-gptr- "IplROI *") thispointer)
    (gptr #{ &(($thispointer)->coi) #} ))

(de alloc_IplROI ()
    (gptr #{ malloc(sizeof(IplROI)) #}))

(de memsize_IplROI ()
    (int #{ sizeof(IplROI) #} ))




(de getp_nShiftR_IplConvKernel ( thispointer )
    ((-gptr- "IplConvKernel *") thispointer)
    (gptr #{ &(($thispointer)->nShiftR) #} ))

(de getp_values_IplConvKernel ( thispointer )
    ((-gptr- "IplConvKernel *") thispointer)
    (gptr #{ &(($thispointer)->values) #} ))

(de getp_anchorY_IplConvKernel ( thispointer )
    ((-gptr- "IplConvKernel *") thispointer)
    (gptr #{ &(($thispointer)->anchorY) #} ))

(de getp_anchorX_IplConvKernel ( thispointer )
    ((-gptr- "IplConvKernel *") thispointer)
    (gptr #{ &(($thispointer)->anchorX) #} ))

(de getp_nRows_IplConvKernel ( thispointer )
    ((-gptr- "IplConvKernel *") thispointer)
    (gptr #{ &(($thispointer)->nRows) #} ))

(de getp_nCols_IplConvKernel ( thispointer )
    ((-gptr- "IplConvKernel *") thispointer)
    (gptr #{ &(($thispointer)->nCols) #} ))

(de alloc_IplConvKernel ()
    (gptr #{ malloc(sizeof(IplConvKernel)) #}))

(de memsize_IplConvKernel ()
    (int #{ sizeof(IplConvKernel) #} ))




(de getp_values_IplConvKernelFP ( thispointer )
    ((-gptr- "IplConvKernelFP *") thispointer)
    (gptr #{ &(($thispointer)->values) #} ))

(de getp_anchorY_IplConvKernelFP ( thispointer )
    ((-gptr- "IplConvKernelFP *") thispointer)
    (gptr #{ &(($thispointer)->anchorY) #} ))

(de getp_anchorX_IplConvKernelFP ( thispointer )
    ((-gptr- "IplConvKernelFP *") thispointer)
    (gptr #{ &(($thispointer)->anchorX) #} ))

(de getp_nRows_IplConvKernelFP ( thispointer )
    ((-gptr- "IplConvKernelFP *") thispointer)
    (gptr #{ &(($thispointer)->nRows) #} ))

(de getp_nCols_IplConvKernelFP ( thispointer )
    ((-gptr- "IplConvKernelFP *") thispointer)
    (gptr #{ &(($thispointer)->nCols) #} ))

(de alloc_IplConvKernelFP ()
    (gptr #{ malloc(sizeof(IplConvKernelFP)) #}))

(de memsize_IplConvKernelFP ()
    (int #{ sizeof(IplConvKernelFP) #} ))





(de getp_filtRecHigh_IplWtKernel ( thispointer )
    ((-gptr- "IplWtKernel *") thispointer)
    (gptr #{ &(($thispointer)->filtRecHigh) #} ))


(de getp_step_arr_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ ($thispointer)->step_arr #} ))

(de getp_step_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->step) #} ))

(de getp_height_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de getp_x_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de getp_bottomline_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->bottomline) #} ))

(de getp_topline_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->topline) #} ))

(de getp_currline_CvPixelPosition8u ( thispointer )
    ((-gptr- "CvPixelPosition8u *") thispointer)
    (gptr #{ &(($thispointer)->currline) #} ))

(de alloc_CvPixelPosition8u ()
    (gptr #{ malloc(sizeof(CvPixelPosition8u)) #}))

(de memsize_CvPixelPosition8u ()
    (int #{ sizeof(CvPixelPosition8u) #} ))




(de getp_step_arr_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ ($thispointer)->step_arr #} ))

(de getp_step_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->step) #} ))

(de getp_height_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de getp_x_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de getp_bottomline_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->bottomline) #} ))

(de getp_topline_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->topline) #} ))

(de getp_currline_CvPixelPosition8s ( thispointer )
    ((-gptr- "CvPixelPosition8s *") thispointer)
    (gptr #{ &(($thispointer)->currline) #} ))

(de alloc_CvPixelPosition8s ()
    (gptr #{ malloc(sizeof(CvPixelPosition8s)) #}))

(de memsize_CvPixelPosition8s ()
    (int #{ sizeof(CvPixelPosition8s) #} ))




(de getp_step_arr_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ ($thispointer)->step_arr #} ))

(de getp_step_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->step) #} ))

(de getp_height_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->height) #} ))

(de getp_width_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->width) #} ))

(de getp_x_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->x) #} ))

(de getp_bottomline_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->bottomline) #} ))

(de getp_topline_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->topline) #} ))

(de getp_currline_CvPixelPosition32f ( thispointer )
    ((-gptr- "CvPixelPosition32f *") thispointer)
    (gptr #{ &(($thispointer)->currline) #} ))

(de alloc_CvPixelPosition32f ()
    (gptr #{ malloc(sizeof(CvPixelPosition32f)) #}))

(de memsize_CvPixelPosition32f ()
    (int #{ sizeof(CvPixelPosition32f) #} ))







;;typedef struct _CvContourScanner* CvContourScanner
;;typedef struct CvPOSITObject CvPOSITObject;

()
;; ********************************************************

(dhc-make ()
  dummy_aux_structure
  getp_data_cvmat
  getp_step_cvmat
  getp_cols_cvmat
  getp_rows_cvmat
  getp_type_cvmat
  alloc_cvmat
  memsize_cvmat
  getp_height_cvrect
  getp_width_cvrect
  getp_y_cvrect
  getp_x_cvrect
  alloc_cvrect
  memsize_cvrect
  getp_y_cvpoint
  getp_x_cvpoint
  alloc_cvpoint
  memsize_cvpoint
  getp_height_cvsize
  getp_width_cvsize
  alloc_cvsize
  memsize_cvsize
  getp_epsilon_cvtermcriteria
  getp_max_iter_cvtermcriteria
  getp_type_cvtermcriteria
  alloc_cvtermcriteria
  memsize_cvtermcriteria
  getp_y_cvpoint2d32f
  getp_x_cvpoint2d32f
  alloc_cvpoint2d32f
  memsize_cvpoint2d32f
  getp_z_cvpoint3d32f
  getp_y_cvpoint3d32f
  getp_x_cvpoint3d32f
  alloc_cvpoint3d32f
  memsize_cvpoint3d32f
  getp_y_cvpoint2d64d
  getp_x_cvpoint2d64d
  alloc_cvpoint2d64d
  memsize_cvpoint2d64d
  getp_z_cvpoint3d64d
  getp_y_cvpoint3d64d
  getp_x_cvpoint3d64d
  alloc_cvpoint3d64d
  memsize_cvpoint3d64d
  getp_height_cvsize2d32f
  getp_width_cvsize2d32f
  alloc_cvsize2d32f
  memsize_cvsize2d32f
  getp_angle_cvbox2d
  getp_size_cvbox2d
  getp_center_cvbox2d
  alloc_cvbox2d
  memsize_cvbox2d
  getp_end_index_cvslice
  getp_start_index_cvslice
  alloc_cvslice
  memsize_cvslice
  getp_val_cvscalar
  alloc_cvscalar
  memsize_cvscalar
  getp_rect_cvconnectedcomp
  getp_value_cvconnectedcomp
  getp_area_cvconnectedcomp
  alloc_cvconnectedcomp
  memsize_cvconnectedcomp
  getp_type_cvhistogram
  getp_bins_cvhistogram
  getp_thresh_cvhistogram
  getp_thresh2_cvhistogram
  getp_mat_cvhistogram
  alloc_cvhistogram
  memsize_cvhistogram
  getp_next_cvmemblock
  getp_prev_cvmemblock
  alloc_cvmemblock
  memsize_cvmemblock
  getp_free_space_cvmemstorage
  getp_block_size_cvmemstorage
  getp_parent_cvmemstorage
  getp_top_cvmemstorage
  getp_bottom_cvmemstorage
  alloc_cvmemstorage
  memsize_cvmemstorage
  getp_free_space_cvmemstoragepos
  getp_top_cvmemstoragepos
  alloc_cvmemstoragepos
  memsize_cvmemstoragepos
  getp_data_cvseqblock
  getp_count_cvseqblock
  getp_start_index_cvseqblock
  getp_next_cvseqblock
  getp_prev_cvseqblock
  alloc_cvseqblock
  memsize_cvseqblock
  getp_first_cvseq
  getp_free_blocks_cvseq
  getp_storage_cvseq
  getp_delta_elems_cvseq
  getp_ptr_cvseq
  getp_block_max_cvseq
  getp_elem_size_cvseq
  getp_total_cvseq
  getp_flags_cvseq
  getp_v_next_cvseq
  getp_v_prev_cvseq
  getp_h_next_cvseq
  getp_h_prev_cvseq
  getp_header_size_cvseq
  alloc_cvseq
  memsize_cvseq
  alloc_cvsetelem
  memsize_cvsetelem
  getp_free_elems_cvset
  getp_first_cvset
  getp_free_blocks_cvset
  getp_storage_cvset
  getp_delta_elems_cvset
  getp_ptr_cvset
  getp_block_max_cvset
  getp_elem_size_cvset
  getp_total_cvset
  getp_flags_cvset
  getp_v_next_cvset
  getp_v_prev_cvset
  getp_h_next_cvset
  getp_h_prev_cvset
  getp_header_size_cvset
  alloc_cvset
  memsize_cvset
  getp_vtx_cvgraphedge
  getp_next_cvgraphedge
  getp_flags_cvgraphedge
  alloc_cvgraphedge
  memsize_cvgraphedge
  getp_first_cvgraphvtx
  getp_flags_cvgraphvtx
  alloc_cvgraphvtx
  memsize_cvgraphvtx
  getp_ptr_cvgraphvtx2d
  getp_first_cvgraphvtx2d
  getp_flags_cvgraphvtx2d
  alloc_cvgraphvtx2d
  memsize_cvgraphvtx2d
  getp_edges_cvgraph
  getp_free_elems_cvgraph
  getp_first_cvgraph
  getp_free_blocks_cvgraph
  getp_storage_cvgraph
  getp_delta_elems_cvgraph
  getp_ptr_cvgraph
  getp_block_max_cvgraph
  getp_elem_size_cvgraph
  getp_total_cvgraph
  getp_flags_cvgraph
  getp_v_next_cvgraph
  getp_v_prev_cvgraph
  getp_h_next_cvgraph
  getp_h_prev_cvgraph
  getp_header_size_cvgraph
  alloc_cvgraph
  memsize_cvgraph
  getp_origin_cvchain
  getp_first_cvchain
  getp_free_blocks_cvchain
  getp_storage_cvchain
  getp_delta_elems_cvchain
  getp_ptr_cvchain
  getp_block_max_cvchain
  getp_elem_size_cvchain
  getp_total_cvchain
  getp_flags_cvchain
  getp_v_next_cvchain
  getp_v_prev_cvchain
  getp_h_next_cvchain
  getp_h_prev_cvchain
  getp_header_size_cvchain
  alloc_cvchain
  memsize_cvchain
  getp_rect_cvcontour
  getp_first_cvcontour
  getp_free_blocks_cvcontour
  getp_storage_cvcontour
  getp_delta_elems_cvcontour
  getp_ptr_cvcontour
  getp_block_max_cvcontour
  getp_elem_size_cvcontour
  getp_total_cvcontour
  getp_flags_cvcontour
  getp_v_next_cvcontour
  getp_v_prev_cvcontour
  getp_h_next_cvcontour
  getp_h_prev_cvcontour
  getp_header_size_cvcontour
  alloc_cvcontour
  memsize_cvcontour
  getp_block_max_cvseqwriter
  getp_block_min_cvseqwriter
  getp_ptr_cvseqwriter
  getp_block_cvseqwriter
  getp_seq_cvseqwriter
  getp_header_size_cvseqwriter
  alloc_cvseqwriter
  memsize_cvseqwriter
  getp_prev_elem_cvseqreader
  getp_delta_index_cvseqreader
  getp_block_min_cvseqreader
  getp_block_max_cvseqreader
  getp_ptr_cvseqreader
  getp_block_cvseqreader
  getp_seq_cvseqreader
  getp_header_size_cvseqreader
  alloc_cvseqreader
  memsize_cvseqreader
  getp_m_cvmatrix3
  alloc_cvmatrix3
  memsize_cvmatrix3
  getp_inv_sqrt_m00_cvmoments
  getp_mu03_cvmoments
  getp_mu12_cvmoments
  getp_mu21_cvmoments
  getp_mu30_cvmoments
  getp_mu02_cvmoments
  getp_mu11_cvmoments
  getp_mu20_cvmoments
  getp_m03_cvmoments
  getp_m12_cvmoments
  getp_m21_cvmoments
  getp_m30_cvmoments
  getp_m02_cvmoments
  getp_m11_cvmoments
  getp_m20_cvmoments
  getp_m01_cvmoments
  getp_m10_cvmoments
  getp_m00_cvmoments
  alloc_cvmoments
  memsize_cvmoments
  getp_hu7_cvhumoments
  getp_hu6_cvhumoments
  getp_hu5_cvhumoments
  getp_hu4_cvhumoments
  getp_hu3_cvhumoments
  getp_hu2_cvhumoments
  getp_hu1_cvhumoments
  alloc_cvhumoments
  memsize_cvhumoments
  getp_dx_cvfont
  getp_thickness_cvfont
  getp_font_face_cvfont
  getp_ascii_cvfont
  getp_greek_cvfont
  getp_shear_cvfont
  alloc_cvfont
  memsize_cvfont
  getp_minus_step_cvlineiterator
  getp_plus_step_cvlineiterator
  getp_minus_delta_cvlineiterator
  getp_plus_delta_cvlineiterator
  getp_err_cvlineiterator
  getp_ptr_cvlineiterator
  alloc_cvlineiterator
  memsize_cvlineiterator
  getp_param_cvrandstate
  getp_state_cvrandstate
  alloc_cvrandstate
  memsize_cvrandstate
  getp_next_cvquadedge2d
  getp_pt_cvquadedge2d
  alloc_cvquadedge2d
  memsize_cvquadedge2d
  getp_pt_cvsubdiv2dpoint
  getp_first_cvsubdiv2dpoint
  getp_flags_cvsubdiv2dpoint
  alloc_cvsubdiv2dpoint
  memsize_cvsubdiv2dpoint
  getp_bottomright_cvsubdiv2d
  getp_topleft_cvsubdiv2d
  getp_recent_edge_cvsubdiv2d
  getp_is_geometry_valid_cvsubdiv2d
  getp_quad_edges_cvsubdiv2d
  getp_edges_cvsubdiv2d
  getp_free_elems_cvsubdiv2d
  getp_first_cvsubdiv2d
  getp_free_blocks_cvsubdiv2d
  getp_storage_cvsubdiv2d
  getp_delta_elems_cvsubdiv2d
  getp_ptr_cvsubdiv2d
  getp_block_max_cvsubdiv2d
  getp_elem_size_cvsubdiv2d
  getp_total_cvsubdiv2d
  getp_flags_cvsubdiv2d
  getp_v_next_cvsubdiv2d
  getp_v_prev_cvsubdiv2d
  getp_h_next_cvsubdiv2d
  getp_h_prev_cvsubdiv2d
  getp_header_size_cvsubdiv2d
  alloc_cvsubdiv2d
  memsize_cvsubdiv2d
  getp_deltas_cvchainptreader
  getp_pt_cvchainptreader
  getp_code_cvchainptreader
  getp_prev_elem_cvchainptreader
  getp_delta_index_cvchainptreader
  getp_block_min_cvchainptreader
  getp_block_max_cvchainptreader
  getp_ptr_cvchainptreader
  getp_block_cvchainptreader
  getp_seq_cvchainptreader
  getp_header_size_cvchainptreader
  alloc_cvchainptreader
  memsize_cvchainptreader
  getp_p2_cvcontourtree
  getp_p1_cvcontourtree
  getp_first_cvcontourtree
  getp_free_blocks_cvcontourtree
  getp_storage_cvcontourtree
  getp_delta_elems_cvcontourtree
  getp_ptr_cvcontourtree
  getp_block_max_cvcontourtree
  getp_elem_size_cvcontourtree
  getp_total_cvcontourtree
  getp_flags_cvcontourtree
  getp_v_next_cvcontourtree
  getp_v_prev_cvcontourtree
  getp_h_next_cvcontourtree
  getp_h_prev_cvcontourtree
  getp_header_size_cvcontourtree
  alloc_cvcontourtree
  memsize_cvcontourtree
  getp_depth_cvconvexitydefect
  getp_depth_point_cvconvexitydefect
  getp_end_cvconvexitydefect
  getp_start_cvconvexitydefect
  alloc_cvconvexitydefect
  memsize_cvconvexitydefect
  getp_rands_cvcondensation
  getp_randomsample_cvcondensation
  getp_temp_cvcondensation
  getp_flcumulative_cvcondensation
  getp_flconfidence_cvcondensation
  getp_flnewsamples_cvcondensation
  getp_flsamples_cvcondensation
  getp_samplesnum_cvcondensation
  getp_state_cvcondensation
  getp_dynammatr_cvcondensation
  getp_dp_cvcondensation
  getp_mp_cvcondensation
  alloc_cvcondensation
  memsize_cvcondensation
  getp_temp2_cvkalman
  getp_temp1_cvkalman
  getp_postererrorcovariance_cvkalman
  getp_priorerrorcovariance_cvkalman
  getp_kalmgainmatr_cvkalman
  getp_pncovariance_cvkalman
  getp_mncovariance_cvkalman
  getp_measurementmatr_cvkalman
  getp_dynammatr_cvkalman
  getp_priorstate_cvkalman
  getp_posterstate_cvkalman
  getp_dp_cvkalman
  getp_mp_cvkalman
  alloc_cvkalman
  memsize_cvkalman
  getp_imagedataorigin_iplimage
  getp_borderconst_iplimage
  getp_bordermode_iplimage
  getp_widthstep_iplimage
  getp_imagedata_iplimage
  getp_imagesize_iplimage
  getp_tileinfo_iplimage
  getp_imageid_iplimage
  getp_maskroi_iplimage
  getp_roi_iplimage
  getp_height_iplimage
  getp_width_iplimage
  getp_align_iplimage
  getp_origin_iplimage
  getp_dataorder_iplimage
  getp_channelseq_iplimage
  getp_colormodel_iplimage
  getp_depth_iplimage
  getp_alphachannel_iplimage
  getp_nchannels_iplimage
  getp_id_iplimage
  getp_nsize_iplimage
  alloc_iplimage
  memsize_iplimage
  getp_height_iplroi
  getp_width_iplroi
  getp_yoffset_iplroi
  getp_xoffset_iplroi
  getp_coi_iplroi
  alloc_iplroi
  memsize_iplroi
  getp_nshiftr_iplconvkernel
  getp_values_iplconvkernel
  getp_anchory_iplconvkernel
  getp_anchorx_iplconvkernel
  getp_nrows_iplconvkernel
  getp_ncols_iplconvkernel
  alloc_iplconvkernel
  memsize_iplconvkernel
  getp_values_iplconvkernelfp
  getp_anchory_iplconvkernelfp
  getp_anchorx_iplconvkernelfp
  getp_nrows_iplconvkernelfp
  getp_ncols_iplconvkernelfp
  alloc_iplconvkernelfp
  memsize_iplconvkernelfp
  getp_step_arr_cvpixelposition8u
  getp_step_cvpixelposition8u
  getp_height_cvpixelposition8u
  getp_width_cvpixelposition8u
  getp_x_cvpixelposition8u
  getp_bottomline_cvpixelposition8u
  getp_topline_cvpixelposition8u
  getp_currline_cvpixelposition8u
  alloc_cvpixelposition8u
  memsize_cvpixelposition8u
  getp_step_arr_cvpixelposition8s
  getp_step_cvpixelposition8s
  getp_height_cvpixelposition8s
  getp_width_cvpixelposition8s
  getp_x_cvpixelposition8s
  getp_bottomline_cvpixelposition8s
  getp_topline_cvpixelposition8s
  getp_currline_cvpixelposition8s
  alloc_cvpixelposition8s
  memsize_cvpixelposition8s
  getp_step_arr_cvpixelposition32f
  getp_step_cvpixelposition32f
  getp_height_cvpixelposition32f
  getp_width_cvpixelposition32f
  getp_x_cvpixelposition32f
  getp_bottomline_cvpixelposition32f
  getp_topline_cvpixelposition32f
  getp_currline_cvpixelposition32f
  alloc_cvpixelposition32f
  memsize_cvpixelposition32f
)
