Image convolution: Difference between revisions

=={{header|Action!}}==

{{libheader|Action! Bitmap tools}}

DEFINE HISTSIZE="256"

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Image_convolution.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

First we define floating-point stimulus and color pixels which will be then used for filtration:

type Float_Pixel is record

begin

return (To_Luminance (X.R), To_Luminance (X.G), To_Luminance (X.B));

Float_Luminance is an unconstrained equivalent of Luminance. Float_Pixel is one to Pixel. Conversion operations To_Luminance and To_Pixel saturate the corresponding values. The operation + is defined per channels. The operation * is defined as multiplying by a scalar. (I.e. Float_Pixel is a vector space.)

Now we are ready to implement the filter. The operation is performed in memory. The access to the image array is minimized using a slid window. The filter is in fact a triplet of filters handling each image channel independently. It can be used with other color models as well.

procedure Filter (Picture : in out Image; K : Kernel_3x3) is

Above (Picture'Last (2)) := W21;

end loop;

Example of use:

begin

Open (F1, In_File, "city.ppm");

Put_PPM (F2, X);

end;

=={{header|BBC BASIC}}==

[[Image:original_bbc.jpg|right]]

[[Image:sharpened_bbc.jpg|right]]

Height% = 200

REPEAT

WAIT 1

=={{header|C}}==

Interface:

The implementation (the <tt>Ks</tt> argument is so that 1 specifies a 3&times;3 matrix, 2 a 5&times;5 matrix ...

N a (2N+1)&times;(2N+1) matrix).

inline static color_component GET_PIXEL_CHECK(image img, int x, int y, int l) {

}

return NULL;

Usage example:

The <tt>read_image</tt> function is from [[Read image file through a pipe|here]].

#include "imglib.h"

free_img(ii);

} else { fprintf(stderr, "err reading %s\n", input); }

=={{header|Common Lisp}}==

