Bilinear interpolation: Difference between revisions

Open an image file, enlarge it by 60% using bilinear interpolation, then either display the result or save the result to a file.

<br><br>

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

In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/lena30g.PPM lena30g.PPM] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

INCLUDE "H6:LOADPPM5.ACT"

 

{{out}}

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

=={{header|C}}==

typedef struct {

uint32_t *pixels;

}

}</syntaxhighlight>

=={{header|C sharp|C#}}==

{{trans|Java}}

Seems to have some artifacting in the output, but the image is at least recognizable.

using System.Drawing;

 

}

}</syntaxhighlight>

=={{header|D}}==

This uses the module from the Grayscale Image task.

{{trans|C}}

 

/// Currently this accepts only a Grayscale image, for simplicity.

im.rescaleGray(1.3, 1.8).savePGM("lena_larger.pgm");

}</syntaxhighlight>

=={{header|F sharp|F#}}==

{{trans|C#}}

open System.Drawing

 

 

0 // return an integer exit code</syntaxhighlight>

=={{header|Go}}==

{{trans|C}}

<code>[https://godoc.org/golang.org/x/image/draw#BiLinear draw.BiLinear]</code>

from the <code>golang.org/x/image/draw</code> pacakge).

 

import (

return err

}</syntaxhighlight>

=={{header|J}}==

Note 'FEA'

Here we develop a general method to generate isoparametric interpolants.

 

Let n mean shape function, C mean constants, i mean interpolant, and the three digits meaning dimensionality, number of corners, and (in base 36) the number of nodes we construct various linear and quadratic interpolants in 1, 2, and 3 dimensions as

Note 'Some elemental information'

 

i38r =: mp (C38r mp~ n38r)

</syntaxhighlight>

=={{header|Java}}==

{{trans|Kotlin}}

import java.awt.image.BufferedImage;

import java.io.File;

}

}</syntaxhighlight>

=={{header|Julia}}==

function enlarge(A::Matrix, factor::AbstractFloat)

save("data/lennaenlarged.jpg", Alarge)

</syntaxhighlight>

=={{header|Kotlin}}==

{{trans|C}}

 

import java.io.File

ImageIO.write(image2, "jpg", lenna2)

}</syntaxhighlight>

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

{{out}}

Shows a downloaded image that is 60% enlarged.

=={{header|Nim}}==

{{trans|F#}}

{{libheader|imageman}}

 

func lerp(s, e, t: float): float =

let newImage = image.scale(1.6, 1.6)

newImage.saveJPEG("Lenna100_bilinear.jpg")</syntaxhighlight>

=={{header|Perl}}==

use warnings;

 

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

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

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

Gui app with slider for between 2 and 200% scaling. Various bits of this code scavenged from C#/Go/Kotlin/Wikipedia.

include pGUI.e

 

IupMainLoop()

IupClose()</syntaxhighlight>

=={{header|Python}}==

 

Of course, it is much faster to use PIL, Pillow or SciPy to resize an image than to rely on this code.

 

import numpy as np

from scipy.misc import imread, imshow

imshow(enlargedImg)

</syntaxhighlight>

=={{header|Racket}}==

This mimics the Wikipedia example.

(require images/flomap)

 

(flomap-bilinear-ref

fm k (+ 1/2 (/ x 250)) (+ 1/2 (/ y 250))))))</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

 

use v6;

Lenna100.jpg: JPEG image data, JFIF standard 1.01, resolution (DPI), density 72x72, segment length 16, baseline, precision 8, 512x512, frames 3

Lenna100-larger.jpg: JPEG image data, JFIF standard 1.01, resolution (DPI), density 96x96, segment length 16, comment: "CREATOR: gd-jpeg v1.0 (using IJG JPEG v80), default quality", baseline, precision 8, 820x820, frames 3</pre>

=={{header|Scala}}==

===Imperative solution===

import java.io.{File, IOException}

 

private def lerp(s: Float, e: Float, t: Float) = s + (e - s) * t

}</syntaxhighlight>

=={{header|Sidef}}==

{{trans|C}}

 

func scale(img, scaleX, scaleY) {

var out = scale(img, 1.6, 1.6)

out.write(file => "output.png")</syntaxhighlight>

=={{header|Tcl}}==

 

The script below will show the computed image in a GUI frame, and present a button to save it.

 

package require Tk

 

 

</syntaxhighlight>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

 

End Module</syntaxhighlight>

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|DOME}}

Note that currently DOME's ImageData class can only save files to disk in .png format.

import "graphics" for Canvas, Color, ImageData

import "math" for Math

 

var Game = BilinearInterpolation.new("Lenna100.jpg", "Lenna100_larger.png", 1.6, 1.6)</syntaxhighlight>

=={{header|Yabasic}}==

{{trans|Nim}}

// Adapted from Nim to Yabasic by Galileo, 01/2022

 

next

next</syntaxhighlight>

=={{header|zkl}}==

{{trans|C}}

 

Not fast enough to be called slow.

fcn blerp(c00,c10,c01,c11, tx,ty){ lerp(lerp(c00,c10,tx), lerp(c01,c11,tx),ty) }

fcn scale(src, scaleX,scaleY){

dst

}</syntaxhighlight>

img2:=scale(img,1.5,1.5);

img2.write(File("lena1.5.ppm","wb"));