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!}}==

{{libheader|Action! Bitmap tools}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

INCLUDE "H6:LOADPPM5.ACT"

 

DO UNTIL CH#$FF OD

CH=$FF

{{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;

putpixel(dst,x, y, result);

}

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

{{trans|Java}}

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

using System.Drawing;

 

}

}

=={{header|D}}==

This uses the module from the Grayscale Image task.

{{trans|C}}

 

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

im.rescaleGray(0.3, 0.1).savePGM("lena_smaller.pgm");

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

{{trans|C#}}

open System.Drawing

 

result.Save("Lenna100_larger.jpg")

 

=={{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

=={{header|J}}==

Note 'FEA'

Here we develop a general method to generate isoparametric interpolants.

shape_functions =: COEFFICIENTS mp~ shape_function

interpolate =: mp shape_functions

<pre>

Note 'demonstrate the interpolant with a saddle'

 

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'

 

i38q =: mp (C38r mp~ n38r)

i38r =: mp (C38r mp~ n38r)

=={{header|Java}}==

{{trans|Kotlin}}

import java.awt.image.BufferedImage;

import java.io.File;

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

}

=={{header|Julia}}==

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

Alarge = enlarge(A, 1.6);

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

=={{header|Kotlin}}==

{{trans|C}}

 

import java.io.File

val lenna2 = File("Lenna100_larger.jpg")

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

=={{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 image = loadImage[ColorRGBU]("Lenna100.jpg")

let newImage = image.scale(1.6, 1.6)

=={{header|Perl}}==

use warnings;

 

my $image2 = $image->copyScaleInterpolated( 1.6*$width, 1.6*$height );

 

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()

=={{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)

=={{header|Racket}}==

This mimics the Wikipedia example.

(require images/flomap)

 

(λ (k x y)

(flomap-bilinear-ref

=={{header|Raku}}==

(formerly Perl 6)

 

use v6;

fclose($fh1);

fclose($fh2);

 

{{out}}

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

=={{header|Sidef}}==

{{trans|C}}

 

func scale(img, scaleX, scaleY) {

var img = %O<Imager>.new(file => "input.png")

var out = scale(img, 1.6, 1.6)

=={{header|Tcl}}==

 

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

 

package require Tk

 

pack [button .b -text "save" -command [list save $im]]

 

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

{{trans|C#}}

 

Module Module1

End Sub

 

=={{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

construct new(filename, filename2, scaleX, scaleY) {

Window.title = "Bilinear interpolation"

var newWidth = (_img.width * scaleX).floor

var newHeight = (_img.height * scaleY).floor

}

 

 

=={{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

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

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

{{out}}

http://www.zenkinetic.com/Images/RosettaCode/3Lenas.jpg