The interpolation method can be used for image enlargement. One simple interpolation method is linear interpolation, which is very effective even though simple.
Linear interpolation
The so-called linear interpolation means that there is a set of discrete data {A (1), a (2 ),..., A (n)}, we want to know the number A (M) (k <m <k + 1) between a (K) and a (k + 1. However, because the data is discrete, we only know a (K) and a (k + 1). Therefore, we can only make an estimation of A (m, the estimated value is called interpolation. A reasonable estimation is that the value of a point between a (K) and a (k + 1) may be a (k) + (A (k + 1) -A (k) * m, M is a constant decimal place between [0, 1], which is called linear interpolation. For example
Linear interpolation and amplification of images
An image is a pixel matrix that can be expressed as P (I, j ). P (I, j) is used to represent a point in the original image, and PS (I, j) is used to represent a point in the enlarged image. The amplification process is as follows:
First, calculate the location where interpolation is required.
The PS (x, y) value of a new image is
PS (x, y) = P (m, n)
M = Original Image Height x (x-ray New Image Height)
N = Original Image Width x (New Image Width of Y Branch)
M and n are usually decimal places, that is, the locations where the original image needs to be interpolated.
After knowing the interpolation position, we need to perform Interpolation on the original image, as shown in figure
Where p (I, n), P (M, J), P (I + 1, n), P (M, J + 1), P (m, n) it is inserted by linear interpolation,
P (I, n) = P (I, j) + (P (I, j + 1)-P (I, j) × (n-j)
P (M, j) = P (I, j) + (P (I + 1, J)-P (I, j) × (M-I)
P (I + 1, n) = P (I + 1, J) + (P (I + 1, J + 1)-P (I + 1, J )) × (n-j)
P (M, J + 1) = P (I, j + 1) + (P (I + 1, J + 1)-P (I, j + 1 )) × (M-I)
P (m, n) = P (I, n) + (P (I + 1, n)-P (I, n) × (M-I)
I = floor (m)
J = floor (N)
Floor is rounded down
In this way, the PS (x, y) values of each point in the image are all ready, and the linear interpolation and amplification of the image are completed by writing it into the new image.
VC implementation
We use opencv (beta_5) library to read the image, and then manually interpolation and amplification. The program is an MFC/doc/view structure.
...
First, access the opencv (beta_5) Library
# Include "highgui. H" // includes
# Pragma comment (Lib, "highgui. lib") // link to. Lib
# Pragma comment (Lib, "cxcore. lib") // link to. Lib
...
Class clinerdoc: Public cdocument
{
...
// Attributes
Public:
Iplimage * IMG; // Original Image
Iplimage * img_s; // scaled Image
...
};
Clinerdoc: clinerdoc ()
: IMG (null)
, Img_s (null)
{
...
}
Bool clinerdoc: onnewdocument ()
{
...
Int I, J;
Double xs = 3.0, ys = 3.0;
// Load the original image
IMG = cvloadimage ("C: // Documents and Settings // administrator // desktop // desktop_girl_v1.jpg ");
// Apply memory for scaled Image
Img_s = cvcreateimage (cvsize (INT) IMG-> width * XS, (INT) IMG-> height * ys), IMG-> depth, IMG-> nchannels );
// Scale by linear interpolation
Double XM, ym;
Unsigned char vff0, vff1, vff2, vcf0, vcf1, vcf2, vfc0, vfc1, vfc2, vcc0, vcc0, vcc2;
Unsigned char v0, V1, V2;
For (I = 0; I height; I ++ ){
For (j = 0; j width; j ++ ){
// Middle Pixel
XM = (IMG-> width-1) * j/(double) img_s-> width;
Ym = (IMG-> height-1) * I/(double) img_s-> height;
// 4 neighbor pixels of 3 color vff0 = IMG-> imagedata [(INT) floor (ym) * IMG-> widthstep + (INT) floor (XM )) * IMG-> nchannels + 0]; vff1 = IMG-> imagedata [(INT) floor (ym) * IMG-> widthstep + (INT) floor (XM )) * IMG-> nchannels + 1];
Vff2 = IMG-> imagedata [(INT) floor (ym) * IMG-> widthstep + (INT) floor (XM) * IMG-> nchannels + 2];
Vcf0 = IMG-> imagedata [(INT) floor (ym) * IMG-> widthstep + (INT) Ceil (XM) * IMG-> nchannels + 0];
Vcf1 = IMG-> imagedata [(INT) floor (ym) * IMG-> widthstep + (INT) Ceil (XM) * IMG-> nchannels + 1];
Vcf2 = IMG-> imagedata [(INT) floor (ym) * IMG-> widthstep + (INT) Ceil (XM) * IMG-> nchannels + 2];
Fcv0 = IMG-> imagedata [(INT) Ceil (ym) * IMG-> widthstep + (INT) floor (XM) * IMG-> nchannels + 0];
Vfc1 = IMG-> imagedata [(INT) Ceil (ym) * IMG-> widthstep + (INT) floor (XM) * IMG-> nchannels + 1];
Vfc2 = IMG-> imagedata [(INT) Ceil (ym) * IMG-> widthstep + (INT) floor (XM) * IMG-> nchannels + 2];
Vcc0 = IMG-> imagedata [(INT) Ceil (ym) * IMG-> widthstep + (INT) Ceil (XM) * IMG-> nchannels + 0];
Vpc3 = IMG-> imagedata [(INT) Ceil (ym) * IMG-> widthstep + (INT) Ceil (XM) * IMG-> nchannels + 1];
Vcc2 = IMG-> imagedata [(INT) Ceil (ym) * IMG-> widthstep + (INT) Ceil (XM) * IMG-> nchannels + 2];
// Perform linear interpolation
V0 = vff0 + (vcf0-vff0) * (XM-(INT) XM)
+ (Vfc0 + (vcc0-vfc0) * (XM-(INT) XM)-vff0-(vcf0-vff0) * (XM-(INT) XM) * (ym-(INT) ym );
V1 = vff1 + (vcf1-vff1) * (XM-(INT) XM)
+ (Vfc1 + (vcc1-vfc1) * (XM-(INT) XM)-vff1-(vcf1-vff1) * (XM-(INT) XM) * (ym-(INT) ym );
V2 = vff2 + (vcf2-vff2) * (XM-(INT) XM)
+ (Vfc2 + (vcc2-vfc2) * (XM-(INT) XM)-vff2-(vcf2-vff2) * (XM-(INT) XM) * (ym-(INT) ym );
// Set pixel of scaled Image
Img_s-> imagedata [I * img_s-> widthstep + J * img_s-> nchannels + 0] = V0;
Img_s-> imagedata [I * img_s-> widthstep + J * img_s-> nchannels + 1] = V1;
Img_s-> imagedata [I * img_s-> widthstep + J * img_s-> nchannels + 2] = V2;
}
}
Return true;
}
Void clinerdoc: onclosedocument ()
{
// Release created image
Cvreleaseimage (& img_s );
...
}
Void clinerview: ondraw (CDC * PDC)
{
Clinerdoc * pdoc = getdocument ();
Assert_valid (pdoc );
If (! Pdoc)
Return;
Int I, J;
Clinerdoc * Doc = (clinerdoc *) This-> getdocument ();
Iplimage * IMG = doc-> IMG; // Original Image
Iplimage * img_s = doc-> img_s; // scaled Image
Int xori = 10, Yori = 10;
Colorref C;
If (IMG ){
// Show Original Image
For (I = 0; I height; I ++ ){
For (j = 0; j width; j ++ ){
C = RGB (IMG-> imagedata [I * IMG-> widthstep + J * IMG-> nchannels + 2],
IMG-> imagedata [I * IMG-> widthstep + J * IMG-> nchannels + 1],
IMG-> imagedata [I * IMG-> widthstep + J * IMG-> nchannels + 0]);
PDC-> setpixel (J + Yori, I + xori, C );
}
}
}
If (img_s ){
// Show scaled Image
For (I = 0; I height; I ++ ){
For (j = 0; j width; j ++ ){
C = RGB (img_s-> imagedata [I * img_s-> widthstep + J * img_s-> nchannels + 2],
Img_s-> imagedata [I * img_s-> widthstep + J * img_s-> nchannels + 1],
Img_s-> imagedata [I * img_s-> widthstep + J * img_s-> nchannels + 0]);
PDC-> setpixel (J + Yori * 2 + IMG-> width, I + xori, C );
}
}
}
}
For more information, see
The left side is the original image, and the right side is magnified by 3 times by linear interpolation. It looks like a pattern.