#!/usr/bin/python

import sys

from gi.repository import Vips

im = Vips.Image.new_from_file(sys.argv[1])

im = im.crop(100, 100, im.width - 200, im.height - 200)
im = im.similarity(scale = 0.9)
mask = Vips.Image.new_from_array([[-1, -1,  -1],
                                  [-1,  16, -1],
                                  [-1, -1,  -1]], scale = 8)
im = im.conv(mask)

im.write_to_file(sys.argv[2])

#!/usr/bin/ruby

require 'vips'

im = Vips::Image.new_from_file ARGV[0]

im = im.crop 100, 100, im.width - 200, im.height - 200
im = im.similarity :scale => 0.9
mask = Vips::Image.new_from_array [
    [-1, -1,  -1],
    [-1,  16, -1],
    [-1, -1,  -1]], 8
im = im.conv(mask)

im.write_to_file ARGV[1]

#!/usr/bin/env php
<?php

require __DIR__ . '/vendor/autoload.php';

use Jcupitt\Vips;

$im = Vips\Image::newFromFile($argv[1]);

$im = $im->crop(100, 100, $im->width - 200, $im->height - 200);

$im = $im->reduce(1.0 / 0.9, 1.0 / 0.9, ["kernel" => "linear"]);

$mask = Vips\Image::newFromArray(
                  [[-1,  -1, -1],
                   [-1,  16, -1],
                   [-1,  -1, -1]], 8);
$im = $im->conv($mask);

$im->writeToFile($argv[2]);
?>

#!/home/john/vips/bin/nip2 -s

main
  = error "usage: infile -o outfile", argc != 2
  = (sharpen @ shrink @ crop) (Image_file argv?1)
{
  crop x = extract_area 100 100 (x.width - 200) (x.height - 200) x;
  shrink = resize Interpolate_bilinear 0.9 0.9;
  sharpen = conv (Matrix_con 8 0 [[/-1,_-1,_-1],_[-1,_16,_-1],_[-1,_-1,_-1|-1, -1, -1], [-1, 16, -1], [-1, -1, -1]]);
}

#!/bin/bash

width=$(vipsheader -f Xsize $1)
height=$(vipsheader -f Ysize $1)

width=$((width - 200))
height=$((height - 200))

vips crop $1 t1.v 100 100 $width $height
vips similarity t1.v t2.v --scale 0.9 --interpolate bilinear

cat > mask.con <<EOF
3 3 8 0
-1 -1 -1
-1 16 -1
-1 -1 -1
EOF
vips conv t2.v $2 mask.con

rm t1.v t2.v

#include <vips/vips8>

using namespace vips;

int
main( int argc, char **argv )
{
        if( VIPS_INIT( argv[0] ) )
                return( -1 );

        VImage in = VImage::new_from_file( argv[1] );

        VImage mask = VImage::new_matrixv( 3, 3,
                -1, -1, -1, -1, 16, -1, -1, -1, -1 );
        mask.set( "scale", 8 );

        in.
                crop( 100, 100, in.width() - 200, in.height() - 200 ).
                similarity( VImage::option()->set( "scale", 0.9 ) ).
                conv( mask ).
                write_to_file( argv[2] );

        return( 0 );
}

// compile with
// gcc -Wall vips.c `pkg-config vips --cflags --libs` -o vips-c

#include <vips/vips.h>

int
main( int argc, char **argv )
{
        VipsImage *global;
        VipsImage **t;

        if( VIPS_INIT( argv[0] ) )
                return( -1 );

        global = vips_image_new();
        t = (VipsImage **) vips_object_local_array( VIPS_OBJECT( global ), 5 );

        if( !(t[0] = vips_image_new_from_file( argv[1], NULL )) )
                vips_error_exit( NULL );

        t[1] = vips_image_new_matrixv( 3, 3,
                -1.0, -1.0, -1.0,
                -1.0, 16.0, -1.0,
                -1.0, -1.0, -1.0 );
        vips_image_set_double( t[1], "scale", 8 );

        if( vips_extract_area( t[0], &t[2],
                100, 100, t[0]->Xsize - 200, t[0]->Ysize - 200, NULL ) ||
                vips_similarity( t[2], &t[3], "scale", 0.9, NULL ) ||
                vips_conv( t[3], &t[4], t[1], NULL ) ||
                vips_image_write_to_file( t[4], argv[2], NULL ) )
                vips_error_exit( NULL );

        g_object_unref( global );

        return( 0 );
}

