精华内容
下载资源
问答
  • 本IP经过功能仿真对960x540图像双线性插值放大结果,放大以后图像分辨率为1920x1080
  • 要对其进行改进,对图像的缩小则可以用“局部均值法”,对于图像的放大则可以用“双线性插值法”。效果如下:2048*1536缩小为100*80时的效果100*80放大到600*400的效果局部均值法缩小图像(1)计算采样间隔设原图的...

    概述

    基于上一节“等距采样法”实现图片放大与缩小的缺点。要对其进行改进,对图像的缩小则可以用“局部均值法”,对于图像的放大则可以用“双线性插值法”。

    效果如下:

    1350201169_1350.jpg

    1350201190_4934.jpg

    2048*1536缩小为100*80时的效果

    100*80放大到600*400的效果

    局部均值法缩小图像

    (1)计算采样间隔

    设原图的大小为W*H,将其放大(缩小)为(k1*W)*(K2*H),则采样区间为

    ii=1/k1; jj=1/k2;

    当k1==k2时为等比例缩小;当k1!=k2时为不等比例放大(缩小);当k1<1&&k2<1时为图片放大,k1<1&&k2>1时时图片缩小

    (2)求出局部子块

    设原图为F(x,y)(i=1,2,……W; j=1,2,……H),缩小的图像为G(x,y)(i=1,2, ……M; j=1,2,……N,其中M=W*k1,N=H*k2),则有原图像局部子块为

    f’(x,y)= f(ii*i, jj*j) …… f(ii*i + ii-1, jj*j)

    …… ……

    f(ii*i, jj*j+jj-1) …… f(ii*i + ii-1, jj*j+jj-1)

    (3)求出缩小的图像

    G(x, y) = f’(x,y)的均值

    例:

    1350201813_9646.jpg

    缩小后的图像

    1350201550_9997.jpg

    例如g11=(f11 +f12 + f21 + f22)/4

    算法源代码(java)

    /**

    * 局部均值的图像缩小

    * @param img 要缩小的图像对象

    * @param m 缩小后图像的宽

    * @param n 缩小后图像的高

    * @return 返回处理后的图像对象

    */

    public static BufferedImage shrink(BufferedImage img, int m, int n) {

    float k1 = (float)m/img.getWidth();

    float k2 = (float)n/img.getHeight();

    return shrink(img, k1, k2);

    }

    /**

    * 局部均值的图像缩小

    * @param img 要缩小的图像对象

    * @param k1 要缩小的列比列

    * @param k2 要缩小的行比列

    * @return 返回处理后的图像对象

    */

    public static BufferedImage shrink(BufferedImage img, float k1, float k2) {

    if(k1 >1 || k2>1) {//如果k1 >1 || k2>1则是图片放大,不是缩小

    System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");

    return null;

    }

    float ii = 1/k1;//采样的行间距

    float jj = 1/k2; //采样的列间距

    int dd = (int)(ii*jj);

    //int m=0 , n=0;

    int imgType = img.getType();

    int w = img.getWidth();

    int h = img.getHeight();

    int m = (int) (k1*w);

    int n = (int) (k2*h);

    int[] pix = new int[w*h];

    pix = img.getRGB(0, 0, w, h, pix, 0, w);

    System.out.println(w + " * " + h);

    System.out.println(m + " * " + n);

    int[] newpix = new int[m*n];

    for(int j=0; j

    for(int i=0; i

    int r = 0, g=0, b=0;

    ColorModel cm = ColorModel.getRGBdefault();

    for(int k=0; k

    for(int l=0; l

    r = r + cm.getRed(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);

    g = g + cm.getGreen(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);

    b = b + cm.getBlue(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);

    }

    }

    r = r/dd;

    g = g/dd;

    b = b/dd;

    newpix[j*m + i] = 255<<24 | r<<16 | g<<8 | b;

    //255<<24 | r<<16 | g<<8 | b 这个公式解释一下,颜色的RGB在内存中是

    //以二进制的形式保存的,从右到左1-8位表示blue,9-16表示green,17-24表示red

    //所以"<<24" "<<16" "<<8"分别表示左移24,16,8位

    //newpix[j*m + i] = new Color(r,g,b).getRGB();

    }

    }

    BufferedImage imgOut = new BufferedImage( m, n, imgType);

    imgOut.setRGB(0, 0, m, n, newpix, 0, m);

    return imgOut;

    }

    /**

    * 局部均值的图像缩小

    * @param img 要缩小的图像对象

    * @param m 缩小后图像的宽

    * @param n 缩小后图像的高

    * @return 返回处理后的图像对象

    */

    public static BufferedImage shrink(BufferedImage img, int m, int n) {

    float k1 = (float)m/img.getWidth();

    float k2 = (float)n/img.getHeight();

    return shrink(img, k1, k2);

    }

    /**

    * 局部均值的图像缩小

    * @param img 要缩小的图像对象

    * @param k1 要缩小的列比列

    * @param k2 要缩小的行比列

    * @return 返回处理后的图像对象

    */

    public static BufferedImage shrink(BufferedImage img, float k1, float k2) {

    if(k1 >1 || k2>1) {//如果k1 >1 || k2>1则是图片放大,不是缩小

    System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");

    return null;

    }

    float ii = 1/k1;//采样的行间距

    float jj = 1/k2; //采样的列间距

    int dd = (int)(ii*jj);

    //int m=0 , n=0;

    int imgType = img.getType();

    int w = img.getWidth();

    int h = img.getHeight();

    int m = (int) (k1*w);

    int n = (int) (k2*h);

    int[] pix = new int[w*h];

    pix = img.getRGB(0, 0, w, h, pix, 0, w);

    System.out.println(w + " * " + h);

    System.out.println(m + " * " + n);

    int[] newpix = new int[m*n];

    for(int j=0; j

    for(int i=0; i

    int r = 0, g=0, b=0;

    ColorModel cm = ColorModel.getRGBdefault();

    for(int k=0; k

    for(int l=0; l

    r = r + cm.getRed(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);

    g = g + cm.getGreen(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);

    b = b + cm.getBlue(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);

    }

    }

    r = r/dd;

    g = g/dd;

    b = b/dd;

    newpix[j*m + i] = 255<<24 | r<<16 | g<<8 | b;

    //255<<24 | r<<16 | g<<8 | b 这个公式解释一下,颜色的RGB在内存中是

    //以二进制的形式保存的,从右到左1-8位表示blue,9-16表示green,17-24表示red

    //所以"<<24" "<<16" "<<8"分别表示左移24,16,8位

    //newpix[j*m + i] = new Color(r,g,b).getRGB();

    }

    }

    BufferedImage imgOut = new BufferedImage( m, n, imgType);

    imgOut.setRGB(0, 0, m, n, newpix, 0, m);

    return imgOut;

    }

    双线性差值法放图像

    子块四个顶点的坐标分别设为(0,0)、(1,0)、(0,1)、(1,1),对应的带处理的像素的坐标(c1,c2),0

    1350202227_5154.jpg

    f(x,0) = f(0,0) + c1*(f(1,0)-f(0,0))

    f(x,1) = f(0,1) + c1*(f(1,1)-f(0,1))

    f(x,y) = f(x,0) + c2*f(f(x,1)-f(x,0))

    例,原图的像素矩阵如下。

    1350201735_6023.jpg

    将其放大成2.5*1.2倍,双线性插值发,填充顶点如下:

    1350201528_1565.jpg

    (1)

    1350201878_8228.jpg

    (2)

    1 2 3 4 5 6 7 7

    2 3 4 5 7 8 8 8

    3 4 5 6 7 8 9 9

    3 4 5 6 7 8 9 9

    (3)

    算法源代码(java)

    /**

    * 双线性插值法图像的放大

    * @param img 要缩小的图像对象

    * @param k1 要缩小的列比列

    * @param k2 要缩小的行比列

    * @return 返回处理后的图像对象

    */

    public static BufferedImage amplify(BufferedImage img, float k1, float k2) {

    if(k1 <1 || k2<1) {//如果k1 <1 || k2<1则是图片缩小,不是放大

    System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");

    return null;

    }

    float ii = 1/k1;//采样的行间距

    float jj = (1/k2); //采样的列间距

    int dd = (int)(ii*jj);

    //int m=0 , n=0;

    int imgType = img.getType();

    int w = img.getWidth();//原图片的宽

    int h = img.getHeight();//原图片的宽

    int m = Math.round(k1*w);//放大后图片的宽

    int n = Math.round(k2*h);//放大后图片的宽

    int[] pix = new int[w*h];

    pix = img.getRGB(0, 0, w, h, pix, 0, w);

    /*System.out.println(w + " * " + h);

    System.out.println(m + " * " + n);*/

    int[] newpix = new int[m*n];

    for(int j=0; j

    for(int i=0; i

    int x0 = Math.round(i*k1);

    int y0 = Math.round(j*k2);

    int x1, y1;

    if(i == w-2) {

    x1 = m-1;

    } else {

    x1 = Math.round((i+1)*k1);

    }

    if(j == h-2) {

    y1 = n-1;

    } else {

    y1 = Math.round((j+1)*k2);

    }

    int d1 = x1 - x0;

    int d2 = y1 - y0;

    if(0 == newpix[y0*m + x0]) {

    newpix[y0*m + x0] = pix[j*w+i];

    }

    if(0 == newpix[y0*m + x1]) {

    if(i == w-2) {

    newpix[y0*m + x1] = pix[j*w+w-1];

    } else {

    newpix[y0*m + x1] = pix[j*w+i+1];

    }

    }

    if(0 == newpix[y1*m + x0]){

    if(j == h-2) {

    newpix[y1*m + x0] = pix[(h-1)*w+i];

    } else {

    newpix[y1*m + x0] = pix[(j+1)*w+i];

    }

    }

    if(0 == newpix[y1*m + x1]) {

    if(i==w-2 && j==h-2) {

    newpix[y1*m + x1] = pix[(h-1)*w+w-1];

    } else {

    newpix[y1*m + x1] = pix[(j+1)*w+i+1];

    }

    }

    int r, g, b;

    float c;

    ColorModel cm = ColorModel.getRGBdefault();

    for(int l=0; l

    for(int k=0; k

    if(0 == l) {

    //f(x,0) = f(0,0) + c1*(f(1,0)-f(0,0))

    if(j

    c = (float)k/d1;

    r = cm.getRed(newpix[y0*m + x0]) + (int)(c*(cm.getRed(newpix[y0*m + x1]) - cm.getRed(newpix[y0*m + x0])));//newpix[(y0+l)*m + k]

    g = cm.getGreen(newpix[y0*m + x0]) + (int)(c*(cm.getGreen(newpix[y0*m + x1]) - cm.getGreen(newpix[y0*m + x0])));

    b = cm.getBlue(newpix[y0*m + x0]) + (int)(c*(cm.getBlue(newpix[y0*m + x1]) - cm.getBlue(newpix[y0*m + x0])));

    newpix[y0*m + x0 + k] = new Color(r,g,b).getRGB();

    }

    if(j+1

    c = (float)k/d1;

    r = cm.getRed(newpix[y1*m + x0]) + (int)(c*(cm.getRed(newpix[y1*m + x1]) - cm.getRed(newpix[y1*m + x0])));

    g = cm.getGreen(newpix[y1*m + x0]) + (int)(c*(cm.getGreen(newpix[y1*m + x1]) - cm.getGreen(newpix[y1*m + x0])));

    b = cm.getBlue(newpix[y1*m + x0]) + (int)(c*(cm.getBlue(newpix[y1*m + x1]) - cm.getBlue(newpix[y1*m + x0])));

    newpix[y1*m + x0 + k] = new Color(r,g,b).getRGB();

    }

    //System.out.println(c);

    } else {

    //f(x,y) = f(x,0) + c2*f(f(x,1)-f(x,0))

    c = (float)l/d2;

    r = cm.getRed(newpix[y0*m + x0+k]) + (int)(c*(cm.getRed(newpix[y1*m + x0+k]) - cm.getRed(newpix[y0*m + x0+k])));

    g = cm.getGreen(newpix[y0*m + x0+k]) + (int)(c*(cm.getGreen(newpix[y1*m + x0+k]) - cm.getGreen(newpix[y0*m + x0+k])));

    b = cm.getBlue(newpix[y0*m + x0+k]) + (int)(c*(cm.getBlue(newpix[y1*m + x0+k]) - cm.getBlue(newpix[y0*m + x0+k])));

    newpix[(y0+l)*m + x0 + k] = new Color(r,g,b).getRGB();

    //System.out.println((int)(c*(cm.getRed(newpix[y1*m + x0+k]) - cm.getRed(newpix[y0*m + x0+k]))));

    }

    }

    if(i==w-2 || l==d2-1) {//最后一列的计算

    //f(1,y) = f(1,0) + c2*f(f(1,1)-f(1,0))

    c = (float)l/d2;

    r = cm.getRed(newpix[y0*m + x1]) + (int)(c*(cm.getRed(newpix[y1*m + x1]) - cm.getRed(newpix[y0*m + x1])));

    g = cm.getGreen(newpix[y0*m + x1]) + (int)(c*(cm.getGreen(newpix[y1*m + x1]) - cm.getGreen(newpix[y0*m + x1])));

    b = cm.getBlue(newpix[y0*m + x1]) + (int)(c*(cm.getBlue(newpix[y1*m + x1]) - cm.getBlue(newpix[y0*m + x1])));

    newpix[(y0+l)*m + x1] = new Color(r,g,b).getRGB();

    }

    }

    }

    }

    /*

    for(int j=0; j<50; j++){

    for(int i=0; i<50; i++) {

    System.out.print(new Color(newpix[j*m + i]).getRed() + "\t");

    }

    System.out.println();

    }

    */

    BufferedImage imgOut = new BufferedImage( m, n, imgType);

    imgOut.setRGB(0, 0, m, n, newpix, 0, m);

    return imgOut;

    }

    分享到:

    18e900b8666ce6f233d25ec02f95ee59.png

    72dd548719f0ace4d5f9bca64e1d7715.png

    2012-10-14 16:09

    浏览 1409

    评论

    展开全文
  • 一个实现对图像进行双线性内插算法的程序代码
  • 概述 基于上一节“等距采样法”实现图片放大与缩小的缺点...要对其进行改进,对图像的缩小则可以用“局部均值法”,对于图像的放大则可以用“双线性插值法”。 效果如下:    2048*1536缩小为100*80时

    原文地址:http://blog.csdn.net/luoweifu/article/details/8069883

    概述

    基于上一节“等距采样法”实现图片放大与缩小的缺点。要对其进行改进,对图像的缩小则可以用“局部均值法”,对于图像的放大则可以用“双线性插值法”。

    效果如下:

          

                       2048*1536缩小为100*80时的效果               100*80放大到600*400的效果

    局部均值法缩小图像

    (1)计算采样间隔

    设原图的大小为W*H,将其放大(缩小)为(k1*W)*(K2*H),则采样区间为

    ii=1/k1;       jj=1/k2;

    当k1==k2时为等比例缩小;当k1!=k2时为不等比例放大(缩小);k1<1 && k2<1时为图片缩小,k1>1 && k2>1时图片放大。

    (2)求出局部子块

    设原图为F(x,y)(i=1,2,……W; j=1,2,……H),缩小的图像为G(x,y)(x=1,2, ……M; y=1,2,……N,其中M=W*k1,N=H*k2),则有原图像局部子块为

    f’(x,y) = f(ii*i, jj*j)        …… f(ii*i + ii-1, jj*j)

                    ……                   ……

                 f(ii*i, jj*j+jj-1) …… f(ii*i + ii-1, jj*j+jj-1)

    (3)求出缩小的图像

    G(x, y) = f’(x,y)的均值

    例:


    缩小后的图像

     

     

    例如g11=(f11 +f12 + f21 + f22)/4

     

    算法源代码(java)

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. /** 
    2.      * 局部均值的图像缩小 
    3.      * @param img 要缩小的图像对象 
    4.      * @param m 缩小后图像的宽 
    5.      * @param n 缩小后图像的高 
    6.      * @return 返回处理后的图像对象 
    7.      */  
    8.     public static BufferedImage shrink(BufferedImage img, int m, int n) {  
    9.         float k1 = (float)m/img.getWidth();  
    10.         float k2 = (float)n/img.getHeight();          
    11.         return shrink(img, k1, k2);  
    12.     }  
    13.       
    14.     /** 
    15.       * 局部均值的图像缩小 
    16.      * @param img 要缩小的图像对象 
    17.      * @param k1 要缩小的列比列 
    18.      * @param k2 要缩小的行比列 
    19.      * @return 返回处理后的图像对象 
    20.      */  
    21.     public static BufferedImage shrink(BufferedImage img, float k1, float k2) {  
    22.         if(k1 >1 || k2>1) {//如果k1 >1 || k2>1则是图片放大,不是缩小  
    23.             System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");  
    24.             return null;  
    25.         }   
    26.         float ii = 1/k1;    //采样的行间距  
    27.         float jj = 1/k2; //采样的列间距         
    28.         int dd = (int)(ii*jj);   
    29.         //int m=0 , n=0;                  
    30.         int imgType = img.getType();  
    31.         int w = img.getWidth();  
    32.         int h = img.getHeight();  
    33.         int m = (int) (k1*w);  
    34.         int n = (int) (k2*h);  
    35.         int[] pix = new int[w*h];  
    36.         pix = img.getRGB(00, w, h, pix, 0, w);  
    37.         System.out.println(w + " * " + h);  
    38.         System.out.println(m + " * " + n);  
    39.         int[] newpix = new int[m*n];  
    40.           
    41.         for(int j=0; j<n; j++) {  
    42.             for(int i=0; i<m; i++) {  
    43.                 int r = 0, g=0, b=0;  
    44.                 ColorModel cm = ColorModel.getRGBdefault();               
    45.                 for(int k=0; k<(int)jj; k++) {  
    46.                     for(int l=0; l<(int)ii; l++) {  
    47.                         r = r + cm.getRed(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    48.                         g = g + cm.getGreen(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    49.                         b = b + cm.getBlue(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    50.                     }  
    51.                 }  
    52.                 r = r/dd;  
    53.                 g = g/dd;  
    54.                 b = b/dd;  
    55.                 newpix[j*m + i] = 255<<24 | r<<16 | g<<8 | b;  
    56.                 //255<<24 | r<<16 | g<<8 | b  这个公式解释一下,颜色的RGB在内存中是  
    57.                 //以二进制的形式保存的,从右到左1-8位表示blue,9-16表示green,17-24表示red  
    58.                 //所以"<<24" "<<16" "<<8"分别表示左移24,16,8位  
    59.                   
    60.                 //newpix[j*m + i] = new Color(r,g,b).getRGB();  
    61.             }  
    62.         }  
    63.           
    64.         BufferedImage imgOut = new BufferedImage( m, n, imgType);  
    65.           
    66.         imgOut.setRGB(00, m, n, newpix, 0, m);              
    67.         return imgOut;  
    68.     }  

     
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. /** 
    2.      * 局部均值的图像缩小 
    3.      * @param img 要缩小的图像对象 
    4.      * @param m 缩小后图像的宽 
    5.      * @param n 缩小后图像的高 
    6.      * @return 返回处理后的图像对象 
    7.      */  
    8.     public static BufferedImage shrink(BufferedImage img, int m, int n) {  
    9.         float k1 = (float)m/img.getWidth();  
    10.         float k2 = (float)n/img.getHeight();          
    11.         return shrink(img, k1, k2);  
    12.     }  
    13.       
    14.     /** 
    15.       * 局部均值的图像缩小 
    16.      * @param img 要缩小的图像对象 
    17.      * @param k1 要缩小的列比列 
    18.      * @param k2 要缩小的行比列 
    19.      * @return 返回处理后的图像对象 
    20.      */  
    21.     public static BufferedImage shrink(BufferedImage img, float k1, float k2) {  
    22.         if(k1 >1 || k2>1) {//如果k1 >1 || k2>1则是图片放大,不是缩小  
    23.             System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");  
    24.             return null;  
    25.         }   
    26.         float ii = 1/k1;    //采样的行间距  
    27.         float jj = 1/k2; //采样的列间距         
    28.         int dd = (int)(ii*jj);   
    29.         //int m=0 , n=0;                  
    30.         int imgType = img.getType();  
    31.         int w = img.getWidth();  
    32.         int h = img.getHeight();  
    33.         int m = (int) (k1*w);  
    34.         int n = (int) (k2*h);  
    35.         int[] pix = new int[w*h];  
    36.         pix = img.getRGB(00, w, h, pix, 0, w);  
    37.         System.out.println(w + " * " + h);  
    38.         System.out.println(m + " * " + n);  
    39.         int[] newpix = new int[m*n];  
    40.           
    41.         for(int j=0; j<n; j++) {  
    42.             for(int i=0; i<m; i++) {  
    43.                 int r = 0, g=0, b=0;  
    44.                 ColorModel cm = ColorModel.getRGBdefault();               
    45.                 for(int k=0; k<(int)jj; k++) {  
    46.                     for(int l=0; l<(int)ii; l++) {  
    47.                         r = r + cm.getRed(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    48.                         g = g + cm.getGreen(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    49.                         b = b + cm.getBlue(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    50.                     }  
    51.                 }  
    52.                 r = r/dd;  
    53.                 g = g/dd;  
    54.                 b = b/dd;  
    55.                 newpix[j*m + i] = 255<<24 | r<<16 | g<<8 | b;  
    56.                 //255<<24 | r<<16 | g<<8 | b  这个公式解释一下,颜色的RGB在内存中是  
    57.                 //以二进制的形式保存的,从右到左1-8位表示blue,9-16表示green,17-24表示red  
    58.                 //所以"<<24" "<<16" "<<8"分别表示左移24,16,8位  
    59.                   
    60.                 //newpix[j*m + i] = new Color(r,g,b).getRGB();  
    61.             }  
    62.         }  
    63.           
    64.         BufferedImage imgOut = new BufferedImage( m, n, imgType);  
    65.           
    66.         imgOut.setRGB(00, m, n, newpix, 0, m);              
    67.         return imgOut;  
    68.     }  

    双线性差值法放图像

    子块四个顶点的坐标分别设为(0,0)、(1,0)、(0,1)、(1,1),对应的带处理的像素的坐标(c1,c2),0<c1<1, 0<y<1.则f(x,y)由上到下得到


    f(x,0) = f(0,0) + c1*(f(1,0)-f(0,0))
    f(x,1) = f(0,1) + c1*(f(1,1)-f(0,1))
    f(x,y) = f(x,0) + c2*f(f(x,1)-f(x,0))

    例,原图的像素矩阵如下。


    将其放大成2.5*1.2倍,双线性插值发,填充顶点如下:


    (1)

     

    (2)

    1  2  3  4  5  6  7  7

    2  3  4  5  7  8  8  8

    3  4  5  6  7  8  9  9

    3  4  5  6  7  8  9  9

    (3)

    算法源代码(java)


    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. /** 
    2.      * 双线性插值法图像的放大 
    3.      * @param img 要缩小的图像对象 
    4.      * @param k1 要缩小的列比列 
    5.      * @param k2 要缩小的行比列 
    6.      * @return 返回处理后的图像对象 
    7.      */  
    8.     public static BufferedImage amplify(BufferedImage img, float k1, float k2) {  
    9.         if(k1 <1 || k2<1) {//如果k1 <1 || k2<1则是图片缩小,不是放大  
    10.             System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");  
    11.             return null;  
    12.         }   
    13.         float ii = 1/k1;    //采样的行间距  
    14.         float jj = (1/k2); //采样的列间距       
    15.         int dd = (int)(ii*jj);   
    16.         //int m=0 , n=0;  
    17.         int imgType = img.getType();  
    18.         int w = img.getWidth();     //原图片的宽  
    19.         int h = img.getHeight();    //原图片的宽  
    20.         int m = Math.round(k1*w);   //放大后图片的宽  
    21.         int n = Math.round(k2*h);   //放大后图片的宽  
    22.         int[] pix = new int[w*h];  
    23.         pix = img.getRGB(00, w, h, pix, 0, w);  
    24.         /*System.out.println(w + " * " + h); 
    25.         System.out.println(m + " * " + n);*/  
    26.         int[] newpix = new int[m*n];  
    27.           
    28.         for(int j=0; j<h-1; j++){  
    29.             for(int i=0; i<w-1; i++) {  
    30.                 int x0 = Math.round(i*k1);  
    31.                 int y0 = Math.round(j*k2);  
    32.                 int x1, y1;  
    33.                 if(i == w-2) {  
    34.                     x1 = m-1;  
    35.                 } else {  
    36.                     x1 = Math.round((i+1)*k1);  
    37.                 }                 
    38.                 if(j == h-2) {  
    39.                     y1 = n-1;  
    40.                 } else {  
    41.                     y1 = Math.round((j+1)*k2);  
    42.                 }                 
    43.                 int d1 = x1 - x0;  
    44.                 int d2 = y1 - y0;  
    45.                 if(0 == newpix[y0*m + x0]) {  
    46.                     newpix[y0*m + x0] =  pix[j*w+i];  
    47.                 }  
    48.                 if(0 == newpix[y0*m + x1]) {  
    49.                     if(i == w-2) {  
    50.                         newpix[y0*m + x1] = pix[j*w+w-1];  
    51.                     } else {  
    52.                         newpix[y0*m + x1] =  pix[j*w+i+1];  
    53.                     }                     
    54.                 }  
    55.                 if(0 == newpix[y1*m + x0]){  
    56.                     if(j == h-2) {  
    57.                         newpix[y1*m + x0] = pix[(h-1)*w+i];  
    58.                     } else {  
    59.                         newpix[y1*m + x0] =  pix[(j+1)*w+i];  
    60.                     }                     
    61.                 }  
    62.                 if(0 == newpix[y1*m + x1]) {  
    63.                     if(i==w-2 && j==h-2) {  
    64.                         newpix[y1*m + x1] = pix[(h-1)*w+w-1];  
    65.                     } else {  
    66.                         newpix[y1*m + x1] = pix[(j+1)*w+i+1];  
    67.                     }                     
    68.                 }  
    69.                 int r, g, b;  
    70.                 float c;  
    71.                 ColorModel cm = ColorModel.getRGBdefault();               
    72.                 for(int l=0; l<d2; l++) {  
    73.                     for(int k=0; k<d1; k++) {  
    74.                         if(0 == l) {  
    75.                             //f(x,0) = f(0,0) + c1*(f(1,0)-f(0,0))  
    76.                             if(j<h-1 && newpix[y0*m + x0 + k] == 0) {  
    77.                                 c = (float)k/d1;  
    78.                                  r = cm.getRed(newpix[y0*m + x0]) + (int)(c*(cm.getRed(newpix[y0*m + x1]) - cm.getRed(newpix[y0*m + x0])));//newpix[(y0+l)*m + k]  
    79.                                  g = cm.getGreen(newpix[y0*m + x0]) + (int)(c*(cm.getGreen(newpix[y0*m + x1]) - cm.getGreen(newpix[y0*m + x0])));  
    80.                                  b = cm.getBlue(newpix[y0*m + x0]) + (int)(c*(cm.getBlue(newpix[y0*m + x1]) - cm.getBlue(newpix[y0*m + x0])));  
    81.                                  newpix[y0*m + x0 + k] = new Color(r,g,b).getRGB();  
    82.                             }  
    83.                             if(j+1<h && newpix[y1*m + x0 + k] == 0) {  
    84.                                  c = (float)k/d1;  
    85.                                     r = cm.getRed(newpix[y1*m + x0]) + (int)(c*(cm.getRed(newpix[y1*m + x1]) - cm.getRed(newpix[y1*m + x0])));  
    86.                                     g = cm.getGreen(newpix[y1*m + x0]) + (int)(c*(cm.getGreen(newpix[y1*m + x1]) - cm.getGreen(newpix[y1*m + x0])));  
    87.                                     b = cm.getBlue(newpix[y1*m + x0]) + (int)(c*(cm.getBlue(newpix[y1*m + x1]) - cm.getBlue(newpix[y1*m + x0])));  
    88.                                     newpix[y1*m + x0 + k] = new Color(r,g,b).getRGB();  
    89.                              }  
    90.                             //System.out.println(c);  
    91.                         } else {  
    92.                             //f(x,y) = f(x,0) + c2*f(f(x,1)-f(x,0))  
    93.                             c = (float)l/d2;  
    94.                             r = cm.getRed(newpix[y0*m + x0+k]) + (int)(c*(cm.getRed(newpix[y1*m + x0+k]) - cm.getRed(newpix[y0*m + x0+k])));  
    95.                             g = cm.getGreen(newpix[y0*m + x0+k]) + (int)(c*(cm.getGreen(newpix[y1*m + x0+k]) - cm.getGreen(newpix[y0*m + x0+k])));  
    96.                             b = cm.getBlue(newpix[y0*m + x0+k]) + (int)(c*(cm.getBlue(newpix[y1*m + x0+k]) - cm.getBlue(newpix[y0*m + x0+k])));  
    97.                             newpix[(y0+l)*m + x0 + k] = new Color(r,g,b).getRGB();   
    98.                             //System.out.println((int)(c*(cm.getRed(newpix[y1*m + x0+k]) - cm.getRed(newpix[y0*m + x0+k]))));  
    99.                         }                 
    100.                     }                     
    101.                     if(i==w-2 || l==d2-1) { //最后一列的计算  
    102.                         //f(1,y) = f(1,0) + c2*f(f(1,1)-f(1,0))  
    103.                         c = (float)l/d2;  
    104.                         r = cm.getRed(newpix[y0*m + x1]) + (int)(c*(cm.getRed(newpix[y1*m + x1]) - cm.getRed(newpix[y0*m + x1])));  
    105.                         g = cm.getGreen(newpix[y0*m + x1]) + (int)(c*(cm.getGreen(newpix[y1*m + x1]) - cm.getGreen(newpix[y0*m + x1])));  
    106.                         b = cm.getBlue(newpix[y0*m + x1]) + (int)(c*(cm.getBlue(newpix[y1*m + x1]) - cm.getBlue(newpix[y0*m + x1])));  
    107.                         newpix[(y0+l)*m + x1] = new Color(r,g,b).getRGB();   
    108.                     }  
    109.                 }  
    110.             }  
    111.         }  
    112.         /* 
    113.         for(int j=0; j<50; j++){ 
    114.             for(int i=0; i<50; i++) { 
    115.                 System.out.print(new Color(newpix[j*m + i]).getRed() + "\t");                
    116.             } 
    117.             System.out.println(); 
    118.         } 
    119.         */  
    120.         BufferedImage imgOut = new BufferedImage( m, n, imgType);  
    121.           
    122.         imgOut.setRGB(00, m, n, newpix, 0, m);          
    123.         return imgOut;  
    124.     }  
    展开全文
  • 要对其进行改进,对图像的缩小则可以用“局部均值法”,对于图像的放大则可以用“双线性插值法”。 效果如下:    2048*1536缩小为100*80时的效果 100*80放大到600*400的效果 局部均值法缩小图像 ...

    概述

    基于上一节“等距采样法”实现图片放大与缩小的缺点。要对其进行改进,对图像的缩小则可以用“局部均值法”,对于图像的放大则可以用“双线性插值法”。

    效果如下:

          

                       2048*1536缩小为100*80时的效果               100*80放大到600*400的效果

    局部均值法缩小图像

    (1)计算采样间隔

    设原图的大小为W*H,将其放大(缩小)为(k1*W)*(K2*H),则采样区间为

    ii=1/k1;       jj=1/k2;

    当k1==k2时为等比例缩小;当k1!=k2时为不等比例放大(缩小);k1<1 && k2<1时为图片缩小,k1>1 && k2>1时图片放大。

    (2)求出局部子块

    设原图为F(x,y)(i=1,2,……W; j=1,2,……H),缩小的图像为G(x,y)(x=1,2, ……M; y=1,2,……N,其中M=W*k1,N=H*k2),则有原图像局部子块为

    f’(x,y) = f(ii*i, jj*j)        …… f(ii*i + ii-1, jj*j)

                    ……                   ……

                 f(ii*i, jj*j+jj-1) …… f(ii*i + ii-1, jj*j+jj-1)

    (3)求出缩小的图像

    G(x, y) = f’(x,y)的均值

    例:


    缩小后的图像

     

     

    例如g11=(f11 +f12 + f21 + f22)/4

     

    算法源代码(Java

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. /** 
    2.      * 局部均值的图像缩小 
    3.      * @param img 要缩小的图像对象 
    4.      * @param m 缩小后图像的宽 
    5.      * @param n 缩小后图像的高 
    6.      * @return 返回处理后的图像对象 
    7.      */  
    8.     public static BufferedImage shrink(BufferedImage img, int m, int n) {  
    9.         float k1 = (float)m/img.getWidth();  
    10.         float k2 = (float)n/img.getHeight();          
    11.         return shrink(img, k1, k2);  
    12.     }  
    13.       
    14.     /** 
    15.       * 局部均值的图像缩小 
    16.      * @param img 要缩小的图像对象 
    17.      * @param k1 要缩小的列比列 
    18.      * @param k2 要缩小的行比列 
    19.      * @return 返回处理后的图像对象 
    20.      */  
    21.     public static BufferedImage shrink(BufferedImage img, float k1, float k2) {  
    22.         if(k1 >1 || k2>1) {//如果k1 >1 || k2>1则是图片放大,不是缩小  
    23.             System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");  
    24.             return null;  
    25.         }   
    26.         float ii = 1/k1;    //采样的行间距  
    27.         float jj = 1/k2; //采样的列间距         
    28.         int dd = (int)(ii*jj);   
    29.         //int m=0 , n=0;                  
    30.         int imgType = img.getType();  
    31.         int w = img.getWidth();  
    32.         int h = img.getHeight();  
    33.         int m = (int) (k1*w);  
    34.         int n = (int) (k2*h);  
    35.         int[] pix = new int[w*h];  
    36.         pix = img.getRGB(00, w, h, pix, 0, w);  
    37.         System.out.println(w + " * " + h);  
    38.         System.out.println(m + " * " + n);  
    39.         int[] newpix = new int[m*n];  
    40.           
    41.         for(int j=0; j<n; j++) {  
    42.             for(int i=0; i<m; i++) {  
    43.                 int r = 0, g=0, b=0;  
    44.                 ColorModel cm = ColorModel.getRGBdefault();               
    45.                 for(int k=0; k<(int)jj; k++) {  
    46.                     for(int l=0; l<(int)ii; l++) {  
    47.                         r = r + cm.getRed(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    48.                         g = g + cm.getGreen(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    49.                         b = b + cm.getBlue(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    50.                     }  
    51.                 }  
    52.                 r = r/dd;  
    53.                 g = g/dd;  
    54.                 b = b/dd;  
    55.                 newpix[j*m + i] = 255<<24 | r<<16 | g<<8 | b;  
    56.                 //255<<24 | r<<16 | g<<8 | b  这个公式解释一下,颜色的RGB在内存中是  
    57.                 //以二进制的形式保存的,从右到左1-8位表示blue,9-16表示green,17-24表示red  
    58.                 //所以"<<24" "<<16" "<<8"分别表示左移24,16,8位  
    59.                   
    60.                 //newpix[j*m + i] = new Color(r,g,b).getRGB();  
    61.             }  
    62.         }  
    63.           
    64.         BufferedImage imgOut = new BufferedImage( m, n, imgType);  
    65.           
    66.         imgOut.setRGB(00, m, n, newpix, 0, m);              
    67.         return imgOut;  
    68.     }  

     
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. /** 
    2.      * 局部均值的图像缩小 
    3.      * @param img 要缩小的图像对象 
    4.      * @param m 缩小后图像的宽 
    5.      * @param n 缩小后图像的高 
    6.      * @return 返回处理后的图像对象 
    7.      */  
    8.     public static BufferedImage shrink(BufferedImage img, int m, int n) {  
    9.         float k1 = (float)m/img.getWidth();  
    10.         float k2 = (float)n/img.getHeight();          
    11.         return shrink(img, k1, k2);  
    12.     }  
    13.       
    14.     /** 
    15.       * 局部均值的图像缩小 
    16.      * @param img 要缩小的图像对象 
    17.      * @param k1 要缩小的列比列 
    18.      * @param k2 要缩小的行比列 
    19.      * @return 返回处理后的图像对象 
    20.      */  
    21.     public static BufferedImage shrink(BufferedImage img, float k1, float k2) {  
    22.         if(k1 >1 || k2>1) {//如果k1 >1 || k2>1则是图片放大,不是缩小  
    23.             System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");  
    24.             return null;  
    25.         }   
    26.         float ii = 1/k1;    //采样的行间距  
    27.         float jj = 1/k2; //采样的列间距         
    28.         int dd = (int)(ii*jj);   
    29.         //int m=0 , n=0;                  
    30.         int imgType = img.getType();  
    31.         int w = img.getWidth();  
    32.         int h = img.getHeight();  
    33.         int m = (int) (k1*w);  
    34.         int n = (int) (k2*h);  
    35.         int[] pix = new int[w*h];  
    36.         pix = img.getRGB(00, w, h, pix, 0, w);  
    37.         System.out.println(w + " * " + h);  
    38.         System.out.println(m + " * " + n);  
    39.         int[] newpix = new int[m*n];  
    40.           
    41.         for(int j=0; j<n; j++) {  
    42.             for(int i=0; i<m; i++) {  
    43.                 int r = 0, g=0, b=0;  
    44.                 ColorModel cm = ColorModel.getRGBdefault();               
    45.                 for(int k=0; k<(int)jj; k++) {  
    46.                     for(int l=0; l<(int)ii; l++) {  
    47.                         r = r + cm.getRed(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    48.                         g = g + cm.getGreen(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    49.                         b = b + cm.getBlue(pix[(int)(jj*j+k)*w + (int)(ii*i+l)]);  
    50.                     }  
    51.                 }  
    52.                 r = r/dd;  
    53.                 g = g/dd;  
    54.                 b = b/dd;  
    55.                 newpix[j*m + i] = 255<<24 | r<<16 | g<<8 | b;  
    56.                 //255<<24 | r<<16 | g<<8 | b  这个公式解释一下,颜色的RGB在内存中是  
    57.                 //以二进制的形式保存的,从右到左1-8位表示blue,9-16表示green,17-24表示red  
    58.                 //所以"<<24" "<<16" "<<8"分别表示左移24,16,8位  
    59.                   
    60.                 //newpix[j*m + i] = new Color(r,g,b).getRGB();  
    61.             }  
    62.         }  
    63.           
    64.         BufferedImage imgOut = new BufferedImage( m, n, imgType);  
    65.           
    66.         imgOut.setRGB(00, m, n, newpix, 0, m);              
    67.         return imgOut;  
    68.     }  

    双线性差值法放图像

    子块四个顶点的坐标分别设为(0,0)、(1,0)、(0,1)、(1,1),对应的带处理的像素的坐标(c1,c2),0<c1<1, 0<y<1.则f(x,y)由上到下得到


    f(x,0) = f(0,0) + c1*(f(1,0)-f(0,0))
    f(x,1) = f(0,1) + c1*(f(1,1)-f(0,1))
    f(x,y) = f(x,0) + c2*f(f(x,1)-f(x,0))

    例,原图的像素矩阵如下。


    将其放大成2.5*1.2倍,双线性插值发,填充顶点如下:


    (1)

     

    (2)

    1  2  3  4  5  6  7  7

    2  3  4  5  7  8  8  8

    3  4  5  6  7  8  9  9

    3  4  5  6  7  8  9  9

    (3)

    算法源代码(java)


    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. /** 
    2.      * 双线性插值法图像的放大 
    3.      * @param img 要缩小的图像对象 
    4.      * @param k1 要缩小的列比列 
    5.      * @param k2 要缩小的行比列 
    6.      * @return 返回处理后的图像对象 
    7.      */  
    8.     public static BufferedImage amplify(BufferedImage img, float k1, float k2) {  
    9.         if(k1 <1 || k2<1) {//如果k1 <1 || k2<1则是图片缩小,不是放大  
    10.             System.err.println("this is shrink image funcation, please set k1<=1 and k2<=1!");  
    11.             return null;  
    12.         }   
    13.         float ii = 1/k1;    //采样的行间距  
    14.         float jj = (1/k2); //采样的列间距       
    15.         int dd = (int)(ii*jj);   
    16.         //int m=0 , n=0;  
    17.         int imgType = img.getType();  
    18.         int w = img.getWidth();     //原图片的宽  
    19.         int h = img.getHeight();    //原图片的宽  
    20.         int m = Math.round(k1*w);   //放大后图片的宽  
    21.         int n = Math.round(k2*h);   //放大后图片的宽  
    22.         int[] pix = new int[w*h];  
    23.         pix = img.getRGB(00, w, h, pix, 0, w);  
    24.         /*System.out.println(w + " * " + h); 
    25.         System.out.println(m + " * " + n);*/  
    26.         int[] newpix = new int[m*n];  
    27.           
    28.         for(int j=0; j<h-1; j++){  
    29.             for(int i=0; i<w-1; i++) {  
    30.                 int x0 = Math.round(i*k1);  
    31.                 int y0 = Math.round(j*k2);  
    32.                 int x1, y1;  
    33.                 if(i == w-2) {  
    34.                     x1 = m-1;  
    35.                 } else {  
    36.                     x1 = Math.round((i+1)*k1);  
    37.                 }                 
    38.                 if(j == h-2) {  
    39.                     y1 = n-1;  
    40.                 } else {  
    41.                     y1 = Math.round((j+1)*k2);  
    42.                 }                 
    43.                 int d1 = x1 - x0;  
    44.                 int d2 = y1 - y0;  
    45.                 if(0 == newpix[y0*m + x0]) {  
    46.                     newpix[y0*m + x0] =  pix[j*w+i];  
    47.                 }  
    48.                 if(0 == newpix[y0*m + x1]) {  
    49.                     if(i == w-2) {  
    50.                         newpix[y0*m + x1] = pix[j*w+w-1];  
    51.                     } else {  
    52.                         newpix[y0*m + x1] =  pix[j*w+i+1];  
    53.                     }                     
    54.                 }  
    55.                 if(0 == newpix[y1*m + x0]){  
    56.                     if(j == h-2) {  
    57.                         newpix[y1*m + x0] = pix[(h-1)*w+i];  
    58.                     } else {  
    59.                         newpix[y1*m + x0] =  pix[(j+1)*w+i];  
    60.                     }                     
    61.                 }  
    62.                 if(0 == newpix[y1*m + x1]) {  
    63.                     if(i==w-2 && j==h-2) {  
    64.                         newpix[y1*m + x1] = pix[(h-1)*w+w-1];  
    65.                     } else {  
    66.                         newpix[y1*m + x1] = pix[(j+1)*w+i+1];  
    67.                     }                     
    68.                 }  
    69.                 int r, g, b;  
    70.                 float c;  
    71.                 ColorModel cm = ColorModel.getRGBdefault();               
    72.                 for(int l=0; l<d2; l++) {  
    73.                     for(int k=0; k<d1; k++) {  
    74.                         if(0 == l) {  
    75.                             //f(x,0) = f(0,0) + c1*(f(1,0)-f(0,0))  
    76.                             if(j<h-1 && newpix[y0*m + x0 + k] == 0) {  
    77.                                 c = (float)k/d1;  
    78.                                  r = cm.getRed(newpix[y0*m + x0]) + (int)(c*(cm.getRed(newpix[y0*m + x1]) - cm.getRed(newpix[y0*m + x0])));//newpix[(y0+l)*m + k]  
    79.                                  g = cm.getGreen(newpix[y0*m + x0]) + (int)(c*(cm.getGreen(newpix[y0*m + x1]) - cm.getGreen(newpix[y0*m + x0])));  
    80.                                  b = cm.getBlue(newpix[y0*m + x0]) + (int)(c*(cm.getBlue(newpix[y0*m + x1]) - cm.getBlue(newpix[y0*m + x0])));  
    81.                                  newpix[y0*m + x0 + k] = new Color(r,g,b).getRGB();  
    82.                             }  
    83.                             if(j+1<h && newpix[y1*m + x0 + k] == 0) {  
    84.                                  c = (float)k/d1;  
    85.                                     r = cm.getRed(newpix[y1*m + x0]) + (int)(c*(cm.getRed(newpix[y1*m + x1]) - cm.getRed(newpix[y1*m + x0])));  
    86.                                     g = cm.getGreen(newpix[y1*m + x0]) + (int)(c*(cm.getGreen(newpix[y1*m + x1]) - cm.getGreen(newpix[y1*m + x0])));  
    87.                                     b = cm.getBlue(newpix[y1*m + x0]) + (int)(c*(cm.getBlue(newpix[y1*m + x1]) - cm.getBlue(newpix[y1*m + x0])));  
    88.                                     newpix[y1*m + x0 + k] = new Color(r,g,b).getRGB();  
    89.                              }  
    90.                             //System.out.println(c);  
    91.                         } else {  
    92.                             //f(x,y) = f(x,0) + c2*f(f(x,1)-f(x,0))  
    93.                             c = (float)l/d2;  
    94.                             r = cm.getRed(newpix[y0*m + x0+k]) + (int)(c*(cm.getRed(newpix[y1*m + x0+k]) - cm.getRed(newpix[y0*m + x0+k])));  
    95.                             g = cm.getGreen(newpix[y0*m + x0+k]) + (int)(c*(cm.getGreen(newpix[y1*m + x0+k]) - cm.getGreen(newpix[y0*m + x0+k])));  
    96.                             b = cm.getBlue(newpix[y0*m + x0+k]) + (int)(c*(cm.getBlue(newpix[y1*m + x0+k]) - cm.getBlue(newpix[y0*m + x0+k])));  
    97.                             newpix[(y0+l)*m + x0 + k] = new Color(r,g,b).getRGB();   
    98.                             //System.out.println((int)(c*(cm.getRed(newpix[y1*m + x0+k]) - cm.getRed(newpix[y0*m + x0+k]))));  
    99.                         }                 
    100.                     }                     
    101.                     if(i==w-2 || l==d2-1) { //最后一列的计算  
    102.                         //f(1,y) = f(1,0) + c2*f(f(1,1)-f(1,0))  
    103.                         c = (float)l/d2;  
    104.                         r = cm.getRed(newpix[y0*m + x1]) + (int)(c*(cm.getRed(newpix[y1*m + x1]) - cm.getRed(newpix[y0*m + x1])));  
    105.                         g = cm.getGreen(newpix[y0*m + x1]) + (int)(c*(cm.getGreen(newpix[y1*m + x1]) - cm.getGreen(newpix[y0*m + x1])));  
    106.                         b = cm.getBlue(newpix[y0*m + x1]) + (int)(c*(cm.getBlue(newpix[y1*m + x1]) - cm.getBlue(newpix[y0*m + x1])));  
    107.                         newpix[(y0+l)*m + x1] = new Color(r,g,b).getRGB();   
    108.                     }  
    109.                 }  
    110.             }  
    111.         }  
    112.         /* 
    113.         for(int j=0; j<50; j++){ 
    114.             for(int i=0; i<50; i++) { 
    115.                 System.out.print(new Color(newpix[j*m + i]).getRed() + "\t");                
    116.             } 
    117.             System.out.println(); 
    118.         } 
    119.         */  
    120.         BufferedImage imgOut = new BufferedImage( m, n, imgType);  
    121.           
    122.         imgOut.setRGB(00, m, n, newpix, 0, m);          
    123.         return imgOut;  
    124.     }  
    展开全文
  • 采用最近邻插值将图像放大1.5倍 放大1.5倍涉及到了一些像素坐标取整的问题,包括像素个数等,实验中都选择了向下取整的办法,由于1.5倍取在四个像素中间,最近邻点可以选择多个节点,这里也统一采用向下取整的节点,...

    1.隔行(列)采样缩小图像1/4的实验,两层for循环遍历,每隔一行,一列采集一个像素,这样在行和列上都缩小1/2,图像缩小了1/4。

    function pt=zoom1_4(p1)
        [m,n]=size(p1);
        for i=1:m
            if(mod(i,2)==0)
                for j=1:n
                    if(mod(j,2)==0)
                        pt(i/2,j/2)=p1(i,j);
                    end
                end
            end
        end
    end
    >> I=imread('cameraman.tif');
    >> pt=zoom1_4(I);
    >> imshow(pt)

     

    2.采用最近邻插值将图像放大1.5倍


    放大1.5倍涉及到了一些像素坐标取整的问题,包括像素个数等,实验中都选择了向下取整的办法,由于1.5倍取在四个像素中间,最近邻点可以选择多个节点,这里也统一采用向下取整的节点,以免边界溢出。

    function pt=amp_neighbor(p1)
        [m1,n1]=size(p1);
        mt=floor(m1*1.5);
        nt=floor(n1*1.5);
        for i=1:mt
            for j=1:nt
                pt(i,j)=p1(ceil(i/1.5),ceil(j/1.5));
            end
        end
    end
    >> I=imread('cameraman.tif');
    >> pt=amp_neighbor(I);
    >> imshow(pt)

     

    3.采用双线性插值将图像放大1.5倍

    像素个数操作同上,对于中间像素点的插值采用周围四个点,经过算术运算取均值的方法进行插值,按照PPT的ABCD四个点来编写函数。

    function pt=amp_doublelinear(p1)
        [m1,n1]=size(p1);
        mt=floor(m1*1.5);
        nt=floor(n1*1.5);
        pt(1,1)=p1(1,1);
        pt(1,2)=p1(1,2);
        pt(2,1)=p1(2,1);
        for i=2:mt
            for j=2:nt
                gf=(ceil(i/1.5)-(i/1.5))*(p1(floor(i/1.5),ceil(j/1.5))-p1(floor(i/1.5),floor(j/1.5)))+p1(floor(i/1.5),floor(j/1.5));
                ge=(ceil(i/1.5)-(i/1.5))*(p1(ceil(i/1.5),ceil(j/1.5))-p1(ceil(i/1.5),floor(j/1.5)))+p1(ceil(i/1.5),floor(j/1.5));
                pt(i,j)=(ceil(j/1.5)-j/1.5)*(gf-ge)+ge;
            end
        end
    end
    >> I=imread('cameraman.tif');
    >> pt=amp_doublelinear(I);
    >> imshow(pt)
    展开全文
  • C# 双线性插值放大图像

    热门讨论 2009-06-23 18:47:13
    C# 双线性插值放大图像 C# 双线性插值放大图像 C# 双线性插值放大图像
  • 【实例简介】纯c语言实现bmp图像的双线性插值放大,最近邻插值放大,【实例截图】【核心代码】graphics└── graphics├── Debug│ ├── graphics.exe│ ├── graphics.ilk│ └── graphics.pdb├── ...
  • 双线性插值

    2015-12-04 16:47:15
    双线性插值 ... “图像的双线性插值放大算法中,目标图像中新创造的象素值,是由源图像位置在它附近的2*2区域4个邻近象素的值通过加权平均计算得出的。双线性内插值算法放大后的图像质量较高
  • 2009 双线性插值图像放大算法优化及硬件实现 帅金晓, 颜永红, 彭 琰, 罗江平 (湖南大学物理与微电子科学学院, 湖南长沙 410082 摘要:提出了一种基于双线性插值图像放大的优化算法, 在算法中加入轮廓增强处
  • 双线性插值图像放大/缩小算法

    千次阅读 2009-10-11 10:03:00
    图像的双线性插值放大算法中,目标图像中新创造的象素值,是由源图像位置在它附近的2*2区域4个邻近象素的值通过加权平均计算得出的。双线性内插值算法放大后的图像质量较高,不会出现像素值不连续的的情况。然而次...
  • 2005-10-25 回答由于很多人都在问彩色图像的双线性插值程序,这里就给出一个简陋的示例程序,根据具体需要稍做一些修改应该就可以用于其它情况了。完整源程序以及说明请下载附件bilinear_rgb.rar。 % this programme...
  • 双线性插值图像放大/缩小算法原理

    热门讨论 2009-03-17 14:11:07
    自己编写整理的双线性插值算法原理,内含原理和实例源码,给大家分享。
  • 学习了双线性插值和三次内插法插值,两种方式实现效果不同,双线性插值放大后,会有明显的马赛克,而三次内插法则比较平滑,当然耗时也长一点。两种方法,参考了其他的文章,我都用js代码来实现了一下,下面给大家...
  • 双线性插值实现图像放大
  • 这是数字图像处理实验内容,老师规定用双线性插值法进行放大缩小,不过双线性插值法也太难了吧!!!
  • 双线性插值计算公式:f(i+u,j+v) = (1-u)(1-v)f(i,j)+u(1-v)f(i+1,j)+(1-u)vf(i,j+1)+uvf(i+1,j+1)这个公式表明了如何利用矩阵中的四个像素值计算新的像素值,这些新的像素值就组成了放大后的图像。下图是如何将3x3...
  • 来源:http://m.blog.csdn.net/HUSTLX/article/details/50810057在对图像进行空间变换的过程中...为了说明这个问题,不妨假设有一副大小为64x64的灰度图像A,现在将图像放大到256x256,不妨令其为图像B,如图1所示。...
  • 在对图像进行空间变换的过程中,典型的情况是在对图像进行放大处理的时候,图像会出现失真的现象。这是由于在变换之后的图像中,存在着一些变换之前的图像中没有的像素位置。为了说明这个问题,不妨假设有一副大小为...
  • 本程序可以从硬盘中读取一个图片然后利用双线性插值对齐进行放大
  • 1.放大缩小图像的放大缩小其实是一回事,都是先创建一张空白目标图像(放大缩小后的图像),其大小就是想要放大缩小后所得到的图像大小。创建图像后我们并不知道这张图像里面的各个像素点RGB(或灰度)值是多少,这个...
  • 双线性插值图像放大 单通道图放大实现代码: #include<iostream> #include<opencv2/opencv.hpp> using namespace cv; //缩放图像函数 void enlargeImg(Mat src,Mat &dst,double size,int type) { ...
  •  “图像的双线性插值放大算法中,目标图像中新创造的象素值,是由源图像位置在它附近的2*2区域4个邻近象素的值通过加权平均计算得出的。双线性内插值算法放大后的图像质量较高,不会出现像素值不连续的的
  • 双线性插值的概念及公式可以参考百度,这里仅对算法原理进行简单的说明: 双线性插值计算公式: f(i+u,j+v) = (1-u)(1-v)f(i,j)+u(1-v)f(i+1,j)+(1-u)vf(i,j+1)+uvf(i+1,j+1) 这个公式表明了如何利用...
  • 目录双线性插值(Bilinear Interpolation)线性插值双线性插值深入理解双线性插值我的插值理解代码官方...首先双线性插值是用来放大图像的,但是我们都知道既然要放大图像,其实是对图像的像素进行扩充,而双线性插值
  • Verilog实现基于双线性插值算法的图像放大IP设计 本文主要介绍一下verilog实现基于双线性插值算法的图像放大IP的实现思路,最终利用该方法实现了实时的图像放大处理。关于双线性插值的原理,网上有很多讲解的特别好...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 405
精华内容 162
关键字:

双线性插值放大