Uses the RGB pixel buffer package defined here [[Basic bitmap storage#Common Lisp]]. Also the PPM file IO functions defined in

[[Bitmap/Read a PPM file#Common_Lisp]] and [[Bitmap/Write a PPM file#Common_Lisp]] merged into one package.

(load "ppm-file-io")

(loop for pars being the hash-values of convolve::*cnv-lib*

do (princ (convolve::convolve "lena_color.ppm" pars)) (terpri)))

=={{header|D}}==

This requires the module from the Grayscale Image Task.

struct ConvolutionFilter {

img.convolve(filter)

.savePGM(format("lenna_gray_%s.ppm", filter.name));

=={{header|Go}}==

Using standard image library:

import (

fmt.Println(err)

}

Alternative version, building on code from bitmap task.

New function for raster package:

import "math"

}

return r

Demonstration program:

// Files required to build supporting package raster are found in:

fmt.Println(err)

}

=={{header|J}}==

NB. (increasing the first two dimensions by 1 less than the kernel size)

pad=: {{

kernel_filter=: {{

[: (0 >. 255 <. <.@:+&0.5) (1,:$m)+/ .*~&(,/)&m;._3 m pad

Example use:

id_kernel=: (=&i.-)3 3

sharpen_kernel=: ({ _1,#@,)id_kernel

sobel_emboss_kernel=: (i:-:<:3)*/1+(<.|.)i.3

=={{header|Java}}==

'''Code:'''

import java.io.File;

import java.io.IOException;

return;

}

'''Code:'''

// precondition: Image is loaded

// returns loaded Image to asynchronous callback function

imageOut.src = can.toDataURL('image/png');

'''Example Usage:'''

=={{header|Julia}}==

using FileIO, Images

save("imagesharper.png", imfilt)

=={{header|Kotlin}}==

{{trans|Java}}

import kotlin.math.round

}

writeOutputImage(args[1], dataArrays)

{{out}}

<br>

NB Things like convolution would be best done by combining LB with ImageMagick, which is easily called from LB.

dim result( 300, 300), image( 300, 300), mask( 100, 100)

w =128

CallDLL #user32, "ReleaseDC", hw as ulong, hdc as ulong

end

Screenview is available at [[http://www.diga.me.uk/convolved.gif]]

=={{header|Maple}}==

Builtin command ImageTools:-Convolution()

mask := Matrix([[1,2,3],[4,5,6],[7,8,9]]);

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Most image processing functions introduced in Mathematica 7

kernel = {{0, -1, 0}, {-1, 4, -1}, {0, -1, 0}};

ImageConvolve[img, kernel]

ImageConvolve[img, GaussianMatrix[35] ]

=={{header|MATLAB}}==

The built-in function [http://www.mathworks.com/help/matlab/ref/conv2.html conv2] handles the basic convolution. Below is a program that has several more options that may be useful in different image processing applications (see comments under convImage for specifics).

Im = [1 2 1 5 5 ; ...

1 2 7 9 9 ; ...

% Convert back to former image data type

ImOut = cast(ImOut, classIm);

{{out}}

<pre>Original image:

As in the D version, we use the modules built for the "bitmap" and "grayscale image" tasks. But we have chosen to read and write PNG files rather than PPM files, using for this purpose the "nimPNG" third party module.

import nimPNG, bitmap, grayscale_image

let output = Output2.format(filter.name)

if savePNG24(output, data, result.w, result.h).isOk:

=={{header|OCaml}}==

let _, r_channel,_,_ = img in

let width = Bigarray.Array2.dim1 r_channel

done;

done;

let kernel = [|

[| -2.; -1.; 0. |];

|] in

convolve_value ~img ~kernel ~divisor:9.0 ~offset:0.0;

=={{header|Octave}}==

'''Use package''' [http://octave.sourceforge.net/image/index.html Image]

r = im2uint8(mat2gray(conv2(a(:,:,1), c)));

g = im2uint8(mat2gray(conv2(a(:,:,2), c)));

jpgwrite("LennaSobel.jpg", r, g, b, 100);

[r, g, b] = rgbconv2(im, sharpen);

=={{header|Perl}}==

use warnings;

my $image = rpic 'pythagoras_tree.png';

my $smoothed = conv2d $image, $kernel, {Boundary => 'Truncate'};

Compare offsite images: [https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/frog.png frog.png] vs.

[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/frog_convolution.png frog_convolution.png]

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Image_convolution.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

=={{header|PicoLisp}}==

(de ppmConvolution (Ppm Kernel)

(* (get X K L C) (get Kernel K L)) ) ) )

(link (min 255 (max 0 (*/ Val 1.0)))) ) ) ) )

Test using 'ppmRead' from [[Bitmap/Read a PPM file#PicoLisp]] and 'ppmWrite'

from [[Bitmap/Write a PPM file#PicoLisp]]:

Image manipulation is normally done using an image processing library. For PIL/Pillow do:

from PIL import Image, ImageFilter

im2 = im.filter(kernel)

Alternatively, SciPy can be used but programmers need to be careful about the colors being clipped since they are normally limited to the 0-255 range:

import numpy as np

from scipy.ndimage.filters import convolve

im3 = np.array(np.clip(im2, 0, 255), dtype=np.uint8) #Apply color clipping

=={{header|Racket}}==

(require images/flomap racket/flonum)

(save-image

(flomap->bitmap (flomap-convolve flmp (flvector -1. -1. -1. -1. 4. -1. -1. -1. -1.)))

=={{header|Raku}}==

===Perl 5 PDL library===

use PDL::Image2D:from<Perl5>;

my $image = rpic 'frog.png';

my $smoothed = conv2d $image, $kernel, {Boundary => 'Truncate'};

Compare offsite images: [https://github.com/SqrtNegInf/Rosettacode-Perl6-Smoke/blob/master/ref/frog.png frog.png] vs.

[https://github.com/SqrtNegInf/Rosettacode-Perl6-Smoke/blob/master/ref/frog_convolution.png frog_convolution.png]

===Imagemagick library===

# Note: must install version from github NOT version from CPAN which needs to be updated.

# Reference:

$original.cleanup if $original.defined;

$o.cleanup if $o.defined;

=={{header|Ruby}}==

{{trans|Tcl}}

# Apply a convolution kernel to a whole image

def convolute(kernel)

savefile = 'teapot_' + label.downcase + '.ppm'

teapot.convolute(kernel).save(savefile)

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

{{libheader|Tk}}

# Function for clamping values to those that we can use with colors

pack [labelframe .$name -text $label] -side left

pack [label .$name.l -image [convolve teapot $kernel]]

=={{header|Wren}}==

{{libheader|DOME}}

Based on the Java/Kotlin solutions, though input details are hard-coded rather than read in as command line arguments and the input and output images are displayed side by side with the latter also being saved to a file.

import "dome" for Window

for (x in 0...k.count) kernel[x, y] = k[x][y]

}

{{out}}