From 01a64422b2c9eadee0bc4d3383bbe01cdc107c3f Mon Sep 17 00:00:00 2001 From: John Cupitt Date: Fri, 18 Nov 2011 09:08:45 +0000 Subject: [PATCH] start revising new docs --- doc/reference/libvips-decl-list.txt.bak | 1733 +++++ doc/reference/libvips-decl.txt.bak | 8234 +++++++++++++++++++++++ libvips/arithmetic/abs.c | 32 +- libvips/arithmetic/add.c | 2 + libvips/arithmetic/avg.c | 27 +- libvips/arithmetic/boolean.c | 535 +- libvips/arithmetic/deviate.c | 30 +- libvips/arithmetic/divide.c | 166 +- libvips/arithmetic/invert.c | 28 +- libvips/arithmetic/linear.c | 59 +- libvips/conversion/join.c | 79 +- libvips/include/vips/arithmetic.h | 67 +- 12 files changed, 10729 insertions(+), 263 deletions(-) create mode 100644 doc/reference/libvips-decl-list.txt.bak create mode 100644 doc/reference/libvips-decl.txt.bak diff --git a/doc/reference/libvips-decl-list.txt.bak b/doc/reference/libvips-decl-list.txt.bak new file mode 100644 index 00000000..334a9c49 --- /dev/null +++ b/doc/reference/libvips-decl-list.txt.bak @@ -0,0 +1,1733 @@ +
+arithmetic +VipsArithmetic +VipsArithmetic +VipsArithmeticClass +VipsArithmeticProcessFn +vips_arithmetic_compile +vips_arithmetic_get_program +vips_arithmetic_get_vector +vips_arithmetic_set_format_table + +VIPS_ARITHMETIC +VIPS_ARITHMETIC_CLASS +VIPS_ARITHMETIC_GET_CLASS +VIPS_IS_ARITHMETIC +VIPS_IS_ARITHMETIC_CLASS +VIPS_TYPE_ARITHMETIC +vips_arithmetic_get_type +
+ +
+arithmetic +VipsOperationBoolean +VipsOperationMath +VipsOperationMath2 +VipsOperationRelational +VipsOperationRound +im_bandmean +im_cross_phase +im_linreg +im_maxpos_avg +im_maxpos_vec +im_minpos_vec +im_point +im_point_bilinear +vips_abs +vips_add +vips_arithmetic_add +vips_avg +vips_boolean +vips_boolean_const +vips_deviate +vips_divide +vips_invert +vips_linear +vips_linear1 +vips_math +vips_math2 +vips_math2_const +vips_math2_const1 +vips_max +vips_measure +vips_min +vips_multiply +vips_recomb +vips_relational +vips_relational_const +vips_relational_const1 +vips_remainder +vips_remainder_const +vips_remainder_const1 +vips_round +vips_sign +vips_stats +vips_subtract +
+ +
+binary +VipsBinary +VipsBinaryClass + +VIPS_BINARY +VIPS_BINARY_CLASS +VIPS_BINARY_GET_CLASS +VIPS_IS_BINARY +VIPS_IS_BINARY_CLASS +VIPS_TYPE_BINARY +vips_binary_get_type +
+ +
+buf +VIPS_BUF_STATIC +VipsBuf +vips_buf_all +vips_buf_append_size +vips_buf_appendc +vips_buf_appendd +vips_buf_appendf +vips_buf_appendg +vips_buf_appendgv +vips_buf_appendns +vips_buf_appends +vips_buf_appendsc +vips_buf_change +vips_buf_destroy +vips_buf_firstline +vips_buf_init +vips_buf_init_dynamic +vips_buf_init_static +vips_buf_is_empty +vips_buf_is_full +vips_buf_len +vips_buf_removec +vips_buf_rewind +vips_buf_set_dynamic +vips_buf_set_static +vips_buf_vappendf +
+ +
+cimg_funcs +im_greyc_mask +
+ +
+colour +IM_A_X0 +IM_A_Y0 +IM_A_Z0 +IM_B_X0 +IM_B_Y0 +IM_B_Z0 +IM_C_X0 +IM_C_Y0 +IM_C_Z0 +IM_D3250_X0 +IM_D3250_Y0 +IM_D3250_Z0 +IM_D50_X0 +IM_D50_Y0 +IM_D50_Z0 +IM_D55_X0 +IM_D55_Y0 +IM_D55_Z0 +IM_D65_X0 +IM_D65_Y0 +IM_D65_Z0 +IM_D75_X0 +IM_D75_Y0 +IM_D75_Z0 +IM_D93_X0 +IM_D93_Y0 +IM_D93_Z0 +IM_E_X0 +IM_E_Y0 +IM_E_Z0 +VipsIntent +im_LCh2Lab +im_LCh2UCS +im_Lab2LCh +im_Lab2LabQ +im_Lab2LabS +im_Lab2UCS +im_Lab2XYZ +im_Lab2XYZ_temp +im_LabQ2Lab +im_LabQ2LabS +im_LabQ2XYZ +im_LabS2Lab +im_LabS2LabQ +im_UCS2LCh +im_UCS2Lab +im_UCS2XYZ +im_XYZ2Lab +im_XYZ2Lab_temp +im_XYZ2UCS +im_XYZ2Yxy +im_XYZ2sRGB +im_Yxy2XYZ +im_col_C2Cucs +im_col_Ch2ab +im_col_Ch2hucs +im_col_Chucs2h +im_col_Cucs2C +im_col_L2Lucs +im_col_Lab2XYZ +im_col_Lucs2L +im_col_XYZ2Lab +im_col_ab2Ch +im_col_ab2h +im_col_dE00 +im_col_dECMC +im_col_make_tables_UCS +im_col_pythagoras +im_dE00_fromLab +im_dECMC_fromLab +im_dE_fromLab +im_dE_fromXYZ +im_float2rad +im_icc_ac2rc +im_icc_export_depth +im_icc_import +im_icc_import_embedded +im_icc_present +im_icc_transform +im_lab_morph +im_rad2float +im_sRGB2XYZ +
+ +
+conversion +VipsConversion +VipsConversion +VipsConversionClass + +VIPS_CONVERSION +VIPS_CONVERSION_CLASS +VIPS_CONVERSION_GET_CLASS +VIPS_IS_CONVERSION +VIPS_IS_CONVERSION_CLASS +VIPS_TYPE_CONVERSION +vips_conversion_get_type +
+ +
+conversion +VipsAlign +VipsAngle +VipsDirection +VipsExtend +im_c2amph +im_c2imag +im_c2real +im_c2rect +im_copy_file +im_falsecolour +im_gaussnoise +im_grid +im_insertset +im_msb +im_msb_band +im_ri2c +im_scale +im_scaleps +im_subsample +im_system +im_system_image +im_text +im_wrap +im_zoom +vips_bandjoin +vips_bandjoin2 +vips_black +vips_cast +vips_copy +vips_embed +vips_extract_area +vips_extract_band +vips_flip +vips_ifthenelse +vips_insert +vips_join +vips_replicate +vips_rot +
+ +
+convolution +im_aconv +im_aconvsep +im_addgnoise +im_compass +im_contrast_surface +im_conv +im_conv_f +im_convsep +im_convsep_f +im_fastcor +im_grad_x +im_grad_y +im_gradcor +im_gradient +im_lindetect +im_sharpen +im_spcor +
+ +
+dispatch +IM_INPUT_DISPLAY +IM_INPUT_DMASK +IM_INPUT_DOUBLE +IM_INPUT_DOUBLEVEC +IM_INPUT_GVALUE +IM_INPUT_IMAGE +IM_INPUT_IMAGEVEC +IM_INPUT_IMASK +IM_INPUT_INT +IM_INPUT_INTERPOLATE +IM_INPUT_INTVEC +IM_INPUT_STRING +IM_MAX_ARGS +IM_OUTPUT_COMPLEX +IM_OUTPUT_DISPLAY +IM_OUTPUT_DMASK +IM_OUTPUT_DMASK_STATS +IM_OUTPUT_DOUBLE +IM_OUTPUT_DOUBLEVEC +IM_OUTPUT_GVALUE +IM_OUTPUT_IMAGE +IM_OUTPUT_IMASK +IM_OUTPUT_INT +IM_OUTPUT_INTVEC +IM_OUTPUT_STRING +IM_RW_IMAGE +IM_TYPE_COMPLEX +IM_TYPE_DISPLAY +IM_TYPE_DMASK +IM_TYPE_DOUBLE +IM_TYPE_DOUBLEVEC +IM_TYPE_GVALUE +IM_TYPE_IMAGE +IM_TYPE_IMAGEVEC +IM_TYPE_IMASK +IM_TYPE_INT +IM_TYPE_INTERPOLATE +IM_TYPE_INTVEC +IM_TYPE_STRING +im__cprint +im__displayprint +im__dmsprint +im__dprint +im__dvprint +im__gprint +im__input_display +im__input_dmask +im__input_double +im__input_doublevec +im__input_gvalue +im__input_image +im__input_imagevec +im__input_imask +im__input_int +im__input_interpolate +im__input_intvec +im__input_string +im__iprint +im__ivprint +im__output_complex +im__output_display +im__output_dmask +im__output_dmask_screen +im__output_double +im__output_doublevec +im__output_gvalue +im__output_image +im__output_imask +im__output_int +im__output_intvec +im__output_string +im__rw_image +im__sprint +im_allocate_vargv +im_arg_desc +im_arg_type +im_close_plugins +im_dest_obj_fn +im_dispatch_fn +im_doublevec_object +im_find_function +im_find_package +im_fn_flags +im_free_vargv +im_function +im_imagevec_object +im_init_obj_fn +im_intvec_object +im_load_plugin +im_load_plugins +im_map_packages +im_mask_object +im_object +im_package +im_package_of_function +im_print_obj_fn +im_run_command +im_type_desc +im_type_flags +
+ +
+draw +DRAW +Draw +im__draw_free +im__draw_init +im__draw_painted +im__draw_pel +im__draw_pel_clip +im__draw_scanline +
+ +
+enumtypes + +VIPS_TYPE_ALIGN +VIPS_TYPE_ANGLE +VIPS_TYPE_ARGUMENT_FLAGS +VIPS_TYPE_BAND_FORMAT +VIPS_TYPE_CODING +VIPS_TYPE_DEMAND_STYLE +VIPS_TYPE_DIRECTION +VIPS_TYPE_EXTEND +VIPS_TYPE_IMAGE_TYPE +VIPS_TYPE_INTERPRETATION +VIPS_TYPE_OPERATION_BOOLEAN +VIPS_TYPE_OPERATION_MATH +VIPS_TYPE_OPERATION_MATH2 +VIPS_TYPE_OPERATION_RELATIONAL +VIPS_TYPE_OPERATION_ROUND +VIPS_TYPE_TOKEN +vips_align_get_type +vips_angle_get_type +vips_argument_flags_get_type +vips_band_format_get_type +vips_coding_get_type +vips_demand_style_get_type +vips_direction_get_type +vips_extend_get_type +vips_image_type_get_type +vips_interpretation_get_type +vips_operation_boolean_get_type +vips_operation_math2_get_type +vips_operation_math_get_type +vips_operation_relational_get_type +vips_operation_round_get_type +vips_token_get_type +
+ +
+error +vips_check_8or16 +vips_check_bandno +vips_check_bands +vips_check_bands_1or3 +vips_check_bands_1orn +vips_check_bands_1orn_unary +vips_check_bands_same +vips_check_coding_known +vips_check_coding_labq +vips_check_coding_noneorlabq +vips_check_coding_rad +vips_check_coding_same +vips_check_complex +vips_check_dmask +vips_check_dmask_1d +vips_check_format +vips_check_format_same +vips_check_hist +vips_check_imask +vips_check_int +vips_check_mono +vips_check_noncomplex +vips_check_size_same +vips_check_u8or16 +vips_check_u8or16orf +vips_check_uint +vips_check_uintorf +vips_check_uncoded +vips_check_vector +vips_diag +vips_error +vips_error_buffer +vips_error_clear +vips_error_exit +vips_error_g +vips_error_system +vips_vdiag +vips_verror +vips_verror_system +vips_vwarn +vips_warn +
+ +
+format +VipsFormat +VipsFormat +VipsFormatClass +VipsFormatFlags +im_analyze2vips +im_bufjpeg2vips +im_csv2vips +im_exr2vips +im_fits2vips +im_jpeg2vips +im_magick2vips +im_mat2vips +im_png2vips +im_ppm2vips +im_rad2vips +im_raw2vips +im_tiff2vips +im_tile_cache +im_vips2bufjpeg +im_vips2bufpng +im_vips2csv +im_vips2fits +im_vips2jpeg +im_vips2mimejpeg +im_vips2png +im_vips2ppm +im_vips2rad +im_vips2raw +im_vips2tiff +vips_format_for_file +vips_format_for_name +vips_format_get_flags +vips_format_map +vips_format_read +vips_format_write + +VIPS_FORMAT +VIPS_FORMAT_CLASS +VIPS_FORMAT_GET_CLASS +VIPS_IS_FORMAT +VIPS_IS_FORMAT_CLASS +VIPS_TYPE_FORMAT +vips_format_get_type +
+ +
+freq_filt +VipsMaskType +im_create_fmask +im_disp_ps +im_flt_image_freq +im_fractsurf +im_freqflt +im_fwfft +im_invfft +im_invfftr +im_phasecor_fft +im_rotquad +
+ +
+generate +VipsGenerateFn +VipsRegionWrite +VipsSinkNotify +VipsStartFn +VipsStopFn +vips_allocate_input_array +vips_demand_hint +vips_demand_hint_array +vips_image_cache +vips_image_generate +vips_sink +vips_sink_disc +vips_sink_memory +vips_sink_screen +vips_sink_tile +vips_start_many +vips_start_one +vips_stop_many +vips_stop_one +
+ +
+header +VIPS_META_EXIF_NAME +VIPS_META_ICC_NAME +VIPS_META_RESOLUTION_UNIT +VIPS_META_XML +VIPS_META_XMP_NAME +VipsImageMapFn +vips_format_sizeof +vips_image_copy_fields +vips_image_copy_fields_array +vips_image_copy_fieldsv +vips_image_get +vips_image_get_area +vips_image_get_as_string +vips_image_get_bands +vips_image_get_blob +vips_image_get_coding +vips_image_get_data +vips_image_get_double +vips_image_get_filename +vips_image_get_format +vips_image_get_height +vips_image_get_history +vips_image_get_int +vips_image_get_interpretation +vips_image_get_mode +vips_image_get_string +vips_image_get_typeof +vips_image_get_width +vips_image_get_xoffset +vips_image_get_xres +vips_image_get_yoffset +vips_image_get_yres +vips_image_history_args +vips_image_history_printf +vips_image_init_fields +vips_image_map +vips_image_remove +vips_image_set +vips_image_set_area +vips_image_set_blob +vips_image_set_double +vips_image_set_int +vips_image_set_string +
+ +
+histograms_lut +im_buildlut +im_gammacorrect +im_heq +im_hist +im_hist_indexed +im_histcum +im_histeq +im_histgr +im_histnD +im_histnorm +im_histplot +im_histspec +im_hsp +im_identity +im_identity_ushort +im_invertlut +im_ismonotonic +im_lhisteq +im_maplut +im_mpercent +im_mpercent_hist +im_project +im_stdif +im_tone_analyse +im_tone_build +im_tone_build_range +im_tone_map +
+ +
+image +VipsImage +VIPS_IMAGE_ADDR +VIPS_IMAGE_N_ELEMENTS +VIPS_IMAGE_SIZEOF_ELEMENT +VIPS_IMAGE_SIZEOF_LINE +VIPS_IMAGE_SIZEOF_PEL +VIPS_MAGIC_INTEL +VIPS_MAGIC_SPARC +VipsBandFormat +VipsCoding +VipsDemandStyle +VipsImage +VipsImageClass +VipsImageType +VipsInterpretation +VipsProgress +vips_band_format_iscomplex +vips_band_format_isfloat +vips_band_format_isint +vips_band_format_isuint +vips_image_eval +vips_image_get_kill +vips_image_inplace +vips_image_invalidate_all +vips_image_isMSBfirst +vips_image_isfile +vips_image_ispartial +vips_image_new +vips_image_new_array +vips_image_new_disc_temp +vips_image_new_from_file +vips_image_new_from_file_raw +vips_image_new_from_memory +vips_image_new_mode +vips_image_pio_input +vips_image_pio_output +vips_image_posteval +vips_image_preeval +vips_image_set_delete_on_close +vips_image_set_kill +vips_image_set_progress +vips_image_wio_input +vips_image_wio_output +vips_image_write +vips_image_write_line +vips_image_write_to_file +vips_image_written + +VIPS_IMAGE +VIPS_IMAGE_CLASS +VIPS_IMAGE_GET_CLASS +VIPS_IMAGE_SIZEOF_IMAGE +VIPS_IS_IMAGE +VIPS_IS_IMAGE_CLASS +VIPS_TYPE_IMAGE +vips_image_get_type +
+ +
+inplace +VipsPlotFn +im_draw_circle +im_draw_flood +im_draw_flood_blob +im_draw_flood_other +im_draw_image +im_draw_line +im_draw_line_user +im_draw_mask +im_draw_point +im_draw_rect +im_draw_smudge +im_lineset +im_read_point +
+ +
+interpolate +VipsInterpolate +VIPS_INTERPOLATE_SCALE +VIPS_INTERPOLATE_SHIFT +VIPS_TRANSFORM_SCALE +VIPS_TRANSFORM_SHIFT +VipsInterpolate +VipsInterpolateClass +VipsInterpolateMethod +vips_interpolate +vips_interpolate_bilinear_static +vips_interpolate_get_method +vips_interpolate_get_window_offset +vips_interpolate_get_window_size +vips_interpolate_nearest_static +vips_interpolate_new + +VIPS_INTERPOLATE +VIPS_INTERPOLATE_CLASS +VIPS_INTERPOLATE_GET_CLASS +VIPS_IS_INTERPOLATE +VIPS_IS_INTERPOLATE_CLASS +VIPS_TYPE_INTERPOLATE +vips_interpolate_get_type +
+ +
+mask +DOUBLEMASK +INTMASK +im_create_dmask +im_create_dmaskv +im_create_imask +im_create_imaskv +im_dmask2imask +im_dup_dmask +im_dup_imask +im_free_dmask +im_free_imask +im_gauss_dmask +im_gauss_dmask_sep +im_gauss_imask +im_gauss_imask_sep +im_imask2dmask +im_local_dmask +im_local_imask +im_log_dmask +im_log_imask +im_lu_decomp +im_lu_solve +im_matcat +im_matinv +im_matinv_inplace +im_matmul +im_mattrn +im_norm_dmask +im_print_dmask +im_print_imask +im_read_dmask +im_read_imask +im_rotate_dmask45 +im_rotate_dmask90 +im_rotate_imask45 +im_rotate_imask90 +im_scale_dmask +im_write_dmask +im_write_dmask_name +im_write_imask +im_write_imask_name +
+ +
+memory +VIPS_ARRAY +VIPS_FREE +VIPS_FREEF +VIPS_NEW +VIPS_SETSTR +vips_free +vips_malloc +vips_strdup +vips_tracked_close +vips_tracked_free +vips_tracked_get_allocs +vips_tracked_get_files +vips_tracked_get_mem +vips_tracked_get_mem_highwater +vips_tracked_malloc +vips_tracked_open +
+ +
+morphology +im_cntlines +im_dilate +im_erode +im_label_regions +im_maxvalue +im_profile +im_rank +im_rank_image +im_zerox +
+ +
+mosaicing +im_align_bands +im_correl +im_global_balance +im_global_balancef +im_lrmerge +im_lrmerge1 +im_lrmosaic +im_lrmosaic1 +im_maxpos_subpel +im_remosaic +im_tbmerge +im_tbmerge1 +im_tbmosaic +im_tbmosaic1 +
+ +
+object +VipsArgument +VipsObject +VIPS_ARGUMENT_FOR_ALL +VIPS_ARGUMENT_FOR_ALL_END +VIPS_ARGUMENT_OPTIONAL_INPUT +VIPS_ARGUMENT_OPTIONAL_OUTPUT +VIPS_ARGUMENT_REQUIRED_INPUT +VIPS_ARGUMENT_REQUIRED_OUTPUT +VIPS_ARG_BOOL +VIPS_ARG_BOXED +VIPS_ARG_DOUBLE +VIPS_ARG_ENUM +VIPS_ARG_IMAGE +VIPS_ARG_INT +VIPS_ARG_POINTER +VIPS_ARG_STRING +VIPS_UNREF +VipsArgument +VipsArgumentClass +VipsArgumentFlags +VipsArgumentInstance +VipsArgumentMapFn +VipsArgumentTable +VipsClassMap +VipsObject +VipsObjectClass +VipsObjectSetArguments +VipsTypeMap +VipsTypeMap2 +vips__argument_get_instance +vips__argument_table_lookup +vips__object_set_member +vips_argument_dispose_all +vips_argument_get_assigned +vips_argument_map +vips_class_depth +vips_class_find +vips_class_map_all +vips_object_build +vips_object_class_install_argument +vips_object_get_argument +vips_object_get_argument_needs_string +vips_object_get_argument_to_string +vips_object_get_property +vips_object_local +vips_object_local_array +vips_object_local_cb +vips_object_map +vips_object_new +vips_object_new_from_string +vips_object_preclose +vips_object_print +vips_object_print_all +vips_object_print_class +vips_object_print_name +vips_object_rewind +vips_object_sanity +vips_object_sanity_all +vips_object_set_argument_from_string +vips_object_set_property +vips_object_set_required +vips_object_set_static +vips_object_to_string +vips_type_find +vips_type_map +vips_type_map_all +vips_value_is_null + +VIPS_IS_OBJECT +VIPS_IS_OBJECT_CLASS +VIPS_OBJECT +VIPS_OBJECT_CLASS +VIPS_OBJECT_GET_CLASS +VIPS_TYPE_OBJECT +vips_object_get_type +
+ +
+operation +VipsOperation +VipsOperation +VipsOperationBuildFn +VipsOperationClass +vips_cache_drop_all +vips_cache_get_max +vips_cache_get_max_files +vips_cache_get_max_mem +vips_cache_get_size +vips_cache_operation_build +vips_cache_set_max +vips_cache_set_max_files +vips_cache_set_max_mem +vips_call +vips_call_argv +vips_call_options +vips_call_split +vips_operation_call_valist +vips_operation_new + +VIPS_IS_OPERATION +VIPS_IS_OPERATION_CLASS +VIPS_OPERATION +VIPS_OPERATION_CLASS +VIPS_OPERATION_GET_CLASS +VIPS_TYPE_OPERATION +vips_operation_get_type +
+ +
+other +im_benchmark2 +im_benchmarkn +im_eye +im_feye +im_fgrey +im_fzone +im_grey +im_make_xy +im_sines +im_zone +
+ +
+rect +VIPS_RECT_BOTTOM +VIPS_RECT_HCENTRE +VIPS_RECT_RIGHT +VIPS_RECT_VCENTRE +VipsRect +vips_rect_dup +vips_rect_equalsrect +vips_rect_includespoint +vips_rect_includesrect +vips_rect_intersectrect +vips_rect_isempty +vips_rect_marginadjust +vips_rect_normalise +vips_rect_unionrect +
+ +
+region +VipsRegion +VIPS_REGION_ADDR +VIPS_REGION_ADDR_TOPLEFT +VIPS_REGION_LSKIP +VIPS_REGION_N_ELEMENTS +VIPS_REGION_SIZEOF_LINE +VipsRegion +VipsRegionClass +vips_region_black +vips_region_buffer +vips_region_copy +vips_region_equalsregion +vips_region_image +vips_region_new +vips_region_paint +vips_region_paint_pel +vips_region_position +vips_region_prepare +vips_region_prepare_many +vips_region_prepare_to +vips_region_region + +VIPS_IS_REGION +VIPS_IS_REGION_CLASS +VIPS_REGION +VIPS_REGION_CLASS +VIPS_REGION_GET_CLASS +VIPS_TYPE_REGION +vips_region_get_type +
+ +
+relational + +
+ +
+resample +im_affinei +im_affinei_all +im_match_linear +im_match_linear_search +im_rightshift_size +im_shrink +
+ +
+semaphore +VipsSemaphore +vips_semaphore_destroy +vips_semaphore_down +vips_semaphore_downn +vips_semaphore_init +vips_semaphore_up +vips_semaphore_upn +
+ +
+sink +SinkBase +vips_sink_base_allocate +vips_sink_base_init +vips_sink_base_progress +vips_sink_thread_state_new +
+ +
+statistic +VipsStatistic +VipsStatistic +VipsStatisticClass +VipsStatisticScanFn +VipsStatisticStartFn +VipsStatisticStopFn + +VIPS_IS_STATISTIC +VIPS_IS_STATISTIC_CLASS +VIPS_STATISTIC +VIPS_STATISTIC_CLASS +VIPS_STATISTIC_GET_CLASS +VIPS_TYPE_STATISTIC +vips_statistic_get_type +
+ +
+threadpool +VipsThreadState +VipsThreadStartFn +VipsThreadState +VipsThreadStateClass +VipsThreadpoolAllocateFn +VipsThreadpoolProgressFn +VipsThreadpoolWorkFn +vips__print_renders +vips_concurrency_get +vips_concurrency_set +vips_get_tile_size +vips_thread_state_new +vips_thread_state_set +vips_threadpool_run + +VIPS_IS_THREAD_STATE +VIPS_IS_THREAD_STATE_CLASS +VIPS_THREAD_STATE +VIPS_THREAD_STATE_CLASS +VIPS_THREAD_STATE_GET_CLASS +VIPS_TYPE_THREAD_STATE +vips_thread_state_get_type +
+ +
+transform +Transformation +im__affine +im__transform_add +im__transform_calc_inverse +im__transform_forward_point +im__transform_forward_rect +im__transform_init +im__transform_invert_point +im__transform_invert_rect +im__transform_isidentity +im__transform_print +im__transform_set_area +
+ +
+type +VipsArea +VipsCallbackFn +vips__meta_init_types +vips_area_copy +vips_area_new +vips_area_new_array +vips_area_new_array_object +vips_area_new_blob +vips_area_unref +vips_value_get_area +vips_value_get_array +vips_value_get_array_double +vips_value_get_array_object +vips_value_get_blob +vips_value_get_ref_string +vips_value_get_save_string +vips_value_set_area +vips_value_set_array +vips_value_set_array_double +vips_value_set_array_object +vips_value_set_blob +vips_value_set_ref_string +vips_value_set_save_string +vips_value_set_save_stringf + +VIPS_TYPE_AREA +VIPS_TYPE_ARRAY_DOUBLE +VIPS_TYPE_ARRAY_IMAGE +VIPS_TYPE_BLOB +VIPS_TYPE_REF_STRING +VIPS_TYPE_SAVE_STRING +vips_area_get_type +vips_array_double_get_type +vips_array_image_get_type +vips_blob_get_type +vips_ref_string_get_type +vips_save_string_get_type +
+ +
+unary +VipsUnary +VipsUnaryClass + +VIPS_IS_UNARY +VIPS_IS_UNARY_CLASS +VIPS_TYPE_UNARY +VIPS_UNARY +VIPS_UNARY_CLASS +VIPS_UNARY_GET_CLASS +vips_unary_get_type +
+ +
+unaryconst +VipsUnaryConst +VipsUnaryConst +VipsUnaryConstClass + +VIPS_IS_UNARY_CONST +VIPS_IS_UNARY_CONST_CLASS +VIPS_TYPE_UNARY_CONST +VIPS_UNARY_CONST +VIPS_UNARY_CONST_CLASS +VIPS_UNARY_CONST_GET_CLASS +vips_unary_const_get_type +
+ +
+util +VIPS_ABS +VIPS_CLIP +VIPS_CLIP_CHAR +VIPS_CLIP_NONE +VIPS_CLIP_SHORT +VIPS_CLIP_UCHAR +VIPS_CLIP_USHORT +VIPS_DEG +VIPS_ENUM_NICK +VIPS_ENUM_STRING +VIPS_MAX +VIPS_MIN +VIPS_NUMBER +VIPS_PI +VIPS_RAD +VIPS_RINT +VIPS_SWAP +VIPS_UNROLL +VipsSListFold2Fn +VipsSListMap2Fn +VipsSListMap4Fn +VipsToken +vips__change_suffix +vips__file_open_read +vips__file_open_write +vips__file_read +vips__file_read_name +vips__file_write +vips__ftruncate +vips__get_bytes +vips__gslist_gvalue_copy +vips__gslist_gvalue_free +vips__gslist_gvalue_get +vips__gslist_gvalue_merge +vips__gvalue_ref_string_new +vips__seek +vips__temp_name +vips__token_get +vips__token_must +vips__token_need +vips__write +vips_amiMSBfirst +vips_break_token +vips_existsf +vips_file_length +vips_filename_split +vips_filename_suffix +vips_filename_suffix_match +vips_getnextoption +vips_getsuboption +vips_hash_table_map +vips_ispostfix +vips_ispoweroftwo +vips_isprefix +vips_map_equal +vips_popenf +vips_skip_dir +vips_slist_equal +vips_slist_filter +vips_slist_fold2 +vips_slist_free_all +vips_slist_map2 +vips_slist_map2_rev +vips_slist_map4 +vips_snprintf +vips_strncpy +vips_strrstr +vips_vsnprintf +
+ +
+version +VIPS_EXEEXT +VIPS_MAJOR_VERSION +VIPS_MICRO_VERSION +VIPS_MINOR_VERSION +VIPS_VERSION +VIPS_VERSION_STRING +
+ +
+video +im_video_test +im_video_v4l1 +
+ +
+vips +vips_check_init +vips_get_argv0 +vips_get_option_group +vips_guess_libdir +vips_guess_prefix +vips_init +vips_shutdown +vips_version +vips_version_string +
+ +
+vips7compat +IMAGE +IM_ABS +IM_ANY +IM_ARRAY +IM_BANDFMT_CHAR +IM_BANDFMT_COMPLEX +IM_BANDFMT_DOUBLE +IM_BANDFMT_DPCOMPLEX +IM_BANDFMT_FLOAT +IM_BANDFMT_INT +IM_BANDFMT_LAST +IM_BANDFMT_NOTSET +IM_BANDFMT_SHORT +IM_BANDFMT_UCHAR +IM_BANDFMT_UINT +IM_BANDFMT_USHORT +IM_CLIP +IM_CLIP_CHAR +IM_CLIP_NONE +IM_CLIP_SHORT +IM_CLIP_UCHAR +IM_CLIP_USHORT +IM_CODING_LABQ +IM_CODING_NONE +IM_CODING_RAD +IM_DEG +IM_EXEEXT +IM_FATSTRIP +IM_FREE +IM_FREEF +IM_IMAGE_ADDR +IM_IMAGE_N_ELEMENTS +IM_IMAGE_SIZEOF_ELEMENT +IM_IMAGE_SIZEOF_LINE +IM_IMAGE_SIZEOF_PEL +IM_MAJOR_VERSION +IM_MAX +IM_META_EXIF_NAME +IM_META_ICC_NAME +IM_META_RESOLUTION_UNIT +IM_META_XML +IM_MICRO_VERSION +IM_MIN +IM_MINOR_VERSION +IM_NEW +IM_NUMBER +IM_PI +IM_RAD +IM_RECT_BOTTOM +IM_RECT_HCENTRE +IM_RECT_RIGHT +IM_RECT_VCENTRE +IM_REGION_ADDR +IM_REGION_ADDR_TOPLEFT +IM_REGION_LSKIP +IM_REGION_N_ELEMENTS +IM_REGION_SIZEOF_LINE +IM_RINT +IM_SETSTR +IM_SIZEOF_HEADER +IM_SMALLTILE +IM_SWAP +IM_THINSTRIP +IM_TYPE_AREA +IM_TYPE_BLOB +IM_TYPE_B_W +IM_TYPE_CMYK +IM_TYPE_FOURIER +IM_TYPE_GREY16 +IM_TYPE_HISTOGRAM +IM_TYPE_LAB +IM_TYPE_LABQ +IM_TYPE_LABS +IM_TYPE_LCH +IM_TYPE_MULTIBAND +IM_TYPE_REF_STRING +IM_TYPE_RGB +IM_TYPE_RGB16 +IM_TYPE_SAVE_STRING +IM_TYPE_UCS +IM_TYPE_XYZ +IM_TYPE_YXY +IM_TYPE_sRGB +IM_UNROLL +IM_VERSION_STRING +REGION +Rect +VIPS_VIP7COMPATS_H +VSListFold2Fn +VSListMap2Fn +VSListMap4Fn +VipsBandFmt +VipsType +error_exit +im_BandFmt2char +im_Coding2char +im_Compression2char +im_Type2char +im__change_suffix +im__end_eval +im__file_open_read +im__file_open_write +im__file_read +im__file_read_name +im__file_write +im__ftruncate +im__get_bytes +im__global_lock +im__gslist_gvalue_copy +im__gslist_gvalue_free +im__gslist_gvalue_get +im__gslist_gvalue_merge +im__gvalue_ref_string_new +im__handle_eval +im__has_extension_block +im__mmap +im__munmap +im__open_image_file +im__open_image_read +im__open_temp +im__print_all +im__print_renders +im__read_2byte +im__read_4byte +im__read_extension_block +im__read_header_bytes +im__region_no_ownership +im__seek +im__sizeof_bandfmt +im__start_eval +im__temp_name +im__test_kill +im__write +im__write_2byte +im__write_4byte +im__write_extension_block +im__write_header_bytes +im__writehist +im_abs +im_acostra +im_add +im_add_callback +im_add_callback1 +im_add_close_callback +im_add_eval_callback +im_add_evalend_callback +im_add_evalstart_callback +im_add_invalidate_callback +im_add_postclose_callback +im_add_preclose_callback +im_allocate_input_array +im_amiMSBfirst +im_andimage +im_andimage_vec +im_andimageconst +im_asintra +im_atantra +im_avg +im_bandjoin +im_binfile +im_bits_of_fmt +im_black +im_blend +im_blob_get +im_blob_set +im_break_token +im_cache +im_callback_fn +im_ceil +im_char2BandFmt +im_char2Coding +im_char2Type +im_char2dhint +im_char2dtype +im_check_8or16 +im_check_bandno +im_check_bands +im_check_bands_1or3 +im_check_bands_1orn +im_check_bands_1orn_unary +im_check_bands_same +im_check_coding_known +im_check_coding_labq +im_check_coding_noneorlabq +im_check_coding_rad +im_check_coding_same +im_check_complex +im_check_dmask +im_check_format +im_check_format_same +im_check_hist +im_check_imask +im_check_int +im_check_mono +im_check_noncomplex +im_check_size_same +im_check_u8or16 +im_check_u8or16orf +im_check_uint +im_check_uintorf +im_check_uncoded +im_check_vector +im_clip2fmt +im_close +im_concurrency_get +im_concurrency_set +im_construct_fn +im_copy +im_copy_morph +im_copy_native +im_copy_set +im_copy_set_meta +im_copy_swap +im_costra +im_cp_desc +im_cp_desc_array +im_cp_descv +im_demand_hint +im_demand_hint_array +im_deviate +im_dhint2char +im_diag +im_divide +im_dtype2char +im_embed +im_eorimage +im_eorimage_vec +im_eorimageconst +im_equal +im_equal_vec +im_equalconst +im_error +im_error_buffer +im_error_clear +im_error_system +im_existsf +im_exp10tra +im_expntra +im_expntra_vec +im_exptra +im_extract_area +im_extract_areabands +im_extract_band +im_extract_bands +im_file_length +im_filename_split +im_filename_suffix +im_filename_suffix_match +im_fliphor +im_flipver +im_floor +im_free +im_gbandjoin +im_generate +im_generate_fn +im_get_argv0 +im_get_option_group +im_getnextoption +im_getsuboption +im_guess_libdir +im_guess_prefix +im_hash_table_map +im_header_as_string +im_header_double +im_header_get +im_header_get_typeof +im_header_int +im_header_map +im_header_map_fn +im_header_string +im_histlin +im_history_get +im_ifthenelse +im_image +im_image_open_input +im_image_open_output +im_image_sanity +im_image_sanity_all +im_incheck +im_init +im_init_world +im_initdesc +im_insert +im_insert_noexpand +im_invalidate +im_invert +im_iocheck +im_isfile +im_ispostfix +im_ispoweroftwo +im_isprefix +im_less +im_less_vec +im_lessconst +im_lesseq +im_lesseq_vec +im_lesseqconst +im_lintra +im_lintra_vec +im_local +im_local_array +im_log10tra +im_logtra +im_lrjoin +im_malloc +im_map_equal +im_mapfile +im_mapfilerw +im_mask2vips +im_max +im_maxpos +im_measure_area +im_meta_get +im_meta_get_area +im_meta_get_blob +im_meta_get_double +im_meta_get_int +im_meta_get_string +im_meta_get_typeof +im_meta_remove +im_meta_set +im_meta_set_area +im_meta_set_blob +im_meta_set_double +im_meta_set_int +im_meta_set_string +im_min +im_minpos +im_more +im_more_vec +im_moreconst +im_moreeq +im_moreeq_vec +im_moreeqconst +im_multiply +im_notequal +im_notequal_vec +im_notequalconst +im_open +im_open_local +im_open_local_array +im_openout +im_orimage +im_orimage_vec +im_orimageconst +im_outcheck +im_pincheck +im_piocheck +im_popenf +im_poutcheck +im_powtra +im_powtra_vec +im_prepare +im_prepare_many +im_prepare_to +im_printdesc +im_recomb +im_rect_dup +im_rect_equalsrect +im_rect_includespoint +im_rect_includesrect +im_rect_intersectrect +im_rect_isempty +im_rect_marginadjust +im_rect_normalise +im_rect_unionrect +im_ref_string_get +im_ref_string_get_length +im_ref_string_set +im_region_black +im_region_buffer +im_region_create +im_region_free +im_region_paint +im_region_region +im_remainder +im_remainder_vec +im_remainderconst +im_remapfilerw +im_replicate +im_rint +im_rot180 +im_rot270 +im_rot90 +im_rwcheck +im_save_string_get +im_save_string_set +im_save_string_setf +im_semaphore_destroy +im_semaphore_down +im_semaphore_downn +im_semaphore_init +im_semaphore_t +im_semaphore_up +im_semaphore_upn +im_setbuf +im_setupout +im_shiftleft +im_shiftleft_vec +im_shiftright +im_shiftright_vec +im_sign +im_sintra +im_skip_dir +im_slist_equal +im_slist_filter +im_slist_fold2 +im_slist_free_all +im_slist_map2 +im_slist_map2_rev +im_slist_map4 +im_snprintf +im_start_fn +im_start_many +im_start_one +im_stats +im_stop_fn +im_stop_many +im_stop_one +im_strdup +im_strncpy +im_strrstr +im_subtract +im_tantra +im_tbjoin +im_updatehist +im_vdiag +im_verror +im_verror_system +im_version +im_version_string +im_vips2mask +im_vsnprintf +im_vwarn +im_warn +im_wrapmany +im_wrapmany_fn +im_wrapone +im_wrapone_fn +im_wraptwo +im_wraptwo_fn +im_writeline +vips_bandfmt_iscomplex +vips_bandfmt_isfloat +vips_bandfmt_isint +vips_bandfmt_isuint +vips_class_map_concrete_all +
+ diff --git a/doc/reference/libvips-decl.txt.bak b/doc/reference/libvips-decl.txt.bak new file mode 100644 index 00000000..73f226a1 --- /dev/null +++ b/doc/reference/libvips-decl.txt.bak @@ -0,0 +1,8234 @@ + +SinkBase +typedef struct _SinkBase { + VipsImage *im; + + /* The position we're at in buf. + */ + int x; + int y; + + /* The tilesize we've picked. + */ + int tile_width; + int tile_height; + int nlines; + +} SinkBase; + + +vips_sink_base_init +void + SinkBase *sink_base, VipsImage *image + + +vips_sink_thread_state_new +VipsThreadState * + VipsImage *im, void *a + + +vips_sink_base_allocate +int + VipsThreadState *state, void *a, gboolean *stop + + +vips_sink_base_progress +int + void *a + + +VIPS_TYPE_UNARY +#define VIPS_TYPE_UNARY (vips_unary_get_type()) + + +VIPS_UNARY +#define VIPS_UNARY( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), VIPS_TYPE_UNARY, VipsUnary )) + + +VIPS_UNARY_CLASS +#define VIPS_UNARY_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), VIPS_TYPE_UNARY, VipsUnaryClass)) + + +VIPS_IS_UNARY +#define VIPS_IS_UNARY( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_UNARY )) + + +VIPS_IS_UNARY_CLASS +#define VIPS_IS_UNARY_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_UNARY )) + + +VIPS_UNARY_GET_CLASS +#define VIPS_UNARY_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), VIPS_TYPE_UNARY, VipsUnaryClass )) + + +VipsUnary +typedef struct _VipsUnary { + VipsArithmetic parent_instance; + + VipsImage *in; + +} VipsUnary; + + +VipsUnaryClass +typedef VipsArithmeticClass VipsUnaryClass; + + +vips_unary_get_type +GType + void + + +VIPS_TYPE_BINARY +#define VIPS_TYPE_BINARY (vips_binary_get_type()) + + +VIPS_BINARY +#define VIPS_BINARY( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), VIPS_TYPE_BINARY, VipsBinary )) + + +VIPS_BINARY_CLASS +#define VIPS_BINARY_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), VIPS_TYPE_BINARY, VipsBinaryClass)) + + +VIPS_IS_BINARY +#define VIPS_IS_BINARY( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_BINARY )) + + +VIPS_IS_BINARY_CLASS +#define VIPS_IS_BINARY_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_BINARY )) + + +VIPS_BINARY_GET_CLASS +#define VIPS_BINARY_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), VIPS_TYPE_BINARY, VipsBinaryClass )) + + +VipsBinary +typedef struct _VipsBinary { + VipsArithmetic parent_instance; + + /* Original left and right image args. + */ + VipsImage *left; + VipsImage *right; + +} VipsBinary; + + +VipsBinaryClass +typedef VipsArithmeticClass VipsBinaryClass; + + +vips_binary_get_type +GType + void + + +VIPS_TYPE_UNARY_CONST +#define VIPS_TYPE_UNARY_CONST (vips_unary_const_get_type()) + + +VIPS_UNARY_CONST +#define VIPS_UNARY_CONST( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_UNARY_CONST, VipsUnaryConst )) + + +VIPS_UNARY_CONST_CLASS +#define VIPS_UNARY_CONST_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_UNARY_CONST, VipsUnaryConstClass)) + + +VIPS_IS_UNARY_CONST +#define VIPS_IS_UNARY_CONST( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_UNARY_CONST )) + + +VIPS_IS_UNARY_CONST_CLASS +#define VIPS_IS_UNARY_CONST_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_UNARY_CONST )) + + +VIPS_UNARY_CONST_GET_CLASS +#define VIPS_UNARY_CONST_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_UNARY_CONST, VipsUnaryConstClass )) + + +VipsUnaryConst +typedef struct _VipsUnaryConst { + VipsUnary parent_instance; + + /* Our constants. + */ + VipsArea *c; + + /* The format the constant should be cast to. Subclasses set this + * ready for unaryconst's build method. + */ + VipsBandFmt const_format; + + /* Our constant expanded to match arith->ready in size and + * const_format in type. + */ + int n; + PEL *c_ready; + +} VipsUnaryConst; + + +VipsUnaryConstClass +typedef struct _VipsUnaryConstClass { + VipsUnaryClass parent_class; + +} VipsUnaryConstClass; + + +vips_unary_const_get_type +GType + void + + +VIPS_TYPE_STATISTIC +#define VIPS_TYPE_STATISTIC (vips_statistic_get_type()) + + +VIPS_STATISTIC +#define VIPS_STATISTIC( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_STATISTIC, VipsStatistic )) + + +VIPS_STATISTIC_CLASS +#define VIPS_STATISTIC_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_STATISTIC, VipsStatisticClass)) + + +VIPS_IS_STATISTIC +#define VIPS_IS_STATISTIC( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_STATISTIC )) + + +VIPS_IS_STATISTIC_CLASS +#define VIPS_IS_STATISTIC_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_STATISTIC )) + + +VIPS_STATISTIC_GET_CLASS +#define VIPS_STATISTIC_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_STATISTIC, VipsStatisticClass )) + + +VipsStatisticStartFn +void * + VipsStatistic *statistic + + +VipsStatisticScanFn +int + VipsStatistic *statistic, + void *seq, int x, int y, void *p, int n + + +VipsStatisticStopFn +int + VipsStatistic *statistic, void *seq + + +VipsStatistic +struct _VipsStatistic { + VipsOperation parent_instance; + + /* All have an input image. + */ + VipsImage *in; + + /* Set this to stop computation early. + */ + gboolean stop; + + /* Client data for the subclass. + */ + void *a; + void *b; +}; + + +VipsStatisticClass +struct _VipsStatisticClass { + VipsOperationClass parent_class; + + /* Start/scan/stop, for vips_sink. + */ + VipsStatisticStartFn start; + VipsStatisticScanFn scan; + VipsStatisticStopFn stop; +}; + + +vips_statistic_get_type +GType + void + + +VIPS_TYPE_ARITHMETIC +#define VIPS_TYPE_ARITHMETIC (vips_arithmetic_get_type()) + + +VIPS_ARITHMETIC +#define VIPS_ARITHMETIC( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_ARITHMETIC, VipsArithmetic )) + + +VIPS_ARITHMETIC_CLASS +#define VIPS_ARITHMETIC_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_ARITHMETIC, VipsArithmeticClass)) + + +VIPS_IS_ARITHMETIC +#define VIPS_IS_ARITHMETIC( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_ARITHMETIC )) + + +VIPS_IS_ARITHMETIC_CLASS +#define VIPS_IS_ARITHMETIC_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_ARITHMETIC )) + + +VIPS_ARITHMETIC_GET_CLASS +#define VIPS_ARITHMETIC_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_ARITHMETIC, VipsArithmeticClass )) + + +VipsArithmeticProcessFn +void + struct _VipsArithmetic *arithmetic, + PEL *out, PEL **in, int width + + +VipsArithmetic +typedef struct _VipsArithmetic { + VipsOperation parent_instance; + + /* All have an output image. + */ + VipsImage *out; + + /* Array of input arguments, set these from a subclass. + */ + VipsImage **in; + int n; + + /* The minimum number of output bands. For example, VipsLinear with a + * three element constant must make at least a three-band output. + */ + int base_bands; + + /* The input images, ready for the operation. + */ + VipsImage **ready; +} VipsArithmetic; + + +VipsArithmeticClass +typedef struct _VipsArithmeticClass { + VipsOperationClass parent_class; + + /* For each input format, what output format. Used for arithmetic + * too, since we cast inputs to match. + */ + const VipsBandFormat *format_table; + + /* A vector program for each input type. + */ + VipsVector *vectors[VIPS_FORMAT_LAST]; + + /* ... and if we've set a program for this format. + */ + gboolean vector_program[VIPS_FORMAT_LAST]; + + /* The buffer processor. + */ + VipsArithmeticProcessFn process_line; +} VipsArithmeticClass; + + +vips_arithmetic_get_type +GType + void + + +vips_arithmetic_set_format_table +void + VipsArithmeticClass *klass, const VipsBandFormat *format_table + + +vips_arithmetic_get_vector +VipsVector * + VipsArithmeticClass *klass, VipsBandFormat fmt + + +vips_arithmetic_compile +void + VipsArithmeticClass *klass + + +vips_arithmetic_get_program +VipsVector * + VipsArithmeticClass *klass, VipsBandFormat fmt + + +VIPS_TYPE_CONVERSION +#define VIPS_TYPE_CONVERSION (vips_conversion_get_type()) + + +VIPS_CONVERSION +#define VIPS_CONVERSION( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_CONVERSION, VipsConversion )) + + +VIPS_CONVERSION_CLASS +#define VIPS_CONVERSION_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_CONVERSION, VipsConversionClass)) + + +VIPS_IS_CONVERSION +#define VIPS_IS_CONVERSION( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_CONVERSION )) + + +VIPS_IS_CONVERSION_CLASS +#define VIPS_IS_CONVERSION_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_CONVERSION )) + + +VIPS_CONVERSION_GET_CLASS +#define VIPS_CONVERSION_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_CONVERSION, VipsConversionClass )) + + +VipsConversion +typedef struct _VipsConversion { + VipsOperation parent_instance; + + /* All have an output image. + */ + VipsImage *out; + +} VipsConversion; + + +VipsConversionClass +typedef struct _VipsConversionClass { + VipsOperationClass parent_class; + +} VipsConversionClass; + + +vips_conversion_get_type +GType + void + + +Draw +typedef struct _Draw { + /* Parameters. + */ + IMAGE *im; /* Draw here */ + PEL *ink; /* Copy of ink param */ + + /* Derived stuff. + */ + size_t lsize; + size_t psize; + + /* If the object to draw is entirely within the image, we have a + * faster noclip path. + */ + gboolean noclip; +} Draw; + + +DRAW +#define DRAW(X) ((Draw *)(X)) + + +im__draw_pel +void + Draw *draw, PEL *q + + +im__draw_pel_clip +void + Draw *draw, int x, int y + + +im__draw_painted +gboolean + Draw *draw, PEL *p + + +im__draw_scanline +void + Draw *draw, int y, int x1, int x2 + + +im__draw_free +void + Draw *draw + + +im__draw_init +Draw * + Draw *draw, IMAGE *im, PEL *ink + + +VipsCallbackFn +int + void *a, void *b + + +VipsArea +typedef struct _VipsArea { + void *data; + size_t length; /* 0 if not known */ + + /* If this area represents an array, the number of elements in the + * array. Equal to length / sizeof(element). + */ + int n; + + /*< private >*/ + + /* Reference count. + */ + int count; + + /* Things like ICC profiles need their own free functions. + */ + VipsCallbackFn free_fn; + + /* If we are holding an array (for exmaple, an array of double), the + * GType of the elements and their size. 0 for not known. + * + * n is always length / sizeof_type, we keep it as a member for + * convenience. + */ + GType type; + size_t sizeof_type; +} VipsArea; + + +vips_area_copy +VipsArea * + VipsArea *area + + +vips_area_unref +void + VipsArea *area + + +vips_area_new +VipsArea * + VipsCallbackFn free_fn, void *data + + +vips_area_new_blob +VipsArea * + VipsCallbackFn free_fn, void *blob, size_t blob_length + + +vips_area_new_array +VipsArea * + GType type, size_t sizeof_type, int n + + +vips_area_new_array_object +VipsArea * + int n + + +VIPS_TYPE_AREA +#define VIPS_TYPE_AREA (vips_area_get_type()) + + +vips_value_set_area +int + GValue *value, VipsCallbackFn free_fn, void *data + + +vips_value_get_area +void * + const GValue *value, size_t *length + + +vips_area_get_type +GType + void + + +VIPS_TYPE_SAVE_STRING +#define VIPS_TYPE_SAVE_STRING (vips_save_string_get_type()) + + +vips_value_get_save_string +const char * + const GValue *value + + +vips_value_set_save_string +void + GValue *value, const char *str + + +vips_value_set_save_stringf +void + GValue *value, const char *fmt, ... + + +vips_save_string_get_type +GType + void + + +VIPS_TYPE_REF_STRING +#define VIPS_TYPE_REF_STRING (vips_ref_string_get_type()) + + +vips_value_get_ref_string +const char * + const GValue *value, size_t *length + + +vips_value_set_ref_string +int + GValue *value, const char *str + + +vips_ref_string_get_type +GType + void + + +VIPS_TYPE_BLOB +#define VIPS_TYPE_BLOB (vips_blob_get_type()) + + +vips_value_get_blob +void * + const GValue *value, size_t *length + + +vips_value_set_blob +int + GValue *value, VipsCallbackFn free_fn, void *data, size_t length + + +vips_blob_get_type +GType + void + + +vips_value_set_array +int + GValue *value, GType type, size_t sizeof_type, int n + + +vips_value_get_array +void * + const GValue *value, int *n, GType *type, size_t *sizeof_type + + +VIPS_TYPE_ARRAY_DOUBLE +#define VIPS_TYPE_ARRAY_DOUBLE (vips_array_double_get_type()) + + +vips_value_get_array_double +double * + const GValue *value, int *n + + +vips_value_set_array_double +int + GValue *value, const double *array, int n + + +vips_array_double_get_type +GType + void + + +VIPS_TYPE_ARRAY_IMAGE +#define VIPS_TYPE_ARRAY_IMAGE (vips_array_image_get_type()) + + +vips_value_get_array_object +GObject ** + const GValue *value, int *n + + +vips_value_set_array_object +int + GValue *value, int n + + +vips_array_image_get_type +GType + void + + +vips__meta_init_types +void + void + + +VIPS_TYPE_OPERATION +#define VIPS_TYPE_OPERATION (vips_operation_get_type()) + + +VIPS_OPERATION +#define VIPS_OPERATION( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_OPERATION, VipsOperation )) + + +VIPS_OPERATION_CLASS +#define VIPS_OPERATION_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_OPERATION, VipsOperationClass )) + + +VIPS_IS_OPERATION +#define VIPS_IS_OPERATION( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_OPERATION )) + + +VIPS_IS_OPERATION_CLASS +#define VIPS_IS_OPERATION_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_OPERATION )) + + +VIPS_OPERATION_GET_CLASS +#define VIPS_OPERATION_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_OPERATION, VipsOperationClass )) + + +VipsOperationBuildFn +gboolean + VipsObject * + + +VipsOperation +typedef struct _VipsOperation { + VipsObject parent_instance; + + /* When we added this oepration to cache .. used to find LRU for + * flush. + */ + int time; + + /* Keep the hash here. + */ + guint hash; + gboolean found_hash; + +} VipsOperation; + + +VipsOperationClass +typedef struct _VipsOperationClass { + VipsObjectClass parent_class; + +} VipsOperationClass; + + +vips_operation_get_type +GType + void + + +vips_operation_call_valist +int + VipsOperation *operation, va_list ap + + +vips_operation_new +VipsOperation * + const char *name + + +vips_call +int + const char *operation_name, ... + + +vips_call_split +int + const char *operation_name, va_list optional, ... + + +vips_call_options +void + GOptionGroup *group, VipsOperation *operation + + +vips_call_argv +int + VipsOperation *operation, int argc, char **argv + + +vips_cache_drop_all +void + void + + +vips_cache_operation_build +int + VipsOperation **operation + + +vips_cache_set_max +void + int max + + +vips_cache_set_max_mem +void + int max_mem + + +vips_cache_get_max +int + void + + +vips_cache_get_size +int + void + + +vips_cache_get_max_mem +size_t + void + + +vips_cache_get_max_files +int + void + + +vips_cache_set_max_files +void + int max_files + + +VIPS_MAGIC_INTEL +#define VIPS_MAGIC_INTEL (0xb6a6f208U) + + +VIPS_MAGIC_SPARC +#define VIPS_MAGIC_SPARC (0x08f2a6b6U) + + +VipsDemandStyle +typedef enum { + VIPS_DEMAND_STYLE_SMALLTILE, + VIPS_DEMAND_STYLE_FATSTRIP, + VIPS_DEMAND_STYLE_THINSTRIP, + VIPS_DEMAND_STYLE_ANY +} VipsDemandStyle; + + +VipsImageType +typedef enum { + VIPS_IMAGE_NONE, /* no type set */ + VIPS_IMAGE_SETBUF, /* malloced memory array */ + VIPS_IMAGE_SETBUF_FOREIGN, /* memory array, don't free on close */ + VIPS_IMAGE_OPENIN, /* input from fd with a window */ + VIPS_IMAGE_MMAPIN, /* memory mapped input file */ + VIPS_IMAGE_MMAPINRW, /* memory mapped read/write file */ + VIPS_IMAGE_OPENOUT, /* output to fd */ + VIPS_IMAGE_PARTIAL /* partial image */ +} VipsImageType; + + +VipsInterpretation +typedef enum { + VIPS_INTERPRETATION_MULTIBAND = 0, + VIPS_INTERPRETATION_B_W = 1, + VIPS_INTERPRETATION_HISTOGRAM = 10, + VIPS_INTERPRETATION_FOURIER = 24, + VIPS_INTERPRETATION_XYZ = 12, + VIPS_INTERPRETATION_LAB = 13, + VIPS_INTERPRETATION_CMYK = 15, + VIPS_INTERPRETATION_LABQ = 16, + VIPS_INTERPRETATION_RGB = 17, + VIPS_INTERPRETATION_UCS = 18, + VIPS_INTERPRETATION_LCH = 19, + VIPS_INTERPRETATION_LABS = 21, + VIPS_INTERPRETATION_sRGB = 22, + VIPS_INTERPRETATION_YXY = 23, + VIPS_INTERPRETATION_RGB16 = 25, + VIPS_INTERPRETATION_GREY16 = 26, + VIPS_INTERPRETATION_ARRAY = 27 +} VipsInterpretation; + + +VipsBandFormat +typedef enum { + VIPS_FORMAT_NOTSET = -1, + VIPS_FORMAT_UCHAR = 0, + VIPS_FORMAT_CHAR = 1, + VIPS_FORMAT_USHORT = 2, + VIPS_FORMAT_SHORT = 3, + VIPS_FORMAT_UINT = 4, + VIPS_FORMAT_INT = 5, + VIPS_FORMAT_FLOAT = 6, + VIPS_FORMAT_COMPLEX = 7, + VIPS_FORMAT_DOUBLE = 8, + VIPS_FORMAT_DPCOMPLEX = 9, + VIPS_FORMAT_LAST = 10 +} VipsBandFormat; + + +VipsCoding +typedef enum { + VIPS_CODING_NONE = 0, + VIPS_CODING_LABQ = 2, + VIPS_CODING_RAD = 6 +} VipsCoding; + + +VipsProgress +typedef struct { + /*< private >*/ + struct _VipsImage *im; /* Image we are part of */ + + /*< public >*/ + int run; /* Time we have been running */ + int eta; /* Estimated seconds of computation left */ + gint64 tpels; /* Number of pels we expect to calculate */ + gint64 npels; /* Number of pels calculated so far */ + int percent; /* Percent complete */ + GTimer *start; /* Start time */ +} VipsProgress; + + +VIPS_TYPE_IMAGE +#define VIPS_TYPE_IMAGE (vips_image_get_type()) + + +VIPS_IMAGE +#define VIPS_IMAGE( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_IMAGE, VipsImage )) + + +VIPS_IMAGE_CLASS +#define VIPS_IMAGE_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_IMAGE, VipsImageClass)) + + +VIPS_IS_IMAGE +#define VIPS_IS_IMAGE( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_IMAGE )) + + +VIPS_IS_IMAGE_CLASS +#define VIPS_IS_IMAGE_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_IMAGE )) + + +VIPS_IMAGE_GET_CLASS +#define VIPS_IMAGE_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_IMAGE, VipsImageClass )) + + +VipsImage +typedef struct _VipsImage { + VipsObject parent_object; + + /*< private >*/ + + /* We have to keep these names for compatibility with the old API. + * Don't use them though, use vips_image_get_width() and friends. + */ + + int Xsize; /* image width, in pixels */ + int Ysize; /* image height, in pixels */ + int Bands; /* number of image bands */ + + VipsBandFormat BandFmt; /* pixel format */ + VipsCoding Coding; /* pixel coding */ + VipsInterpretation Type;/* pixel interpretation */ + float Xres; /* horizontal pixels per millimetre */ + float Yres; /* vertical pixels per millimetre */ + + int Xoffset; /* image origin hint */ + int Yoffset; /* image origin hint */ + + /* No longer used, the names are here for compat with very, very old + * code. + */ + int Length; + short Compression; + short Level; + int Bbits; /* was number of bits in this format */ + + /* Old code expects to see this member, newer code has a param on + * eval(). + */ + VipsProgress *time; + + /* Derived fields that some code can fiddle with. New code should use + * vips_image_get_history() and friends. + */ + char *Hist; /* don't use, see vips_image_get_history() */ + char *filename; /* pointer to copy of filename */ + char *data; /* start of image data for WIO */ + int kill; /* set to non-zero to block eval */ + + /* Everything below this private and only used internally by + * VipsImage. + */ + + char *mode; /* mode string passed to _new() */ + VipsImageType dtype; /* descriptor type */ + int fd; /* file descriptor */ + char *baseaddr; /* pointer to the start of an mmap file */ + size_t length; /* size of mmap area */ + guint32 magic; /* magic from header, endian-ness of image */ + + /* Partial image stuff. All these fields are initialised + * to NULL and ignored unless set by vips_image_generate() etc. + */ + void *(*start_fn)(); /* user-supplied start function */ + int (*generate_fn)(); /* user-supplied generate function */ + int (*stop_fn)(); /* user-supplied stop function */ + void *client1; /* user arguments */ + void *client2; + GMutex *sslock; /* start-stop lock */ + GSList *regions; /* list of regions current for this image */ + VipsDemandStyle dhint; /* demand style hint */ + + /* Extra user-defined fields ... see vips_image_get() etc. + */ + GHashTable *meta; /* GhashTable of GValue */ + GSList *meta_traverse; /* traverse order for Meta */ + + /* Part of mmap() read ... the sizeof() the header we skip from the + * file start. Usually VIPS_SIZEOF_HEADER, but can be something else + * for binary file read. + */ + int sizeof_header; + + /* If this is a large disc image, don't map the whole thing, instead + * have a set of windows shared between the regions active on the + * image. List of VipsWindow. + */ + GSList *windows; + + /* Upstream/downstream relationships, built from args to + * vips_demand_hint(). + * + * We use these to invalidate downstream pixel buffers. + * Use 'serial' to spot circular dependencies. + * + * See also hint_set below. + */ + GSList *upstream; + GSList *downstream; + int serial; + + /* Keep a list of recounted GValue strings so we can share hist + * efficiently. + */ + GSList *history_list; + + /* The VipsImage (if any) we should signal eval progress on. + */ + struct _VipsImage *progress_signal; + + /* Record the file length here. We use this to stop ourselves mapping + * things beyond the end of the file in the case that the file has + * been truncated. + * + * gint64 so that we can guarantee to work even on systems with + * strange ideas about large files. + */ + gint64 file_length; + + /* Set this when vips_demand_hint_array() is called, and check in any + * operation that will demand pixels from the image. + * + * We use vips_demand_hint_array() to build the tree of + * upstream/downstream relationships, so it's a mandatory thing. + */ + gboolean hint_set; + + /* Delete-on-close is hard to do with signals and callbacks since we + * really need to do this in finalize after the fd has been closed, + * but you can't emit signals then. + * + * Also keep a private copy of the filename string to be deleted, + * since image->filename will be freed in _dispose(). + */ + gboolean delete_on_close; + char *delete_on_close_filename; + +} VipsImage; + + +VipsImageClass +typedef struct _VipsImageClass { + VipsObjectClass parent_class; + + /* Signals we emit. + */ + + /* Evaluation is starting. + */ + void (*preeval)( VipsImage *image, VipsProgress *progress ); + + /* Evaluation progress. + */ + void (*eval)( VipsImage *image, VipsProgress *progress ); + + /* Evaluation is ending. + */ + void (*posteval)( VipsImage *image, VipsProgress *progress ); + + /* An image has been written to. + * Used by eg. vips_image_new_mode("x.jpg", "w") to do the + * final write to jpeg. + * Set *result to non-zero to indicate an error on write. + */ + void (*written)( VipsImage *image, int *result ); + + /* An image has been modified in some way and all caches + * need dropping. + */ + void (*invalidate)( VipsImage *image ); + +} VipsImageClass; + + +vips_image_get_type +GType + void + + +VIPS_IMAGE_SIZEOF_ELEMENT +#define VIPS_IMAGE_SIZEOF_ELEMENT( I ) \ + (vips__image_sizeof_bandformat[(I)->BandFmt]) + + +VIPS_IMAGE_SIZEOF_PEL +#define VIPS_IMAGE_SIZEOF_PEL( I ) \ + (VIPS_IMAGE_SIZEOF_ELEMENT( I ) * (I)->Bands) + + +VIPS_IMAGE_SIZEOF_LINE +#define VIPS_IMAGE_SIZEOF_LINE( I ) \ + (VIPS_IMAGE_SIZEOF_PEL( I ) * (I)->Xsize) + + +VIPS_IMAGE_SIZEOF_IMAGE +#define VIPS_IMAGE_SIZEOF_IMAGE( I ) \ + (VIPS_IMAGE_SIZEOF_LINE( I ) * (I)->Ysize) + + +VIPS_IMAGE_N_ELEMENTS +#define VIPS_IMAGE_N_ELEMENTS( I ) \ + ((I)->Bands * (I)->Xsize) + + +VIPS_IMAGE_ADDR +#define VIPS_IMAGE_ADDR( I, X, Y ) \ + ( ((X) >= 0 && (X) < (I)->Xsize && \ + (Y) >= 0 && (Y) < (I)->Ysize) ? \ + ((I)->data + \ + (Y) * VIPS_IMAGE_SIZEOF_LINE( I ) + \ + (X) * VIPS_IMAGE_SIZEOF_PEL( I )) : \ + (fprintf( stderr, \ + "VIPS_IMAGE_ADDR: point out of bounds, " \ + "file \"%s\", line %d\n" \ + "(point x=%d, y=%d\n" \ + " should have been within VipsRect left=%d, top=%d, " \ + "width=%d, height=%d)\n", \ + __FILE__, __LINE__, \ + (X), (Y), \ + 0, 0, \ + (I)->Xsize, \ + (I)->Ysize ), abort(), (char *) NULL) \ + ) + + +vips_image_written +int + VipsImage *image + + +vips_image_invalidate_all +void + VipsImage *image + + +vips_image_preeval +void + VipsImage *image + + +vips_image_eval +void + VipsImage *image, int w, int h + + +vips_image_posteval +void + VipsImage *image + + +vips_image_set_progress +void + VipsImage *image, gboolean progress + + +vips_image_get_kill +gboolean + VipsImage *image + + +vips_image_set_kill +void + VipsImage *image, gboolean kill + + +vips_image_new +VipsImage * + void + + +vips_image_new_mode +VipsImage * + const char *filename, const char *mode + + +vips_image_new_from_file +VipsImage * + const char *filename + + +vips_image_new_from_file_raw +VipsImage * + const char *filename, int xsize, int ysize, int bands, int offset + + +vips_image_new_from_memory +VipsImage * + void *buffer, int xsize, int ysize, int bands, VipsBandFormat bandfmt + + +vips_image_new_array +VipsImage * + int xsize, int ysize + + +vips_image_set_delete_on_close +void + VipsImage *image, gboolean delete_on_close + + +vips_image_new_disc_temp +VipsImage * + const char *format + + +vips_image_write +int + VipsImage *image, VipsImage *out + + +vips_image_write_to_file +int + VipsImage *image, const char *filename + + +vips_image_isMSBfirst +gboolean + VipsImage *image + + +vips_image_isfile +gboolean + VipsImage *image + + +vips_image_ispartial +gboolean + VipsImage *image + + +vips_image_write_line +int + VipsImage *image, int ypos, PEL *linebuffer + + +vips_image_wio_input +int + VipsImage *image + + +vips_image_wio_output +int + VipsImage *image + + +vips_image_inplace +int + VipsImage *image + + +vips_image_pio_input +int + VipsImage *image + + +vips_image_pio_output +int + VipsImage *image + + +vips_band_format_isint +gboolean + VipsBandFormat format + + +vips_band_format_isuint +gboolean + VipsBandFormat format + + +vips_band_format_isfloat +gboolean + VipsBandFormat format + + +vips_band_format_iscomplex +gboolean + VipsBandFormat format + + +im_lrmerge +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int dx, int dy, int mwidth + + +im_tbmerge +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int dx, int dy, int mwidth + + +im_lrmerge1 +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int mwidth + + +im_tbmerge1 +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int mwidth + + +im_lrmosaic +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int bandno, int xref, int yref, int xsec, int ysec, int hwindowsize, int hsearchsize, int balancetype, int mwidth + + +im_tbmosaic +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int bandno, int xref, int yref, int xsec, int ysec, int hwindowsize, int hsearchsize, int balancetype, int mwidth + + +im_lrmosaic1 +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int bandno, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int hwindowsize, int hsearchsize, int balancetype, int mwidth + + +im_tbmosaic1 +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int bandno, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int hwindowsize, int hsearchsize, int balancetype, int mwidth + + +im_global_balance +int + VipsImage *in, VipsImage *out, double gamma + + +im_global_balancef +int + VipsImage *in, VipsImage *out, double gamma + + +im_correl +int + VipsImage *ref, VipsImage *sec, int xref, int yref, int xsec, int ysec, int hwindowsize, int hsearchsize, double *correlation, int *x, int *y + + +im_remosaic +int + VipsImage *in, VipsImage *out, const char *old_str, const char *new_str + + +im_align_bands +int + VipsImage *in, VipsImage *out + + +im_maxpos_subpel +int + VipsImage *in, double *x, double *y + + +VipsMaskType +typedef enum { + VIPS_MASK_IDEAL_HIGHPASS = 0, + VIPS_MASK_IDEAL_LOWPASS = 1, + VIPS_MASK_BUTTERWORTH_HIGHPASS = 2, + VIPS_MASK_BUTTERWORTH_LOWPASS = 3, + VIPS_MASK_GAUSS_HIGHPASS = 4, + VIPS_MASK_GAUSS_LOWPASS = 5, + + VIPS_MASK_IDEAL_RINGPASS = 6, + VIPS_MASK_IDEAL_RINGREJECT = 7, + VIPS_MASK_BUTTERWORTH_RINGPASS = 8, + VIPS_MASK_BUTTERWORTH_RINGREJECT = 9, + VIPS_MASK_GAUSS_RINGPASS = 10, + VIPS_MASK_GAUSS_RINGREJECT = 11, + + VIPS_MASK_IDEAL_BANDPASS = 12, + VIPS_MASK_IDEAL_BANDREJECT = 13, + VIPS_MASK_BUTTERWORTH_BANDPASS = 14, + VIPS_MASK_BUTTERWORTH_BANDREJECT = 15, + VIPS_MASK_GAUSS_BANDPASS = 16, + VIPS_MASK_GAUSS_BANDREJECT = 17, + + VIPS_MASK_FRACTAL_FLT = 18 +} VipsMaskType; + + +im_fwfft +int + VipsImage *in, VipsImage *out + + +im_invfft +int + VipsImage *in, VipsImage *out + + +im_invfftr +int + VipsImage *in, VipsImage *out + + +im_freqflt +int + VipsImage *in, VipsImage *mask, VipsImage *out + + +im_disp_ps +int + VipsImage *in, VipsImage *out + + +im_rotquad +int + VipsImage *in, VipsImage *out + + +im_phasecor_fft +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_flt_image_freq +int + VipsImage *in, VipsImage *out, VipsMaskType flag, ... + + +im_create_fmask +int + VipsImage *out, int xsize, int ysize, VipsMaskType flag, ... + + +im_fractsurf +int + VipsImage *out, int size, double frd + + +VipsBuf +typedef struct { + /* All fields are private. + */ + /* */ + char *base; /* String base */ + int mx; /* Maximum length */ + int i; /* Current write point */ + gboolean full; /* String has filled, block writes */ + int lasti; /* For read-recent */ + gboolean dynamic; /* We own the string with malloc() */ +} VipsBuf; + + +VIPS_BUF_STATIC +#define VIPS_BUF_STATIC( TEXT ) \ + { &TEXT[0], sizeof( TEXT ), 0, FALSE, 0, FALSE } + + +vips_buf_rewind +void + VipsBuf *buf + + +vips_buf_destroy +void + VipsBuf *buf + + +vips_buf_init +void + VipsBuf *buf + + +vips_buf_set_static +void + VipsBuf *buf, char *base, int mx + + +vips_buf_set_dynamic +void + VipsBuf *buf, int mx + + +vips_buf_init_static +void + VipsBuf *buf, char *base, int mx + + +vips_buf_init_dynamic +void + VipsBuf *buf, int mx + + +vips_buf_appendns +gboolean + VipsBuf *buf, const char *str, int sz + + +vips_buf_appends +gboolean + VipsBuf *buf, const char *str + + +vips_buf_appendf +gboolean + VipsBuf *buf, const char *fmt, ... + + +vips_buf_vappendf +gboolean + VipsBuf *buf, const char *fmt, va_list ap + + +vips_buf_appendc +gboolean + VipsBuf *buf, char ch + + +vips_buf_appendsc +gboolean + VipsBuf *buf, gboolean quote, const char *str + + +vips_buf_appendgv +gboolean + VipsBuf *buf, GValue *value + + +vips_buf_append_size +gboolean + VipsBuf *buf, size_t n + + +vips_buf_removec +gboolean + VipsBuf *buf, char ch + + +vips_buf_change +gboolean + VipsBuf *buf, const char *o, const char *n + + +vips_buf_is_empty +gboolean + VipsBuf *buf + + +vips_buf_is_full +gboolean + VipsBuf *buf + + +vips_buf_all +const char * + VipsBuf *buf + + +vips_buf_firstline +const char * + VipsBuf *buf + + +vips_buf_appendg +gboolean + VipsBuf *buf, double g + + +vips_buf_appendd +gboolean + VipsBuf *buf, int d + + +vips_buf_len +int + VipsBuf *buf + + +VIPS_TYPE_THREAD_STATE +#define VIPS_TYPE_THREAD_STATE (vips_thread_state_get_type()) + + +VIPS_THREAD_STATE +#define VIPS_THREAD_STATE( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_THREAD_STATE, VipsThreadState )) + + +VIPS_THREAD_STATE_CLASS +#define VIPS_THREAD_STATE_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_THREAD_STATE, VipsThreadStateClass)) + + +VIPS_IS_THREAD_STATE +#define VIPS_IS_THREAD_STATE( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_THREAD_STATE )) + + +VIPS_IS_THREAD_STATE_CLASS +#define VIPS_IS_THREAD_STATE_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_THREAD_STATE )) + + +VIPS_THREAD_STATE_GET_CLASS +#define VIPS_THREAD_STATE_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_THREAD_STATE, VipsThreadStateClass )) + + +VipsThreadState +typedef struct _VipsThreadState { + VipsObject parent_object; + + /*< public >*/ + /* Image we run on. + */ + VipsImage *im; + + /* This region is created and destroyed by the threadpool for the + * use of the worker. + */ + VipsRegion *reg; + + /* Neither used nor set, do what you like with them. + */ + VipsRect pos; + int x, y; + + /* Set in work to get the allocate to signal stop. + */ + gboolean stop; + + /* The client data passed to the enclosing vips_threadpool_run(). + */ + void *a; + +} VipsThreadState; + + +VipsThreadStateClass +typedef struct _VipsThreadStateClass { + VipsObjectClass parent_class; + /*< public >*/ + +} VipsThreadStateClass; + + +vips_thread_state_set +void * + VipsObject *object, void *a, void *b + + +vips_thread_state_get_type +GType + void + + +vips_thread_state_new +VipsThreadState * + VipsImage *im, void *a + + +VipsThreadStartFn +VipsThreadState * + VipsImage *im, void *a + + +VipsThreadpoolAllocateFn +int + VipsThreadState *state, + void *a, gboolean *stop + + +VipsThreadpoolWorkFn +int + VipsThreadState *state, void *a + + +VipsThreadpoolProgressFn +int + void *a + + +vips_threadpool_run +int + VipsImage *im, VipsThreadStartFn start, VipsThreadpoolAllocateFn allocate, VipsThreadpoolWorkFn work, VipsThreadpoolProgressFn progress, void *a + + +vips_get_tile_size +void + VipsImage *im, int *tile_width, int *tile_height, int *nlines + + +vips__print_renders +void + void + + +vips_concurrency_set +void + int concurrency + + +vips_concurrency_get +int + void + + +VIPS_META_EXIF_NAME +#define VIPS_META_EXIF_NAME "exif-data" + + +VIPS_META_XMP_NAME +#define VIPS_META_XMP_NAME "xmp-data" + + +VIPS_META_ICC_NAME +#define VIPS_META_ICC_NAME "icc-profile-data" + + +VIPS_META_XML +#define VIPS_META_XML "xml-header" + + +VIPS_META_RESOLUTION_UNIT +#define VIPS_META_RESOLUTION_UNIT "resolution-unit" + + +vips_format_sizeof +int + VipsBandFormat format + + +vips_image_get_width +int + const VipsImage *image + + +vips_image_get_height +int + const VipsImage *image + + +vips_image_get_bands +int + const VipsImage *image + + +vips_image_get_format +VipsBandFormat + const VipsImage *image + + +vips_image_get_coding +VipsCoding + const VipsImage *image + + +vips_image_get_interpretation +VipsInterpretation + const VipsImage *image + + +vips_image_get_xres +double + const VipsImage *image + + +vips_image_get_yres +double + const VipsImage *image + + +vips_image_get_xoffset +int + const VipsImage *image + + +vips_image_get_yoffset +int + const VipsImage *image + + +vips_image_get_filename +const char * + const VipsImage *image + + +vips_image_get_mode +const char * + const VipsImage *image + + +vips_image_get_data +void * + VipsImage *image + + +vips_image_init_fields +void + VipsImage *image, int xsize, int ysize, int bands, VipsBandFormat format, VipsCoding coding, VipsInterpretation interpretation, float xres, float yres + + +vips_image_copy_fields_array +int + VipsImage *out, VipsImage *in[] + + +vips_image_copy_fieldsv +int + VipsImage *out, VipsImage *in1, ... + + +vips_image_copy_fields +int + VipsImage *out, VipsImage *in + + +vips_image_set +void + VipsImage *image, const char *field, GValue *value + + +vips_image_get +int + VipsImage *image, const char *field, GValue *value_copy + + +vips_image_get_as_string +int + VipsImage *image, const char *field, char **out + + +vips_image_get_typeof +GType + VipsImage *image, const char *field + + +vips_image_remove +gboolean + VipsImage *image, const char *field + + +VipsImageMapFn +void * + VipsImage *image, + const char *field, GValue *value, void *a + + +vips_image_map +void * + VipsImage *im, VipsImageMapFn fn, void *a + + +vips_image_set_area +void + VipsImage *image, const char *field, VipsCallbackFn free_fn, void *data + + +vips_image_get_area +int + VipsImage *image, const char *field, void **data + + +vips_image_set_string +void + VipsImage *image, const char *field, const char *str + + +vips_image_get_string +int + VipsImage *image, const char *field, char **str + + +vips_image_set_blob +void + VipsImage *image, const char *field, VipsCallbackFn free_fn, void *data, size_t length + + +vips_image_get_blob +int + VipsImage *image, const char *field, void **data, size_t *length + + +vips_image_get_int +int + VipsImage *image, const char *field, int *out + + +vips_image_set_int +void + VipsImage *image, const char *field, int i + + +vips_image_get_double +int + VipsImage *image, const char *field, double *out + + +vips_image_set_double +void + VipsImage *image, const char *field, double d + + +vips_image_history_printf +int + VipsImage *image, const char *format, ... + + +vips_image_history_args +int + VipsImage *image, const char *name, int argc, char *argv[] + + +vips_image_get_history +const char * + VipsImage *image + + +VipsRegionWrite +int + VipsRegion *region, VipsRect *area, void *a + + +vips_sink_disc +int + VipsImage *im, VipsRegionWrite write_fn, void *a + + +VipsStartFn +void * + VipsImage *out, void *a, void *b + + +VipsGenerateFn +int + VipsRegion *out, + void *seq, void *a, void *b, gboolean *stop + + +VipsStopFn +int + void *seq, void *a, void *b + + +vips_sink +int + VipsImage *im, VipsStartFn start_fn, VipsGenerateFn generate_fn, VipsStopFn stop_fn, void *a, void *b + + +vips_sink_tile +int + VipsImage *im, int tile_width, int tile_height, VipsStartFn start_fn, VipsGenerateFn generate_fn, VipsStopFn stop_fn, void *a, void *b + + +VipsSinkNotify +void + VipsImage *im, VipsRect *rect, void *a + + +vips_sink_screen +int + VipsImage *in, VipsImage *out, VipsImage *mask, int tile_width, int tile_height, int max_tiles, int priority, VipsSinkNotify notify, void *a + + +vips_image_cache +int + VipsImage *in, VipsImage *out, int width, int height, int max + + +vips_sink_memory +int + VipsImage *im + + +vips_start_one +void * + VipsImage *out, void *a, void *b + + +vips_stop_one +int + void *seq, void *a, void *b + + +vips_start_many +void * + VipsImage *out, void *a, void *b + + +vips_stop_many +int + void *seq, void *a, void *b + + +vips_allocate_input_array +VipsImage ** + VipsImage *out, ... + + +vips_image_generate +int + VipsImage *im, VipsStartFn start_fn, VipsGenerateFn generate_fn, VipsStopFn stop_fn, void *a, void *b + + +vips_demand_hint_array +void + VipsImage *image, VipsDemandStyle hint, VipsImage **in + + +vips_demand_hint +void + VipsImage *image, VipsDemandStyle hint, ... + + +im_greyc_mask +int + VipsImage *in, VipsImage *out, VipsImage *mask, int iterations, float amplitude, float sharpness, float anisotropy, float alpha, float sigma, float dl, float da, float gauss_prec, int interpolation, int fast_approx + + +VIPS_UNREF +#define VIPS_UNREF( X ) VIPS_FREEF( g_object_unref, (X) ) + + +VipsArgumentFlags +typedef enum { + VIPS_ARGUMENT_NONE = 0, + VIPS_ARGUMENT_REQUIRED = 1, + VIPS_ARGUMENT_CONSTRUCT = 2, + VIPS_ARGUMENT_SET_ONCE = 4, + VIPS_ARGUMENT_INPUT = 8, + VIPS_ARGUMENT_OUTPUT = 16 +} VipsArgumentFlags; + + +VIPS_ARGUMENT_REQUIRED_INPUT +#define VIPS_ARGUMENT_REQUIRED_INPUT \ + (VIPS_ARGUMENT_INPUT | \ + VIPS_ARGUMENT_REQUIRED | \ + VIPS_ARGUMENT_CONSTRUCT) + + +VIPS_ARGUMENT_OPTIONAL_INPUT +#define VIPS_ARGUMENT_OPTIONAL_INPUT \ + (VIPS_ARGUMENT_INPUT | \ + VIPS_ARGUMENT_CONSTRUCT) + + +VIPS_ARGUMENT_REQUIRED_OUTPUT +#define VIPS_ARGUMENT_REQUIRED_OUTPUT \ + (VIPS_ARGUMENT_OUTPUT | \ + VIPS_ARGUMENT_REQUIRED | \ + VIPS_ARGUMENT_CONSTRUCT) + + +VIPS_ARGUMENT_OPTIONAL_OUTPUT +#define VIPS_ARGUMENT_OPTIONAL_OUTPUT \ + (VIPS_ARGUMENT_OUTPUT | \ + VIPS_ARGUMENT_CONSTRUCT) + + +VIPS_ARG_IMAGE +#define VIPS_ARG_IMAGE( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_object( (NAME), (LONG), (DESC), \ + VIPS_TYPE_IMAGE, \ + G_PARAM_READWRITE ); \ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_BOOL +#define VIPS_ARG_BOOL( CLASS, NAME, PRIORITY, LONG, DESC, \ + FLAGS, OFFSET, VALUE ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_boolean( (NAME), (LONG), (DESC), \ + (VALUE), \ + G_PARAM_READWRITE ); \ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_DOUBLE +#define VIPS_ARG_DOUBLE( CLASS, NAME, PRIORITY, LONG, DESC, \ + FLAGS, OFFSET, MIN, MAX, VALUE ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_double( (NAME), (LONG), (DESC), \ + (MIN), (MAX), (VALUE), \ + G_PARAM_READWRITE );\ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_BOXED +#define VIPS_ARG_BOXED( CLASS, NAME, PRIORITY, LONG, DESC, \ + FLAGS, OFFSET, TYPE ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_boxed( (NAME), (LONG), (DESC), \ + (TYPE), \ + G_PARAM_READWRITE );\ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_INT +#define VIPS_ARG_INT( CLASS, NAME, PRIORITY, LONG, DESC, \ + FLAGS, OFFSET, MIN, MAX, VALUE ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_int( (NAME), (LONG), (DESC), \ + (MIN), (MAX), (VALUE), \ + G_PARAM_READWRITE );\ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_ENUM +#define VIPS_ARG_ENUM( CLASS, NAME, PRIORITY, LONG, DESC, \ + FLAGS, OFFSET, TYPE, VALUE ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_enum( (NAME), (LONG), (DESC), \ + (TYPE), (VALUE), \ + G_PARAM_READWRITE );\ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_STRING +#define VIPS_ARG_STRING( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET, \ + VALUE ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_string( (NAME), (LONG), (DESC), \ + (VALUE), \ + G_PARAM_READWRITE ); \ + g_object_class_install_property( G_OBJECT_CLASS( CLASS ), \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VIPS_ARG_POINTER +#define VIPS_ARG_POINTER( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET ) { \ + GParamSpec *pspec; \ + \ + pspec = g_param_spec_pointer( (NAME), (LONG), (DESC), \ + G_PARAM_READWRITE ); \ + g_object_class_install_property( gobject_class, \ + _vips__argument_id++, pspec ); \ + vips_object_class_install_argument( VIPS_OBJECT_CLASS( CLASS ), \ + pspec, (FLAGS), (PRIORITY), (OFFSET) ); \ +} + + +VipsArgument +typedef struct _VipsArgument { + GParamSpec *pspec; /* pspec for this argument */ + + /* More stuff, see below */ +} VipsArgument; + + +VipsArgumentClass +typedef struct _VipsArgumentClass { + VipsArgument parent; + + /* The class of the object we are an arg for. + */ + VipsObjectClass *object_class; + + VipsArgumentFlags flags; + int priority; /* Order args by this */ + guint offset; /* G_STRUCT_OFFSET of member in object */ +} VipsArgumentClass; + + +VipsArgumentInstance +typedef struct _VipsArgumentInstance { + VipsArgument parent; + + /* The class we are part of. + */ + VipsArgumentClass *argument_class; + + /* The object we are attached to. + */ + VipsObject *object; + + /* Has been set. + */ + gboolean assigned; + + /* If this is an output argument, keep the id of our "close" handler + * here. + */ + gulong close_id; +} VipsArgumentInstance; + + +VipsArgumentTable +typedef GHashTable VipsArgumentTable; + + +vips__argument_get_instance +VipsArgumentInstance * + VipsArgumentClass *, VipsObject * + + +vips__argument_table_lookup +VipsArgument * + VipsArgumentTable *, GParamSpec * + + +vips__object_set_member +void + VipsObject *object, GParamSpec *pspec, GObject **member, GObject *argument + + +VipsArgumentMapFn +void * + VipsObject *, GParamSpec *, + VipsArgumentClass *, VipsArgumentInstance *, void *a, void *b + + +vips_argument_map +void * + VipsObject *object, VipsArgumentMapFn fn, void *a, void *b + + +vips_argument_dispose_all +void + VipsObject *object + + +vips_object_get_argument +int + VipsObject *object, const char *name, GParamSpec **pspec, VipsArgumentClass **argument_class, VipsArgumentInstance **argument_instance + + +vips_argument_get_assigned +gboolean + VipsObject *object, const char *name + + +VIPS_ARGUMENT_FOR_ALL +#define VIPS_ARGUMENT_FOR_ALL( OBJECT, PSPEC, ARG_CLASS, ARG_INSTANCE ) { \ + VipsObjectClass *object_class = VIPS_OBJECT_GET_CLASS( OBJECT ); \ + GSList *p; \ + \ + for( p = object_class->argument_table_traverse; p; p = p->next ) { \ + VipsArgumentClass *ARG_CLASS = \ + (VipsArgumentClass *) p->data; \ + VipsArgument *argument = (VipsArgument *) argument_class; \ + GParamSpec *PSPEC = argument->pspec; \ + VipsArgumentInstance *ARG_INSTANCE = \ + vips__argument_get_instance( argument_class, \ + VIPS_OBJECT( OBJECT ) ); \ + \ + /* We have many props on the arg table ... filter out the \ + * ones for this class. \ + */ \ + if( g_object_class_find_property( \ + G_OBJECT_CLASS( object_class ), \ + g_param_spec_get_name( PSPEC ) ) == PSPEC ) { + + +VIPS_ARGUMENT_FOR_ALL_END +#define VIPS_ARGUMENT_FOR_ALL_END } } } + + +VIPS_TYPE_OBJECT +#define VIPS_TYPE_OBJECT (vips_object_get_type()) + + +VIPS_OBJECT +#define VIPS_OBJECT( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), VIPS_TYPE_OBJECT, VipsObject )) + + +VIPS_OBJECT_CLASS +#define VIPS_OBJECT_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), VIPS_TYPE_OBJECT, VipsObjectClass)) + + +VIPS_IS_OBJECT +#define VIPS_IS_OBJECT( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_OBJECT )) + + +VIPS_IS_OBJECT_CLASS +#define VIPS_IS_OBJECT_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_OBJECT )) + + +VIPS_OBJECT_GET_CLASS +#define VIPS_OBJECT_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), VIPS_TYPE_OBJECT, VipsObjectClass )) + + +VipsObject +struct _VipsObject { + GObject parent_object; + + /* Set after ->build() has run succesfully: construct is fully done + * and checked. + */ + gboolean constructed; + + /* Set for static objects which are allocated at startup and never + * freed. These objects are ommitted from leak reports. + */ + gboolean static_object; + + /* Table of argument instances for this class and any derived classes. + */ + VipsArgumentTable *argument_table; + + /* Class properties (see below), duplicated in the instance so we can + * get at them easily via the property system. + */ + char *nickname; + char *description; + + /* The pre/post/close callbacks are all fire-once. + */ + gboolean preclose; + gboolean close; + gboolean postclose; +}; + + +VipsObjectClass +struct _VipsObjectClass { + GObjectClass parent_class; + + /* Build the object ... all argument properties have been set, + * now build the thing. + */ + int (*build)( VipsObject *object ); + + /* Try to print something about the class, handy for help displays. + */ + void (*print_class)( struct _VipsObjectClass *, VipsBuf * ); + + /* Try to print something about the object, handy for debugging. + */ + void (*print)( VipsObject *, VipsBuf * ); + + /* Sanity-check the object. Print messages and stuff. + * Handy for debugging. + */ + void (*sanity)( VipsObject *, VipsBuf * ); + + /* Rewind. Save and restore any stuff that needs to survive a + * dispose(). + */ + void (*rewind)( VipsObject * ); + + /* Just before close, everything is still alive. + */ + void (*preclose)( VipsObject * ); + + /* Close, time to free stuff. + */ + void (*close)( VipsObject * ); + + /* Post-close, everything is dead, except the VipsObject pointer. + * Useful for eg. deleting the file associated with a temp image. + */ + void (*postclose)( VipsObject * ); + + /* The CLI interface. Implement these four to get CLI input and output + * for your object. + */ + + /* Given a command-line arg (eg. a filename), make an instance of the + * object. Just do the g_object_new(), don't call _build(). + * + * Don't call this directly, see vips_object_new_from_string(). + */ + VipsObject *(*new_from_string)( const char *string ); + + /* The inverse of ^^. Given an object, output what ->new_from_string() + * would have been given to make that object. + */ + void (*to_string)( VipsObject *, VipsBuf * ); + + /* Does this output arg need an arg from the command line? Image + * output, for example, needs a filename to write to. + */ + gboolean output_needs_arg; + + /* Write the object to the string. Return 0 for success, or -1 on + * error, setting vips_error(). string is NULL if output_needs_arg() + * was FALSE. + */ + int (*output_to_arg)( VipsObject *object, const char *string ); + + /* Class nickname, eg. "VipsInterpolateBicubic" has "bicubic" as a + * nickname. Not internationalised. + */ + const char *nickname; + + /* Class description. Used for help messages, so internationalised. + */ + const char *description; + + /* Table of arguments for this class and any derived classes. Order + * is important, so keep a traverse list too. We can't rely on the + * ordering given by g_object_class_list_properties() since it comes + * from a hash :-( + */ + VipsArgumentTable *argument_table; + GSList *argument_table_traverse; +}; + + +vips_value_is_null +gboolean + GParamSpec *psoec, const GValue *value + + +vips_object_set_property +void + GObject *gobject, guint property_id, const GValue *value, GParamSpec *pspec + + +vips_object_get_property +void + GObject *gobject, guint property_id, GValue *value, GParamSpec *pspec + + +vips_object_preclose +void + VipsObject *object + + +vips_object_build +int + VipsObject *object + + +vips_object_print_class +void + VipsObjectClass *klass + + +vips_object_print +void + VipsObject *object + + +vips_object_print_name +void + VipsObject *object + + +vips_object_sanity +gboolean + VipsObject *object + + +vips_object_get_type +GType + void + + +vips_object_class_install_argument +void + VipsObjectClass *, GParamSpec *pspec, VipsArgumentFlags flags, int priority, guint offset + + +vips_object_set_argument_from_string +int + VipsObject *object, const char *name, const char *value + + +vips_object_get_argument_needs_string +gboolean + VipsObject *object, const char *name + + +vips_object_get_argument_to_string +int + VipsObject *object, const char *name, const char *arg + + +vips_object_set_required +int + VipsObject *object, const char *value + + +VipsObjectSetArguments +void * + VipsObject *, void *, void * + + +vips_object_new +VipsObject * + GType type, VipsObjectSetArguments set, void *a, void *b + + +vips_object_new_from_string +VipsObject * + VipsObjectClass *object_class, const char *p + + +vips_object_to_string +void + VipsObject *object, VipsBuf *buf + + +vips_object_map +void * + VipsSListMap2Fn fn, void *a, void *b + + +VipsTypeMap +void * + GType, void * + + +VipsTypeMap2 +void * + GType, void *, void * + + +VipsClassMap +void * + VipsObjectClass *, void * + + +vips_type_map +void * + GType base, VipsTypeMap2 fn, void *a, void *b + + +vips_type_map_all +void * + GType base, VipsTypeMap fn, void *a + + +vips_class_map_all +void * + GType base, VipsClassMap fn, void *a + + +vips_class_depth +int + VipsObjectClass *klass + + +vips_class_find +VipsObjectClass * + const char *basename, const char *nickname + + +vips_type_find +GType + const char *basename, const char *nickname + + +vips_object_local_array +VipsObject ** + VipsObject *parent, int n + + +vips_object_local_cb +void + VipsObject *vobject, GObject *gobject + + +vips_object_local +#define vips_object_local( V, G ) \ + (g_signal_connect( V, "close", \ + G_CALLBACK( vips_object_local_cb ), G ), 0) + + +vips_object_set_static +void + VipsObject *object, gboolean static_object + + +vips_object_print_all +void + void + + +vips_object_sanity_all +void + void + + +vips_object_rewind +void + VipsObject *object + + +im_grey +int + VipsImage *out, const int xsize, const int ysize + + +im_fgrey +int + VipsImage *out, const int xsize, const int ysize + + +im_make_xy +int + VipsImage *out, const int xsize, const int ysize + + +im_feye +int + VipsImage *out, const int xsize, const int ysize, const double factor + + +im_eye +int + VipsImage *out, const int xsize, const int ysize, const double factor + + +im_zone +int + VipsImage *out, int size + + +im_fzone +int + VipsImage *out, int size + + +im_sines +int + VipsImage *out, int xsize, int ysize, double horfreq, double verfreq + + +im_benchmarkn +int + VipsImage *in, VipsImage *out, int n + + +im_benchmark2 +int + VipsImage *in, double *out + + +VIPS_PI +#define VIPS_PI (3.14159265358979323846) + + +VIPS_RAD +#define VIPS_RAD( R ) (((R) / 360.0) * 2.0 * VIPS_PI) + + +VIPS_DEG +#define VIPS_DEG( A ) (((A) / (2.0 * VIPS_PI)) * 360.0) + + +VIPS_MAX +#define VIPS_MAX( A, B ) ((A) > (B) ? (A) : (B)) + + +VIPS_MIN +#define VIPS_MIN( A, B ) ((A) < (B) ? (A) : (B)) + + +VIPS_ABS +#define VIPS_ABS( X ) (((X) >= 0) ? (X) : -(X)) + + +VIPS_CLIP +#define VIPS_CLIP( A, V, B ) VIPS_MAX( (A), VIPS_MIN( (B), (V) ) ) + + +VIPS_NUMBER +#define VIPS_NUMBER( R ) ((int) (sizeof(R) / sizeof(R[0]))) + + +VIPS_SWAP +#define VIPS_SWAP( TYPE, A, B ) \ +G_STMT_START { \ + TYPE t = (A); \ + (A) = (B); \ + (B) = t; \ +} G_STMT_END + + +VIPS_UNROLL +#define VIPS_UNROLL( N, OPER ) \ +G_STMT_START { \ + if( (N) ) { \ + int duff_count = ((N) + 15) / 16; \ + \ + switch( (N) % 16 ) { \ + case 0: do { OPER; \ + case 15: OPER; \ + case 14: OPER; \ + case 13: OPER; \ + case 12: OPER; \ + case 11: OPER; \ + case 10: OPER; \ + case 9: OPER; \ + case 8: OPER; \ + case 7: OPER; \ + case 6: OPER; \ + case 5: OPER; \ + case 4: OPER; \ + case 3: OPER; \ + case 2: OPER; \ + case 1: OPER; \ + } while( --duff_count > 0 ); \ + } \ + } \ +} G_STMT_END + + +VIPS_RINT +#define VIPS_RINT( R ) ((int) ((R) > 0 ? ((R) + 0.5) : ((R) - 0.5))) + + +VIPS_CLIP_UCHAR +#define VIPS_CLIP_UCHAR( V, SEQ ) \ +G_STMT_START { \ + if( (V) < 0 ) { \ + (SEQ)->underflow++; \ + (V) = 0; \ + } \ + else if( (V) > UCHAR_MAX ) { \ + (SEQ)->overflow++; \ + (V) = UCHAR_MAX; \ + } \ +} G_STMT_END + + +VIPS_CLIP_CHAR +#define VIPS_CLIP_CHAR( V, SEQ ) \ +G_STMT_START { \ + if( (V) < SCHAR_MIN ) { \ + (SEQ)->underflow++; \ + (V) = SCHAR_MIN; \ + } \ + else if( (V) > SCHAR_MAX ) { \ + (SEQ)->overflow++; \ + (V) = SCHAR_MAX; \ + } \ +} G_STMT_END + + +VIPS_CLIP_USHORT +#define VIPS_CLIP_USHORT( V, SEQ ) \ +G_STMT_START { \ + if( (V) < 0 ) { \ + (SEQ)->underflow++; \ + (V) = 0; \ + } \ + else if( (V) > USHRT_MAX ) { \ + (SEQ)->overflow++; \ + (V) = USHRT_MAX; \ + } \ +} G_STMT_END + + +VIPS_CLIP_SHORT +#define VIPS_CLIP_SHORT( V, SEQ ) \ +G_STMT_START { \ + if( (V) < SHRT_MIN ) { \ + (SEQ)->underflow++; \ + (V) = SHRT_MIN; \ + } \ + else if( (V) > SHRT_MAX ) { \ + (SEQ)->overflow++; \ + (V) = SHRT_MAX; \ + } \ +} G_STMT_END + + +VIPS_CLIP_NONE +#define VIPS_CLIP_NONE( V, SEQ ) {} + + +VIPS_ENUM_STRING +#define VIPS_ENUM_STRING( ENUM, VALUE ) \ + (g_enum_get_value( g_type_class_ref( ENUM ), VALUE )->value_name) + + +VIPS_ENUM_NICK +#define VIPS_ENUM_NICK( ENUM, VALUE ) \ + (g_enum_get_value( g_type_class_ref( ENUM ), VALUE )->value_nick) + + +VipsSListMap2Fn +void * + void *, void *, void * + + +VipsSListMap4Fn +void * + void *, void *, void *, void *, void * + + +VipsSListFold2Fn +void * + void *, void *, void *, void * + + +vips_slist_equal +gboolean + GSList *l1, GSList *l2 + + +vips_slist_map2 +void * + GSList *list, VipsSListMap2Fn fn, void *a, void *b + + +vips_slist_map2_rev +void * + GSList *list, VipsSListMap2Fn fn, void *a, void *b + + +vips_slist_map4 +void * + GSList *list, VipsSListMap4Fn fn, void *a, void *b, void *c, void *d + + +vips_slist_fold2 +void * + GSList *list, void *start, VipsSListFold2Fn fn, void *a, void *b + + +vips_slist_filter +GSList * + GSList *list, VipsSListMap2Fn fn, void *a, void *b + + +vips_slist_free_all +void + GSList *list + + +vips_map_equal +void * + void *a, void *b + + +vips_hash_table_map +void * + GHashTable *hash, VipsSListMap2Fn fn, void *a, void *b + + +vips_strncpy +char * + char *dest, const char *src, int n + + +vips_strrstr +char * + const char *haystack, const char *needle + + +vips_ispostfix +gboolean + const char *a, const char *b + + +vips_isprefix +gboolean + const char *a, const char *b + + +vips_break_token +char * + char *str, const char *brk + + +vips_vsnprintf +int + char *str, size_t size, const char *format, va_list ap + + +vips_snprintf +int + char *str, size_t size, const char *format, ... + + +vips_filename_split +void + const char *path, char *name, char *mode + + +vips_skip_dir +const char * + const char *filename + + +vips_filename_suffix +void + const char *path, char *suffix + + +vips_filename_suffix_match +int + const char *path, const char *suffixes[] + + +vips_getnextoption +char * + char **in + + +vips_getsuboption +char * + const char *buf + + +vips_file_length +gint64 + int fd + + +vips__write +int + int fd, const void *buf, size_t count + + +vips__file_open_read +FILE * + const char *filename, const char *fallback_dir, gboolean text_mode + + +vips__file_open_write +FILE * + const char *filename, gboolean text_mode + + +vips__file_read +char * + FILE *fp, const char *name, unsigned int *length_out + + +vips__file_read_name +char * + const char *name, const char *fallback_dir, unsigned int *length_out + + +vips__file_write +int + void *data, size_t size, size_t nmemb, FILE *stream + + +vips__get_bytes +int + const char *filename, unsigned char buf[], int len + + +vips__gvalue_ref_string_new +GValue * + const char *text + + +vips__gslist_gvalue_free +void + GSList *list + + +vips__gslist_gvalue_copy +GSList * + const GSList *list + + +vips__gslist_gvalue_merge +GSList * + GSList *a, const GSList *b + + +vips__gslist_gvalue_get +char * + const GSList *list + + +vips__seek +int + int fd, gint64 pos + + +vips__ftruncate +int + int fd, gint64 pos + + +vips_existsf +int + const char *name, ... + + +vips_popenf +FILE * + const char *fmt, const char *mode, ... + + +VipsToken +typedef enum { + VIPS_TOKEN_LEFT = 1, + VIPS_TOKEN_RIGHT, + VIPS_TOKEN_STRING, + VIPS_TOKEN_EQUALS, + VIPS_TOKEN_COMMA +} VipsToken; + + +vips__token_get +const char * + const char *buffer, VipsToken *token, char *string, int size + + +vips__token_must +const char * + const char *buffer, VipsToken *token, char *string, int size + + +vips__token_need +const char * + const char *buffer, VipsToken need_token, char *string, int size + + +vips_ispoweroftwo +int + int p + + +vips_amiMSBfirst +int + void + + +vips__temp_name +char * + const char *format + + +vips__change_suffix +void + const char *name, char *out, int mx, const char *new_suff, const char **olds, int nolds + + +im_draw_rect +int + VipsImage *image, int left, int top, int width, int height, int fill, PEL *ink + + +im_draw_circle +int + VipsImage *image, int x, int y, int radius, gboolean fill, PEL *ink + + +im_draw_image +int + VipsImage *image, VipsImage *sub, int x, int y + + +VipsPlotFn +int + VipsImage *image, int x, int y, + void *a, void *b, void *c + + +im_draw_line_user +int + VipsImage *image, int x1, int y1, int x2, int y2, VipsPlotFn plot, void *a, void *b, void *c + + +im_draw_line +int + VipsImage *image, int x1, int y1, int x2, int y2, PEL *ink + + +im_lineset +int + VipsImage *in, VipsImage *out, VipsImage *mask, VipsImage *ink, int n, int *x1v, int *y1v, int *x2v, int *y2v + + +im_draw_flood +int + VipsImage *image, int x, int y, PEL *ink, VipsRect *dout + + +im_draw_flood_blob +int + VipsImage *image, int x, int y, PEL *ink, VipsRect *dout + + +im_draw_flood_other +int + VipsImage *image, VipsImage *test, int x, int y, int serial, VipsRect *dout + + +im_draw_mask +int + VipsImage *image, VipsImage *mask_im, int x, int y, PEL *ink + + +im_draw_point +int + VipsImage *image, int x, int y, PEL *ink + + +im_read_point +int + VipsImage *image, int x, int y, PEL *ink + + +im_draw_smudge +int + VipsImage *image, int left, int top, int width, int height + + +VIPS_VERSION +#define VIPS_VERSION "7.27.0" + + +VIPS_VERSION_STRING +#define VIPS_VERSION_STRING "7.27.0-Thu Nov 17 17:07:37 GMT 2011" + + +VIPS_MAJOR_VERSION +#define VIPS_MAJOR_VERSION (7) + + +VIPS_MINOR_VERSION +#define VIPS_MINOR_VERSION (27) + + +VIPS_MICRO_VERSION +#define VIPS_MICRO_VERSION (0) + + +VIPS_EXEEXT +#define VIPS_EXEEXT "" + + +VipsExtend +typedef enum { + VIPS_EXTEND_BLACK = 0, + VIPS_EXTEND_COPY = 1, + VIPS_EXTEND_REPEAT = 2, + VIPS_EXTEND_MIRROR = 3, + VIPS_EXTEND_WHITE = 4, + VIPS_EXTEND_LAST = 5 +} VipsExtend; + + +VipsDirection +typedef enum { + VIPS_DIRECTION_HORIZONTAL, + VIPS_DIRECTION_VERTICAL, + VIPS_DIRECTION_LAST +} VipsDirection; + + +VipsAlign +typedef enum { + VIPS_ALIGN_LOW, + VIPS_ALIGN_CENTRE, + VIPS_ALIGN_HIGH, + VIPS_ALIGN_LAST +} VipsAlign; + + +VipsAngle +typedef enum { + VIPS_ANGLE_0, + VIPS_ANGLE_90, + VIPS_ANGLE_180, + VIPS_ANGLE_270, + VIPS_ANGLE_LAST +} VipsAngle; + + +vips_copy +int + VipsImage *in, VipsImage **out, ... + + +vips_embed +int + VipsImage *in, VipsImage **out, int x, int y, int width, int height, ... + + +vips_flip +int + VipsImage *in, VipsImage **out, VipsDirection direction, ... + + +vips_insert +int + VipsImage *main, VipsImage *sub, VipsImage **out, int x, int y, ... + + +vips_join +int + VipsImage *main, VipsImage *sub, VipsImage **out, VipsDirection direction, ... + + +vips_extract_area +int + VipsImage *input, VipsImage **output, int left, int top, int width, int height, ... + + +vips_extract_band +int + VipsImage *input, VipsImage **output, int band, ... + + +vips_replicate +int + VipsImage *in, VipsImage **out, int across, int down, ... + + +vips_cast +int + VipsImage *in, VipsImage **out, VipsBandFormat format, ... + + +vips_bandjoin +int + VipsImage **in, VipsImage **out, int n, ... + + +vips_bandjoin2 +int + VipsImage *in1, VipsImage *in2, VipsImage **out, ... + + +vips_black +int + VipsImage **out, int width, int height, ... + + +vips_rot +int + VipsImage *in, VipsImage **out, VipsAngle angle, ... + + +vips_ifthenelse +int + VipsImage *cond, VipsImage *in1, VipsImage *in2, VipsImage **out, ... + + +im_copy_file +int + VipsImage *in, VipsImage *out + + +im_scale +int + VipsImage *in, VipsImage *out + + +im_msb +int + VipsImage *in, VipsImage *out + + +im_msb_band +int + VipsImage *in, VipsImage *out, int band + + +im_c2amph +int + VipsImage *in, VipsImage *out + + +im_c2rect +int + VipsImage *in, VipsImage *out + + +im_ri2c +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_c2imag +int + VipsImage *in, VipsImage *out + + +im_c2real +int + VipsImage *in, VipsImage *out + + +im_scaleps +int + VipsImage *in, VipsImage *out + + +im_falsecolour +int + VipsImage *in, VipsImage *out + + +im_gaussnoise +int + VipsImage *out, int x, int y, double mean, double sigma + + +im_text +int + VipsImage *out, const char *text, const char *font, int width, int alignment, int dpi + + +im_insertset +int + VipsImage *main, VipsImage *sub, VipsImage *out, int n, int *x, int *y + + +im_grid +int + VipsImage *in, VipsImage *out, int tile_height, int across, int down + + +im_wrap +int + VipsImage *in, VipsImage *out, int x, int y + + +im_subsample +int + VipsImage *in, VipsImage *out, int xshrink, int yshrink + + +im_zoom +int + VipsImage *in, VipsImage *out, int xfac, int yfac + + +im_system +int + VipsImage *im, const char *cmd, char **out + + +im_system_image +VipsImage * + VipsImage *im, const char *in_format, const char *out_format, const char *cmd_format, char **log + + +im_affinei +int + VipsImage *in, VipsImage *out, VipsInterpolate *interpolate, double a, double b, double c, double d, double dx, double dy, int ox, int oy, int ow, int oh + + +im_affinei_all +int + VipsImage *in, VipsImage *out, VipsInterpolate *interpolate, double a, double b, double c, double d, double dx, double dy + + +im_shrink +int + VipsImage *in, VipsImage *out, double xshrink, double yshrink + + +im_rightshift_size +int + VipsImage *in, VipsImage *out, int xshift, int yshift, int band_fmt + + +im_match_linear +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2 + + +im_match_linear_search +int + VipsImage *ref, VipsImage *sec, VipsImage *out, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int hwindowsize, int hsearchsize + + +IM_TYPE_IMAGEVEC +#define IM_TYPE_IMAGEVEC "imagevec" /* im_object is ptr to IMAGE[] */ + + +IM_TYPE_DOUBLEVEC +#define IM_TYPE_DOUBLEVEC "doublevec" /* im_object is ptr to double[] */ + + +IM_TYPE_INTVEC +#define IM_TYPE_INTVEC "intvec" /* im_object is ptr to int[] */ + + +IM_TYPE_DOUBLE +#define IM_TYPE_DOUBLE "double" /* im_object is ptr to double */ + + +IM_TYPE_INT +#define IM_TYPE_INT "integer" /* 32-bit integer */ + + +IM_TYPE_COMPLEX +#define IM_TYPE_COMPLEX "complex" /* Pair of doubles */ + + +IM_TYPE_STRING +#define IM_TYPE_STRING "string" /* Zero-terminated char array */ + + +IM_TYPE_IMASK +#define IM_TYPE_IMASK "intmask" /* Integer mask type */ + + +IM_TYPE_DMASK +#define IM_TYPE_DMASK "doublemask" /* Double mask type */ + + +IM_TYPE_IMAGE +#define IM_TYPE_IMAGE "image" /* IMAGE descriptor */ + + +IM_TYPE_DISPLAY +#define IM_TYPE_DISPLAY "display" /* Display descriptor */ + + +IM_TYPE_GVALUE +#define IM_TYPE_GVALUE "gvalue" /* GValue wrapper */ + + +IM_TYPE_INTERPOLATE +#define IM_TYPE_INTERPOLATE "interpolate"/* A subclass of VipsInterpolate */ + + +im_arg_type +typedef char *im_arg_type; /* Type of argument id */ + + +im_object +typedef void *im_object; + + +im_type_flags +typedef enum { + IM_TYPE_NONE = 0, /* No flags */ + IM_TYPE_OUTPUT = 0x1, /* Output/input object */ + IM_TYPE_ARG = 0x2, /* Uses a str arg in construction */ + IM_TYPE_RW = 0x4 /* Read-write */ +} im_type_flags; + + +im_init_obj_fn +int + im_object *obj, char *str + + +im_dest_obj_fn +int + im_object obj + + +im_type_desc +typedef struct { + im_arg_type type; /* Type of argument */ + int size; /* sizeof( im_object repres. ) */ + im_type_flags flags; /* Flags */ + im_init_obj_fn init; /* Operation functions */ + im_dest_obj_fn dest; /* Destroy object */ +} im_type_desc; + + +im_print_obj_fn +int + im_object obj + + +im_arg_desc +typedef struct { + char *name; /* eg. "width" */ + im_type_desc *desc; /* Type description */ + im_print_obj_fn print; /* Print some output objects */ +} im_arg_desc; + + +im_dispatch_fn +int + im_object *argv + + +IM_MAX_ARGS +#define IM_MAX_ARGS (1000) + + +im_fn_flags +typedef enum { + IM_FN_NONE = 0, /* No flags set */ + IM_FN_PIO = 0x1, /* Is a partial function */ + IM_FN_TRANSFORM = 0x2, /* Performs coordinate transformations */ + IM_FN_PTOP = 0x4, /* Point-to-point ... can be done with a LUT */ + IM_FN_NOCACHE = 0x8 /* Result should not be cached */ +} im_fn_flags; + + +im_function +typedef struct { + char *name; /* eg "im_invert" */ + char *desc; /* Description - eg "photographic negative" */ + im_fn_flags flags; /* Flags for this function */ + im_dispatch_fn disp; /* Dispatch */ + int argc; /* Number of args */ + im_arg_desc *argv; /* Arg table */ +} im_function; + + +im_package +typedef struct { + char *name; /* Package name (eg "arithmetic") */ + int nfuncs; /* Number of functions in package */ + im_function **table; /* Array of function descriptors */ +} im_package; + + +im_mask_object +typedef struct { + char *name; /* Command-line name in */ + void *mask; /* Mask --- DOUBLE or INT */ +} im_mask_object; + + +im_doublevec_object +typedef struct { + int n; /* Vector length */ + double *vec; /* Vector */ +} im_doublevec_object; + + +im_intvec_object +typedef struct { + int n; /* Vector length */ + int *vec; /* Vector */ +} im_intvec_object; + + +im_imagevec_object +typedef struct { + int n; /* Vector length */ + IMAGE **vec; /* Vector */ +} im_imagevec_object; + + +im__input_int +extern im_type_desc im__input_int; + + +im__input_intvec +extern im_type_desc im__input_intvec; + + +im__input_imask +extern im_type_desc im__input_imask; + + +im__output_int +extern im_type_desc im__output_int; + + +im__output_intvec +extern im_type_desc im__output_intvec; + + +im__output_imask +extern im_type_desc im__output_imask; + + +im__input_double +extern im_type_desc im__input_double; + + +im__input_doublevec +extern im_type_desc im__input_doublevec; + + +im__input_dmask +extern im_type_desc im__input_dmask; + + +im__output_double +extern im_type_desc im__output_double; + + +im__output_doublevec +extern im_type_desc im__output_doublevec; + + +im__output_dmask +extern im_type_desc im__output_dmask; + + +im__output_dmask_screen +extern im_type_desc im__output_dmask_screen; + + +im__output_complex +extern im_type_desc im__output_complex; + + +im__input_string +extern im_type_desc im__input_string; + + +im__output_string +extern im_type_desc im__output_string; + + +im__input_imagevec +extern im_type_desc im__input_imagevec; + + +im__input_image +extern im_type_desc im__input_image; + + +im__output_image +extern im_type_desc im__output_image; + + +im__rw_image +extern im_type_desc im__rw_image; + + +im__input_display +extern im_type_desc im__input_display; + + +im__output_display +extern im_type_desc im__output_display; + + +im__input_gvalue +extern im_type_desc im__input_gvalue; + + +im__output_gvalue +extern im_type_desc im__output_gvalue; + + +im__input_interpolate +extern im_type_desc im__input_interpolate; + + +im__iprint +int + im_object obj + + +im__ivprint +int + im_object obj + + +im__dprint +int + im_object obj + + +im__dvprint +int + im_object obj + + +im__dmsprint +int + im_object obj + + +im__cprint +int + im_object obj + + +im__sprint +int + im_object obj + + +im__displayprint +int + im_object obj + + +im__gprint +int + im_object obj + + +IM_INPUT_INT +#define IM_INPUT_INT( S ) { S, &im__input_int, NULL } + + +IM_INPUT_INTVEC +#define IM_INPUT_INTVEC( S ) { S, &im__input_intvec, NULL } + + +IM_INPUT_IMASK +#define IM_INPUT_IMASK( S ) { S, &im__input_imask, NULL } + + +IM_OUTPUT_INT +#define IM_OUTPUT_INT( S ) { S, &im__output_int, im__iprint } + + +IM_OUTPUT_INTVEC +#define IM_OUTPUT_INTVEC( S ) { S, &im__output_intvec, im__ivprint } + + +IM_OUTPUT_IMASK +#define IM_OUTPUT_IMASK( S ) { S, &im__output_imask, NULL } + + +IM_INPUT_DOUBLE +#define IM_INPUT_DOUBLE( S ) { S, &im__input_double, NULL } + + +IM_INPUT_DOUBLEVEC +#define IM_INPUT_DOUBLEVEC( S ) { S, &im__input_doublevec, NULL } + + +IM_INPUT_DMASK +#define IM_INPUT_DMASK( S ) { S, &im__input_dmask, NULL } + + +IM_OUTPUT_DOUBLE +#define IM_OUTPUT_DOUBLE( S ) { S, &im__output_double, im__dprint } + + +IM_OUTPUT_DOUBLEVEC +#define IM_OUTPUT_DOUBLEVEC( S ) { S, &im__output_doublevec, im__dvprint } + + +IM_OUTPUT_DMASK +#define IM_OUTPUT_DMASK( S ) { S, &im__output_dmask, NULL } + + +IM_OUTPUT_DMASK_STATS +#define IM_OUTPUT_DMASK_STATS( S ) { S, &im__output_dmask_screen, im__dmsprint } + + +IM_OUTPUT_COMPLEX +#define IM_OUTPUT_COMPLEX( S ) { S, &im__output_complex, im__cprint } + + +IM_INPUT_STRING +#define IM_INPUT_STRING( S ) { S, &im__input_string, NULL } + + +IM_OUTPUT_STRING +#define IM_OUTPUT_STRING( S ) { S, &im__output_string, im__sprint } + + +IM_INPUT_IMAGE +#define IM_INPUT_IMAGE( S ) { S, &im__input_image, NULL } + + +IM_INPUT_IMAGEVEC +#define IM_INPUT_IMAGEVEC( S ) { S, &im__input_imagevec, NULL } + + +IM_OUTPUT_IMAGE +#define IM_OUTPUT_IMAGE( S ) { S, &im__output_image, NULL } + + +IM_RW_IMAGE +#define IM_RW_IMAGE( S ) { S, &im__rw_image, NULL } + + +IM_INPUT_DISPLAY +#define IM_INPUT_DISPLAY( S ) { S, &im__input_display, NULL } + + +IM_OUTPUT_DISPLAY +#define IM_OUTPUT_DISPLAY( S ) { S, &im__output_display, im__displayprint } + + +IM_INPUT_GVALUE +#define IM_INPUT_GVALUE( S ) { S, &im__input_gvalue, NULL } + + +IM_OUTPUT_GVALUE +#define IM_OUTPUT_GVALUE( S ) { S, &im__output_gvalue, im__gprint } + + +IM_INPUT_INTERPOLATE +#define IM_INPUT_INTERPOLATE( S ) { S, &im__input_interpolate, NULL } + + +im_load_plugin +im_package * + const char *name + + +im_load_plugins +int + const char *fmt, ... + + +im_close_plugins +int + void + + +im_map_packages +void * + VipsSListMap2Fn fn, void *a + + +im_find_function +im_function * + const char *name + + +im_find_package +im_package * + const char *name + + +im_package_of_function +im_package * + const char *name + + +im_free_vargv +int + im_function *fn, im_object *vargv + + +im_allocate_vargv +int + im_function *fn, im_object *vargv + + +im_run_command +int + char *name, int argc, char **argv + + +VipsRect +typedef struct _VipsRect { + /*< public >*/ + int left; + int top; + int width; + int height; +} VipsRect; + + +VIPS_RECT_RIGHT +#define VIPS_RECT_RIGHT(R) ((R)->left + (R)->width) + + +VIPS_RECT_BOTTOM +#define VIPS_RECT_BOTTOM(R) ((R)->top + (R)->height) + + +VIPS_RECT_HCENTRE +#define VIPS_RECT_HCENTRE(R) ((R)->left + (R)->width / 2) + + +VIPS_RECT_VCENTRE +#define VIPS_RECT_VCENTRE(R) ((R)->top + (R)->height / 2) + + +vips_rect_isempty +gboolean + const VipsRect *r + + +vips_rect_includespoint +gboolean + const VipsRect *r, int x, int y + + +vips_rect_includesrect +gboolean + const VipsRect *r1, const VipsRect *r2 + + +vips_rect_equalsrect +gboolean + const VipsRect *r1, const VipsRect *r2 + + +vips_rect_marginadjust +void + VipsRect *r, int n + + +vips_rect_intersectrect +void + const VipsRect *r1, const VipsRect *r2, VipsRect *out + + +vips_rect_unionrect +void + const VipsRect *r1, const VipsRect *r2, VipsRect *out + + +vips_rect_dup +VipsRect * + const VipsRect *r + + +vips_rect_normalise +void + VipsRect *r + + +VipsSemaphore +typedef struct { + char *name; + int v; + + GMutex *mutex; + GCond *cond; +} VipsSemaphore; + + +vips_semaphore_up +int + VipsSemaphore *s + + +vips_semaphore_down +int + VipsSemaphore *s + + +vips_semaphore_upn +int + VipsSemaphore *s, int n + + +vips_semaphore_downn +int + VipsSemaphore *s, int n + + +vips_semaphore_destroy +void + VipsSemaphore *s + + +vips_semaphore_init +void + VipsSemaphore *s, int v, char *name + + +IM_D93_X0 +#define IM_D93_X0 (89.7400) + + +IM_D93_Y0 +#define IM_D93_Y0 (100.0) + + +IM_D93_Z0 +#define IM_D93_Z0 (130.7700) + + +IM_D75_X0 +#define IM_D75_X0 (94.9682) + + +IM_D75_Y0 +#define IM_D75_Y0 (100.0) + + +IM_D75_Z0 +#define IM_D75_Z0 (122.5710) + + +IM_D65_X0 +#define IM_D65_X0 (95.0470) + + +IM_D65_Y0 +#define IM_D65_Y0 (100.0) + + +IM_D65_Z0 +#define IM_D65_Z0 (108.8827) + + +IM_D55_X0 +#define IM_D55_X0 (95.6831) + + +IM_D55_Y0 +#define IM_D55_Y0 (100.0) + + +IM_D55_Z0 +#define IM_D55_Z0 (92.0871) + + +IM_D50_X0 +#define IM_D50_X0 (96.4250) + + +IM_D50_Y0 +#define IM_D50_Y0 (100.0) + + +IM_D50_Z0 +#define IM_D50_Z0 (82.4680) + + +IM_A_X0 +#define IM_A_X0 (109.8503) + + +IM_A_Y0 +#define IM_A_Y0 (100.0) + + +IM_A_Z0 +#define IM_A_Z0 (35.5849) + + +IM_B_X0 +#define IM_B_X0 (99.0720) + + +IM_B_Y0 +#define IM_B_Y0 (100.0) + + +IM_B_Z0 +#define IM_B_Z0 (85.2230) + + +IM_C_X0 +#define IM_C_X0 (98.0700) + + +IM_C_Y0 +#define IM_C_Y0 (100.0) + + +IM_C_Z0 +#define IM_C_Z0 (118.2300) + + +IM_E_X0 +#define IM_E_X0 (100.0) + + +IM_E_Y0 +#define IM_E_Y0 (100.0) + + +IM_E_Z0 +#define IM_E_Z0 (100.0) + + +IM_D3250_X0 +#define IM_D3250_X0 (105.6590) + + +IM_D3250_Y0 +#define IM_D3250_Y0 (100.0) + + +IM_D3250_Z0 +#define IM_D3250_Z0 (45.8501) + + +im_col_ab2Ch +void + float a, float b, float *C, float *h + + +im_col_Ch2ab +void + float C, float h, float *a, float *b + + +im_col_XYZ2Lab +void + float X, float Y, float Z, float *L, float *a, float *b + + +im_col_Lab2XYZ +void + float L, float a, float b, float *X, float *Y, float *Z + + +im_col_pythagoras +float + float L1, float a1, float b1, float L2, float a2, float b2 + + +im_col_make_tables_UCS +void + void + + +im_col_L2Lucs +float + float L + + +im_col_Lucs2L +float + float Lucs + + +im_col_C2Cucs +float + float C + + +im_col_Cucs2C +float + float Cucs + + +im_col_Ch2hucs +float + float C, float h + + +im_col_Chucs2h +float + float C, float hucs + + +im_col_ab2h +double + double a, double b + + +im_col_dECMC +float + float L1, float a1, float b1, float L2, float a2, float b2 + + +im_col_dE00 +float + float L1, float a1, float b1, float L2, float a2, float b2 + + +im_LCh2Lab +int + VipsImage *in, VipsImage *out + + +im_LabQ2XYZ +int + VipsImage *in, VipsImage *out + + +im_rad2float +int + VipsImage *in, VipsImage *out + + +im_float2rad +int + VipsImage *in, VipsImage *out + + +im_LCh2UCS +int + VipsImage *in, VipsImage *out + + +im_Lab2LCh +int + VipsImage *in, VipsImage *out + + +im_Lab2LabQ +int + VipsImage *in, VipsImage *out + + +im_Lab2LabS +int + VipsImage *in, VipsImage *out + + +im_Lab2XYZ +int + VipsImage *in, VipsImage *out + + +im_Lab2XYZ_temp +int + VipsImage *in, VipsImage *out, double X0, double Y0, double Z0 + + +im_Lab2UCS +int + VipsImage *in, VipsImage *out + + +im_LabQ2Lab +int + VipsImage *in, VipsImage *out + + +im_LabQ2LabS +int + VipsImage *in, VipsImage *out + + +im_LabS2LabQ +int + VipsImage *in, VipsImage *out + + +im_LabS2Lab +int + VipsImage *in, VipsImage *out + + +im_UCS2XYZ +int + VipsImage *in, VipsImage *out + + +im_UCS2LCh +int + VipsImage *in, VipsImage *out + + +im_UCS2Lab +int + VipsImage *in, VipsImage *out + + +im_XYZ2Lab +int + VipsImage *in, VipsImage *out + + +im_XYZ2Lab_temp +int + VipsImage *in, VipsImage *out, double X0, double Y0, double Z0 + + +im_XYZ2UCS +int + VipsImage *in, VipsImage *out + + +im_sRGB2XYZ +int + VipsImage *in, VipsImage *out + + +im_XYZ2sRGB +int + VipsImage *in, VipsImage *out + + +im_Yxy2XYZ +int + VipsImage *in, VipsImage *out + + +im_XYZ2Yxy +int + VipsImage *in, VipsImage *out + + +im_dECMC_fromLab +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_dE00_fromLab +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_dE_fromXYZ +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_dE_fromLab +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_lab_morph +int + VipsImage *in, VipsImage *out, DOUBLEMASK *mask, double L_offset, double L_scale, double a_scale, double b_scale + + +VipsIntent +typedef enum { + IM_INTENT_PERCEPTUAL = 0, + IM_INTENT_RELATIVE_COLORIMETRIC, + IM_INTENT_SATURATION, + IM_INTENT_ABSOLUTE_COLORIMETRIC +} VipsIntent; + + +im_icc_present +int + void + + +im_icc_transform +int + VipsImage *in, VipsImage *out, const char *input_profile_filename, const char *output_profile_filename, VipsIntent intent + + +im_icc_import +int + VipsImage *in, VipsImage *out, const char *input_profile_filename, VipsIntent intent + + +im_icc_import_embedded +int + VipsImage *in, VipsImage *out, VipsIntent intent + + +im_icc_export_depth +int + VipsImage *in, VipsImage *out, int depth, const char *output_profile_filename, VipsIntent intent + + +im_icc_ac2rc +int + VipsImage *in, VipsImage *out, const char *profile_filename + + +vips_operation_math_get_type +GType +void + + +VIPS_TYPE_OPERATION_MATH +#define VIPS_TYPE_OPERATION_MATH (vips_operation_math_get_type()) + + +vips_operation_math2_get_type +GType +void + + +VIPS_TYPE_OPERATION_MATH2 +#define VIPS_TYPE_OPERATION_MATH2 (vips_operation_math2_get_type()) + + +vips_operation_round_get_type +GType +void + + +VIPS_TYPE_OPERATION_ROUND +#define VIPS_TYPE_OPERATION_ROUND (vips_operation_round_get_type()) + + +vips_operation_relational_get_type +GType +void + + +VIPS_TYPE_OPERATION_RELATIONAL +#define VIPS_TYPE_OPERATION_RELATIONAL (vips_operation_relational_get_type()) + + +vips_operation_boolean_get_type +GType +void + + +VIPS_TYPE_OPERATION_BOOLEAN +#define VIPS_TYPE_OPERATION_BOOLEAN (vips_operation_boolean_get_type()) + + +vips_extend_get_type +GType +void + + +VIPS_TYPE_EXTEND +#define VIPS_TYPE_EXTEND (vips_extend_get_type()) + + +vips_direction_get_type +GType +void + + +VIPS_TYPE_DIRECTION +#define VIPS_TYPE_DIRECTION (vips_direction_get_type()) + + +vips_align_get_type +GType +void + + +VIPS_TYPE_ALIGN +#define VIPS_TYPE_ALIGN (vips_align_get_type()) + + +vips_angle_get_type +GType +void + + +VIPS_TYPE_ANGLE +#define VIPS_TYPE_ANGLE (vips_angle_get_type()) + + +vips_token_get_type +GType +void + + +VIPS_TYPE_TOKEN +#define VIPS_TYPE_TOKEN (vips_token_get_type()) + + +vips_demand_style_get_type +GType +void + + +VIPS_TYPE_DEMAND_STYLE +#define VIPS_TYPE_DEMAND_STYLE (vips_demand_style_get_type()) + + +vips_image_type_get_type +GType +void + + +VIPS_TYPE_IMAGE_TYPE +#define VIPS_TYPE_IMAGE_TYPE (vips_image_type_get_type()) + + +vips_interpretation_get_type +GType +void + + +VIPS_TYPE_INTERPRETATION +#define VIPS_TYPE_INTERPRETATION (vips_interpretation_get_type()) + + +vips_band_format_get_type +GType +void + + +VIPS_TYPE_BAND_FORMAT +#define VIPS_TYPE_BAND_FORMAT (vips_band_format_get_type()) + + +vips_coding_get_type +GType +void + + +VIPS_TYPE_CODING +#define VIPS_TYPE_CODING (vips_coding_get_type()) + + +vips_argument_flags_get_type +GType +void + + +VIPS_TYPE_ARGUMENT_FLAGS +#define VIPS_TYPE_ARGUMENT_FLAGS (vips_argument_flags_get_type()) + + +VIPS_TYPE_REGION +#define VIPS_TYPE_REGION (vips_region_get_type()) + + +VIPS_REGION +#define VIPS_REGION( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_REGION, VipsRegion )) + + +VIPS_REGION_CLASS +#define VIPS_REGION_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_REGION, VipsRegionClass)) + + +VIPS_IS_REGION +#define VIPS_IS_REGION( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_REGION )) + + +VIPS_IS_REGION_CLASS +#define VIPS_IS_REGION_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_REGION )) + + +VIPS_REGION_GET_CLASS +#define VIPS_REGION_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_REGION, VipsRegionClass )) + + +VipsRegion +typedef struct _VipsRegion { + VipsObject parent_object; + + /*< public >*/ + /* Users may read these two fields. + */ + VipsImage *im; /* Link back to parent image */ + VipsRect valid; /* Area of parent we can see */ + + /* The rest of VipsRegion is private. + */ + /*< private >*/ + RegionType type; /* What kind of attachment */ + char *data; /* Off here to get data */ + int bpl; /* Bytes-per-line for data */ + void *seq; /* Sequence we are using to fill region */ + + /* The thread that made this region. Used to assert() test that + * regions are not being shared between threads. + */ + GThread *thread; + + /* Ref to the window we use for this region, if any. + */ + VipsWindow *window; + + /* Ref to the buffer we use for this region, if any. + */ + VipsBuffer *buffer; + + /* The image this region is on has changed and caches need to be + * dropped. + */ + gboolean invalid; +} VipsRegion; + + +VipsRegionClass +typedef struct _VipsRegionClass { + VipsObjectClass parent_class; + +} VipsRegionClass; + + +vips_region_get_type +GType + void + + +vips_region_new +VipsRegion * + VipsImage *im + + +vips_region_buffer +int + VipsRegion *reg, VipsRect *r + + +vips_region_image +int + VipsRegion *reg, VipsRect *r + + +vips_region_region +int + VipsRegion *reg, VipsRegion *dest, VipsRect *r, int x, int y + + +vips_region_equalsregion +int + VipsRegion *reg1, VipsRegion *reg2 + + +vips_region_position +int + VipsRegion *reg, int x, int y + + +vips_region_paint +void + VipsRegion *reg, VipsRect *r, int value + + +vips_region_paint_pel +void + VipsRegion *reg, VipsRect *r, PEL *ink + + +vips_region_black +void + VipsRegion *reg + + +vips_region_copy +void + VipsRegion *reg, VipsRegion *dest, VipsRect *r, int x, int y + + +vips_region_prepare +int + VipsRegion *reg, VipsRect *r + + +vips_region_prepare_to +int + VipsRegion *reg, VipsRegion *dest, VipsRect *r, int x, int y + + +vips_region_prepare_many +int + VipsRegion **reg, VipsRect *r + + +VIPS_REGION_LSKIP +#define VIPS_REGION_LSKIP( R ) \ + ((size_t)((R)->bpl)) + + +VIPS_REGION_N_ELEMENTS +#define VIPS_REGION_N_ELEMENTS( R ) \ + ((size_t)((R)->valid.width * (R)->im->Bands)) + + +VIPS_REGION_SIZEOF_LINE +#define VIPS_REGION_SIZEOF_LINE( R ) \ + ((size_t)((R)->valid.width * VIPS_IMAGE_SIZEOF_PEL( (R)->im) )) + + +VIPS_REGION_ADDR +#define VIPS_REGION_ADDR( R, X, Y ) \ + ( (vips_rect_includespoint( &(R)->valid, (X), (Y) ))? \ + ((R)->data + ((Y) - (R)->valid.top) * VIPS_REGION_LSKIP(R) + \ + ((X) - (R)->valid.left) * VIPS_IMAGE_SIZEOF_PEL((R)->im)): \ + (fprintf( stderr, \ + "VIPS_REGION_ADDR: point out of bounds, " \ + "file \"%s\", line %d\n" \ + "(point x=%d, y=%d\n" \ + " should have been within VipsRect left=%d, top=%d, " \ + "width=%d, height=%d)\n", \ + __FILE__, __LINE__, \ + (X), (Y), \ + (R)->valid.left, \ + (R)->valid.top, \ + (R)->valid.width, \ + (R)->valid.height ), abort(), (char *) NULL) \ + ) + + +VIPS_REGION_ADDR_TOPLEFT +#define VIPS_REGION_ADDR_TOPLEFT( R ) ((R)->data) + + +im_dilate +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_erode +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_rank +int + VipsImage *in, VipsImage *out, int width, int height, int index + + +im_rank_image +int + VipsImage **in, VipsImage *out, int n, int index + + +im_maxvalue +int + VipsImage **in, VipsImage *out, int n + + +im_cntlines +int + VipsImage *im, double *nolines, int flag + + +im_zerox +int + VipsImage *in, VipsImage *out, int sign + + +im_profile +int + VipsImage *in, VipsImage *out, int dir + + +im_label_regions +int + VipsImage *test, VipsImage *mask, int *segments + + +VIPS_TYPE_FORMAT +#define VIPS_TYPE_FORMAT (vips_format_get_type()) + + +VIPS_FORMAT +#define VIPS_FORMAT( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_FORMAT, VipsFormat )) + + +VIPS_FORMAT_CLASS +#define VIPS_FORMAT_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_FORMAT, VipsFormatClass)) + + +VIPS_IS_FORMAT +#define VIPS_IS_FORMAT( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_FORMAT )) + + +VIPS_IS_FORMAT_CLASS +#define VIPS_IS_FORMAT_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_FORMAT )) + + +VIPS_FORMAT_GET_CLASS +#define VIPS_FORMAT_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_FORMAT, VipsFormatClass )) + + +VipsFormatFlags +typedef enum { + VIPS_FORMAT_NONE = 0, /* No flags set */ + VIPS_FORMAT_PARTIAL = 1, /* Lazy read OK (eg. tiled tiff) */ + VIPS_FORMAT_BIGENDIAN = 2 /* Most-significant byte first */ +} VipsFormatFlags; + + +VipsFormat +typedef struct _VipsFormat { + VipsObject parent_object; + /*< public >*/ + +} VipsFormat; + + +VipsFormatClass +typedef struct _VipsFormatClass { + VipsObjectClass parent_class; + + /*< public >*/ + /* Is a file in this format. + */ + gboolean (*is_a)( const char * ); + + /* Read just the header into the VipsImage. + */ + int (*header)( const char *, VipsImage * ); + + /* Load the whole image. + */ + int (*load)( const char *, VipsImage * ); + + /* Write the VipsImage to the file in this format. + */ + int (*save)( VipsImage *, const char * ); + + /* Get the flags for this file in this format. + */ + VipsFormatFlags (*get_flags)( const char * ); + + /* Loop over formats in this order, default 0. We need this because + * some formats can be read by several loaders (eg. tiff can be read + * by the libMagick loader as well as by the tiff loader), and we want + * to make sure the better loader comes first. + */ + int priority; + + /* Null-terminated list of allowed suffixes, eg. ".tif", ".tiff". + */ + const char **suffs; +} VipsFormatClass; + + +vips_format_get_type +GType + void + + +vips_format_map +void * + VipsSListMap2Fn fn, void *a, void *b + + +vips_format_for_file +VipsFormatClass * + const char *filename + + +vips_format_for_name +VipsFormatClass * + const char *filename + + +vips_format_get_flags +VipsFormatFlags + VipsFormatClass *format, const char *filename + + +vips_format_read +int + const char *filename, VipsImage *out + + +vips_format_write +int + VipsImage *in, const char *filename + + +im_jpeg2vips +int + const char *filename, VipsImage *out + + +im_bufjpeg2vips +int + void *buf, size_t len, VipsImage *out, gboolean header_only + + +im_vips2jpeg +int + VipsImage *in, const char *filename + + +im_vips2mimejpeg +int + VipsImage *in, int qfac + + +im_vips2bufjpeg +int + VipsImage *in, VipsImage *out, int qfac, char **obuf, int *olen + + +im_tiff2vips +int + const char *filename, VipsImage *out + + +im_vips2tiff +int + VipsImage *in, const char *filename + + +im_tile_cache +int + VipsImage *in, VipsImage *out, int tile_width, int tile_height, int max_tiles + + +im_magick2vips +int + const char *filename, VipsImage *out + + +im_exr2vips +int + const char *filename, VipsImage *out + + +im_ppm2vips +int + const char *filename, VipsImage *out + + +im_vips2ppm +int + VipsImage *in, const char *filename + + +im_analyze2vips +int + const char *filename, VipsImage *out + + +im_csv2vips +int + const char *filename, VipsImage *out + + +im_vips2csv +int + VipsImage *in, const char *filename + + +im_png2vips +int + const char *filename, VipsImage *out + + +im_vips2png +int + VipsImage *in, const char *filename + + +im_vips2bufpng +int + VipsImage *in, VipsImage *out, int compression, int interlace, char **obuf, size_t *olen + + +im_raw2vips +int + const char *filename, VipsImage *out, int width, int height, int bpp, int offset + + +im_vips2raw +int + VipsImage *in, int fd + + +im_mat2vips +int + const char *filename, VipsImage *out + + +im_rad2vips +int + const char *filename, VipsImage *out + + +im_vips2rad +int + VipsImage *in, const char *filename + + +im_fits2vips +int + const char *filename, VipsImage *out + + +im_vips2fits +int + VipsImage *in, const char *filename + + +VIPS_TYPE_INTERPOLATE +#define VIPS_TYPE_INTERPOLATE (vips_interpolate_get_type()) + + +VIPS_INTERPOLATE +#define VIPS_INTERPOLATE( obj ) \ + (G_TYPE_CHECK_INSTANCE_CAST( (obj), \ + VIPS_TYPE_INTERPOLATE, VipsInterpolate )) + + +VIPS_INTERPOLATE_CLASS +#define VIPS_INTERPOLATE_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_CAST( (klass), \ + VIPS_TYPE_INTERPOLATE, VipsInterpolateClass)) + + +VIPS_IS_INTERPOLATE +#define VIPS_IS_INTERPOLATE( obj ) \ + (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_INTERPOLATE )) + + +VIPS_IS_INTERPOLATE_CLASS +#define VIPS_IS_INTERPOLATE_CLASS( klass ) \ + (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_INTERPOLATE )) + + +VIPS_INTERPOLATE_GET_CLASS +#define VIPS_INTERPOLATE_GET_CLASS( obj ) \ + (G_TYPE_INSTANCE_GET_CLASS( (obj), \ + VIPS_TYPE_INTERPOLATE, VipsInterpolateClass )) + + +VipsInterpolate +typedef struct _VipsInterpolate { + VipsObject parent_object; + +} VipsInterpolate; + + +VipsInterpolateMethod +void + VipsInterpolate *interpolate, + PEL *out, VipsRegion *in, double x, double y + + +VipsInterpolateClass +typedef struct _VipsInterpolateClass { + VipsObjectClass parent_class; + + /* Write to pixel out(x,y), interpolating from in(x,y). The caller has + * to set the regions up. + */ + VipsInterpolateMethod interpolate; + + /* This interpolator needs a window this many pixels across and down. + */ + int (*get_window_size)( VipsInterpolate * ); + + /* Or just set this if you want a constant. + */ + int window_size; + + /* Stencils are offset by this much. Default to window_size / 2 - 1 + * (centering) if get_window_offset is NULL and window_offset is -1. + */ + int (*get_window_offset)( VipsInterpolate * ); + int window_offset; +} VipsInterpolateClass; + + +vips_interpolate_get_type +GType + void + + +vips_interpolate +void + VipsInterpolate *interpolate, PEL *out, VipsRegion *in, double x, double y + + +vips_interpolate_get_method +VipsInterpolateMethod + VipsInterpolate *interpolate + + +vips_interpolate_get_window_size +int + VipsInterpolate *interpolate + + +vips_interpolate_get_window_offset +int + VipsInterpolate *interpolate + + +VIPS_TRANSFORM_SHIFT +#define VIPS_TRANSFORM_SHIFT (6) + + +VIPS_TRANSFORM_SCALE +#define VIPS_TRANSFORM_SCALE (1 << VIPS_TRANSFORM_SHIFT) + + +VIPS_INTERPOLATE_SHIFT +#define VIPS_INTERPOLATE_SHIFT (12) + + +VIPS_INTERPOLATE_SCALE +#define VIPS_INTERPOLATE_SCALE (1 << VIPS_INTERPOLATE_SHIFT) + + +vips_interpolate_nearest_static +VipsInterpolate * + void + + +vips_interpolate_bilinear_static +VipsInterpolate * + void + + +vips_interpolate_new +VipsInterpolate * + const char *nickname + + +VIPS_FREEF +#define VIPS_FREEF( F, S ) \ +G_STMT_START { \ + if( S ) { \ + (void) F( (S) ); \ + (S) = 0; \ + } \ +} G_STMT_END + + +VIPS_FREE +#define VIPS_FREE( S ) VIPS_FREEF( g_free, (S) ); + + +VIPS_SETSTR +#define VIPS_SETSTR( S, V ) \ +G_STMT_START { \ + const char *sst = (V); \ + \ + if( (S) != sst ) { \ + if( !(S) || !sst || strcmp( (S), sst ) != 0 ) { \ + VIPS_FREE( S ); \ + if( sst ) \ + (S) = g_strdup( sst ); \ + } \ + } \ +} G_STMT_END + + +VIPS_NEW +#define VIPS_NEW( OBJ, T ) \ + ((T *) vips_malloc( VIPS_OBJECT( OBJ ), sizeof( T ))) + + +VIPS_ARRAY +#define VIPS_ARRAY( OBJ, N, T ) \ + ((T *) vips_malloc( VIPS_OBJECT( OBJ ), (N) * sizeof( T ))) + + +vips_malloc +void * + VipsObject *object, size_t size + + +vips_strdup +char * + VipsObject *object, const char *str + + +vips_free +int + void *buf + + +vips_tracked_free +void + void *s + + +vips_tracked_malloc +void * + size_t size + + +vips_tracked_get_mem +size_t + void + + +vips_tracked_get_mem_highwater +size_t + void + + +vips_tracked_get_allocs +int + void + + +vips_tracked_open +int + const char *pathname, int flags, ... + + +vips_tracked_close +int + int fd + + +vips_tracked_get_files +int + void + + +Transformation +typedef struct { + /* Area of input we can use. This can be smaller than the real input + * image: we expand the input to add extra pixels for interpolation. + */ + VipsRect iarea; + + /* The area of the output we've been asked to generate. left/top can + * be negative. + */ + VipsRect oarea; + + /* The transform. + */ + double a, b, c, d; + double dx, dy; + + double ia, ib, ic, id; /* Inverse of matrix abcd */ +} Transformation; + + +im__transform_init +void + Transformation *trn + + +im__transform_calc_inverse +int + Transformation *trn + + +im__transform_isidentity +int + const Transformation *trn + + +im__transform_add +int + const Transformation *in1, const Transformation *in2, Transformation *out + + +im__transform_print +void + const Transformation *trn + + +im__transform_forward_point +void + const Transformation *trn, const double x, const double y, double *ox, double *oy + + +im__transform_invert_point +void + const Transformation *trn, const double x, const double y, double *ox, double *oy + + +im__transform_forward_rect +void + const Transformation *trn, const VipsRect *in, VipsRect *out + + +im__transform_invert_rect +void + const Transformation *trn, const VipsRect *in, VipsRect *out + + +im__transform_set_area +void + Transformation * + + +im__affine +int + VipsImage *in, VipsImage *out, Transformation *trn + + +vips_error_buffer +const char * + void + + +vips_error_clear +void + void + + +vips_error +void + const char *domain, const char *fmt, ... + + +vips_verror +void + const char *domain, const char *fmt, va_list ap + + +vips_error_system +void + int err, const char *domain, const char *fmt, ... + + +vips_verror_system +void + int err, const char *domain, const char *fmt, va_list ap + + +vips_error_g +void + GError **error + + +vips_warn +void + const char *domain, const char *fmt, ... + + +vips_vwarn +void + const char *domain, const char *fmt, va_list ap + + +vips_diag +void + const char *domain, const char *fmt, ... + + +vips_vdiag +void + const char *domain, const char *fmt, va_list ap + + +vips_error_exit +void + const char *fmt, ... + + +vips_check_uncoded +int + const char *domain, VipsImage *im + + +vips_check_coding_known +int + const char *domain, VipsImage *im + + +vips_check_coding_labq +int + const char *domain, VipsImage *im + + +vips_check_coding_rad +int + const char *domain, VipsImage *im + + +vips_check_coding_noneorlabq +int + const char *domain, VipsImage *im + + +vips_check_coding_same +int + const char *domain, VipsImage *im1, VipsImage *im2 + + +vips_check_mono +int + const char *domain, VipsImage *im + + +vips_check_bands_1or3 +int + const char *domain, VipsImage *in + + +vips_check_bands +int + const char *domain, VipsImage *im, int bands + + +vips_check_bands_1orn +int + const char *domain, VipsImage *im1, VipsImage *im2 + + +vips_check_bands_1orn_unary +int + const char *domain, VipsImage *im, int n + + +vips_check_bands_same +int + const char *domain, VipsImage *im1, VipsImage *im2 + + +vips_check_bandno +int + const char *domain, VipsImage *im, int bandno + + +vips_check_int +int + const char *domain, VipsImage *im + + +vips_check_uint +int + const char *domain, VipsImage *im + + +vips_check_uintorf +int + const char *domain, VipsImage *im + + +vips_check_noncomplex +int + const char *domain, VipsImage *im + + +vips_check_complex +int + const char *domain, VipsImage *im + + +vips_check_format +int + const char *domain, VipsImage *im, VipsBandFormat fmt + + +vips_check_u8or16 +int + const char *domain, VipsImage *im + + +vips_check_8or16 +int + const char *domain, VipsImage *im + + +vips_check_u8or16orf +int + const char *domain, VipsImage *im + + +vips_check_format_same +int + const char *domain, VipsImage *im1, VipsImage *im2 + + +vips_check_size_same +int + const char *domain, VipsImage *im1, VipsImage *im2 + + +vips_check_vector +int + const char *domain, int n, VipsImage *im + + +vips_check_hist +int + const char *domain, VipsImage *im + + +vips_check_imask +int + const char *domain, INTMASK *mask + + +vips_check_dmask +int + const char *domain, DOUBLEMASK *mask + + +vips_check_dmask_1d +int + const char *domain, DOUBLEMASK *mask + + +im_aconvsep +int + VipsImage *in, VipsImage *out, DOUBLEMASK *mask, int n_layers + + +im_aconv +int + VipsImage *in, VipsImage *out, DOUBLEMASK *mask, int n_layers, int cluster + + +im_conv +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_conv_f +int + VipsImage *in, VipsImage *out, DOUBLEMASK *mask + + +im_convsep +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_convsep_f +int + VipsImage *in, VipsImage *out, DOUBLEMASK *mask + + +im_compass +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_gradient +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_lindetect +int + VipsImage *in, VipsImage *out, INTMASK *mask + + +im_sharpen +int + VipsImage *in, VipsImage *out, int mask_size, double x1, double y2, double y3, double m1, double m2 + + +im_grad_x +int + VipsImage *in, VipsImage *out + + +im_grad_y +int + VipsImage *in, VipsImage *out + + +im_fastcor +int + VipsImage *in, VipsImage *ref, VipsImage *out + + +im_spcor +int + VipsImage *in, VipsImage *ref, VipsImage *out + + +im_gradcor +int + VipsImage *in, VipsImage *ref, VipsImage *out + + +im_contrast_surface +int + VipsImage *in, VipsImage *out, int half_win_size, int spacing + + +im_addgnoise +int + VipsImage *in, VipsImage *out, double sigma + + +INTMASK +typedef struct im__INTMASK { + int xsize; + int ysize; + int scale; + int offset; + int *coeff; + char *filename; +} INTMASK; + + +DOUBLEMASK +typedef struct im__DOUBLEMASK { + int xsize; + int ysize; + double scale; + double offset; + double *coeff; + char *filename; +} DOUBLEMASK; + + +im_create_imask +INTMASK * + const char *filename, int xsize, int ysize + + +im_create_imaskv +INTMASK * + const char *filename, int xsize, int ysize, ... + + +im_create_dmask +DOUBLEMASK * + const char *filename, int xsize, int ysize + + +im_create_dmaskv +DOUBLEMASK * + const char *filename, int xsize, int ysize, ... + + +im_read_imask +INTMASK * + const char *filename + + +im_read_dmask +DOUBLEMASK * + const char *filename + + +im_print_imask +void + INTMASK *in + + +im_print_dmask +void + DOUBLEMASK *in + + +im_write_imask +int + INTMASK *in + + +im_write_dmask +int + DOUBLEMASK *in + + +im_write_imask_name +int + INTMASK *in, const char *filename + + +im_write_dmask_name +int + DOUBLEMASK *in, const char *filename + + +im_free_imask +int + INTMASK *in + + +im_free_dmask +int + DOUBLEMASK *in + + +im_log_imask +INTMASK * + const char *filename, double sigma, double min_ampl + + +im_log_dmask +DOUBLEMASK * + const char *filename, double sigma, double min_ampl + + +im_gauss_imask +INTMASK * + const char *filename, double sigma, double min_ampl + + +im_gauss_imask_sep +INTMASK * + const char *filename, double sigma, double min_ampl + + +im_gauss_dmask +DOUBLEMASK * + const char *filename, double sigma, double min_ampl + + +im_gauss_dmask_sep +DOUBLEMASK * + const char *filename, double sigma, double min_ampl + + +im_dup_imask +INTMASK * + INTMASK *in, const char *filename + + +im_dup_dmask +DOUBLEMASK * + DOUBLEMASK *in, const char *filename + + +im_scale_dmask +INTMASK * + DOUBLEMASK *in, const char *filename + + +im_norm_dmask +void + DOUBLEMASK *mask + + +im_imask2dmask +DOUBLEMASK * + INTMASK *in, const char *filename + + +im_dmask2imask +INTMASK * + DOUBLEMASK *in, const char *filename + + +im_rotate_imask90 +INTMASK * + INTMASK *in, const char *filename + + +im_rotate_imask45 +INTMASK * + INTMASK *in, const char *filename + + +im_rotate_dmask90 +DOUBLEMASK * + DOUBLEMASK *in, const char *filename + + +im_rotate_dmask45 +DOUBLEMASK * + DOUBLEMASK *in, const char *filename + + +im_mattrn +DOUBLEMASK * + DOUBLEMASK *in, const char *filename + + +im_matcat +DOUBLEMASK * + DOUBLEMASK *top, DOUBLEMASK *bottom, const char *filename + + +im_matmul +DOUBLEMASK * + DOUBLEMASK *in1, DOUBLEMASK *in2, const char *filename + + +im_lu_decomp +DOUBLEMASK * + const DOUBLEMASK *mat, const char *filename + + +im_lu_solve +int + const DOUBLEMASK *lu, double *vec + + +im_matinv +DOUBLEMASK * + const DOUBLEMASK *mat, const char *filename + + +im_matinv_inplace +int + DOUBLEMASK *mat + + +im_local_dmask +DOUBLEMASK * + struct _VipsImage *out, DOUBLEMASK *mask + + +im_local_imask +INTMASK * + struct _VipsImage *out, INTMASK *mask + + +vips_get_argv0 +const char * + void + + +vips_init +int + const char *argv0 + + +vips_check_init +void + void + + +vips_shutdown +void + void + + +vips_get_option_group +GOptionGroup * + void + + +vips_version_string +const char * + void + + +vips_version +int + int flag + + +vips_guess_prefix +const char * + const char *argv0, const char *env_name + + +vips_guess_libdir +const char * + const char *argv0, const char *env_name + + +VIPS_VIP7COMPATS_H +#define VIPS_VIP7COMPATS_H + + +IM_BANDFMT_NOTSET +#define IM_BANDFMT_NOTSET VIPS_FORMAT_NOTSET + + +IM_BANDFMT_UCHAR +#define IM_BANDFMT_UCHAR VIPS_FORMAT_UCHAR + + +IM_BANDFMT_CHAR +#define IM_BANDFMT_CHAR VIPS_FORMAT_CHAR + + +IM_BANDFMT_USHORT +#define IM_BANDFMT_USHORT VIPS_FORMAT_USHORT + + +IM_BANDFMT_SHORT +#define IM_BANDFMT_SHORT VIPS_FORMAT_SHORT + + +IM_BANDFMT_UINT +#define IM_BANDFMT_UINT VIPS_FORMAT_UINT + + +IM_BANDFMT_INT +#define IM_BANDFMT_INT VIPS_FORMAT_INT + + +IM_BANDFMT_FLOAT +#define IM_BANDFMT_FLOAT VIPS_FORMAT_FLOAT + + +IM_BANDFMT_COMPLEX +#define IM_BANDFMT_COMPLEX VIPS_FORMAT_COMPLEX + + +IM_BANDFMT_DOUBLE +#define IM_BANDFMT_DOUBLE VIPS_FORMAT_DOUBLE + + +IM_BANDFMT_DPCOMPLEX +#define IM_BANDFMT_DPCOMPLEX VIPS_FORMAT_DPCOMPLEX + + +IM_BANDFMT_LAST +#define IM_BANDFMT_LAST VIPS_FORMAT_LAST + + +VipsBandFmt +#define VipsBandFmt VipsBandFormat + + +IM_SMALLTILE +#define IM_SMALLTILE VIPS_DEMAND_STYLE_SMALLTILE + + +IM_FATSTRIP +#define IM_FATSTRIP VIPS_DEMAND_STYLE_FATSTRIP + + +IM_THINSTRIP +#define IM_THINSTRIP VIPS_DEMAND_STYLE_THINSTRIP + + +IM_ANY +#define IM_ANY VIPS_DEMAND_STYLE_ANY + + +IM_CODING_NONE +#define IM_CODING_NONE VIPS_CODING_NONE + + +IM_CODING_LABQ +#define IM_CODING_LABQ VIPS_CODING_LABQ + + +IM_CODING_RAD +#define IM_CODING_RAD VIPS_CODING_RAD + + +IM_TYPE_MULTIBAND +#define IM_TYPE_MULTIBAND VIPS_INTERPRETATION_MULTIBAND + + +IM_TYPE_B_W +#define IM_TYPE_B_W VIPS_INTERPRETATION_B_W + + +IM_TYPE_HISTOGRAM +#define IM_TYPE_HISTOGRAM VIPS_INTERPRETATION_HISTOGRAM + + +IM_TYPE_FOURIER +#define IM_TYPE_FOURIER VIPS_INTERPRETATION_FOURIER + + +IM_TYPE_XYZ +#define IM_TYPE_XYZ VIPS_INTERPRETATION_XYZ + + +IM_TYPE_LAB +#define IM_TYPE_LAB VIPS_INTERPRETATION_LAB + + +IM_TYPE_CMYK +#define IM_TYPE_CMYK VIPS_INTERPRETATION_CMYK + + +IM_TYPE_LABQ +#define IM_TYPE_LABQ VIPS_INTERPRETATION_LABQ + + +IM_TYPE_RGB +#define IM_TYPE_RGB VIPS_INTERPRETATION_RGB + + +IM_TYPE_UCS +#define IM_TYPE_UCS VIPS_INTERPRETATION_UCS + + +IM_TYPE_LCH +#define IM_TYPE_LCH VIPS_INTERPRETATION_LCH + + +IM_TYPE_LABS +#define IM_TYPE_LABS VIPS_INTERPRETATION_LABS + + +IM_TYPE_sRGB +#define IM_TYPE_sRGB VIPS_INTERPRETATION_sRGB + + +IM_TYPE_YXY +#define IM_TYPE_YXY VIPS_INTERPRETATION_YXY + + +IM_TYPE_RGB16 +#define IM_TYPE_RGB16 VIPS_INTERPRETATION_RGB16 + + +IM_TYPE_GREY16 +#define IM_TYPE_GREY16 VIPS_INTERPRETATION_GREY16 + + +VipsType +#define VipsType VipsInterpretation + + +IMAGE +#define IMAGE VipsImage + + +REGION +#define REGION VipsRegion + + +IM_MAX +#define IM_MAX VIPS_MAX + + +IM_MIN +#define IM_MIN VIPS_MIN + + +IM_RAD +#define IM_RAD VIPS_RAD + + +IM_DEG +#define IM_DEG VIPS_DEG + + +IM_PI +#define IM_PI VIPS_PI + + +IM_RINT +#define IM_RINT VIPS_RINT + + +IM_ABS +#define IM_ABS VIPS_ABS + + +IM_NUMBER +#define IM_NUMBER VIPS_NUMBER + + +IM_CLIP +#define IM_CLIP VIPS_CLIP + + +IM_CLIP_UCHAR +#define IM_CLIP_UCHAR VIPS_CLIP_UCHAR + + +IM_CLIP_CHAR +#define IM_CLIP_CHAR VIPS_CLIP_CHAR + + +IM_CLIP_USHORT +#define IM_CLIP_USHORT VIPS_CLIP_USHORT + + +IM_CLIP_SHORT +#define IM_CLIP_SHORT VIPS_CLIP_SHORT + + +IM_CLIP_NONE +#define IM_CLIP_NONE VIPS_CLIP_NONE + + +IM_UNROLL +#define IM_UNROLL VIPS_UNROLL + + +IM_SWAP +#define IM_SWAP VIPS_SWAP + + +IM_IMAGE_ADDR +#define IM_IMAGE_ADDR VIPS_IMAGE_ADDR + + +IM_IMAGE_N_ELEMENTS +#define IM_IMAGE_N_ELEMENTS VIPS_IMAGE_N_ELEMENTS + + +IM_IMAGE_SIZEOF_ELEMENT +#define IM_IMAGE_SIZEOF_ELEMENT VIPS_IMAGE_SIZEOF_ELEMENT + + +IM_IMAGE_SIZEOF_PEL +#define IM_IMAGE_SIZEOF_PEL VIPS_IMAGE_SIZEOF_PEL + + +IM_IMAGE_SIZEOF_LINE +#define IM_IMAGE_SIZEOF_LINE VIPS_IMAGE_SIZEOF_LINE + + +IM_REGION_LSKIP +#define IM_REGION_LSKIP VIPS_REGION_LSKIP + + +IM_REGION_ADDR +#define IM_REGION_ADDR VIPS_REGION_ADDR + + +IM_REGION_ADDR_TOPLEFT +#define IM_REGION_ADDR_TOPLEFT VIPS_REGION_ADDR_TOPLEFT + + +IM_REGION_N_ELEMENTS +#define IM_REGION_N_ELEMENTS VIPS_REGION_N_ELEMENTS + + +IM_REGION_SIZEOF_LINE +#define IM_REGION_SIZEOF_LINE VIPS_REGION_SIZEOF_LINE + + +im__sizeof_bandfmt +#define im__sizeof_bandfmt vips__image_sizeof_bandformat + + +im_error +#define im_error vips_error + + +im_verror +#define im_verror vips_verror + + +im_verror_system +#define im_verror_system vips_verror_system + + +im_error_system +#define im_error_system vips_error_system + + +im_error_buffer +#define im_error_buffer vips_error_buffer + + +im_error_clear +#define im_error_clear vips_error_clear + + +im_warn +#define im_warn vips_warn + + +im_vwarn +#define im_vwarn vips_vwarn + + +im_diag +#define im_diag vips_diag + + +im_vdiag +#define im_vdiag vips_vdiag + + +error_exit +#define error_exit vips_error_exit + + +im_get_argv0 +#define im_get_argv0 vips_get_argv0 + + +im_version_string +#define im_version_string vips_version_string + + +im_version +#define im_version vips_version + + +im_init_world +#define im_init_world vips_init + + +im_get_option_group +#define im_get_option_group vips_get_option_group + + +im_guess_prefix +#define im_guess_prefix vips_guess_prefix + + +im_guess_libdir +#define im_guess_libdir vips_guess_libdir + + +im__global_lock +#define im__global_lock vips__global_lock + + +im_cp_desc +#define im_cp_desc vips_image_copy_fields + + +im_cp_descv +#define im_cp_descv vips_image_copy_fieldsv + + +im_cp_desc_array +#define im_cp_desc_array vips_image_copy_fields_array + + +im_image +#define im_image vips_image_new_from_memory + + +im_binfile +#define im_binfile vips_image_new_from_file_raw + + +im__open_temp +#define im__open_temp vips_image_new_disc_temp + + +im__test_kill +#define im__test_kill( I ) (vips_image_get_kill( I )) + + +im__start_eval +#define im__start_eval( I ) (vips_image_preeval( I ), vips_image_get_kill( I )) + + +im__handle_eval +#define im__handle_eval( I, W, H ) \ + (vips_image_eval( I, W, H ), vips_image_get_kill( I )) + + +im__end_eval +#define im__end_eval vips_image_posteval + + +im_invalidate +#define im_invalidate vips_image_invalidate_all + + +im_isfile +#define im_isfile vips_image_isfile + + +im_printdesc +#define im_printdesc( I ) vips_object_print( VIPS_OBJECT( I ) ) + + +im_openout +#define im_openout( F ) vips_image_new_mode( F, "w" ) + + +im_setbuf +#define im_setbuf( F ) vips_image_new( "t" ) + + +im_initdesc +#define im_initdesc( image, \ + xsize, ysize, bands, bandbits, bandfmt, coding, \ + type, xres, yres, xo, yo ) \ + vips_image_init_fields( image, \ + xsize, ysize, bands, bandfmt, coding, \ + type, xres, yres ) + + +im__open_image_file +#define im__open_image_file vips__open_image_read + + +im_setupout +#define im_setupout( I ) vips__image_write_prepare( I ) + + +im_writeline +#define im_writeline( Y, IM, P ) vips_image_write_line( IM, Y, P ) + + +im_prepare +#define im_prepare vips_region_prepare + + +im_prepare_to +#define im_prepare_to vips_region_prepare_to + + +im_region_create +#define im_region_create vips_region_new + + +im_region_free +#define im_region_free g_object_unref + + +im_region_region +#define im_region_region vips_region_region + + +im_region_buffer +#define im_region_buffer vips_region_buffer + + +im_region_black +#define im_region_black vips_region_black + + +im_region_paint +#define im_region_paint vips_region_paint + + +im_prepare_many +#define im_prepare_many vips_region_prepare_many + + +im__region_no_ownership +#define im__region_no_ownership vips__region_no_ownership + + +im_image_sanity +#define im_image_sanity( I ) (!vips_object_sanity( VIPS_OBJECT( I ) )) + + +im_image_sanity_all +#define im_image_sanity_all vips_object_sanity_all + + +im__print_all +#define im__print_all vips_object_print_all + + +im_open +VipsImage * + const char *filename, const char *mode + + +im_open_local +VipsImage * + VipsImage *parent, const char *filename, const char *mode + + +im_open_local_array +int + VipsImage *parent, VipsImage **images, int n, const char *filename, const char *mode + + +im_callback_fn +#define im_callback_fn VipsCallbackFn + + +im_add_callback +int + VipsImage *im, const char *callback, im_callback_fn fn, void *a, void *b + + +im_add_callback1 +int + VipsImage *im, const char *callback, im_callback_fn fn, void *a, void *b + + +im_add_close_callback +#define im_add_close_callback( IM, FN, A, B ) \ + im_add_callback( IM, "close", FN, A, B ) + + +im_add_postclose_callback +#define im_add_postclose_callback( IM, FN, A, B ) \ + im_add_callback( IM, "postclose", FN, A, B ) + + +im_add_preclose_callback +#define im_add_preclose_callback( IM, FN, A, B ) \ + im_add_callback( IM, "preclose", FN, A, B ) + + +im_add_evalstart_callback +#define im_add_evalstart_callback( IM, FN, A, B ) \ + im_add_callback1( IM, "preeval", FN, A, B ) + + +im_add_evalend_callback +#define im_add_evalend_callback( IM, FN, A, B ) \ + im_add_callback1( IM, "posteval", FN, A, B ) + + +im_add_eval_callback +#define im_add_eval_callback( IM, FN, A, B ) \ + (vips_image_set_progress( IM, TRUE ), \ + im_add_callback1( IM, "eval", FN, A, B )) + + +im_add_invalidate_callback +#define im_add_invalidate_callback( IM, FN, A, B ) \ + im_add_callback( IM, "invalidate", FN, A, B ) + + +im_bits_of_fmt +#define im_bits_of_fmt( fmt ) (vips_format_sizeof( fmt ) << 3) + + +im_construct_fn +void * + void *, void *, void * + + +im_local +void * + VipsImage *im, im_construct_fn cons, im_callback_fn dest, void *a, void *b, void *c + + +im_local_array +int + VipsImage *im, void **out, int n, im_construct_fn cons, im_callback_fn dest, void *a, void *b, void *c + + +im_close +int + VipsImage *im + + +im_init +VipsImage * + const char *filename + + +im_Type2char +const char * + VipsInterpretation type + + +im_BandFmt2char +const char * + VipsBandFormat fmt + + +im_Coding2char +const char * + VipsCoding coding + + +im_Compression2char +const char * + int n + + +im_dtype2char +const char * + VipsImageType n + + +im_dhint2char +const char * + VipsDemandStyle style + + +im_char2Type +VipsInterpretation + const char *str + + +im_char2BandFmt +VipsBandFormat + const char *str + + +im_char2Coding +VipsCoding + const char *str + + +im_char2dtype +VipsImageType + const char *str + + +im_char2dhint +VipsDemandStyle + const char *str + + +Rect +#define Rect VipsRect + + +IM_RECT_RIGHT +#define IM_RECT_RIGHT VIPS_RECT_RIGHT + + +IM_RECT_BOTTOM +#define IM_RECT_BOTTOM VIPS_RECT_BOTTOM + + +IM_RECT_HCENTRE +#define IM_RECT_HCENTRE VIPS_RECT_HCENTRE + + +IM_RECT_VCENTRE +#define IM_RECT_VCENTRE VIPS_RECT_VCENTRE + + +im_rect_marginadjust +#define im_rect_marginadjust vips_rect_marginadjust + + +im_rect_includespoint +#define im_rect_includespoint vips_rect_includespoint + + +im_rect_includesrect +#define im_rect_includesrect vips_rect_includesrect + + +im_rect_intersectrect +#define im_rect_intersectrect vips_rect_intersectrect + + +im_rect_isempty +#define im_rect_isempty vips_rect_isempty + + +im_rect_unionrect +#define im_rect_unionrect vips_rect_unionrect + + +im_rect_equalsrect +#define im_rect_equalsrect vips_rect_equalsrect + + +im_rect_dup +#define im_rect_dup vips_rect_dup + + +im_rect_normalise +#define im_rect_normalise vips_rect_normalise + + +im_demand_hint +int +IMAGE * im, VipsDemandStyle hint, ... + + +im_demand_hint_array +#define im_demand_hint_array( A, B, C ) (vips_demand_hint_array( A, B, C ), 0) + + +im_start_one +#define im_start_one vips_start_one + + +im_stop_one +#define im_stop_one vips_stop_one + + +im_start_many +#define im_start_many vips_start_many + + +im_stop_many +#define im_stop_many vips_stop_many + + +im_allocate_input_array +#define im_allocate_input_array vips_allocate_input_array + + +im_start_fn +#define im_start_fn VipsStartFn + + +im_generate_fn +int + VipsRegion *out, void *seq, void *a, void *b + + +im_stop_fn +#define im_stop_fn VipsStopFn + + +im_generate +int + VipsImage *im, im_start_fn start, im_generate_fn generate, im_stop_fn stop, void *a, void *b + + +im__mmap +#define im__mmap vips__mmap + + +im__munmap +#define im__munmap vips__munmap + + +im_mapfile +#define im_mapfile vips_mapfile + + +im_mapfilerw +#define im_mapfilerw vips_mapfilerw + + +im_remapfilerw +#define im_remapfilerw vips_remapfilerw + + +im__print_renders +#define im__print_renders vips__print_renders + + +im_cache +#define im_cache vips_image_cache + + +IM_FREEF +#define IM_FREEF( F, S ) \ +G_STMT_START { \ + if( S ) { \ + (void) F( (S) ); \ + (S) = 0; \ + } \ +} G_STMT_END + + +IM_FREE +#define IM_FREE( S ) \ +G_STMT_START { \ + if( S ) { \ + (void) im_free( (void *) (S) ); \ + (S) = 0; \ + } \ +} G_STMT_END + + +IM_SETSTR +#define IM_SETSTR( S, V ) \ +G_STMT_START { \ + const char *sst = (V); \ + \ + if( (S) != sst ) { \ + if( !(S) || !sst || strcmp( (S), sst ) != 0 ) { \ + IM_FREE( S ); \ + if( sst ) \ + (S) = im_strdup( NULL, sst ); \ + } \ + } \ +} G_STMT_END + + +im_malloc +#define im_malloc( IM, SZ ) \ + (vips_malloc( VIPS_OBJECT( IM ), (SZ) )) + + +im_free +#define im_free vips_free + + +im_strdup +#define im_strdup( IM, STR ) \ + (vips_strdup( VIPS_OBJECT( IM ), (STR) )) + + +IM_NEW +#define IM_NEW( IM, T ) ((T *) im_malloc( (IM), sizeof( T ))) + + +IM_ARRAY +#define IM_ARRAY( IM, N, T ) ((T *) im_malloc( (IM), (N) * sizeof( T ))) + + +im_incheck +#define im_incheck vips_image_wio_input + + +im_outcheck +#define im_outcheck vips_image_wio_output + + +im_rwcheck +#define im_rwcheck vips_image_inplace + + +im_pincheck +#define im_pincheck vips_image_pio_input + + +im_poutcheck +#define im_poutcheck vips_image_pio_output + + +im_iocheck +#define im_iocheck( I, O ) (im_incheck( I ) || im_outcheck( O )) + + +im_piocheck +#define im_piocheck( I, O ) (im_pincheck( I ) || im_poutcheck( O )) + + +im_check_uncoded +#define im_check_uncoded vips_check_uncoded + + +im_check_coding_known +#define im_check_coding_known vips_check_coding_known + + +im_check_coding_labq +#define im_check_coding_labq vips_check_coding_labq + + +im_check_coding_rad +#define im_check_coding_rad vips_check_coding_rad + + +im_check_coding_noneorlabq +#define im_check_coding_noneorlabq vips_check_coding_noneorlabq + + +im_check_coding_same +#define im_check_coding_same vips_check_coding_same + + +im_check_mono +#define im_check_mono vips_check_mono + + +im_check_bands_1or3 +#define im_check_bands_1or3 vips_check_bands_1or3 + + +im_check_bands +#define im_check_bands vips_check_bands + + +im_check_bands_1orn +#define im_check_bands_1orn vips_check_bands_1orn + + +im_check_bands_1orn_unary +#define im_check_bands_1orn_unary vips_check_bands_1orn_unary + + +im_check_bands_same +#define im_check_bands_same vips_check_bands_same + + +im_check_bandno +#define im_check_bandno vips_check_bandno + + +im_check_int +#define im_check_int vips_check_int + + +im_check_uint +#define im_check_uint vips_check_uint + + +im_check_uintorf +#define im_check_uintorf vips_check_uintorf + + +im_check_noncomplex +#define im_check_noncomplex vips_check_noncomplex + + +im_check_complex +#define im_check_complex vips_check_complex + + +im_check_format +#define im_check_format vips_check_format + + +im_check_u8or16 +#define im_check_u8or16 vips_check_u8or16 + + +im_check_8or16 +#define im_check_8or16 vips_check_8or16 + + +im_check_u8or16orf +#define im_check_u8or16orf vips_check_u8or16orf + + +im_check_format_same +#define im_check_format_same vips_check_format_same + + +im_check_size_same +#define im_check_size_same vips_check_size_same + + +im_check_vector +#define im_check_vector vips_check_vector + + +im_check_hist +#define im_check_hist vips_check_hist + + +im_check_imask +#define im_check_imask vips_check_imask + + +im_check_dmask +#define im_check_dmask vips_check_dmask + + +vips_bandfmt_isint +#define vips_bandfmt_isint vips_band_format_isint + + +vips_bandfmt_isuint +#define vips_bandfmt_isuint vips_band_format_isuint + + +vips_bandfmt_isfloat +#define vips_bandfmt_isfloat vips_band_format_isfloat + + +vips_bandfmt_iscomplex +#define vips_bandfmt_iscomplex vips_band_format_iscomplex + + +im__change_suffix +#define im__change_suffix vips__change_suffix + + +im_wrapone_fn +void + void *in, void *out, int width, + void *a, void *b + + +im_wrapone +int + VipsImage *in, VipsImage *out, im_wrapone_fn fn, void *a, void *b + + +im_wraptwo_fn +void + void *in1, void *in2, void *out, + int width, void *a, void *b + + +im_wraptwo +int + VipsImage *in1, VipsImage *in2, VipsImage *out, im_wraptwo_fn fn, void *a, void *b + + +im_wrapmany_fn +void + void **in, void *out, int width, + void *a, void *b + + +im_wrapmany +int + VipsImage **in, VipsImage *out, im_wrapmany_fn fn, void *a, void *b + + +IM_META_EXIF_NAME +#define IM_META_EXIF_NAME VIPS_META_EXIF_NAME + + +IM_META_ICC_NAME +#define IM_META_ICC_NAME VIPS_META_ICC_NAME + + +IM_META_XML +#define IM_META_XML VIPS_META_XML + + +IM_META_RESOLUTION_UNIT +#define IM_META_RESOLUTION_UNIT VIPS_META_RESOLUTION_UNIT + + +IM_TYPE_SAVE_STRING +#define IM_TYPE_SAVE_STRING VIPS_TYPE_SAVE_STRING + + +IM_TYPE_BLOB +#define IM_TYPE_BLOB VIPS_TYPE_BLOB + + +IM_TYPE_AREA +#define IM_TYPE_AREA VIPS_TYPE_AREA + + +IM_TYPE_REF_STRING +#define IM_TYPE_REF_STRING VIPS_TYPE_REF_STRING + + +im_header_map_fn +#define im_header_map_fn VipsImageMapFn + + +im_header_map +#define im_header_map vips_image_map + + +im_header_int +#define im_header_int vips_image_get_int + + +im_header_double +#define im_header_double vips_image_get_double + + +im_header_string +#define im_header_string vips_image_get_string + + +im_header_as_string +#define im_header_as_string vips_image_get_as_string + + +im_header_get_typeof +#define im_header_get_typeof vips_image_get_typeof + + +im_header_get +#define im_header_get vips_image_get + + +im_histlin +#define im_histlin vips_image_history_printf + + +im_updatehist +#define im_updatehist vips_image_history_args + + +im_history_get +#define im_history_get vips_image_get_history + + +im_save_string_get +#define im_save_string_get vips_value_get_save_string + + +im_save_string_set +#define im_save_string_set vips_value_set_save_string + + +im_save_string_setf +#define im_save_string_setf vips_value_set_save_stringf + + +im_ref_string_set +#define im_ref_string_set vips_value_set_ref_string + + +im_ref_string_get +#define im_ref_string_get( V ) vips_value_get_ref_string( V, NULL ) + + +im_ref_string_get_length +size_t + const GValue *value + + +im_blob_get +#define im_blob_get vips_value_get_blob + + +im_blob_set +#define im_blob_set vips_value_set_blob + + +im_meta_set +#define im_meta_set( A, B, C ) (vips_image_set( A, B, C ), 0) + + +im_meta_remove +#define im_meta_remove vips_image_remove + + +im_meta_get +#define im_meta_get vips_image_get + + +im_meta_get_typeof +#define im_meta_get_typeof vips_image_get_typeof + + +im_meta_set_int +#define im_meta_set_int( A, B, C ) (vips_image_set_int( A, B, C ), 0) + + +im_meta_get_int +#define im_meta_get_int vips_image_get_int + + +im_meta_set_double +#define im_meta_set_double( A, B, C ) (vips_image_set_double( A, B, C ), 0) + + +im_meta_get_double +#define im_meta_get_double vips_image_get_double + + +im_meta_set_area +#define im_meta_set_area( A, B, C, D ) (vips_image_set_area( A, B, C, D ), 0) + + +im_meta_get_area +#define im_meta_get_area vips_image_get_area + + +im_meta_set_string +#define im_meta_set_string( A, B, C ) (vips_image_set_string( A, B, C ), 0) + + +im_meta_get_string +#define im_meta_get_string vips_image_get_string + + +im_meta_set_blob +#define im_meta_set_blob( A, B, C, D, E ) \ + (vips_image_set_blob( A, B, C, D, E ), 0) + + +im_meta_get_blob +#define im_meta_get_blob vips_image_get_blob + + +im_semaphore_t +#define im_semaphore_t VipsSemaphore + + +im_semaphore_up +#define im_semaphore_up vips_semaphore_up + + +im_semaphore_down +#define im_semaphore_down vips_semaphore_down + + +im_semaphore_upn +#define im_semaphore_upn vips_semaphore_upn + + +im_semaphore_downn +#define im_semaphore_downn vips_semaphore_downn + + +im_semaphore_destroy +#define im_semaphore_destroy vips_semaphore_destroy + + +im_semaphore_init +#define im_semaphore_init vips_semaphore_init + + +im__open_image_read +#define im__open_image_read vips__open_image_read + + +im_image_open_input +#define im_image_open_input vips_image_open_input + + +im_image_open_output +#define im_image_open_output vips_image_open_output + + +im__read_4byte +#define im__read_4byte vips__read_4byte + + +im__read_2byte +#define im__read_2byte vips__read_2byte + + +im__write_4byte +#define im__write_4byte vips__write_4byte + + +im__write_2byte +#define im__write_2byte vips__write_2byte + + +im__has_extension_block +#define im__has_extension_block vips__has_extension_block + + +im__read_extension_block +#define im__read_extension_block vips__read_extension_block + + +im__write_extension_block +#define im__write_extension_block vips__write_extension_block + + +im__writehist +#define im__writehist vips__writehist + + +im__read_header_bytes +#define im__read_header_bytes vips__read_header_bytes + + +im__write_header_bytes +#define im__write_header_bytes vips__write_header_bytes + + +VSListMap2Fn +#define VSListMap2Fn VipsSListMap2Fn + + +VSListMap4Fn +#define VSListMap4Fn VipsSListMap4Fn + + +VSListFold2Fn +#define VSListFold2Fn VipsSListFold2Fn + + +im_slist_equal +#define im_slist_equal vips_slist_equal + + +im_slist_map2 +#define im_slist_map2 vips_slist_map2 + + +im_slist_map2_rev +#define im_slist_map2_rev vips_slist_map2_rev + + +im_slist_map4 +#define im_slist_map4 vips_slist_map4 + + +im_slist_fold2 +#define im_slist_fold2 vips_slist_fold2 + + +im_slist_filter +#define im_slist_filter vips_slist_filter + + +im_slist_free_all +#define im_slist_free_all vips_slist_free_all + + +im_map_equal +#define im_map_equal vips_map_equal + + +im_hash_table_map +#define im_hash_table_map vips_hash_table_map + + +im_strncpy +#define im_strncpy vips_strncpy + + +im_strrstr +#define im_strrstr vips_strrstr + + +im_ispostfix +#define im_ispostfix vips_ispostfix + + +im_isprefix +#define im_isprefix vips_isprefix + + +im_break_token +#define im_break_token vips_break_token + + +im_vsnprintf +#define im_vsnprintf vips_vsnprintf + + +im_snprintf +#define im_snprintf vips_snprintf + + +im_filename_split +#define im_filename_split vips_filename_split + + +im_skip_dir +#define im_skip_dir vips_skip_dir + + +im_filename_suffix +#define im_filename_suffix vips_filename_suffix + + +im_filename_suffix_match +#define im_filename_suffix_match vips_filename_suffix_match + + +im_getnextoption +#define im_getnextoption vips_getnextoption + + +im_getsuboption +#define im_getsuboption vips_getsuboption + + +im_file_length +#define im_file_length vips_file_length + + +im__write +#define im__write vips__write + + +im__file_open_read +#define im__file_open_read vips__file_open_read + + +im__file_open_write +#define im__file_open_write vips__file_open_write + + +im__file_read +#define im__file_read vips__file_read + + +im__file_read_name +#define im__file_read_name vips__file_read_name + + +im__file_write +#define im__file_write vips__file_write + + +im__get_bytes +#define im__get_bytes vips__get_bytes + + +im__gvalue_ref_string_new +#define im__gvalue_ref_string_new vips__gvalue_ref_string_new + + +im__gslist_gvalue_free +#define im__gslist_gvalue_free vips__gslist_gvalue_free + + +im__gslist_gvalue_copy +#define im__gslist_gvalue_copy vips__gslist_gvalue_copy + + +im__gslist_gvalue_merge +#define im__gslist_gvalue_merge vips__gslist_gvalue_merge + + +im__gslist_gvalue_get +#define im__gslist_gvalue_get vips__gslist_gvalue_get + + +im__seek +#define im__seek vips__seek + + +im__ftruncate +#define im__ftruncate vips__ftruncate + + +im_existsf +#define im_existsf vips_existsf + + +im_popenf +#define im_popenf vips_popenf + + +im_ispoweroftwo +#define im_ispoweroftwo vips_ispoweroftwo + + +im_amiMSBfirst +#define im_amiMSBfirst vips_amiMSBfirst + + +im__temp_name +#define im__temp_name vips__temp_name + + +IM_VERSION_STRING +#define IM_VERSION_STRING VIPS_VERSION_STRING + + +IM_MAJOR_VERSION +#define IM_MAJOR_VERSION VIPS_MAJOR_VERSION + + +IM_MINOR_VERSION +#define IM_MINOR_VERSION VIPS_MINOR_VERSION + + +IM_MICRO_VERSION +#define IM_MICRO_VERSION VIPS_MICRO_VERSION + + +IM_EXEEXT +#define IM_EXEEXT VIPS_EXEEXT + + +IM_SIZEOF_HEADER +#define IM_SIZEOF_HEADER VIPS_SIZEOF_HEADER + + +im_concurrency_set +#define im_concurrency_set vips_concurrency_set + + +im_concurrency_get +#define im_concurrency_get vips_concurrency_get + + +im_add +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_subtract +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_multiply +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_divide +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_min +int + VipsImage *in, double *out + + +im_minpos +int + VipsImage *in, int *xpos, int *ypos, double *out + + +im_max +int + VipsImage *in, double *out + + +im_maxpos +int + VipsImage *in, int *xpos, int *ypos, double *out + + +im_avg +int + VipsImage *in, double *out + + +im_deviate +int + VipsImage *in, double *out + + +im_invert +int + VipsImage *in, VipsImage *out + + +im_lintra +int + double a, VipsImage *in, double b, VipsImage *out + + +im_lintra_vec +int + int n, double *a, VipsImage *in, double *b, VipsImage *out + + +im_abs +int + VipsImage *in, VipsImage *out + + +im_sign +int + VipsImage *in, VipsImage *out + + +im_stats +DOUBLEMASK * + VipsImage *in + + +im_measure_area +DOUBLEMASK * + VipsImage *im, int left, int top, int width, int height, int h, int v, int *sel, int nsel, const char *name + + +im_recomb +int + VipsImage *in, VipsImage *out, DOUBLEMASK *recomb + + +im_sintra +int + VipsImage *in, VipsImage *out + + +im_costra +int + VipsImage *in, VipsImage *out + + +im_tantra +int + VipsImage *in, VipsImage *out + + +im_asintra +int + VipsImage *in, VipsImage *out + + +im_acostra +int + VipsImage *in, VipsImage *out + + +im_atantra +int + VipsImage *in, VipsImage *out + + +im_logtra +int + VipsImage *in, VipsImage *out + + +im_log10tra +int + VipsImage *in, VipsImage *out + + +im_exptra +int + VipsImage *in, VipsImage *out + + +im_exp10tra +int + VipsImage *in, VipsImage *out + + +im_floor +int + VipsImage *in, VipsImage *out + + +im_rint +int + VipsImage *in, VipsImage *out + + +im_ceil +int + VipsImage *in, VipsImage *out + + +im_equal +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_notequal +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_less +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_lesseq +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_more +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_moreeq +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_andimage +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_orimage +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_eorimage +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_andimage_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_orimage_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_eorimage_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_andimageconst +int + VipsImage *in, VipsImage *out, double c + + +im_orimageconst +int + VipsImage *in, VipsImage *out, double c + + +im_eorimageconst +int + VipsImage *in, VipsImage *out, double c + + +im_shiftleft_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_shiftleft +int + VipsImage *in, VipsImage *out, int n + + +im_shiftright_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_shiftright +int + VipsImage *in, VipsImage *out, int n + + +im_remainder +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_remainder_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_remainderconst +int + VipsImage *in, VipsImage *out, double c + + +im_powtra +int + VipsImage *in, VipsImage *out, double e + + +im_powtra_vec +int + VipsImage *in, VipsImage *out, int n, double *e + + +im_expntra +int + VipsImage *in, VipsImage *out, double e + + +im_expntra_vec +int + VipsImage *in, VipsImage *out, int n, double *e + + +im_equal_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_notequal_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_less_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_lesseq_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_more_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_moreeq_vec +int + VipsImage *in, VipsImage *out, int n, double *c + + +im_equalconst +int + VipsImage *in, VipsImage *out, double c + + +im_notequalconst +int + VipsImage *in, VipsImage *out, double c + + +im_lessconst +int + VipsImage *in, VipsImage *out, double c + + +im_lesseqconst +int + VipsImage *in, VipsImage *out, double c + + +im_moreconst +int + VipsImage *in, VipsImage *out, double c + + +im_moreeqconst +int + VipsImage *in, VipsImage *out, double c + + +im_copy +int + VipsImage *in, VipsImage *out + + +im_copy_set +int + VipsImage *in, VipsImage *out, VipsInterpretation interpretation, float xres, float yres, int xoffset, int yoffset + + +im_copy_set_meta +int + VipsImage *in, VipsImage *out, const char *field, GValue *value + + +im_copy_morph +int + VipsImage *in, VipsImage *out, int bands, VipsBandFormat format, VipsCoding coding + + +im_copy_swap +int + VipsImage *in, VipsImage *out + + +im_copy_native +int + VipsImage *in, VipsImage *out, gboolean is_msb_first + + +im_embed +int + VipsImage *in, VipsImage *out, int type, int x, int y, int width, int height + + +im_fliphor +int + VipsImage *in, VipsImage *out + + +im_flipver +int + VipsImage *in, VipsImage *out + + +im_insert +int + VipsImage *main, VipsImage *sub, VipsImage *out, int x, int y + + +im_insert_noexpand +int + VipsImage *main, VipsImage *sub, VipsImage *out, int x, int y + + +im_lrjoin +int + VipsImage *left, VipsImage *right, VipsImage *out + + +im_tbjoin +int + VipsImage *top, VipsImage *bottom, VipsImage *out + + +im_extract_area +int + VipsImage *in, VipsImage *out, int left, int top, int width, int height + + +im_extract_band +int + VipsImage *in, VipsImage *out, int band + + +im_extract_bands +int + VipsImage *in, VipsImage *out, int band, int nbands + + +im_extract_areabands +int + VipsImage *in, VipsImage *out, int left, int top, int width, int height, int band, int nbands + + +im_replicate +int + VipsImage *in, VipsImage *out, int across, int down + + +im_clip2fmt +int + VipsImage *in, VipsImage *out, VipsBandFormat fmt + + +im_bandjoin +int + VipsImage *in1, VipsImage *in2, VipsImage *out + + +im_gbandjoin +int + VipsImage **in, VipsImage *out, int n + + +im_black +int + VipsImage *out, int x, int y, int bands + + +im_rot90 +int + VipsImage *in, VipsImage *out + + +im_rot180 +int + VipsImage *in, VipsImage *out + + +im_rot270 +int + VipsImage *in, VipsImage *out + + +im_ifthenelse +int + VipsImage *c, VipsImage *a, VipsImage *b, VipsImage *out + + +im_blend +int + VipsImage *c, VipsImage *a, VipsImage *b, VipsImage *out + + +im_vips2mask +DOUBLEMASK * + VipsImage *in, const char *filename + + +im_mask2vips +int + DOUBLEMASK *in, VipsImage *out + + +vips_class_map_concrete_all +#define vips_class_map_concrete_all vips_class_map_all + + +im_histgr +int + VipsImage *in, VipsImage *out, int bandno + + +im_histnD +int + VipsImage *in, VipsImage *out, int bins + + +im_hist_indexed +int + VipsImage *index, VipsImage *value, VipsImage *out + + +im_identity +int + VipsImage *lut, int bands + + +im_identity_ushort +int + VipsImage *lut, int bands, int sz + + +im_invertlut +int + DOUBLEMASK *input, VipsImage *output, int lut_size + + +im_buildlut +int + DOUBLEMASK *input, VipsImage *output + + +im_project +int + VipsImage *in, VipsImage *hout, VipsImage *vout + + +im_histnorm +int + VipsImage *in, VipsImage *out + + +im_histcum +int + VipsImage *in, VipsImage *out + + +im_histeq +int + VipsImage *in, VipsImage *out + + +im_histspec +int + VipsImage *in, VipsImage *ref, VipsImage *out + + +im_ismonotonic +int + VipsImage *lut, int *out + + +im_histplot +int + VipsImage *in, VipsImage *out + + +im_maplut +int + VipsImage *in, VipsImage *out, VipsImage *lut + + +im_hist +int + VipsImage *in, VipsImage *out, int bandno + + +im_hsp +int + VipsImage *in, VipsImage *ref, VipsImage *out + + +im_gammacorrect +int + VipsImage *in, VipsImage *out, double exponent + + +im_mpercent +int + VipsImage *in, double percent, int *out + + +im_mpercent_hist +int + VipsImage *hist, double percent, int *out + + +im_heq +int + VipsImage *in, VipsImage *out, int bandno + + +im_lhisteq +int + VipsImage *in, VipsImage *out, int xwin, int ywin + + +im_stdif +int + VipsImage *in, VipsImage *out, double a, double m0, double b, double s0, int xwin, int ywin + + +im_tone_build_range +int + VipsImage *out, int in_max, int out_max, double Lb, double Lw, double Ps, double Pm, double Ph, double S, double M, double H + + +im_tone_build +int + VipsImage *out, double Lb, double Lw, double Ps, double Pm, double Ph, double S, double M, double H + + +im_tone_analyse +int + VipsImage *in, VipsImage *out, double Ps, double Pm, double Ph, double S, double M, double H + + +im_tone_map +int + VipsImage *in, VipsImage *out, VipsImage *lut + + +im_video_v4l1 +int + VipsImage *im, const char *device, int channel, int brightness, int colour, int contrast, int hue, int ngrabs + + +im_video_test +int + VipsImage *im, int brightness, int error + + +VipsOperationMath +typedef enum { + VIPS_OPERATION_MATH_SIN, + VIPS_OPERATION_MATH_COS, + VIPS_OPERATION_MATH_TAN, + VIPS_OPERATION_MATH_ASIN, + VIPS_OPERATION_MATH_ACOS, + VIPS_OPERATION_MATH_ATAN, + VIPS_OPERATION_MATH_LOG, + VIPS_OPERATION_MATH_LOG10, + VIPS_OPERATION_MATH_EXP, + VIPS_OPERATION_MATH_EXP10, + VIPS_OPERATION_MATH_LAST +} VipsOperationMath; + + +VipsOperationMath2 +typedef enum { + VIPS_OPERATION_MATH2_POW, + VIPS_OPERATION_MATH2_WOP, + VIPS_OPERATION_MATH2_LAST +} VipsOperationMath2; + + +VipsOperationRound +typedef enum { + VIPS_OPERATION_ROUND_NEAREST, + VIPS_OPERATION_ROUND_CEIL, + VIPS_OPERATION_ROUND_FLOOR, + VIPS_OPERATION_ROUND_LAST +} VipsOperationRound; + + +VipsOperationRelational +typedef enum { + VIPS_OPERATION_RELATIONAL_EQUAL, + VIPS_OPERATION_RELATIONAL_NOTEQUAL, + VIPS_OPERATION_RELATIONAL_LESS, + VIPS_OPERATION_RELATIONAL_LESSEQ, + VIPS_OPERATION_RELATIONAL_MORE, + VIPS_OPERATION_RELATIONAL_MOREEQ, + VIPS_OPERATION_RELATIONAL_LAST +} VipsOperationRelational; + + +VipsOperationBoolean +typedef enum { + VIPS_OPERATION_BOOLEAN_AND, + VIPS_OPERATION_BOOLEAN_OR, + VIPS_OPERATION_BOOLEAN_EOR, + VIPS_OPERATION_BOOLEAN_LSHIFT, + VIPS_OPERATION_BOOLEAN_RSHIFT, + VIPS_OPERATION_BOOLEAN_LAST +} VipsOperationBoolean; + + +vips_add +int + VipsImage *left, VipsImage *right, VipsImage **out, ... + + +vips_arithmetic_add +int + VipsImage *left, VipsImage *right, VipsImage **out, ... + + +vips_subtract +int + VipsImage *in1, VipsImage *in2, VipsImage **out, ... + + +vips_multiply +int + VipsImage *left, VipsImage *right, VipsImage **out, ... + + +vips_divide +int + VipsImage *left, VipsImage *right, VipsImage **out, ... + + +vips_avg +int + VipsImage *in, double *out, ... + + +vips_deviate +int + VipsImage *in, double *out, ... + + +vips_min +int + VipsImage *in, double *out, ... + + +vips_max +int + VipsImage *in, double *out, ... + + +vips_invert +int + VipsImage *in, VipsImage **out, ... + + +vips_linear +int + VipsImage *in, VipsImage **out, double *a, double *b, int n, ... + + +vips_linear1 +int + VipsImage *in, VipsImage **out, double a, double b, ... + + +vips_math +int + VipsImage *in, VipsImage **out, VipsOperationMath math, ... + + +vips_abs +int + VipsImage *in, VipsImage **out, ... + + +vips_sign +int + VipsImage *in, VipsImage **out, ... + + +vips_stats +int + VipsImage *in, VipsImage **out, ... + + +vips_measure +int + VipsImage *in, VipsImage **out, int h, int v, ... + + +vips_recomb +int + VipsImage *in, VipsImage **out, VipsImage *m, ... + + +vips_round +int + VipsImage *in, VipsImage **out, VipsOperationRound round, ... + + +vips_relational +int + VipsImage *left, VipsImage *right, VipsImage **out, VipsOperationRelational relational, ... + + +vips_relational_const +int + VipsImage *in, VipsImage **out, VipsOperationRelational relational, double *c, int n, ... + + +vips_relational_const1 +int + VipsImage *in, VipsImage **out, VipsOperationRelational relational, double c, ... + + +vips_remainder +int + VipsImage *left, VipsImage *right, VipsImage **out, ... + + +vips_remainder_const +int + VipsImage *in, VipsImage **out, double *c, int n, ... + + +vips_remainder_const1 +int + VipsImage *in, VipsImage **out, double c, ... + + +vips_boolean +int + VipsImage *left, VipsImage *right, VipsImage **out, VipsOperationBoolean boolean, ... + + +vips_boolean_const +int + VipsImage *in, VipsImage **out, VipsOperationBoolean boolean, double *c, int n, ... + + +vips_math2 +int + VipsImage *left, VipsImage *right, VipsImage **out, VipsOperationMath2 math2, ... + + +vips_math2_const +int + VipsImage *in, VipsImage **out, VipsOperationMath2 math2, double *c, int n, ... + + +vips_math2_const1 +int + VipsImage *in, VipsImage **out, VipsOperationMath2 math2, double c, ... + + +im_maxpos_avg +int + VipsImage *im, double *xpos, double *ypos, double *out + + +im_maxpos_vec +int + VipsImage *im, int *xpos, int *ypos, double *maxima, int n + + +im_minpos_vec +int + VipsImage *im, int *xpos, int *ypos, double *minima, int n + + +im_bandmean +int + VipsImage *in, VipsImage *out + + +im_linreg +int + VipsImage **ins, VipsImage *out, double *xs + + +im_point +int + VipsImage *im, VipsInterpolate *interpolate, double x, double y, int band, double *out + + +im_point_bilinear +int + VipsImage *im, double x, double y, int band, double *out + + +im_cross_phase +int + VipsImage *a, VipsImage *b, VipsImage *out + diff --git a/libvips/arithmetic/abs.c b/libvips/arithmetic/abs.c index d9de0117..79bb41f7 100644 --- a/libvips/arithmetic/abs.c +++ b/libvips/arithmetic/abs.c @@ -69,22 +69,6 @@ #include "unary.h" -/** - * VipsAbs: - * @in: input #VipsImage - * @out: output #VipsImage - * - * This operation finds the absolute value of an image. It does a copy for - * unsigned integer types, negate for negative values in - * signed integer types, fabs(3) for - * float types, and calculate modulus for complex - * types. - * - * See also: im_sign(). - * - * Returns: 0 on success, -1 on error - */ - typedef VipsUnary VipsAbs; typedef VipsUnaryClass VipsAbsClass; @@ -249,6 +233,22 @@ vips_abs_init( VipsAbs *abs ) { } +/** + * vips_abs: + * @in: input #VipsImage + * @out: output #VipsImage + * @...: %NULL-terminated list of optional named arguments + * + * This operation finds the absolute value of an image. It does a copy for + * unsigned integer types, negate for negative values in + * signed integer types, fabs(3) for + * float types, and calculate modulus for complex + * types. + * + * See also: vips_sign(). + * + * Returns: 0 on success, -1 on error + */ int vips_abs( VipsImage *in, VipsImage **out, ... ) { diff --git a/libvips/arithmetic/add.c b/libvips/arithmetic/add.c index f2b8a859..fb823c7a 100644 --- a/libvips/arithmetic/add.c +++ b/libvips/arithmetic/add.c @@ -314,6 +314,8 @@ vips_add_init( VipsAdd *add ) * if possible. Disable this with --vips-novector or IM_NOVECTOR. * * See also: vips_subtract(), vips_linear(). + * + * Returns: 0 on success, -1 on error */ int vips_add( VipsImage *left, VipsImage *right, VipsImage **out, ... ) diff --git a/libvips/arithmetic/avg.c b/libvips/arithmetic/avg.c index f52ee598..7452d128 100644 --- a/libvips/arithmetic/avg.c +++ b/libvips/arithmetic/avg.c @@ -74,18 +74,6 @@ #include "statistic.h" -/** - * VipsAvg: - * @in: input #VipsImage - * @out: output pixel average - * - * This operation finds the average value in an image. It operates on all - * bands of the input image: use im_stats() if you need to calculate an - * average for each band. For complex images, return the average modulus. - * - * See also: im_stats(), im_bandmean(), im_deviate(), im_rank() - */ - typedef struct _VipsAvg { VipsStatistic parent_instance; @@ -239,6 +227,21 @@ vips_avg_init( VipsAvg *avg ) { } + +/** + * vips_avg: + * @in: input #VipsImage + * @out: output pixel average + * @...: %NULL-terminated list of optional named arguments + * + * This operation finds the average value in an image. It operates on all + * bands of the input image: use vips_stats() if you need to calculate an + * average for each band. For complex images, return the average modulus. + * + * See also: vips_stats(), vips_bandmean(), vips_deviate(), vips_rank() + * + * Returns: 0 on success, -1 on error + */ int vips_avg( VipsImage *in, double *out, ... ) { diff --git a/libvips/arithmetic/boolean.c b/libvips/arithmetic/boolean.c index ffd56321..eea2bdf8 100644 --- a/libvips/arithmetic/boolean.c +++ b/libvips/arithmetic/boolean.c @@ -76,34 +76,6 @@ #include "binary.h" #include "unaryconst.h" -/** - * VipsBoolean: - * @left: left-hand input #VipsImage - * @right: right-hand input #VipsImage - * @out: output #VipsImage - * @boolean: boolean operation to perform - * - * Perform various boolean operations on pairs of images. - * - * The output image is the same format as the upcast input images for integer - * types. Float types are cast to int before processing. Complex types are not - * supported. - * - * If the images differ in size, the smaller image is enlarged to match the - * larger by adding zero pixels along the bottom and right. - * - * If the number of bands differs, one of the images - * must have one band. In this case, an n-band image is formed from the - * one-band image by joining n copies of the one-band image together, and then - * the two n-band images are operated upon. - * - * The two input images are cast up to the smallest common type (see table - * Smallest common format in - * arithmetic). - * - * See also: #VipsBoolean, #VipsBooleanConst. - */ - typedef struct _VipsBoolean { VipsBinary parent_instance; @@ -256,6 +228,44 @@ vips_boolean_init( VipsBoolean *boolean ) { } +static int +vips_booleanv( VipsImage *left, VipsImage *right, VipsImage **out, + VipsOperationBoolean boolean, va_list ap ) +{ + return( vips_call_split( "boolean", ap, left, right, out, + boolean ) ); +} + +/** + * vips_boolean: + * @left: left-hand input #VipsImage + * @right: right-hand input #VipsImage + * @out: output #VipsImage + * @boolean: boolean operation to perform + * @...: %NULL-terminated list of optional named arguments + * + * Perform various boolean operations on pairs of images. + * + * The output image is the same format as the upcast input images for integer + * types. Float types are cast to int before processing. Complex types are not + * supported. + * + * If the images differ in size, the smaller image is enlarged to match the + * larger by adding zero pixels along the bottom and right. + * + * If the number of bands differs, one of the images + * must have one band. In this case, an n-band image is formed from the + * one-band image by joining n copies of the one-band image together, and then + * the two n-band images are operated upon. + * + * The two input images are cast up to the smallest common type (see table + * Smallest common format in + * arithmetic). + * + * See also: vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ int vips_boolean( VipsImage *left, VipsImage *right, VipsImage **out, VipsOperationBoolean boolean, ... ) @@ -264,33 +274,141 @@ vips_boolean( VipsImage *left, VipsImage *right, VipsImage **out, int result; va_start( ap, boolean ); - result = vips_call_split( "boolean", ap, left, right, out, - boolean ); + result = vips_booleanv( left, right, out, boolean, ap ); va_end( ap ); return( result ); } /** - * VipsBooleanConst: - * @in: input image - * @out: output image - * @a: array of constants - * @boolean: boolean operation to perform + * vips_andimage: + * @left: left-hand input #VipsImage + * @right: right-hand input #VipsImage + * @out: output #VipsImage + * @...: %NULL-terminated list of optional named arguments * - * Perform various boolean operations on an image against a constant. + * Perform #VIPS_OPERATION_BOOLEAN_AND on a pair of images. See + * vips_boolean(). * - * The output type is always uchar, with 0 for FALSE and 255 for TRUE. - * - * If the array of constants has just one element, that constant is used for - * all image bands. If the array has more than one element and they have - * the same number of elements as there are bands in the image, then - * one array element is used for each band. If the arrays have more than one - * element and the image only has a single band, the result is a many-band - * image where each band corresponds to one array element. - * - * See also: #VipsBoolean, #VipsBoolean. + * Returns: 0 on success, -1 on error */ +int +vips_andimage( VipsImage *left, VipsImage *right, VipsImage **out, ... ) +{ + va_list ap; + int result; + + va_start( ap, out ); + result = vips_booleanv( left, right, out, + VIPS_OPERATION_BOOLEAN_AND, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_orimage: + * @left: left-hand input #VipsImage + * @right: right-hand input #VipsImage + * @out: output #VipsImage + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_OR on a pair of images. See + * vips_boolean(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_orimage( VipsImage *left, VipsImage *right, VipsImage **out, ... ) +{ + va_list ap; + int result; + + va_start( ap, out ); + result = vips_booleanv( left, right, out, + VIPS_OPERATION_BOOLEAN_OR, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_eorimage: + * @left: left-hand input #VipsImage + * @right: right-hand input #VipsImage + * @out: output #VipsImage + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_EOR on a pair of images. See + * vips_boolean(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_eorimage( VipsImage *left, VipsImage *right, VipsImage **out, ... ) +{ + va_list ap; + int result; + + va_start( ap, out ); + result = vips_booleanv( left, right, out, + VIPS_OPERATION_BOOLEAN_EOR, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_lshift: + * @left: left-hand input #VipsImage + * @right: right-hand input #VipsImage + * @out: output #VipsImage + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_LSHIFT on a pair of images. See + * vips_boolean(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_lshift( VipsImage *left, VipsImage *right, VipsImage **out, ... ) +{ + va_list ap; + int result; + + va_start( ap, out ); + result = vips_booleanv( left, right, out, + VIPS_OPERATION_BOOLEAN_LSHIFT, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_rshift: + * @left: left-hand input #VipsImage + * @right: right-hand input #VipsImage + * @out: output #VipsImage + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_RSHIFT on a pair of images. See + * vips_boolean(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_rshift( VipsImage *left, VipsImage *right, VipsImage **out, ... ) +{ + va_list ap; + int result; + + va_start( ap, out ); + result = vips_booleanv( left, right, out, + VIPS_OPERATION_BOOLEAN_RSHIFT, ap ); + va_end( ap ); + + return( result ); +} typedef struct _VipsBooleanConst { VipsUnaryConst parent_instance; @@ -434,6 +552,31 @@ vips_boolean_constv( VipsImage *in, VipsImage **out, return( result ); } +/** + * vips_boolean_const: + * @in: input image + * @out: output image + * @boolean: boolean operation to perform + * @c: array of constants + * @n: number of constants in @c + * @...: %NULL-terminated list of optional named arguments + * + * Perform various boolean operations on an image against an array of + * constants. + * + * The output type is always uchar, with 0 for FALSE and 255 for TRUE. + * + * If the array of constants has just one element, that constant is used for + * all image bands. If the array has more than one element and they have + * the same number of elements as there are bands in the image, then + * one array element is used for each band. If the arrays have more than one + * element and the image only has a single band, the result is a many-band + * image where each band corresponds to one array element. + * + * See also: vips_boolean(), vips_boolean_const1(). + * + * Returns: 0 on success, -1 on error + */ int vips_boolean_const( VipsImage *in, VipsImage **out, VipsOperationBoolean boolean, double *c, int n, ... ) @@ -448,6 +591,166 @@ vips_boolean_const( VipsImage *in, VipsImage **out, return( result ); } +/** + * vips_andimage_const: + * @in: input image + * @out: output image + * @c: array of constants + * @n: number of constants in @c + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_AND on an image and an array of constants. + * See vips_boolean_const(). + * + * See also: vips_boolean(), vips_boolean_const1(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_andimage_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) +{ + va_list ap; + int result; + + va_start( ap, n ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_AND, c, n, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_orimage_const: + * @in: input image + * @out: output image + * @c: array of constants + * @n: number of constants in @c + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_OR on an image and an array of constants. + * See vips_boolean_const(). + * + * See also: vips_boolean(), vips_boolean_const1(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_orimage_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) +{ + va_list ap; + int result; + + va_start( ap, n ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_OR, c, n, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_eorimage_const: + * @in: input image + * @out: output image + * @c: array of constants + * @n: number of constants in @c + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_EOR on an image and an array of constants. + * See vips_boolean_const(). + * + * See also: vips_boolean(), vips_boolean_const1(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_eorimage_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) +{ + va_list ap; + int result; + + va_start( ap, n ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_EOR, c, n, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_lshift_const: + * @in: input image + * @out: output image + * @c: array of constants + * @n: number of constants in @c + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_LSHIFT on an image and an array of constants. + * See vips_boolean_const(). + * + * See also: vips_boolean(), vips_boolean_const1(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_lshift_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) +{ + va_list ap; + int result; + + va_start( ap, n ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_LSHIFT, c, n, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_rshift_const: + * @in: input image + * @out: output image + * @c: array of constants + * @n: number of constants in @c + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_LSHIFT on an image and an array of constants. + * See vips_boolean_const(). + * + * See also: vips_boolean(), vips_boolean_const1(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_rshift_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) +{ + va_list ap; + int result; + + va_start( ap, n ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_RSHIFT, c, n, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_boolean_const1: + * @in: input image + * @out: output image + * @boolean: boolean operation to perform + * @c: constant + * @...: %NULL-terminated list of optional named arguments + * + * Perform various boolean operations on an image with a single constant. See + * vips_boolean_const(). + * + * See also: vips_boolean(), vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ int vips_boolean_const1( VipsImage *in, VipsImage **out, VipsOperationBoolean boolean, double c, ... ) @@ -461,3 +764,143 @@ vips_boolean_const1( VipsImage *in, VipsImage **out, return( result ); } + +/** + * vips_andimage_const1: + * @in: input image + * @out: output image + * @c: constant + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_AND on an image and a constant. + * See vips_boolean_const1(). + * + * See also: vips_boolean(), vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_andimage_const1( VipsImage *in, VipsImage **out, double c, ... ) +{ + va_list ap; + int result; + + va_start( ap, c ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_AND, &c, 1, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_orimage_const1: + * @in: input image + * @out: output image + * @c: constant + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_OR on an image and a constant. + * See vips_boolean_const1(). + * + * See also: vips_boolean(), vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_orimage_const1( VipsImage *in, VipsImage **out, double c, ... ) +{ + va_list ap; + int result; + + va_start( ap, c ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_OR, &c, 1, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_eorimage_const1: + * @in: input image + * @out: output image + * @c: constant + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_EOR on an image and a constant. + * See vips_boolean_const1(). + * + * See also: vips_boolean(), vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_eorimage_const1( VipsImage *in, VipsImage **out, double c, ... ) +{ + va_list ap; + int result; + + va_start( ap, c ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_EOR, &c, 1, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_lshift_const1: + * @in: input image + * @out: output image + * @c: constant + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_LSHIFT on an image and a constant. + * See vips_boolean_const1(). + * + * See also: vips_boolean(), vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_lshift_const1( VipsImage *in, VipsImage **out, double c, ... ) +{ + va_list ap; + int result; + + va_start( ap, c ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_LSHIFT, &c, 1, ap ); + va_end( ap ); + + return( result ); +} + +/** + * vips_rshift_const1: + * @in: input image + * @out: output image + * @c: constant + * @...: %NULL-terminated list of optional named arguments + * + * Perform #VIPS_OPERATION_BOOLEAN_RSHIFT on an image and a constant. + * See vips_boolean_const1(). + * + * See also: vips_boolean(), vips_boolean_const(). + * + * Returns: 0 on success, -1 on error + */ +int +vips_rshift_const1( VipsImage *in, VipsImage **out, double c, ... ) +{ + va_list ap; + int result; + + va_start( ap, c ); + result = vips_boolean_constv( in, out, + VIPS_OPERATION_BOOLEAN_RSHIFT, &c, 1, ap ); + va_end( ap ); + + return( result ); +} diff --git a/libvips/arithmetic/deviate.c b/libvips/arithmetic/deviate.c index 9e12d6a6..e69e24c3 100644 --- a/libvips/arithmetic/deviate.c +++ b/libvips/arithmetic/deviate.c @@ -73,20 +73,6 @@ #include "statistic.h" -/** - * VipsDeviate: - * @in: input #IMAGE - * @out: output pixel standard deviation - * - * This operation finds the standard deviation of all pixels in @in. It - * operates on all bands of the input image: use im_stats() if you need - * to calculate an average for each band. - * - * Non-complex images only. - * - * See also: VipsDeviate. - */ - typedef struct _VipsDeviate { VipsStatistic parent_instance; @@ -242,6 +228,22 @@ vips_deviate_init( VipsDeviate *deviate ) { } +/** + * vips_deviate(): + * @in: input #VipsImage + * @out: output pixel standard deviation + * @...: %NULL-terminated list of optional named arguments + * + * This operation finds the standard deviation of all pixels in @in. It + * operates on all bands of the input image: use vips_stats() if you need + * to calculate an average for each band. + * + * Non-complex images only. + * + * See also: vips_avg(), vips_stats().. + * + * Returns: 0 on success, -1 on error + */ int vips_deviate( VipsImage *in, double *out, ... ) { diff --git a/libvips/arithmetic/divide.c b/libvips/arithmetic/divide.c index 0d3f1ad1..d4043725 100644 --- a/libvips/arithmetic/divide.c +++ b/libvips/arithmetic/divide.c @@ -73,88 +73,6 @@ #include "binary.h" -/** - * VipsDivide:: - * @in1: input #IMAGE 1 - * @in2: input #IMAGE 2 - * @out: output #IMAGE - * - * This operation calculates @in1 / @in2 and writes the result to @out. If any - * pixels in @in2 are zero, the corresponding pixel in @out is also zero. - * - * If the images differ in size, the smaller image is enlarged to match the - * larger by adding zero pixels along the bottom and right. - * - * If the number of bands differs, one of the images - * must have one band. In this case, an n-band image is formed from the - * one-band image by joining n copies of the one-band image together, and then - * the two n-band images are operated upon. - * - * The two input images are cast up to the smallest common type (see table - * Smallest common format in - * arithmetic), then the - * following table is used to determine the output type: - * - * - * im_divide() type promotion - * - * - * - * input type - * output type - * - * - * - * - * uchar - * float - * - * - * char - * float - * - * - * ushort - * float - * - * - * short - * float - * - * - * uint - * float - * - * - * int - * float - * - * - * float - * float - * - * - * double - * double - * - * - * complex - * complex - * - * - * double complex - * double complex - * - * - * - *
- * - * In other words, the output type is just large enough to hold the whole - * range of possible values. - * - * See also: #VipsAdd, #VipsSubtract. - */ - typedef VipsBinary VipsDivide; typedef VipsBinaryClass VipsDivideClass; @@ -302,6 +220,90 @@ vips_divide_init( VipsDivide *divide ) { } +/** + * vips_divide:: + * @in1: input image 1 + * @in2: input image 2 + * @out: output image + * @...: %NULL-terminated list of optional named arguments + * + * This operation calculates @in1 / @in2 and writes the result to @out. If any + * pixels in @in2 are zero, the corresponding pixel in @out is also zero. + * + * If the images differ in size, the smaller image is enlarged to match the + * larger by adding zero pixels along the bottom and right. + * + * If the number of bands differs, one of the images + * must have one band. In this case, an n-band image is formed from the + * one-band image by joining n copies of the one-band image together, and then + * the two n-band images are operated upon. + * + * The two input images are cast up to the smallest common type (see table + * Smallest common format in + * arithmetic), then the + * following table is used to determine the output type: + * + * + * im_divide() type promotion + * + * + * + * input type + * output type + * + * + * + * + * uchar + * float + * + * + * char + * float + * + * + * ushort + * float + * + * + * short + * float + * + * + * uint + * float + * + * + * int + * float + * + * + * float + * float + * + * + * double + * double + * + * + * complex + * complex + * + * + * double complex + * double complex + * + * + * + *
+ * + * In other words, the output type is just large enough to hold the whole + * range of possible values. + * + * See also: vips_multiply(), vips_linear(), vips_power(). + * + * Returns: 0 on success, -1 on error + */ int vips_divide( VipsImage *left, VipsImage *right, VipsImage **out, ... ) { diff --git a/libvips/arithmetic/invert.c b/libvips/arithmetic/invert.c index 5407a466..5c3de271 100644 --- a/libvips/arithmetic/invert.c +++ b/libvips/arithmetic/invert.c @@ -60,20 +60,6 @@ #include "unary.h" -/** - * VipsInvert: - * @in: input #VipsImage - * @out: output #VipsImage - * - * For unsigned formats, this operation calculates (max - @in), eg. (255 - - * @in) for uchar. For signed and float formats, this operation calculates (-1 - * * @in). - * - * See also: im_lintra(). - * - * Returns: 0 on success, -1 on error - */ - typedef VipsUnary VipsInvert; typedef VipsUnaryClass VipsInvertClass; @@ -174,6 +160,20 @@ vips_invert_init( VipsInvert *invert ) { } +/** + * vips_invert: + * @in: input image + * @out: output image + * @...: %NULL-terminated list of optional named arguments + * + * For unsigned formats, this operation calculates (max - @in), eg. (255 - + * @in) for uchar. For signed and float formats, this operation calculates (-1 + * * @in). + * + * See also: vips_linear(). + * + * Returns: 0 on success, -1 on error + */ int vips_invert( VipsImage *in, VipsImage **out, ... ) { diff --git a/libvips/arithmetic/linear.c b/libvips/arithmetic/linear.c index 38121df3..1a599be2 100644 --- a/libvips/arithmetic/linear.c +++ b/libvips/arithmetic/linear.c @@ -83,29 +83,6 @@ #include "unary.h" -/** - * VipsLinear: - * @in: image to transform - * @out: output image - * @a: array of constants for multiplication - * @b: array of constants for addition - * - * Pass an image through a linear transform, ie. (@out = @in * @a + @b). Output - * is always float for integer input, double for double input, complex for - * complex input and double complex for double complex input. - * - * If the arrays of constants have just one element, that constant is used for - * all image bands. If the arrays have more than one element and they have - * the same number of elements as there are bands in the image, then - * one array element is used for each band. If the arrays have more than one - * element and the image only has a single band, the result is a many-band - * image where each band corresponds to one array element. - * - * See also: #VipsAdd. - * - * Returns: 0 on success, -1 on error - */ - typedef struct _VipsLinear { VipsUnary parent_instance; @@ -323,6 +300,29 @@ vips_linearv( VipsImage *in, VipsImage **out, return( result ); } +/** + * vips_linear: + * @in: image to transform + * @out: output image + * @a: array of constants for multiplication + * @b: array of constants for addition + * @n: length of constant arrays + * + * Pass an image through a linear transform, ie. (@out = @in * @a + @b). Output + * is always float for integer input, double for double input, complex for + * complex input and double complex for double complex input. + * + * If the arrays of constants have just one element, that constant is used for + * all image bands. If the arrays have more than one element and they have + * the same number of elements as there are bands in the image, then + * one array element is used for each band. If the arrays have more than one + * element and the image only has a single band, the result is a many-band + * image where each band corresponds to one array element. + * + * See also: vips_linear1(), vips_add(). + * + * Returns: 0 on success, -1 on error + */ int vips_linear( VipsImage *in, VipsImage **out, double *a, double *b, int n, ... ) { @@ -336,6 +336,19 @@ vips_linear( VipsImage *in, VipsImage **out, double *a, double *b, int n, ... ) return( result ); } +/** + * vips_linear1: + * @in: image to transform + * @out: output image + * @a: constant for multiplication + * @b: constant for addition + * + * Run vips_linear() with a single constant. + * + * See also: vips_linear(). + * + * Returns: 0 on success, -1 on error + */ int vips_linear1( VipsImage *in, VipsImage **out, double a, double b, ... ) { diff --git a/libvips/conversion/join.c b/libvips/conversion/join.c index 01d117ce..2a659317 100644 --- a/libvips/conversion/join.c +++ b/libvips/conversion/join.c @@ -68,46 +68,6 @@ #include "conversion.h" -/** - * VipsJoin: - * @in1: first input image - * @in2: second input image - * @out: output image - * @direction: join horizontally or vertically - * @expand: %TRUE to expand the output image to hold all of the input pixels - * @shim: space between images, in pixels - * @background: background ink colour - * @align: low, centre or high alignment - * - * Join @in1 and @in2 together, left-right or up-down depending on the value - * of @direction. - * - * If one is taller or wider than the - * other, @out will be has high as the smaller. If @expand is %TRUE, then - * the output will be expanded to contain all of the input pixels. - * - * Use @align to set the edge that the images align on. By default, they align - * on the edge with the lower value coordinate. - * - * Use @background to set the colour of any pixels in @out which are not - * present in either @in1 or @in2. - * - * Use @shim to set the spacing between the images. By default this is 0. - * - * If the number of bands differs, one of the images - * must have one band. In this case, an n-band image is formed from the - * one-band image by joining n copies of the one-band image together, and then - * the two n-band images are operated upon. - * - * The two input images are cast up to the smallest common type (see table - * Smallest common format in - * arithmetic). - * - * See also: vips_insert(). - * - * Returns: 0 on success, -1 on error - */ - typedef struct _VipsJoin { VipsConversion parent_instance; @@ -309,6 +269,45 @@ vips_join_init( VipsJoin *join ) ((double *) (join->background->data))[0] = 0.0; } +/** + * vips_join: + * @in1: first input image + * @in2: second input image + * @out: output image + * @direction: join horizontally or vertically + * @expand: %TRUE to expand the output image to hold all of the input pixels + * @shim: space between images, in pixels + * @background: background ink colour + * @align: low, centre or high alignment + * + * Join @in1 and @in2 together, left-right or up-down depending on the value + * of @direction. + * + * If one is taller or wider than the + * other, @out will be has high as the smaller. If @expand is %TRUE, then + * the output will be expanded to contain all of the input pixels. + * + * Use @align to set the edge that the images align on. By default, they align + * on the edge with the lower value coordinate. + * + * Use @background to set the colour of any pixels in @out which are not + * present in either @in1 or @in2. + * + * Use @shim to set the spacing between the images. By default this is 0. + * + * If the number of bands differs, one of the images + * must have one band. In this case, an n-band image is formed from the + * one-band image by joining n copies of the one-band image together, and then + * the two n-band images are operated upon. + * + * The two input images are cast up to the smallest common type (see table + * Smallest common format in + * arithmetic). + * + * See also: vips_insert(). + * + * Returns: 0 on success, -1 on error + */ int vips_join( VipsImage *in1, VipsImage *in2, VipsImage **out, VipsDirection direction, ... ) diff --git a/libvips/include/vips/arithmetic.h b/libvips/include/vips/arithmetic.h index ebfb1bbf..873d3ab7 100644 --- a/libvips/include/vips/arithmetic.h +++ b/libvips/include/vips/arithmetic.h @@ -140,21 +140,13 @@ int vips_multiply( VipsImage *left, VipsImage *right, VipsImage **out, ... ) __attribute__((sentinel)); int vips_divide( VipsImage *left, VipsImage *right, VipsImage **out, ... ) __attribute__((sentinel)); -int vips_avg( VipsImage *in, double *out, ... ) - __attribute__((sentinel)); -int vips_deviate( VipsImage *in, double *out, ... ) - __attribute__((sentinel)); -int vips_min( VipsImage *in, double *out, ... ) - __attribute__((sentinel)); -int vips_max( VipsImage *in, double *out, ... ) - __attribute__((sentinel)); -int vips_invert( VipsImage *in, VipsImage **out, ... ) - __attribute__((sentinel)); int vips_linear( VipsImage *in, VipsImage **out, double *a, double *b, int n, ... ) __attribute__((sentinel)); int vips_linear1( VipsImage *in, VipsImage **out, double a, double b, ... ) __attribute__((sentinel)); +int vips_invert( VipsImage *in, VipsImage **out, ... ) + __attribute__((sentinel)); int vips_math( VipsImage *in, VipsImage **out, VipsOperationMath math, ... ) __attribute__((sentinel)); @@ -162,12 +154,6 @@ int vips_abs( VipsImage *in, VipsImage **out, ... ) __attribute__((sentinel)); int vips_sign( VipsImage *in, VipsImage **out, ... ) __attribute__((sentinel)); -int vips_stats( VipsImage *in, VipsImage **out, ... ) - __attribute__((sentinel)); -int vips_measure( VipsImage *in, VipsImage **out, int h, int v, ... ) - __attribute__((sentinel)); -int vips_recomb( VipsImage *in, VipsImage **out, VipsImage *m, ... ) - __attribute__((sentinel)); int vips_round( VipsImage *in, VipsImage **out, VipsOperationRound round, ... ) __attribute__((sentinel)); int vips_relational( VipsImage *left, VipsImage *right, VipsImage **out, @@ -187,12 +173,45 @@ int vips_remainder_const( VipsImage *in, VipsImage **out, int vips_remainder_const1( VipsImage *in, VipsImage **out, double c, ... ) __attribute__((sentinel)); + int vips_boolean( VipsImage *left, VipsImage *right, VipsImage **out, VipsOperationBoolean boolean, ... ) __attribute__((sentinel)); +int vips_andimage( VipsImage *left, VipsImage *right, VipsImage **out, ... ) + __attribute__((sentinel)); +int vips_orimage( VipsImage *left, VipsImage *right, VipsImage **out, ... ) + __attribute__((sentinel)); +int vips_eorimage( VipsImage *left, VipsImage *right, VipsImage **out, ... ) + __attribute__((sentinel)); +int vips_lshift( VipsImage *left, VipsImage *right, VipsImage **out, ... ) + __attribute__((sentinel)); +int vips_rshift( VipsImage *left, VipsImage *right, VipsImage **out, ... ) + __attribute__((sentinel)); + int vips_boolean_const( VipsImage *in, VipsImage **out, VipsOperationBoolean boolean, double *c, int n, ... ) __attribute__((sentinel)); +int vips_andimage_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) + __attribute__((sentinel)); +int vips_orimage_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) + __attribute__((sentinel)); +int vips_eorimage_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) + __attribute__((sentinel)); +int vips_lshift_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) + __attribute__((sentinel)); +int vips_rshift_const( VipsImage *in, VipsImage **out, double *c, int n, ... ) + __attribute__((sentinel)); +int vips_andimage_const1( VipsImage *in, VipsImage **out, double c, ... ) + __attribute__((sentinel)); +int vips_orimage_const1( VipsImage *in, VipsImage **out, double c, ... ) + __attribute__((sentinel)); +int vips_eorimage_const1( VipsImage *in, VipsImage **out, double c, ... ) + __attribute__((sentinel)); +int vips_lshift_const1( VipsImage *in, VipsImage **out, double c, ... ) + __attribute__((sentinel)); +int vips_rshift_const1( VipsImage *in, VipsImage **out, double c, ... ) + __attribute__((sentinel)); + int vips_math2( VipsImage *left, VipsImage *right, VipsImage **out, VipsOperationMath2 math2, ... ) __attribute__((sentinel)); @@ -203,6 +222,22 @@ int vips_math2_const1( VipsImage *in, VipsImage **out, VipsOperationMath2 math2, double c, ... ) __attribute__((sentinel)); +int vips_recomb( VipsImage *in, VipsImage **out, VipsImage *m, ... ) + __attribute__((sentinel)); + +int vips_avg( VipsImage *in, double *out, ... ) + __attribute__((sentinel)); +int vips_deviate( VipsImage *in, double *out, ... ) + __attribute__((sentinel)); +int vips_min( VipsImage *in, double *out, ... ) + __attribute__((sentinel)); +int vips_max( VipsImage *in, double *out, ... ) + __attribute__((sentinel)); +int vips_stats( VipsImage *in, VipsImage **out, ... ) + __attribute__((sentinel)); +int vips_measure( VipsImage *in, VipsImage **out, int h, int v, ... ) + __attribute__((sentinel)); +