operator op::math1::abs {
    section transform math unary

    note Applies the unary function `abs(I)`.

    input

    simplify for   src/type @self   returns src
    simplify for   constant abs

    state -setup {
    #define IN_GEOM aktive_image_get_geometry (srcs->v[0])
	aktive_geometry_copy (domain, IN_GEOM);
    }

    pixels {
    #define FETCH aktive_region_fetch_area (srcs->v[0], request)
	aktive_blit_unary0 (block, dst, fabs, FETCH);
    }
}
      

proc aktive::op::math1::abs {src} {
    ::aktive simplify do \
        src/type op::math1::abs \
        /src
    ::aktive simplify do \
        src/type image::from::value \
        /fold/constant/0 abs 
    Iabs $src
}
      

critcl::cproc aktive::op::math1::Iabs {
  Tcl_Interp*  ip 
  aktive_image src
} aktive_image {
  /* src :: keep */
  /* no parameters */
  aktive_image _r = aktive_image_check (ip,
        aktive_op_math1_abs_new (ip, src));
  return _r;
}
      

extern aktive_image
aktive_op_math1_abs_new (Tcl_Interp* ip, aktive_image src) {
  TRACE_FUNC("", 0);

  static aktive_image_type aktive_op_math1_abs_opspec = {
    .name         = "op::math1::abs"
  , .sz_param     = 0
  , .setup        = (aktive_image_setup)  aktive_op_math1_abs_setup
  , .region_fetch = (aktive_region_fetch) aktive_op_math1_abs_region_fetch
  };

  aktive_image_vector srcs = {
      .c = 1, .v = &src
  };

  aktive_image r = aktive_image_new (&aktive_op_math1_abs_opspec,
                                     NULL, &srcs);
  TRACE_RETURN ("(aktive_image) %p", r);
}
      

static int
aktive_op_math1_abs_setup (
  aktive_image_info* info
, Tcl_Obj**          meta
) {
  TRACE_FUNC("((aktive_image_info*) %p)", info);
  aktive_image_vector* srcs   = &info->srcs;
  aktive_geometry*     domain = &info->domain;
#define                state  (info->state)
  // - - -- --- ----- -------- ------------- ----------------

  #define IN_GEOM aktive_image_get_geometry (srcs->v[0])
  aktive_geometry_copy (domain, IN_GEOM);

  // - - -- --- ----- -------- ------------- ----------------
  TRACE_GEOMETRY (domain);
#undef state
  TRACE_RETURN ("(ok) %d", 1);
}
      

static void
aktive_op_math1_abs_region_fetch (
  aktive_region_info* info    // Params, inputs, (image) state
, aktive_rectangle*   request // Area to fetch
, aktive_rectangle*   dst     // Destination in `block`
, aktive_block*       block   // Pixel storage
) {
  [...]
  aktive_region_vector* srcs    = &info->srcs;
  aktive_geometry*      idomain = info->domain;
  [...]
  // - - -- --- ----- -------- ------------- ----------------

  #define FETCH aktive_region_fetch_area (srcs->v[0], request)
  aktive_blit_unary0 (block, dst, fabs, FETCH);

  // - - -- --- ----- -------- ------------- ----------------
  TRACE_RETURN_VOID;
}
      

do-scale-down

param pnm src

lassign [aktive query domain $src] _ _ w h
set w   [expr {$w / [factor]}]
set h   [expr {$h / [factor]}]

result wtxt geo [list $w $h]
result ppm  dst [aktive op resize $src width $w height $h]

aktive op resize

::aktive parameter validate         interpolate 0 width 0 height 0
::aktive parameter collect required width height
set interpolate bilinear
::aktive parameter collect optional interpolate

lassign [aktive query domain $src] _ _ w h

set xscale  [expr {double($width)  / $w}]
set yscale  [expr {double($height) / $h}]
set trafo   [aktive transform scale x $xscale y $yscale]
set resized [aktive op transform by $trafo $src interpolate $interpolate]

lassign [aktive query geometry $resized] x y rw rh
if {($rw != $width) || ($h != $height)} {
    set resized [aktive op view $resized port [list $x $y $width $height]]
}

return $resized

do-convert-to-grey

param  pnm src

result pgm dst [aktive op color sRGB to gray $src]

do-binarize

param  pnm src

set bw [aktive image mask per phansalkar $src radius 7]

result pgm dst [aktive op math1 invert $bw]

aktive image threshold phansalkar