#!/usr/bin/python

import sys
from PIL import Image, ImageFilter, PILLOW_VERSION

# just to confirm we are getting the right version
# print("pillow.py: PILLOW_VERSION =", PILLOW_VERSION)

im = Image.open(sys.argv[1])

# Crop 100 pixels off all edges.
im = im.crop((100, 100, im.size[0] - 100, im.size[1] - 100))

# Shrink by 10%

# starting with 2.7, Pillow uses a high-quality convolution-based resize for
# BILINEAR ... the other systems in this benchmark are using affine + bilinear,
# so this is rather unfair. Use NEAREST instead, it gets closest to what
# everyone else is doing
im = im.resize((int (im.size[0] * 0.9), int (im.size[1] * 0.9)), Image.NEAREST)

# sharpen
filter = ImageFilter.Kernel((3, 3),
          (-1, -1, -1,
           -1, 16, -1,
           -1, -1, -1))
im = im.filter(filter)

# write back again
im.save(sys.argv[2])

#!/usr/bin/octave -qf

pkg load image

im = imread(argv(){1});
im = im(101:end-100, 101:end-100);        % Crop
im = imresize(im, 0.9, 'linear');         % Shrink
myFilter = [-1 -1 -1
            -1 16 -1
            -1 -1 -1];
im = conv2(double(im), myFilter);         % Sharpen
im = max(0, im ./ (max(max(im)) / 255));  % Renormalize
imwrite(argv(){2}, uint8(im));           % Write back again

#!/bin/bash

# we crop on load, it's a bit quicker and saves some memory
# we can't crop 100 pixels with the crop-on-load syntax, so we have to
# find the width and height ourselves
width=$(vipsheader -f Xsize $1)
height=$(vipsheader -f Ysize $1)

width=$((width - 200))
height=$((height - 200))

set -x

convert "$1[${width}x${height}+100+100]" \
        -filter triangle -resize 90x90% \
        -convolve "-1, -1, -1, -1, 16, -1, -1, -1, -1" \
        $2

#!/bin/bash

set -x

# GraphicsMagick does not have crop-on-load so we use -shave instead
gm convert $1 \
        -shave 100x100 \
        -filter triangle -resize 90x90% \
        -convolve "-1, -1, -1, -1, 16, -1, -1, -1, -1" \
        $2

#!/bin/bash

width=$(vipsheader -f Xsize $1)
height=$(vipsheader -f Ysize $1)

width=$((width - 200))
height=$((height - 200))

# set -x

econvert -i $1 \
    --crop "100,100,$width,$height" \
    --bilinear-scale 0.9 \
    --convolve "-1, -1, -1, -1, 16, -1, -1, -1, -1" \
    -o $2

#!/bin/bash

width=$(vipsheader -f Xsize $1)
height=$(vipsheader -f Ysize $1)
crop_width=$((width - 200))
crop_height=$((height - 200))

gmic \
        -verbose - \
        -input $1 \
        -crop 100,100,$crop_width,$crop_height \
        -resize 90%,90%,1,3,3,1 \
        "(-1,-1,-1;-1,9,-1;-1,-1,-1)" -convolve[-2] [-1] -keep[-2] \
        -type uchar \
        -output $2

/* Compile with:

   gcc freeimage.c -lfreeimage

 */

#include <FreeImage.h>

int
main (int argc, char **argv)
{
  FIBITMAP *t1;
  FIBITMAP *t2;
  int width;
  int height;

  FreeImage_Initialise (FALSE);

  t1 = FreeImage_Load (FIF_TIFF, argv[1], TIFF_DEFAULT);

  width = FreeImage_GetWidth (t1);
  height = FreeImage_GetHeight (t1);

  t2 = FreeImage_Copy (t1, 100, 100, width - 100, height - 100);
  FreeImage_Unload (t1);

  t1 = FreeImage_Rescale (t2, (width - 200) * 0.9, (height - 200) * 0.9,
                          FILTER_BILINEAR);
  FreeImage_Unload (t2);

  /* FreeImage does not have a sharpen operation, so we skip that.
   */

  FreeImage_Save (FIF_TIFF, t1, argv[2], TIFF_DEFAULT);
  FreeImage_Unload (t1);

  FreeImage_DeInitialise ();

  return 0;
}

