Bilinear interpolation: Difference between revisions
Content added Content deleted
(fixed some signed-ness stuff) |
(must be a draft: task description unfinished and only two (possible) implementations) |
||
Line 1: | Line 1: | ||
{{task}} |
{{draft task}} |
||
Bilinear Interpolation is linear interpolation in 2 dimensions |
Bilinear Interpolation is linear interpolation in 2 dimensions, and is typically used for image scaling. |
||
<!-- TODO: Describe a *task*; must be a draft until that is done, and four implementations are written --> |
|||
... |
|||
=={{header|C}}== |
=={{header|C}}== |
||
<lang c> |
<lang c>#include <stdint.h> |
||
#include <stdint.h> |
|||
typedef struct { |
typedef struct { |
||
uint32_t *pixels; |
uint32_t *pixels; |
||
unsigned int w; |
unsigned int w; |
||
unsigned int h; |
unsigned int h; |
||
}image_t; |
} image_t; |
||
#define getByte(value, n) (value >> (n*8) & 0xFF) |
#define getByte(value, n) (value >> (n*8) & 0xFF) |
||
Line 46: | Line 46: | ||
putpixel(dst,x, y, result); |
putpixel(dst,x, y, result); |
||
} |
} |
||
⚫ | |||
} |
|||
⚫ | |||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
This mimics the Wikipedia example. |
This mimics the Wikipedia example. |
||
⚫ | |||
⚫ | |||
#lang racket |
|||
(require images/flomap) |
(require images/flomap) |
||
Line 75: | Line 71: | ||
(λ (k x y) |
(λ (k x y) |
||
(flomap-bilinear-ref |
(flomap-bilinear-ref |
||
fm k (+ 1/2 (/ x 250)) (+ 1/2 (/ y 250)))))) |
fm k (+ 1/2 (/ x 250)) (+ 1/2 (/ y 250))))))</lang> |
||
</lang> |
Revision as of 15:28, 23 June 2013
Bilinear interpolation is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Bilinear Interpolation is linear interpolation in 2 dimensions, and is typically used for image scaling.
C
<lang c>#include <stdint.h> typedef struct {
uint32_t *pixels; unsigned int w; unsigned int h;
} image_t;
- define getByte(value, n) (value >> (n*8) & 0xFF)
uint32_t getpixel(image_t *image, unsigned int x, unsigned int y){
return image->pixels[(y*image->w)+x];
} 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){
return lerp(lerp(c00, c10, tx), lerp(c01, c11, tx), ty);
} void putpixel(image_t *image, unsigned int x, unsigned int y, uint32_t color){
image->pixels[(y*image->w) + x] = color;
} void scale(image_t *src, image_t *dst, float scalex, float scaley){
int newWidth = (int)src->w*scalex; int newHeight= (int)src->h*scaley; int x, y; for(x= 0, y=0; y < newHeight; x++){ if(x > newWidth){ x = 0; y++; } float gx = x / (float)(newWidth) * (src->w-1); float gy = y / (float)(newHeight) * (src->h-1); int gxi = (int)gx; int gyi = (int)gy; uint32_t result=0; uint32_t c00 = getpixel(src, gxi, gyi); uint32_t c10 = getpixel(src, gxi+1, gyi); uint32_t c01 = getpixel(src, gxi, gyi+1); uint32_t c11 = getpixel(src, gxi+1, gyi+1); uint8_t i; for(i = 0; i < 3; i++){ //((uint8_t*)&result)[i] = blerp( ((uint8_t*)&c00)[i], ((uint8_t*)&c10)[i], ((uint8_t*)&c01)[i], ((uint8_t*)&c11)[i], gxi - gx, gyi - gy); // this is shady result |= (uint8_t)blerp(getByte(c00, i), getByte(c10, i), getByte(c01, i), getByte(c11, i), gx - gxi, gy -gyi) << (8*i); } putpixel(dst,x, y, result); }
}</lang>
Racket
This mimics the Wikipedia example. <lang racket>#lang racket (require images/flomap)
(define fm
(draw-flomap (λ (dc) (define (pixel x y color) (send dc set-pen color 1 'solid) (send dc draw-point (+ x .5) (+ y 0.5))) (send dc set-alpha 1) (pixel 0 0 "blue") (pixel 0 1 "red") (pixel 1 0 "red") (pixel 1 1 "green")) 2 2))
(flomap->bitmap
(build-flomap 4 250 250 (λ (k x y) (flomap-bilinear-ref fm k (+ 1/2 (/ x 250)) (+ 1/2 (/ y 250))))))</lang>