::aktive parameter validate         k 0 R 0 p 0 q 0 radius 0
::aktive parameter collect required radius
set k 0.25
set R 0.5
set p 3
set q 10
::aktive parameter collect optional k R p q

set e    [aktive op embed mirror $src left $radius right $radius top $radius bottom $radius]
set mean [aktive op tile mean   $e radius $radius]
set std  [aktive op tile stddev $e radius $radius]


return [aktive op math mul  $mean  [aktive op math add  [aktive op math1 scale  [aktive op math1 exp  [aktive op math1 scale $mean  factor [expr {- $q}]]]  factor $p]  [aktive op math1 linear  [aktive op math1 linear $std  scale [expr {1.0/$R}] gain -1]  scale $k gain 1]]]

Phansalkar is an extension of Sauvola.

Which is a modification of Niblack.

See the Craft Of Coding Blog Post

do-get-borders

param  pnm src

result pgm dst [aktive op morph gradient internal $src]

aktive op morph gradient internal

::aktive parameter validate         radius 0 embed 0
set radius 1
set embed black
::aktive parameter collect optional radius embed

set e   [aktive op morph erode $src radius $radius embed $embed]
set src [aktive op math sub $src $e]

• Issues?
• Edge loss in going to grey & binarization?
• Example: Coffee table books
• Color content up to the page border
• Color edge algorithms ?

do-select

param pnm src

set ccs     [aktive op connected-components get $src]
set ccs     [region-bbox-max $ccs]
set ranges  [lsort -dict [lmap part [dict get $ccs 1 parts] {
    linsert $part end 1
}]]
set domain  [aktive query domain $src]
result pgm dst [aktive image from sparse ranges geometry $domain ranges {*}$ranges]

do-show-border

param pnm src
param pnm border

result ppm dst [overlay $src += $border yellow]

overlay

lassign [aktive query domain $bg] _ _ w h

set mask [aktive op morph dilate $mask radius 2]

return [aktive op if-then-else $mask [{*}$color $w $h] $bg]

yellow

color $w $h yellow 

color

aktive image from color width $w height $h color $name 

aktive image from color

::aktive parameter validate         x 0 y 0 width 0 height 0 color 0
::aktive parameter collect required width height color
set x 0
set y 0
::aktive parameter collect optional x y

set values [aktive color css $color]
band x $x y $y width $width height $height values {*}$values

do-left-profile

param pnm  src
param rtxt geo

set profile [aktive op row profile $src]
set profile [aktive query values $profile]
set poly    [v-path-of $profile]

result        wtxt dstdata $poly
placeholder        dstshow
debugs {result pgm dstshow [draw-poly {*}$geo $poly]}

draw-poly

fat [aktive image sdf polyline width $w height $h points {*}$poly] 

See Inigo Quilez's page about 2D distance functions

do-find-threshold

param rtxt profile
param rtxt geo

set threshold [expr {[lindex $geo 0]/2}]

if 0 {
    set xs        [as-image [xs $profile]]
    set xs        [aktive op math1 fit min-max $xs]
    set stretch   [aktive meta get $xs stretch]
    set scale     [dict get $stretch scale]
    set gain      [dict get $stretch gain]
    set threshold [aktive image threshold global otsu $xs]
    set threshold [expr {($threshold - $gain)/double($scale)}]
}

result        wtxt dstdata $threshold
placeholder        dstshow
debugs {result pgm dstshow [draw-vertical {*}$geo $threshold]}

do-apply-threshold

param rtxt profile
param rtxt geo
param rtxt threshold

set poly [{*}$selector $threshold $profile]

result        wtxt dstdata $poly
placeholder        dstshow
debugs {result pgm dstshow [draw-poly {*}$geo $poly]}

do-fit-vertical-line

param rtxt profile
param rtxt geo

lassign $geo w h
lassign [linreg-v $profile] slope intercept


set a   [lerp-pv $slope $intercept 0]
set b   [lerp-pv $slope $intercept [expr {$h-1}]]
set hug [hugs-image-border $edge $w $a $b]

result        wtxt dstdata [list $slope $intercept $hug]
placeholder        dstshow
debugs {result pgm dstshow [draw-line $w $h $a $b]}

do-top-profile

param pnm  src
param rtxt geo

set profile [aktive op column profile $src]
set profile [aktive query values $profile]
set poly    [h-path-of $profile]

result        wtxt dstdata $poly
placeholder        dstshow
debugs {result pgm dstshow [draw-poly {*}$geo $poly]}

do-cut-horiz

param rtxt geo
param rtxt top
param rtxt left
param rtxt right