#!/bin/bash

cat > mask <<EOF
P2
3 3
32
14 14 14
14 48 14
14 14 14
EOF

tifftopnm $1 | \
  pnmcut -left 100 -right -100 -top 100 -bottom -100 | \
  pnmscale 0.9 | \
  pnmconvol mask | \
  pnmtotiff -truecolor -color > $2

#!/usr/bin/ruby

require 'rubygems'
require 'image_science'

ImageScience.with_image(ARGV[0]) do |img|
    img.with_crop(100, 100, img.width() - 100, img.height() - 100) do |crop|
        crop.resize(crop.width() * 0.9, crop.height() * 0.9) do |small|
            small.save(ARGV[1])
        end
    end
end

#!/bin/bash

width=$(vipsheader -f Xsize $1)
height=$(vipsheader -f Ysize $1)

width=$((width - 200))
height=$((height - 200))

# resize with triangle is bilinear

# this will blur rather than sharpen, but the speed should be the same

oiiotool $1 \
    --crop $widthx$height+100+100 --origin +0+0 --fullpixels \
    --resize:filter=triangle 90% \
    --kernel gaussian 3x3 --convolve \
    -o $2

#!/usr/bin/ruby

require 'rubygems'
require 'RMagick'
include Magick

im = ImageList.new(ARGV[0])

im = im.shave(100, 100)
im = im.resize(im.columns * 0.9, im.rows * 0.9, filter = TriangleFilter)
kernel = [-1, -1, -1, -1, 16, -1, -1, -1, -1]
im = im.convolve(3, kernel)

im.write(ARGV[1])

/* compile with:

   g++ -g -Wall opencv.cc `pkg-config opencv --cflags --libs`

   code from Amadan@shacknews, thank you very much!

 */

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

using namespace cv;

int
main (int argc, char **argv)
{
  Mat img = imread (argv[1]);

  if (img.empty ())
    return 1;

  Mat crop = Mat (img, Rect (100, 100, img.cols - 200, img.rows - 200));

  Mat shrunk;
  resize (crop, shrunk, Size (0, 0), 0.9, 0.9);

  float m[3][3] = { {-1, -1, -1}, {-1, 16, -1}, {-1, -1, -1} };
  Mat kernel = Mat (3, 3, CV_32F, m) / 8.0;

  Mat sharp;
  filter2D (shrunk, sharp, -1, kernel, Point (-1, -1), 0, BORDER_REPLICATE);

  imwrite (argv[2], sharp);

  return 0;
}

#!/bin/bash

width=$(vipsheader -f Xsize $1)
height=$(vipsheader -f Ysize $1)

crop_width=$((width - 200))
crop_height=$((height - 200))

resize_width=$((crop_width * 9 / 10))

# set -x

sips \
        --cropToHeightWidth $crop_height $crop_width \
        --resampleWidth $resize_width \
        $1 --out $2 &> /dev/null

#!/usr/bin/pike

int main(int argc, array(string) argv)
{
        object image = Image.load(argv[1]);

        image = image->copy(100, 100,
                image->xsize() - 101, image->ysize() - 101);

        image = image->scale(0.9);

        image = image->apply_matrix(
                ({({-1,-1,-1}),
                  ({-1,16,-1}),
                  ({-1,-1,-1})}));

        Stdio.write_file(argv[2], Image.TIFF.encode(image));

        return 0;
}

/* compile with
 *
 * gcc -g -Wall imlib2.c `pkg-config imlib2 --cflags --libs`
 */

#include <string.h>
#include <stdlib.h>

#include <Imlib2.h>

int
main( int argc, char **argv )
{
    Imlib_Image image;
    int width;
    int height;
    char *tmp;

    if( argc != 3 )
        exit( 1 );

    if( !(image = imlib_load_image( argv[1] )) )
        exit( 1 );

    /* set the image we loaded as the current context image to work on
     */
    imlib_context_set_image( image );
    width = imlib_image_get_width();
    height = imlib_image_get_height();
    if( !(image = imlib_create_cropped_scaled_image( 100, 100,
        width - 200, height - 200,
        (width - 200) * 0.9,
        (height - 200) * 0.9 )) )
        exit( 1 );
    imlib_free_image();
    imlib_context_set_image( image );

    imlib_image_sharpen( 1 );

    if( (tmp = strrchr( argv[2], '.' )) )
        imlib_image_set_format( tmp + 1 );

    /* save the image
     */
    imlib_save_image( argv[2] );
    imlib_free_image();

    return( 0 );
}

