Bilinear interpolation: Difference between revisions
m
→{{header|Wren}}: ImageData.loadFromFile now deprecated, changed to ImageData.load
m (→{{header|Wren}}: ImageData.loadFromFile now deprecated, changed to ImageData.load) |
|||
(23 intermediate revisions by 13 users not shown) | |||
Line 3:
[[wp:Bilinear interpolation|Bilinear interpolation]] is linear interpolation in 2 dimensions, and is typically used for image scaling and for 2D finite element analysis.
;Task:
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! Bitmap tools}}
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<syntaxhighlight lang="action!">INCLUDE "H6:REALMATH.ACT"
INCLUDE "H6:LOADPPM5.ACT"
PROC PutBigPixel(INT x,y BYTE col)
IF x>=0 AND x<=79 AND y>=0 AND y<=47 THEN
y==LSH 2
col==RSH 4
IF col<0 THEN col=0
ELSEIF col>15 THEN col=15 FI
Color=col
Plot(x,y)
DrawTo(x,y+3)
FI
RETURN
PROC DrawImage(GrayImage POINTER image INT x,y)
INT i,j
BYTE c
FOR j=0 TO image.gh-1
DO
FOR i=0 TO image.gw-1
DO
c=GetGrayPixel(image,i,j)
PutBigPixel(x+i,y+j,c)
OD
OD
RETURN
PROC Lerp(REAL POINTER s,e,t,res)
REAL tmp1,tmp2
RealSub(e,s,tmp1) ;tmp1=e-s
RealMult(tmp1,t,tmp2) ;tmp2=(e-s)*t
RealAdd(s,tmp2,res) ;res=s+(e-s)*t
RETURN
PROC BilinearInterpolation(GrayImage POINTER src,dst)
INT i,j,x,y,c
REAL mx,my,rx,ry,fx,fy,tmp1,tmp2,tmp3,r00,r01,r10,r11
BYTE c00,c01,c10,c11
IntToReal(src.gw-1,tmp1) ;tmp1=src.width-1
IntToReal(dst.gw,tmp2) ;tmp2=dst.width
RealDiv(tmp1,tmp2,mx) ;mx=(src.width-1)/dst.width
IntToReal(src.gh-1,tmp1) ;tmp1=src.height-1
IntToReal(dst.gh,tmp2) ;tmp2=dst.height
RealDiv(tmp1,tmp2,my) ;my=(src.height-1)/dst.height
FOR j=0 TO dst.gh-1
DO
IntToReal(j,tmp1) ;tmp=j
RealMult(tmp1,my,ry) ;ry=j*my
y=Floor(ry)
IntToReal(y,tmp1) ;tmp1=floor(ry)
RealSub(ry,tmp1,fy) ;fy=frac(ry)
FOR i=0 TO dst.gw-1
DO
IntToReal(i,tmp1) ;tmp=i
RealMult(tmp1,mx,rx) ;rx=i*mx
x=Floor(rx)
IntToReal(x,tmp1) ;tmp1=floor(rx)
RealSub(rx,tmp1,fx) ;fx=frac(rx)
c00=GetGrayPixel(src,x,y)
c01=GetGrayPixel(src,x,y+1)
c10=GetGrayPixel(src,x+1,y)
c11=GetGrayPixel(src,x+1,y+1)
IntToReal(c00,r00)
IntToReal(c01,r01)
IntToReal(c10,r10)
IntToReal(c11,r11)
Lerp(r00,r10,fx,tmp1)
Lerp(r01,r11,fx,tmp2)
Lerp(tmp1,tmp2,fy,tmp3)
c=RealToInt(tmp3)
IF c<0 THEN
c=0
ELSEIF c>255 THEN
c=255
FI
SetGrayPixel(dst,i,j,c)
OD
OD
RETURN
PROC Main()
BYTE CH=$02FC ;Internal hardware value for last key pressed
BYTE ARRAY data30x30(900),data48x48(2304)
GrayImage im30x30,im48x48
Put(125) PutE() ;clear the screen
MathInit()
InitGrayImage(im30x30,30,30,data30x30)
InitGrayImage(im48x48,48,48,data48x48)
PrintE("Loading source image...")
LoadPPM5(im30x30,"H6:LENA30G.PPM")
PrintE("Bilinear interpolation...")
BilinearInterpolation(im30x30,im48x48)
Graphics(9)
DrawImage(im30x30,0,0)
DrawImage(im48x48,32,0)
DO UNTIL CH#$FF OD
CH=$FF
RETURN</syntaxhighlight>
{{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;
Line 19 ⟶ 134:
return image->pixels[(y*image->w)+x];
}
float max(float a, float b) { return (a < b) ? a : b; };
float lerp(float s, float e, float t){return s+(e-s)*t;}
float blerp(float c00, float c10, float c01, float c11, float tx, float ty){
Line 34 ⟶ 151:
x = 0; y++;
}
//float gx = x / (float)(newWidth) * (src->w - 1);
//float gy = y / (float)(newHeight) * (src->h - 1);
// Image should be clamped at the edges and not scaled.
float gx = max(x / (float)(newWidth) * (src->w) - 0.5f, src->w - 1);
float gy = max(y / (float)(newHeight) * (src->h) - 0.5, src->h - 1);
int gxi = (int)gx;
int gyi = (int)gy;
Line 50 ⟶ 170:
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;
Line 85 ⟶ 204:
int red = (int)Blerp(c00.R, c10.R, c01.R, c11.R, gx - gxi, gy - gyi);
int green = (int)Blerp(c00.G, c10.G, c01.G, c11.
int blue = (int)Blerp(c00.B, c10.B, c01.B, c11.
Color rgb = Color.FromArgb(red, green, blue);
newImage.SetPixel(x, y, rgb);
Line 105 ⟶ 224:
}
}
}</
=={{header|D}}==
This uses the module from the Grayscale Image task.
{{trans|C}}
<
/// Currently this accepts only a Grayscale image, for simplicity.
Line 158 ⟶ 276:
im.rescaleGray(0.3, 0.1).savePGM("lena_smaller.pgm");
im.rescaleGray(1.3, 1.8).savePGM("lena_larger.pgm");
}</
=={{header|F sharp|F#}}==
{{trans|C#}}
<
open System.Drawing
Line 208 ⟶ 325:
result.Save("Lenna100_larger.jpg")
0 // return an integer exit code</
=={{header|Go}}==
{{trans|C}}
Line 215 ⟶ 331:
<code>[https://godoc.org/golang.org/x/image/draw#BiLinear draw.BiLinear]</code>
from the <code>golang.org/x/image/draw</code> pacakge).
<
import (
Line 307 ⟶ 423:
}
return err
}</
=={{header|J}}==
<syntaxhighlight lang="j">
Note 'FEA'
Here we develop a general method to generate isoparametric interpolants.
Line 372 ⟶ 487:
shape_functions =: COEFFICIENTS mp~ shape_function
interpolate =: mp shape_functions
</syntaxhighlight>
<pre>
Note 'demonstrate the interpolant with a saddle'
Line 391 ⟶ 506:
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
<syntaxhighlight lang="j">
Note 'Some elemental information'
Line 487 ⟶ 602:
i38q =: mp (C38r mp~ n38r)
i38r =: mp (C38r mp~ n38r)
</syntaxhighlight>
=={{header|Java}}==
{{trans|Kotlin}}
<
import java.awt.image.BufferedImage;
import java.io.File;
Line 546 ⟶ 660:
ImageIO.write(image2, "jpg", lenna2);
}
}</
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Images, FileIO, Interpolations
function enlarge(A::Matrix, factor::AbstractFloat)
lx, ly = size(A)
nx, ny = round.(Int, factor .* (lx, ly))
vx, vy =
itp = interpolate(A, BSpline(Linear()
return itp
end
A = load("data/lenna100.jpg") |> Matrix{RGB{Float64}};
Alarge = enlarge(A, 1.6);
save("data/lennaenlarged.jpg", Alarge)
</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|C}}
<
import java.io.File
Line 616 ⟶ 727:
val lenna2 = File("Lenna100_larger.jpg")
ImageIO.write(image2, "jpg", lenna2)
}</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ImageResize[Import["http://www.rosettacode.org/mw/title.png"], Scaled[1.6], Resampling -> "Linear"]</syntaxhighlight>
{{out}}
Shows a downloaded image that is 60% enlarged.
=={{header|Nim}}==
{{trans|F#}}
{{libheader|imageman}}
<syntaxhighlight lang="nim">import imageman
func lerp(s, e, t: float): float =
s + (e - s) * t
func blerp(c00, c10, c01, c11, tx, ty: float): float =
lerp(lerp(c00, c10, tx), lerp(c01, c11, tx), ty)
func scale(img: Image; scaleX, scaleY: float): Image =
let newWidth = (img.width.toFloat * scaleX).toInt
let newHeight = (img.height.toFloat * scaleY).toInt
result = initImage[ColorRGBU](newWidth, newHeight)
for x in 0..<newWidth:
for y in 0..<newHeight:
let gx = x * (img.width - 1) / newWidth
let gy = y * (img.height - 1) / newHeight
let gxi = gx.int
let gyi = gy.int
let gxf = gx - float(gxi)
let gyf = gy - float(gyi)
let c00 = img[gxi, gyi]
let c10 = img[gxi + 1, gyi]
let c01 = img[gxi, gyi + 1]
let c11 = img[gxi + 1, gyi + 1]
let red = blerp(float(c00[0]), float(c10[0]), float(c01[0]), float(c11[0]), gxf, gyf).toInt
let green = blerp(float(c00[1]), float(c10[1]), float(c01[1]), float(c11[1]), gxf, gyf).toInt
let blue = blerp(float(c00[2]), float(c10[2]), float(c01[2]), float(c11[2]), gxf, gyf).toInt
result[x, y] = ColorRGBU([byte(red), byte(green), byte(blue)])
when isMainModule:
let newImage = image.scale(1.6, 1.6)
newImage.saveJPEG("Lenna100_bilinear.jpg")</syntaxhighlight>
=={{header|Perl}}==
<syntaxhighlight lang="perl">use strict;
use warnings;
use GD;
my $image = GD::Image->newFromPng('color_wheel.png');
$image->interpolationMethod( ['GD_BILINEAR_FIXED'] );
my($width,$height) = $image->getBounds();
my $image2 = $image->copyScaleInterpolated( 1.6*$width, 1.6*$height );
$image2->_file('color_wheel_interpolated.png');</syntaxhighlight>
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
Line 765 ⟶ 893:
function redraw_cb(Ihandle /*redraw*/)
IupSetAttributeHandle(label2, "IMAGE", NULL)
image2 = IupDestroy(image2)
atom v = IupGetDouble(scale,"VALUE")/100
image2 = scale_image(im1,v,v)
Line 778 ⟶ 906:
IupHbox({label1, label2})}))
IupSetAttribute(dlg, "TITLE", "Bilinear interpolation")
IupShow(dlg)
IupMainLoop()
IupClose()</
=={{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
Line 834 ⟶ 960:
imshow(enlargedImg)
</syntaxhighlight>
=={{header|Racket}}==
This mimics the Wikipedia example.
<
(require images/flomap)
Line 859 ⟶ 984:
(λ (k x y)
(flomap-bilinear-ref
fm k (+ 1/2 (/ x 250)) (+ 1/2 (/ y 250))))))</
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>#!/usr/bin/env perl6
use v6;
use GD::Raw;
# Reference:
# https://github.com/dagurval/perl6-gd-raw
my $fh1 = fopen('./Lenna100.jpg', "rb") or die;
my $img1 = gdImageCreateFromJpeg($fh1);
my $fh2 = fopen('./Lenna100-larger.jpg',"wb") or die;
my $img1X = gdImageSX($img1);
my $img1Y = gdImageSY($img1);
my $NewX = $img1X * 1.6;
my $NewY = $img1Y * 1.6;
gdImageSetInterpolationMethod($img1, +GD_BILINEAR_FIXED);
my $img2 = gdImageScale($img1, $NewX.ceiling, $NewY.ceiling);
gdImageJpeg($img2,$fh2,-1);
gdImageDestroy($img1);
gdImageDestroy($img2);
fclose($fh1);
fclose($fh2);
</syntaxhighlight>
{{out}}
<pre>file Lenna100*
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}
Line 921 ⟶ 1,083:
private def lerp(s: Float, e: Float, t: Float) = s + (e - s) * t
}</
=={{header|Sidef}}==
{{trans|C}}
<
func scale(img, scaleX, scaleY) {
Line 964 ⟶ 1,126:
var img = %O<Imager>.new(file => "input.png")
var out = scale(img, 1.6, 1.6)
out.write(file => "output.png")</
=={{header|Tcl}}==
Line 972 ⟶ 1,133:
The script below will show the computed image in a GUI frame, and present a button to save it.
<syntaxhighlight lang="tcl">
package require Tk
Line 1,017 ⟶ 1,178:
pack [button .b -text "save" -command [list save $im]]
</syntaxhighlight>
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports System.Drawing
Module Module1
Function Lerp(s As Single, e As Single, t As Single) As Single
Return s + (e - s) * t
End Function
Function Blerp(c00 As Single, c10 As Single, c01 As Single, c11 As Single, tx As Single, ty As Single) As Single
Return Lerp(Lerp(c00, c10, tx), Lerp(c01, c11, tx), ty)
End Function
Function Scale(self As Bitmap, scaleX As Single, scaleY As Single) As Image
Dim newWidth = CInt(Math.Floor(self.Width * scaleX))
Dim newHeight = CInt(Math.Floor(self.Height * scaleY))
Dim newImage As New Bitmap(newWidth, newHeight, self.PixelFormat)
For x = 0 To newWidth - 1
For y = 0 To newHeight - 1
Dim gx = CSng(x) / newWidth * (self.Width - 1)
Dim gy = CSng(y) / newHeight * (self.Height - 1)
Dim gxi = CInt(Math.Floor(gx))
Dim gyi = CInt(Math.Floor(gy))
Dim c00 = self.GetPixel(gxi, gyi)
Dim c10 = self.GetPixel(gxi + 1, gyi)
Dim c01 = self.GetPixel(gxi, gyi + 1)
Dim c11 = self.GetPixel(gxi + 1, gyi + 1)
Dim red = CInt(Blerp(c00.R, c10.R, c01.R, c11.R, gx - gxi, gy - gyi))
Dim green = CInt(Blerp(c00.G, c10.G, c01.G, c11.G, gx - gxi, gy - gyi))
Dim blue = CInt(Blerp(c00.B, c10.B, c01.B, c11.B, gx - gxi, gy - gyi))
Dim rgb = Color.FromArgb(red, green, blue)
newImage.SetPixel(x, y, rgb)
Next
Next
Return newImage
End Function
Sub Main()
Dim newImage = Image.FromFile("Lenna100.jpg")
If TypeOf newImage Is Bitmap Then
Dim oi As Bitmap = newImage
Dim result = Scale(oi, 1.6, 1.6)
result.Save("Lenna100_larger.jpg")
Else
Console.WriteLine("Could not open the source file.")
End If
End Sub
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.
<syntaxhighlight lang="wren">import "dome" for Window
import "graphics" for Canvas, Color, ImageData
import "math" for Math
/* gets the 'n'th byte of a 4-byte integer */
var GetByte = Fn.new { |i, n| (i >> (n * 8)) & 0xff }
var Blerp = Fn.new { |c00, c10, c01, c11, tx, ty|
return Math.lerp(Math.lerp(c00, tx, c10), ty, Math.lerp(c01, tx, c11))
}
var ColorToInt = Fn.new { |c| (c.r) + (c.g << 8) + (c.b << 16) + (c.a << 24) }
class BilinearInterpolation {
construct new(filename, filename2, scaleX, scaleY) {
Window.title = "Bilinear interpolation"
_img = ImageData.load(filename)
var newWidth = (_img.width * scaleX).floor
var newHeight = (_img.height * scaleY).floor
Window.resize(newWidth, newHeight)
Canvas.resize(newWidth, newHeight)
_img2 = ImageData.create(filename2, newWidth, newHeight)
_filename2 = filename2
}
init() {
scaleImage()
}
scaleImage() {
for (x in 0..._img2.width) {
for (y in 0..._img2.height) {
var gx = x / _img2.width * (_img.width - 1)
var gy = y / _img2.height * (_img.height - 1)
var gxi = gx.floor
var gyi = gy.floor
var rgb = 0
var c00 = _img.pget(gxi, gyi)
var c10 = _img.pget(gxi+1, gyi)
var c01 = _img.pget(gxi, gyi+1)
var c11 = _img.pget(gxi+1, gyi+1)
for (i in 0..3) {
var b00 = GetByte.call(ColorToInt.call(c00), i)
var b10 = GetByte.call(ColorToInt.call(c10), i)
var b01 = GetByte.call(ColorToInt.call(c01), i)
var b11 = GetByte.call(ColorToInt.call(c11), i)
var ble = Blerp.call(b00, b10, b01, b11, gx-gxi, gy-gyi).floor << (8 * i)
rgb = rgb | ble
}
var r = GetByte.call(rgb, 0)
var g = GetByte.call(rgb, 1)
var b = GetByte.call(rgb, 2)
var a = GetByte.call(rgb, 3)
_img2.pset(x, y, Color.rgb(r, g, b, a))
}
}
_img2.draw(0, 0)
_img2.saveToFile(_filename2)
}
update() {}
draw(alpha) {}
}
var Game = BilinearInterpolation.new("Lenna100.jpg", "Lenna100_larger.png", 1.6, 1.6)</syntaxhighlight>
=={{header|Yabasic}}==
{{trans|Nim}}
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Bilinear_interpolation
// Adapted from Nim to Yabasic by Galileo, 01/2022
import ReadFromPPM2
sub lerp(s, e, t)
return s + (e - s) * t
end sub
sub blerp(c00, c10, c01, c11, tx, ty)
return lerp(lerp(c00, c10, tx), lerp(c01, c11, tx), ty)
end sub
sub scale(scaleX, scaleY)
local width, height, x, y, gx, gy, gxi, gyi, gxf, gyf, c00$, c10$, c01$, c11$
width = peek("winwidth")
height = peek("winheight")
let newWidth = int(width * scaleX)
let newHeight = int(height * scaleY)
dim result(newWidth, newHeight, 3)
for x = 1 to newWidth
for y = 1 to newHeight:
let gx = x * (width - 1) / newWidth
let gy = y * (height - 1) / newHeight
let gxi = int(gx)
let gyi = int(gy)
let gxf = gx - gxi
let gyf = gy - gyi
let c00$ = right$(getbit$(gxi, gyi, gxi, gyi), 6)
let c10$ = right$(getbit$(gxi + 1, gyi, gxi + 1, gyi), 6)
let c01$ = right$(getbit$(gxi, gyi + 1, gxi, gyi + 1), 6)
let c11$ = right$(getbit$(gxi + 1, gyi + 1, gxi + 1, gyi + 1), 6)
result(x, y, 1) = int(blerp(dec(left$(c00$, 2)), dec(left$(c10$, 2)), dec(left$(c01$, 2)), dec(left$(c11$, 2)), gxf, gyf))
result(x, y, 2) = int(blerp(dec(mid$(c00$, 3, 2)), dec(mid$(c10$, 3, 2)), dec(mid$(c01$, 3, 2)), dec(mid$(c11$, 3, 2)), gxf, gyf))
result(x, y, 3) = int(blerp(dec(right$(c00$, 2)), dec(right$(c10$, 2)), dec(right$(c01$, 2)), dec(right$(c11$, 2)), gxf, gyf))
next
next
end sub
readPPM("lena.ppm")
print "Be patient, please ..."
scale(1.6, 1.6)
close window
open window newWidth, newHeight
for x = 1 to newWidth
for y = 1 to newHeight
color result(x, y, 1), result(x, y, 2), result(x, y, 3)
dot x, y
next
next</syntaxhighlight>
=={{header|zkl}}==
{{trans|C}}
Line 1,023 ⟶ 1,363:
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){
Line 1,043 ⟶ 1,383:
}
dst
}</
<
img2:=scale(img,1.5,1.5);
img2.write(File("lena1.5.ppm","wb"));
scale(img,0.5,0.5).write(File("lena.5.ppm","wb"));</
{{out}}
http://www.zenkinetic.com/Images/RosettaCode/3Lenas.jpg
|