lassign $left  lslope lintercept lhug
lassign $right rslope rintercept rhug
lassign [$cliffs $lhug $rhug $lslope $rslope] lcliff rcliff

set top  [limit-left  $lcliff $lslope $lintercept $top]
set top  [limit-right $rcliff $rslope $rintercept $top]

result        wtxt dstdata $top
placeholder        dstshow
debugs {result pgm dstshow [draw-poly {*}$geo $top]}

top-cliff

set lcliff [expr {!$lhug && ($lslope < 0)}]
set rcliff [expr {!$rhug && ($rslope > 0)}]
list $lcliff $rcliff

do-refine-horiz

param rtxt geo
param rtxt profile
param rtxt left
param rtxt right

lassign $left  lslope lintercept lhug
lassign $right rslope rintercept rhug

if {[llength $profile] > 10} {
    set profile [dehug $lhug $rhug $isbetter $profile]
}

result        wtxt dstdata $profile
placeholder        dstshow
debugs {result pgm dstshow [draw-poly {*}$geo $profile]}

do-collect-tangents

param rtxt geo
param rtxt profile

if {[llength $profile] > 100 } {
    set hullspec [join [list 2 [llength $profile] {*}$profile] \n]
    set result   [exec qconvex Fx << $hullspec]
    set indices  [lassign [split [string trim $result] \n] n]
    set profile  [lmap i [lreverse $indices] { lindex $profile $i }]
}

set pairs    [pairs $profile]
set tangents [filter $pairs $where $profile]
set tangents [unique-tangents $tangents]

result    wtxt dstdata $tangents
placeholder    dstshow
debugs {
    lassign $geo w h
    result pgm dstshow [draw-lines $w $h [t-lines $w $tangents]]
}

do-choose-tangent

param rtxt geo
param rtxt profile
param rtxt tangents

if {![llength $tangents]} return

set tareas [map $tangents line-area-delta $profile]
set best   [fold {{} {} {} {} Inf} $tareas min-area]
lassign $geo w h
lassign [h-expand $w $best] a b

result        wtxt dstdata [list $a $b]
placeholder        dstshow
debugs {result pgm dstshow [draw-line $w $h $a $b]}

do-fit-quadrilateral

param rtxt geo
param rtxt left
param rtxt right
param rtxt top
param rtxt bottom

if {[catch {
    set i [intersect $a $d $e $f]
    set j [intersect $b $c $e $f]
    set k [intersect $b $c $g $h]
    set l [intersect $a $d $g $h]

set poly      [list $i $j $k $l]
set polyclose $poly ; lappend polyclose $i

result        wtxt dstdata $poly
placeholder        dstshow
debugs {result pgm dstshow [draw-poly {*}$geo $polyclose]}

do-rectify

param pnm  src
param rtxt quad
param rtxt top	; set top    [sup $top]
param rtxt bottom	; set bottom [sup $bottom]

lassign [aktive query domain $src] _ _ w h
lassign $quad i j k l

set quad      [aktive transform quad unit2 a $i b $j c $k d $l]
set iquad     [aktive transform invert $quad]
set scale     [aktive transform scale x $w y $h]
set transform [aktive transform compose $scale $iquad]
set rect      [aktive op transform by  $transform $src]
set top       [aktive transform points $transform series {*}$top]
set bottom    [aktive transform points $transform series {*}$bottom]

result         ppm  dst      [aktive op view $rect port [list 0 0 $w $h]]
result         wtxt tresidue $top
result         wtxt bresidue $bottom
debugs {result pgm  tshow [draw-poly $w $h $top]}
debugs {result pgm  bshow [draw-poly $w $h $bottom]}

AKTIVE documentation; quadrilateral warping

• Future Work                                                                        

• Future Work                                                                        
• Generally

• Future Work                                                                        
• Generally
• Benchmarking
• FFT
• Hough Transform
• Hit/Miss Transform
• More file formats
• Matrix ops
• Image Smoothing via L₀ Gradient Minimization
• ...

• Future Work                                                                        
• Generally
• Demo Task

• Future Work                                                                        
• Generally
• Demo Task
• Color edges for better borders?
• Remove residual curvature
• Blank page detection
• Text/Image Segmentation
• OCR

• Future Work                                                                        
• Generally
• Demo Task
• Color edges for better borders?
• Remove residual curvature
• Forward transform profiles
• Profile approximations (spline, cubic, ...)
• Unwarp along the approximation
• Blank page detection
• Text/Image Segmentation
• OCR