// compile with
// gcc -Wall gd.c `pkg-config gdlib --cflags --libs` -o gd

#include <stdio.h>
#include <stdlib.h>

#include <gd.h>

int
main( int argc, char **argv )
{
    FILE *fp;
    gdImagePtr original, cropped,resized;
    gdRect crop;

    if( argc != 3 ) {
        printf( "usage: %s in-jpeg out-jpeg\n", argv[0] );
        exit( 1 );
    }

    if( !(fp = fopen( argv[1], "r" )) ) {
        printf( "unable to open \"%s\"\n", argv[1] );
        exit( 1 );
    }
    if( !(original = gdImageCreateFromJpeg( fp )) ) {
        printf( "unable to load \"%s\"\n", argv[1] );
        exit( 1 );
    }
    fclose( fp );

    crop.x = 100;
    crop.y = 100;
    crop.width = original->sx - 200;
    crop.height = original->sy - 200;
    cropped = gdImageCrop( original, &crop );
    gdImageDestroy( original );
    original = 0;
    if( !cropped ) {
        printf( "unable to crop image\n" );
        exit( 1 );
    }

    resized = gdImageScale( cropped, crop.width * 0.9, crop.height * 0.9 );
    gdImageDestroy( cropped );
    cropped = 0;
    if( !resized ) {
        printf( "unable to resize image\n" );
        exit( 1 );
    }

    //gdImageSharpen is extremely slow
    gdImageSharpen( resized, 75 );

    if( !(fp = fopen( argv[2], "w" )) ) {
        printf( "unable to open \"%s\"\n", argv[2] );
        exit( 1 );
    }
    gdImageJpeg( resized, fp, -1 );
    fclose( fp );

    gdImageDestroy( resized );

    return( 0 );
}

/* compile with

   gcc -g -Wall gegl.c `pkg-config gegl-0.3 --cflags --libs`

 */

#include <stdio.h>
#include <stdlib.h>

#include <gegl.h>

static void
null_log_handler (const gchar *log_domain,
          GLogLevelFlags log_level,
          const gchar *message,
          gpointer user_data)
{
}

int
main (int argc, char **argv)
{
  GeglNode *gegl, *load, *crop, *scale, *sharp, *save;

  gegl_init (&argc, &argv);

  if (argc != 3)
    {
      fprintf (stderr, "usage: %s file-in file-out\n", argv[0]);
      exit (1);
    }

  g_log_set_handler ("GEGL-load.c",
    G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
    null_log_handler, NULL);
  g_log_set_handler ("GEGL-gegl-tile-handler-cache.c",
    G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
    null_log_handler, NULL);

  gegl = gegl_node_new ();

  load = gegl_node_new_child (gegl,
                              "operation", "gegl:load",
                              "path", argv[1],
                              NULL);

  crop = gegl_node_new_child (gegl,
                              "operation", "gegl:crop",
                              "x", 100.0,
                              "y", 100.0,
                              "width", 4800.0,
                              "height", 4800.0,
                              NULL);

  scale = gegl_node_new_child (gegl,
                               "operation", "gegl:scale-ratio",
                               "x", 0.9,
                               "y", 0.9,
                               "sampler", GEGL_SAMPLER_LINEAR,
                               NULL);

  sharp = gegl_node_new_child (gegl,
                               "operation", "gegl:unsharp-mask",
                               "std-dev", 1.0, // diameter 7 mask in gegl
                               NULL);

  save = gegl_node_new_child (gegl,
                              "operation", "gegl:save",
                              //"operation", "gegl:png-save",
                              //"bitdepth", 8,
                              "path", argv[2],
                              NULL);

  gegl_node_link_many (load, crop, scale, sharp, save, NULL);

  gegl_node_process (save);

  g_object_unref (gegl);

  gegl_exit ();

  return (0);
}