sig
  external sizeof_quantum : unit -> int = "im_sizeof_quantum"
  external sizeof_quantum_bit : unit -> int = "im_sizeof_quantum_bit"
  type image_handle
  external read_image : filename:string -> Magick.image_handle
    = "im_readimage"
  external get_canvas :
    width:int -> height:int -> color:string -> Magick.image_handle
    = "im_getimagecanvas"
  external create_image :
    width:int -> height:int -> pseudo_format:string -> Magick.image_handle
    = "im_create_image"
  external clone_image : Magick.image_handle -> Magick.image_handle
    = "im_cloneimage"
  external write_image : Magick.image_handle -> filename:string -> unit
    = "im_writeimage"
  external display : Magick.image_handle -> unit = "im_displayimages"
  external image_to_stdout : Magick.image_handle -> unit
    = "imper_imagetoblob_stdout"
  external blob_of_image : Magick.image_handle -> int list
    = "imper_imagetoblob_bytes"
  val dump_to_stdout : Magick.image_handle -> unit
  external get_image_width : Magick.image_handle -> int
    = "imper_getimagewidth"
  external get_image_height : Magick.image_handle -> int
    = "imper_getimageheight"
  external get_image_depth : Magick.image_handle -> int
    = "imper_getimagedepth"
  external get_image_quality : Magick.image_handle -> int
    = "imper_getimagequality"
  external get_image_mimetype : Magick.image_handle -> string
    = "imper_getimagemimetype"
  external get_image_size : Magick.image_handle -> string
    = "imper_getimagesize"
  external get_image_colors : Magick.image_handle -> int
    = "imper_getimagecolors"
  external get_image_colorspace : Magick.image_handle -> int
    = "imper_getimagecolorspace"
  external ping_image_infos : string -> int * int * int * int * int * string
    = "imper_ping_image_infos"
  external ping_image : string -> bool = "imper_ping_image"
  external get_number_colors : Magick.image_handle -> int
    = "imper_getimagehistogram"
  external get_image_histogram :
    Magick.image_handle -> histogram_file:string -> int
    = "imper_getnumbercolors"
  external get_max_colormap : unit -> int = "imper_getmaxcolormap"
  type image_type =
      Undefined_image_type
    | Bilevel
    | Grayscale
    | GrayscaleMatte
    | Palette
    | PaletteMatte
    | TrueColor
    | TrueColorMatte
    | ColorSeparation
    | ColorSeparationMatte
    | Optimize
  external get_image_type : Magick.image_handle -> Magick.image_type
    = "imper_getimagetype"
  val string_of_image_type : Magick.image_type -> string
  type magick_boolean = MagickFalse | MagickTrue
  val magick_boolean_of_string : string -> Magick.magick_boolean
  type noise_type =
      UndefinedNoise
    | UniformNoise
    | GaussianNoise
    | MultiplicativeGaussianNoise
    | ImpulseNoise
    | LaplacianNoise
    | PoissonNoise
  type resize_filter =
      Undefined_resize_filter
    | Point
    | Box
    | Triangle
    | Hermite
    | Hanning
    | Hamming
    | Blackman
    | Gaussian
    | Quadratic
    | Cubic
    | Catrom
    | Mitchell
    | Lanczos
    | Bessel
    | Sinc
  val resize_filter_of_string : string -> Magick.resize_filter
  val resize_filter_of_string' : string -> Magick.resize_filter
  val string_of_resize_filter : Magick.resize_filter -> string
  type channel_type =
      Undefined_Channel
    | Red
    | Gray
    | Cyan
    | Green
    | Magenta
    | Blue
    | Yellow
    | Alpha
    | Opacity
    | Black
    | Index
    | All_Channels
    | Default_Channels
  val channel_type_of_string : string -> Magick.channel_type
  val channel_type_of_string' : string -> Magick.channel_type
  val string_of_channel_type : Magick.channel_type -> string
  type composite_operator =
      Undefined_composite_operator
    | No_composite_operator
    | Add
    | Atop
    | Blend
    | Bumpmap
    | Clear
    | ColorBurn
    | ColorDodge
    | Colorize
    | CopyBlack
    | CopyBlue
    | Copy
    | CopyCyan
    | CopyGreen
    | CopyMagenta
    | CopyOpacity
    | CopyRed
    | CopyYellow
    | Darken
    | DstAtop
    | Dst
    | DstIn
    | DstOut
    | DstOver
    | Difference
    | Displace
    | Dissolve
    | Exclusion
    | HardLight
    | Hue
    | In
    | Lighten
    | Luminize
    | Minus
    | Modulate
    | Multiply
    | Out
    | Over
    | Overlay
    | Plus
    | Replace
    | Saturate
    | Screen
    | SoftLight
    | SrcAtop
    | Src
    | SrcIn
    | SrcOut
    | SrcOver
    | Subtract
    | Threshold
    | Xor
  val composite_operator_of_string : string -> Magick.composite_operator
  val composite_operator_of_string' : string -> Magick.composite_operator
  val string_of_composite_operator : Magick.composite_operator -> string
  module Imper :
    sig
      external plasma_image :
        Magick.image_handle ->
        x1:int ->
        y1:int -> x2:int -> y2:int -> attenuate:int -> depth:int -> unit
        = "imper_plasmaimage_bytecode" "imper_plasmaimage_native"
      external flip : Magick.image_handle -> unit = "imper_flipimage"
      external flop : Magick.image_handle -> unit = "imper_flopimage"
      external magnify : Magick.image_handle -> unit = "imper_magnifyimage"
      external minify : Magick.image_handle -> unit = "imper_minifyimage"
      external enhance : Magick.image_handle -> unit = "imper_enhanceimage"
      external trim : Magick.image_handle -> unit = "imper_trimimage"
      external despeckle : Magick.image_handle -> unit = "imper_despeckle"
      val negate :
        Magick.image_handle ->
        ?grayscale:Magick.magick_boolean -> unit -> unit
      external contrast :
        Magick.image_handle -> sharpen:Magick.magick_boolean -> unit
        = "imper_contrastimage"
      external equalize : Magick.image_handle -> unit = "imper_equalizeimage"
      external normalize : Magick.image_handle -> unit
        = "imper_normalizeimage"
      external white_threshold :
        Magick.image_handle -> threshold:string -> unit
        = "imper_whitethresholdimage"
      external black_threshold :
        Magick.image_handle -> threshold:string -> unit
        = "imper_blackthresholdimage"
      external cyclecolormap : Magick.image_handle -> displace:int -> unit
        = "imper_cyclecolormapimage"
      external solarize : Magick.image_handle -> threshold:float -> unit
        = "imper_solarizeimage"
      external modulate' : Magick.image_handle -> factors:string -> unit
        = "imper_modulateimage"
      val modulate :
        Magick.image_handle ->
        ?brightness:int -> ?saturation:int -> ?hue:int -> unit -> unit
      val blur :
        Magick.image_handle -> ?radius:float -> sigma:float -> unit -> unit
      val gaussian_blur :
        Magick.image_handle -> ?radius:float -> sigma:float -> unit -> unit
      val motion_blur :
        Magick.image_handle ->
        ?radius:float -> sigma:float -> angle:float -> unit -> unit
      val charcoal :
        Magick.image_handle -> ?radius:float -> sigma:float -> unit -> unit
      external edge : Magick.image_handle -> radius:float -> unit
        = "imper_edgeimage"
      val emboss :
        Magick.image_handle -> ?radius:float -> sigma:float -> unit -> unit
      external implode : Magick.image_handle -> amount:float -> unit
        = "imper_implodeimage"
      external medianfilter : Magick.image_handle -> radius:float -> unit
        = "imper_medianfilterimage"
      external oilpaint : Magick.image_handle -> radius:float -> unit
        = "imper_oilpaintimage"
      external reduce_noise : Magick.image_handle -> radius:float -> unit
        = "imper_reducenoiseimage"
      external roll : Magick.image_handle -> x:int -> y:int -> unit
        = "imper_rollimage"
      val shade :
        Magick.image_handle ->
        ?gray:Magick.magick_boolean ->
        azimuth:float -> elevation:float -> unit -> unit
      external spread : Magick.image_handle -> radius:float -> unit
        = "imper_spreadimage"
      external swirl : Magick.image_handle -> degrees:float -> unit
        = "imper_swirlimage"
      val sharpen :
        Magick.image_handle -> ?radius:float -> sigma:float -> unit -> unit
      external unsharpmask :
        Magick.image_handle ->
        radius:float ->
        sigma:float -> amount:float -> threshold:float -> unit
        = "imper_unsharpmaskimage"
      external wave :
        Magick.image_handle -> amplitude:float -> wave_length:float -> unit
        = "imper_waveimage"
      external rotate : Magick.image_handle -> degrees:float -> unit
        = "imper_rotateimage"
      external shear : Magick.image_handle -> x:float -> y:float -> unit
        = "imper_shearimage"
      val affine_transform :
        Magick.image_handle ->
        ?tx:float ->
        ?ty:float ->
        ?sx:float -> ?sy:float -> ?rx:float -> ?ry:float -> unit -> unit
      external adaptive_threshold :
        Magick.image_handle -> width:int -> height:int -> offset:int -> unit
        = "imper_adaptivethresholdimage"
      external crop :
        Magick.image_handle ->
        x:int -> y:int -> width:int -> height:int -> unit = "imper_cropimage"
      external chop :
        Magick.image_handle ->
        x:int -> y:int -> width:int -> height:int -> unit = "imper_chopimage"
      external splice :
        Magick.image_handle ->
        x:int -> y:int -> width:int -> height:int -> unit
        = "imper_spliceimage"
      external colorize :
        Magick.image_handle -> string -> int -> int -> int -> int -> unit
        = "imper_colorizeimage_bytecode" "imper_colorizeimage_native"
      external acquire_pixel :
        Magick.image_handle -> int -> int -> int * int * int * int
        = "imper_acquireonepixel"
      val composite_image :
        Magick.image_handle ->
        Magick.image_handle ->
        compose:Magick.composite_operator -> ?x:int -> ?y:int -> unit -> unit
      external texture_image :
        Magick.image_handle -> Magick.image_handle -> unit
        = "imper_textureimage"
      external bilevel_channel :
        Magick.image_handle -> channel:Magick.channel_type -> float -> unit
        = "imper_bilevelimagechannel"
      val blur_channel :
        Magick.image_handle ->
        channel:Magick.channel_type ->
        ?radius:float -> sigma:float -> unit -> unit
      val gaussian_blur_channel :
        Magick.image_handle ->
        channel:Magick.channel_type ->
        ?radius:float -> sigma:float -> unit -> unit
      external radial_blur : Magick.image_handle -> angle:float -> unit
        = "imper_radialblurimage"
      external radial_blur_channel :
        Magick.image_handle ->
        channel:Magick.channel_type -> angle:float -> unit
        = "imper_radialblurimagechannel"
      val sharpen_image_channel :
        Magick.image_handle ->
        channel:Magick.channel_type ->
        ?radius:float -> sigma:float -> unit -> unit
      external add_noise : Magick.image_handle -> Magick.noise_type -> unit
        = "imper_addnoiseimage"
      external resize :
        Magick.image_handle ->
        width:int ->
        height:int -> filter:Magick.resize_filter -> blur:float -> unit
        = "imper_resizeimage"
      external sample :
        Magick.image_handle -> width:int -> height:int -> unit
        = "imper_sampleimage"
      external scale : Magick.image_handle -> width:int -> height:int -> unit
        = "imper_scaleimage"
      external thumbnail :
        Magick.image_handle -> width:int -> height:int -> unit
        = "imper_thumbnailimage"
      external set_image_colors : Magick.image_handle -> int -> unit
        = "imper_setimagecolors"
      external set_compression_quality : Magick.image_handle -> int -> unit
        = "imper_setcompressionquality"
      external set_image_type :
        Magick.image_handle -> image_type:Magick.image_type -> unit
        = "imper_setimagetype"
      external set_type : Magick.image_handle -> unit
        = "imper_setimagetype__"
      external strip_image : Magick.image_handle -> unit = "imper_stripimage"
      external level : Magick.image_handle -> string -> unit
        = "imper_levelimage"
      external level_channel :
        Magick.image_handle ->
        channel:Magick.channel_type -> float -> float -> float -> unit
        = "imper_levelimagechannel"
      external gamma_channel :
        Magick.image_handle ->
        channel:Magick.channel_type -> gamma:float -> unit
        = "imper_gammaimagechannel"
      external negate_channel :
        Magick.image_handle ->
        channel:Magick.channel_type -> Magick.magick_boolean -> unit
        = "imper_negateimagechannel"
      external ordered_dither : Magick.image_handle -> unit
        = "imper_orderedditherimage"
      external compress_colormap : Magick.image_handle -> unit
        = "imper_compressimagecolormap"
      external posterize :
        Magick.image_handle ->
        levels:int -> dither:Magick.magick_boolean -> unit
        = "imper_posterizeimage"
      external map_image :
        Magick.image_handle ->
        map_image:Magick.image_handle -> dither:Magick.magick_boolean -> unit
        = "imper_mapimage"
      external is_gray : Magick.image_handle -> bool = "imper_isgrayimage"
      external is_monochrome : Magick.image_handle -> bool
        = "imper_ismonochromeimage"
      external is_opaque : Magick.image_handle -> bool
        = "imper_isopaqueimage"
      external is_palette : Magick.image_handle -> bool
        = "imper_ispaletteimage"
      external is_taint : Magick.image_handle -> bool = "imper_istaintimage"
      external is_equal :
        Magick.image_handle ->
        Magick.image_handle -> bool * float * float * float
        = "imper_isimagesequal"
      type line_cap = UndefinedCap | ButtCap | RoundCap | SquareCap
      type line_join = UndefinedJoin | MiterJoin | RoundJoin | BevelJoin
      type color = int * int * int * int
      val channels_of_color : Magick.Imper.color -> int * int * int * int
      external acquire_pixel_opacity :
        Magick.image_handle -> int -> int -> int * int * int * int
        = "imper_acquireonepixel_opacity"
      external set_image_opacity : Magick.image_handle -> opacity:int -> unit
        = "imper_setimageopacity"
      external color_of_string : string -> Magick.Imper.color
        = "imper_querycolordatabase"
      val color_of_rgbo_tuple : int * int * int * int -> Magick.Imper.color
      val rgbo_tuple_of_color : Magick.Imper.color -> int * int * int * int
      val max_color_map : int
      val add_colors :
        Magick.Imper.color -> Magick.Imper.color -> Magick.Imper.color
      val sub_colors :
        Magick.Imper.color -> Magick.Imper.color -> Magick.Imper.color
      val mul_colors :
        Magick.Imper.color -> Magick.Imper.color -> Magick.Imper.color
      val dump_color : Magick.Imper.color -> unit
      val div_colors :
        Magick.Imper.color -> Magick.Imper.color -> Magick.Imper.color
      val rgb_string_of_color : Magick.Imper.color -> string
      val rgba_string_of_color : Magick.Imper.color -> string
      val hexa_string_of_color : Magick.Imper.color -> string
      val color_of_hex : string -> int * int * int * int
      val black : Magick.Imper.color
      val transparent : Magick.Imper.color
      type affine_matrix = {
        sx : float;
        rx : float;
        ry : float;
        sy : float;
        tx : float;
        ty : float;
      }
      val identity_matrix : Magick.Imper.affine_matrix
      val tuple_of_matrix :
        affine_matrix:Magick.Imper.affine_matrix ->
        float * float * float * float * float * float
      external set_pixel :
        Magick.image_handle ->
        x:int ->
        y:int -> red:int -> green:int -> blue:int -> opacity:int -> unit
        = "imper_draw_point_bytecode" "imper_draw_point_native"
      val draw_point :
        Magick.image_handle ->
        x:int -> y:int -> color:Magick.Imper.color -> unit
      val draw_line :
        Magick.image_handle ->
        x0:int ->
        y0:int ->
        x1:int ->
        y1:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?line_cap:Magick.Imper.line_cap -> unit -> unit
      val draw_circle :
        Magick.image_handle ->
        x0:int ->
        y0:int ->
        x1:int ->
        y1:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_width:float ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_rectangle :
        Magick.image_handle ->
        x0:int ->
        y0:int ->
        x1:int ->
        y1:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_width:float ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?line_join:Magick.Imper.line_join ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_round_rectangle :
        Magick.image_handle ->
        x0:int ->
        y0:int ->
        x1:int ->
        y1:int ->
        wc:int ->
        hc:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_arc :
        Magick.image_handle ->
        x0:int ->
        y0:int ->
        x1:int ->
        y1:int ->
        a0:int ->
        a1:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?line_cap:Magick.Imper.line_cap ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_ellipse :
        Magick.image_handle ->
        cx:int ->
        cy:int ->
        rx:int ->
        ry:int ->
        ?a0:int ->
        ?a1:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_polyline :
        Magick.image_handle ->
        coords:(int * int) array ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?line_join:Magick.Imper.line_join ->
        ?line_cap:Magick.Imper.line_cap ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_polygon :
        Magick.image_handle ->
        coords:(int * int) array ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?line_join:Magick.Imper.line_join ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_bezier :
        Magick.image_handle ->
        coords:(int * int) array ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?line_cap:Magick.Imper.line_cap ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      val draw_path :
        Magick.image_handle ->
        path:string ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?stroke_width:float ->
        ?line_join:Magick.Imper.line_join ->
        ?line_cap:Magick.Imper.line_cap ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      type style_type =
          Undefined_Style
        | Normal_Style
        | Italic
        | Oblique
        | Any_Style
      type decoration_type =
          Undefined_Decoration
        | No_Decoration
        | Underline
        | Overline
        | LineThrough
      type stretch_type =
          Undefined_Stretch
        | Normal_Stretch
        | UltraCondensed
        | ExtraCondensed
        | Condensed
        | SemiCondensed
        | SemiExpanded
        | Expanded
        | ExtraExpanded
        | UltraExpanded
        | Any_Stretch
      val draw_text :
        Magick.image_handle ->
        text:string ->
        ?font:string ->
        x:int ->
        y:int ->
        point_size:float ->
        ?density_x:int ->
        ?density_y:int ->
        ?style:Magick.Imper.style_type ->
        ?weight:int ->
        ?fill_color:Magick.Imper.color ->
        ?stroke_color:Magick.Imper.color ->
        ?decoration:Magick.Imper.decoration_type ->
        ?stretch:Magick.Imper.stretch_type ->
        ?stroke_width:float ->
        ?stroke_antialias:Magick.magick_boolean ->
        ?text_antialias:Magick.magick_boolean ->
        ?encoding:string ->
        ?affine_matrix:Magick.Imper.affine_matrix -> unit -> unit
      type metrics_infos = {
        ascent : float;
        descent : float;
        text_width : float;
        text_height : float;
        max_advance : float;
        underline_position : float;
        underline_thickness : float;
        pixels_per_em_x : float;
        pixels_per_em_y : float;
        bounds_x1 : float;
        bounds_y1 : float;
        bounds_x2 : float;
        bounds_y2 : float;
      }
      val get_metrics :
        Magick.image_handle ->
        text:string ->
        ?font:string ->
        x:int ->
        y:int ->
        point_size:float ->
        ?density_x:int ->
        ?density_y:int ->
        ?style:Magick.Imper.style_type ->
        ?weight:int ->
        ?decoration:Magick.Imper.decoration_type ->
        ?stretch:Magick.Imper.stretch_type ->
        ?stroke_width:float -> unit -> Magick.Imper.metrics_infos
      val transform_metrics :
        metrics:Magick.Imper.metrics_infos ->
        affine_matrix:Magick.Imper.affine_matrix ->
        Magick.Imper.metrics_infos
      external draw_text_devel : Magick.image_handle -> text:string -> unit
        = "imper_draw_text_new1"
      external draw_mvg : Magick.image_handle -> mvg:string -> unit
        = "imper_draw_mvg"
      external get_raw :
        Magick.image_handle -> (int * int * int * int) array array
        = "imper_get_raw"
      external get_raw' :
        Magick.image_handle -> (int * int * int * int) array array
        = "imper_get_raw2"
      external get_raw_opacity :
        Magick.image_handle -> (int * int * int * int) array array
        = "imper_get_raw_opacity"
      external get_raw_without_alpha :
        Magick.image_handle -> (int * int * int) array array
        = "imper_get_raw_without_alpha"
      external get_raw_gl_indexed :
        Magick.image_handle -> (int * int * int * int) array
        = "imper_get_raw_gl_indexed"
      external get_raw_gl_indexed_without_alpha :
        Magick.image_handle -> (int * int * int) array
        = "imper_get_raw_gl_indexed_without_alpha"
      val set_raw :
        raw:(int * int * int * int) array array -> Magick.image_handle
      val set_raw_c :
        raw:(int * int * int * int) array array -> Magick.image_handle
      type image_list_handle
      external new_image_list : unit -> Magick.Imper.image_list_handle
        = "imper_new_image_list"
      external no_op : Magick.image_handle -> unit = "imper_no_op"
      external display_images : Magick.Imper.image_list_handle -> unit
        = "im_displayimages"
      val append_image_to_list :
        Magick.Imper.image_list_handle ->
        Magick.image_handle -> ?delay:int -> unit -> unit
      external image_list_length : Magick.Imper.image_list_handle -> int
        = "imper_getimagelistlength"
      external deconstruct_images : Magick.Imper.image_list_handle -> unit
        = "imper_deconstructimages"
      external coalesce_images : Magick.Imper.image_list_handle -> unit
        = "imper_coalesceimages"
      external flatten_images : Magick.Imper.image_list_handle -> unit
        = "imper_flattenimages"
      val average_images :
        Magick.Imper.image_list_handle -> Magick.image_handle
      external animate_images : Magick.Imper.image_list_handle -> unit
        = "imper_animateimages"
      external write_images :
        Magick.Imper.image_list_handle -> string -> unit = "im_writeimage"
      external get_last_image_in_list :
        Magick.Imper.image_list_handle -> Magick.image_handle
        = "imper_getlastimageinlist"
      external get_first_image_in_list :
        Magick.Imper.image_list_handle -> Magick.image_handle
        = "imper_getfirstimageinlist"
      external has_link : Magick.image_handle -> bool = "imper_has_link"
      type stack = Left_to_right | Top_to_bottom
      val stack_dir_of_string : stack:string -> Magick.Imper.stack
      val append_images :
        Magick.Imper.image_list_handle ->
        stack:Magick.Imper.stack -> Magick.image_handle
    end
  module Fun :
    sig
      val create_image :
        width:int ->
        height:int -> pseudo_format:string -> unit -> Magick.image_handle
      val get_canvas :
        width:int ->
        height:int -> color:string -> unit -> Magick.image_handle
      val read_image : filename:string -> unit -> Magick.image_handle
      val blur :
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val radial_blur :
        angle:float -> unit -> Magick.image_handle -> Magick.image_handle
      val radial_blur_channel :
        channel:Magick.channel_type ->
        angle:float -> unit -> Magick.image_handle -> Magick.image_handle
      val charcoal :
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val edge :
        radius:float -> unit -> Magick.image_handle -> Magick.image_handle
      val emboss :
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val gaussian_blur :
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val implode :
        amount:float -> unit -> Magick.image_handle -> Magick.image_handle
      val medianfilter :
        radius:float -> unit -> Magick.image_handle -> Magick.image_handle
      val motion_blur :
        ?radius:float ->
        sigma:float ->
        angle:float -> unit -> Magick.image_handle -> Magick.image_handle
      val oilpaint :
        radius:float -> unit -> Magick.image_handle -> Magick.image_handle
      val reduce_noise :
        radius:float -> unit -> Magick.image_handle -> Magick.image_handle
      val roll :
        x:int -> y:int -> unit -> Magick.image_handle -> Magick.image_handle
      val shade :
        ?gray:Magick.magick_boolean ->
        azimuth:float ->
        elevation:float -> unit -> Magick.image_handle -> Magick.image_handle
      val sharpen :
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val spread :
        radius:float -> unit -> Magick.image_handle -> Magick.image_handle
      val swirl :
        degrees:float -> unit -> Magick.image_handle -> Magick.image_handle
      val unsharpmask :
        radius:float ->
        sigma:float ->
        amount:float ->
        threshold:float -> unit -> Magick.image_handle -> Magick.image_handle
      val wave :
        amplitude:float ->
        wave_length:float ->
        unit -> Magick.image_handle -> Magick.image_handle
      val rotate :
        degrees:float -> unit -> Magick.image_handle -> Magick.image_handle
      val shear :
        x:float ->
        y:float -> unit -> Magick.image_handle -> Magick.image_handle
      val sample :
        width:int ->
        height:int -> unit -> Magick.image_handle -> Magick.image_handle
      val scale :
        width:int ->
        height:int -> unit -> Magick.image_handle -> Magick.image_handle
      val thumbnail :
        width:int ->
        height:int -> unit -> Magick.image_handle -> Magick.image_handle
      val adaptive_threshold :
        width:int ->
        height:int ->
        offset:int -> unit -> Magick.image_handle -> Magick.image_handle
      val blur_channel :
        channel:Magick.channel_type ->
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val gaussian_blur_channel :
        channel:Magick.channel_type ->
        ?radius:float ->
        sigma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val add_noise :
        noise_type:Magick.noise_type ->
        unit -> Magick.image_handle -> Magick.image_handle
      val resize :
        width:int ->
        height:int ->
        filter:Magick.resize_filter ->
        blur:float -> unit -> Magick.image_handle -> Magick.image_handle
      val enhance : unit -> Magick.image_handle -> Magick.image_handle
      val despeckle : unit -> Magick.image_handle -> Magick.image_handle
      val minify : unit -> Magick.image_handle -> Magick.image_handle
      val magnify : unit -> Magick.image_handle -> Magick.image_handle
      val flip : unit -> Magick.image_handle -> Magick.image_handle
      val flop : unit -> Magick.image_handle -> Magick.image_handle
      val splice :
        x:int ->
        y:int ->
        width:int ->
        height:int -> unit -> Magick.image_handle -> Magick.image_handle
      val crop :
        x:int ->
        y:int ->
        width:int ->
        height:int -> unit -> Magick.image_handle -> Magick.image_handle
      val affine_transform :
        ?tx:float ->
        ?ty:float ->
        ?sx:float ->
        ?sy:float ->
        ?rx:float ->
        ?ry:float -> unit -> Magick.image_handle -> Magick.image_handle
      val negate :
        ?grayscale:Magick.magick_boolean ->
        unit -> Magick.image_handle -> Magick.image_handle
      val contrast :
        sharpen:Magick.magick_boolean ->
        unit -> Magick.image_handle -> Magick.image_handle
      val equalize : unit -> Magick.image_handle -> Magick.image_handle
      val normalize : unit -> Magick.image_handle -> Magick.image_handle
      val black_threshold :
        threshold:string ->
        unit -> Magick.image_handle -> Magick.image_handle
      val white_threshold :
        threshold:string ->
        unit -> Magick.image_handle -> Magick.image_handle
      val cyclecolormap :
        displace:int -> unit -> Magick.image_handle -> Magick.image_handle
      val solarize :
        threshold:float -> unit -> Magick.image_handle -> Magick.image_handle
      val strip : unit -> Magick.image_handle -> Magick.image_handle
      val gamma_channel :
        channel:Magick.channel_type ->
        gamma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val level :
        levels:string -> unit -> Magick.image_handle -> Magick.image_handle
      val level_channel :
        channel:Magick.channel_type ->
        black_point:float ->
        white_point:float ->
        gamma:float -> unit -> Magick.image_handle -> Magick.image_handle
      val negate_channel :
        channel:Magick.channel_type ->
        grayscale:Magick.magick_boolean ->
        unit -> Magick.image_handle -> Magick.image_handle
      val ordered_dither : unit -> Magick.image_handle -> Magick.image_handle
      val composite_image :
        compose:Magick.composite_operator ->
        ?x:int ->
        ?y:int ->
        unit ->
        img_below:Magick.image_handle ->
        img_above:Magick.image_handle -> Magick.image_handle
      val texture_image :
        img:Magick.image_handle ->
        tex_img:Magick.image_handle -> Magick.image_handle
      val modulate :
        ?brightness:int ->
        ?saturation:int ->
        ?hue:int -> unit -> Magick.image_handle -> Magick.image_handle
      val modulate' :
        factors:string -> unit -> Magick.image_handle -> Magick.image_handle
      val view : unit -> Magick.image_handle -> Magick.image_handle
    end
  external get_magick_copyright : unit -> string = "imper_getmagickcopyright"
  external get_magick_home_url : unit -> string = "imper_getmagickhomeurl"
  external get_magick_release_date : unit -> string
    = "imper_getmagickreleasedate"
  external get_magick_version : unit -> int * string
    = "imper_getmagickversion"
  external get_magick_quantum_depth : unit -> int * string
    = "imper_getmagickquantumdepth"
  external get_magick_quantum_range : unit -> int * string
    = "imper_getmagickquantumrange"
  external get_binding_version : unit -> string = "imper_getbindingversion"
  type shared_data =
      UI8 of
        (int, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
        Bigarray.Array3.t
    | UI16 of
        (int, Bigarray.int16_unsigned_elt, Bigarray.c_layout)
        Bigarray.Array3.t
    | UI32 of (int, Bigarray.int32_elt, Bigarray.c_layout) Bigarray.Array3.t
    | UI64 of (int, Bigarray.int64_elt, Bigarray.c_layout) Bigarray.Array3.t
  external inspect_big_array : ('a, 'b, 'c) Bigarray.Array2.t -> unit
    = "ml_big_array_test"
  val select : unit -> int
  val big_array2_dump : (int, 'a, 'b) Bigarray.Array2.t -> unit
  external image_of_bigarray :
    ('a, 'b, 'c) Bigarray.Array3.t -> Magick.image_handle
    = "constituteimage_from_big_array_char"
  type coords_2d = { x : int; y : int; }
  type dimentions = { width : int; height : int; }
  type bounding_box = { pos : Magick.coords_2d; dims : Magick.dimentions; }
  type gradient_spreadMethod = Pad_spread | Repeat_spread | Reflect_spread
  val _linear_gradient :
    width:int ->
    height:int ->
    a:Magick.coords_2d ->
    b:Magick.coords_2d ->
    ?spread_method:Magick.gradient_spreadMethod ->
    ?bounding_box:Magick.bounding_box -> unit -> Magick.image_handle
  val linear_gradient :
    Magick.image_handle ->
    a:Magick.coords_2d ->
    b:Magick.coords_2d ->
    stop:(float * string) list ->
    ?matrix:(float * float * float) * (float * float * float) *
            (float * float * float) ->
    ?spread_method:Magick.gradient_spreadMethod ->
    ?bounding_box:Magick.bounding_box -> unit -> unit
end