如何在Java中粘贴图像对象

我有一个场景，在这个场景中，我从我的映射服务器中获得了许多分幅（例如12）。现在对于缓冲和脱机函数，我需要再次将它们连接起来，以便我们必须处理1个图像对象，而不是12个。我试着在没有JAI的情况下完成我的代码如下

package imagemerge;


import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;

public class ImageSticher extends WindowAdapter {

    Image tile1;
    Image tile2;
    Image result;
    ColorModel colorModel;
    int width,height,widthr,heightr;
    //int t1,t2;
    int t12[];


    public ImageSticher()
    {

    }

    public ImageSticher (Image img1,Image img2,int w,int h)
    {
        tile1=img1;
        tile2=img2;

        width=w;
        height=h;
        colorModel=ColorModel.getRGBdefault();

    }

    public Image horizontalStich() throws Exception
    {

        widthr=width*2;
        heightr=height;

        t12=new int[widthr *  heightr];

        int t1[]=new int[width*height];
        PixelGrabber p1 =new PixelGrabber(tile1, 0, 0, width, height, t1, 0, width);
        p1.grabPixels();

        int t2[]=new int[width*height];
        PixelGrabber p2 =new PixelGrabber(tile2, 0, 0, width, height, t1, 0, width);
        p2.grabPixels();

        int y, x, rp, rpi;
        int red1, red2, redr;
        int green1, green2, greenr;
        int blue1, blue2, bluer;
        int alpha1, alpha2, alphar;

        for(y=0;y<heightr;y++)
        {
            for(x=0;x<widthr;x++)
            {
                //System.out.println(x);
                rpi=y*widthr+x; // index of resulting pixel;
                rp=0;           //initializing resulting pixel
                System.out.println(rpi);

                if(x<(widthr/2)) // x is less than width , copy first tile
                {
                    //System.out.println("tile1="+x);
                    blue1 = t1[rpi] & 0x00ff; // ERROR occurs here
                    green1=(t1[rpi] >> 8) & 0x00ff;
                    red1=(t1[rpi] >> 16) & 0x00ff;
                    alpha1 = (t1[rpi] >> 24) & 0x00ff;

                    redr = (int)(red1 * 1.0); // copying red band pixel into redresult,,,,1.0 is the alpha valye
                    redr = (redr < 0)?(0):((redr>255)?(255):(redr));
                    greenr = (int)(green1 * 1.0); //
                    redr = (int)(red1 * 1.0); //
                    greenr = (greenr < 0)?(0):((greenr>255)?(255):(greenr));
                    bluer = (int)(blue1 * 1.0);
                    bluer =  (bluer < 0)?(0):((bluer>255)?(255):(bluer));
                    alphar = 255;

                    //resulting pixel computed
                    rp = (((((alphar << 8) + (redr & 0x0ff)) << 8) + (greenr & 0x0ff)) << 8) + (bluer & 0x0ff);


                }
                else // index is ahead of half way...copy second tile
                {

                    blue2 = t2[rpi] & 0x00ff; // blue band bit of first tile
                    green2=(t2[rpi] >> 8) & 0x00ff;
                    red2=(t2[rpi] >> 16) & 0x00ff;
                    alpha2 = (t2[rpi] >> 24) & 0x00ff;

                    redr = (int)(red2 * 1.0); // copying red band pixel into redresult,,,,1.0 is the alpha valye
                    redr = (redr < 0)?(0):((redr>255)?(255):(redr));
                    greenr = (int)(green2 * 1.0); //
                    redr = (int)(red2 * 1.0); //
                    greenr = (greenr < 0)?(0):((greenr>255)?(255):(greenr));
                    bluer = (int)(blue2 * 1.0);
                    bluer =  (bluer < 0)?(0):((bluer>255)?(255):(bluer));
                    alphar = 255;

                    //resulting pixel computed
                    rp = (((((alphar << 8) + (redr & 0x0ff)) << 8) + (greenr & 0x0ff)) << 8) + (bluer & 0x0ff);


                }
                t12[rpi] = rp; // copying resulting pixel in the result int array which will be converted to image

            }
        }

        MemoryImageSource mis;
        if (t12!=null) {
            mis = new MemoryImageSource(widthr, heightr, colorModel, t12, 0, widthr);
            result = Toolkit.getDefaultToolkit().createImage(mis);
            return result;

        }
        return null;

    }





}

packageimagemerge；
导入java.awt.*；
导入java.awt.image.*；
导入java.awt.event.*；
公共类ImageSticher扩展了WindowAdapter{
图像拼接1；
图像拼接2；
图像结果；
颜色模型；
整数宽度、高度、宽度、高度；
//int t1，t2；
int t12[]；
公共图像粘贴器（）
{
}
公共图像粘贴器（图像img1、图像img2、int w、int h）
{
tile1=img1；
tile2=img2；
宽度=w；
高度=h；
colorModel=colorModel.getRGBdefault（）；
}
公共映像水平粘贴（）引发异常
{
宽度R=宽度*2；
heightr=高度；
t12=新整数[宽度*高度]；
int t1[]=新int[宽度*高度]；
PixelGrabber p1=新的PixelGrabber（tile1，0，0，宽度，高度，t1，0，宽度）；
p1.抓取像素（）；
int t2[]=新int[宽度*高度]；
PixelGrabber p2=新的PixelGrabber（tile2，0，0，宽度，高度，t1，0，宽度）；
p2.抓取像素（）；
int y，x，rp，rpi；
int red1，red2，redr；
int green1、green2、greenr；
int蓝色1，蓝色2，蓝色；
int alpha1、alpha2、alphar；
对于（y=0；y>16）&0x00ff；
alpha1=（t1[rpi]>>24）和0x00ff；
redr=（int）（red1*1.0）；//将红色带像素复制到redresult，，，，1.0是alpha值
redr=（redr<0）？（0）：（（redr>255）？（255）：（redr））；
绿色=（整数）（绿色1*1.0）//
redr=（int）（red1*1.0）//
greenr=（greenr<0）？（0）：（greenr>255）？（255）：（greenr））；
蓝色=（整数）（蓝色1*1.0）；
蓝色=（蓝色<0）？（0）：（（蓝色>255）？（255）：（蓝色））；
阿尔法=255；
//计算得到的像素
rp=（（（阿尔法>16）和0x00ff；
alpha2=（t2[rpi]>>24）和0x00ff；
redr=（int）（red2*1.0）；//将红色带像素复制到redresult，，，，1.0是alpha值
redr=（redr<0）？（0）：（（redr>255）？（255）：（redr））；
绿色=（整数）（绿色2*1.0）//
redr=（int）（red2*1.0）//
greenr=（greenr<0）？（0）：（greenr>255）？（255）：（greenr））；
蓝色=（整数）（蓝色2*1.0）；
蓝色=（蓝色<0）？（0）：（（蓝色>255）？（255）：（蓝色））；
阿尔法=255；
//计算得到的像素
rp=（（（（（）alphar
rpi
是结果像素的索引，而不是
t1
中源磁贴数据的索引，它是大小的一半。
好的，谢谢我进行了更正，但现在它只显示第二个图像对象，也显示在第一个图像的位置，并且在新图像中它自己的空间是黑色的