bimage 0.2.1 · OCaml Package

Expr implements an operation combinator which can be used to build operations from low-level functions

type _ t =

| Kernel : Input.index * Kernel.t -> float t
| Input : Input.index * int t * int t * int t -> float t
| X : int t
| Y : int t
| C : int t
| Int : int -> int t
| Float : float -> float t
| Bool : bool -> bool t
| Float_of_int : int t -> float t
| Int_of_float : float t -> int t
| Fadd : float t * float t -> float t
| Fsub : float t * float t -> float t
| Fmul : float t * float t -> float t
| Fdiv : float t * float t -> float t
| Fpow : float t * float t -> float t
| Fsqrt : float t -> float t
| Fsin : float t -> float t
| Fcos : float t -> float t
| Ftan : float t -> float t
| Fmod : float t * float t -> float t
| Iadd : int t * int t -> int t
| Isub : int t * int t -> int t
| Imul : int t * int t -> int t
| Idiv : int t * int t -> int t
| Imod : int t * int t -> int t
| Gt : 'a t * 'a t -> bool t
| Eq : 'a t * 'a t -> bool t
| Lt : 'a t * 'a t -> bool t
| And : bool t * bool t -> bool t
| Or : bool t * bool t -> bool t
| Not : bool t -> bool t
| Cond : bool t * 'a t * 'a t -> 'a t
| Func : 'b t * (int -> int -> int -> 'b -> 'a t) -> 'a t
| Pixel : Input.index * int t * int t -> Pixel.t t
| Pixel_norm : Input.index * int t * int t -> Pixel.t t
| Value : 'a -> 'a t
| Pair : 'a t * 'b t -> ('a * 'b) t
| Kind_min : Input.index -> float t
| Kind_max : Input.index -> float t
| Channels : Input.index -> int t
| Shape : Input.index -> (int * int * int) t

val op : 
  ?x:int ref ->
  ?y:int ref ->
  ?c:int ref ->
  float t ->
  ('a, 'b, 'c) Image.t array ->
  int ->
  int ->
  int ->
  float

val int : int -> int t

Create an int Expr

val float : float -> float t

Create a float Expr

val int_of_float : float t -> int t

val float_of_int : int t -> float t

val x : int t

val y : int t

val c : int t

val kernel : Input.index -> Kernel.t -> float t

Create a kernel expr from an existing kernel

val join_kernel : 
  Input.index ->
  (float t -> float t -> float t) ->
  Kernel.t ->
  Kernel.t ->
  float t

Create a kernel expession using two kernels combined using the designated operation

val combine_kernel : Input.index -> Kernel.t -> Kernel.t -> float t

val transform : Input.index -> Transform.t -> float t

Apply a transformation

val rotate : Input.index -> ?center:(float * float) -> float -> float t

val scale : Input.index -> float -> float -> float t

val threshold : Input.index -> float array -> float t

val pair : 'a t -> 'b t -> ('a * 'b) t

Create a new Pair expr, used for joining existing expressions

val pixel : Input.index -> int t -> int t -> Pixel.t t

Create a Pixel expr, for extracting pixels

val pixel_norm : Input.index -> int t -> int t -> Pixel.t t

Create a Pixel_norm expr, for extracting normalized pixels

val kind_min : Input.index -> float t

val kind_max : Input.index -> float t

val channels : Input.index -> int t

val value : 'a -> 'a t

Create a Value expr

val shape : Input.index -> (int * int * int) t

val func : 'b t -> (int -> int -> int -> 'b -> 'a t) -> 'a t

Create a Func expr

val map : ('b -> 'a t) -> 'b t -> 'a t

val input : int -> int t -> int t -> int t -> float t

Get input data from the specified index

val fadd : float t -> float t -> float t

val fsub : float t -> float t -> float t

val fmul : float t -> float t -> float t

val fdiv : float t -> float t -> float t

val iadd : int t -> int t -> int t

val isub : int t -> int t -> int t

val imul : int t -> int t -> int t

val idiv : int t -> int t -> int t

val pow : float t -> float t -> float t

val sqrt : float t -> float t

val sin : float t -> float t

val cos : float t -> float t

val tan : float t -> float t

val pi : unit -> float t

val and_ : bool t -> bool t -> bool t

val or_ : bool t -> bool t -> bool t

val not_ : bool t -> bool t

val cond : bool t -> 'a t -> 'a t -> 'a t

val blend : Input.index -> Input.index -> float t

An expression to average two images

val min : Input.index -> Input.index -> float t

An expression to take the lowest value from two images

val max : Input.index -> Input.index -> float t

An expression to take the highest value from two images

val brightness : Input.index -> float t -> float t

Multiply each pixel component

val grayscale : Input.index -> float t

val color : Input.index -> float t

val kernel_3x3 : Input.index -> Kernel.t -> float t

module Infix : sig ... end

package bimage