Java读取BMP格式图片(源代码,转)

原创 2004年07月21日 17:28:00
Basic Objective
   A windows BMP file is a common image format that Java does not handle. While BMP images are used only on windows machines, they are reasonably common. Reading these shows how to read complex structures in Java and
how to alter they byte order from the big endian order used by Java to the little endian order used by the windows and the intel processor.
--------------------------------------------------------
//
//This code was taken and cleaned up from a
//Javaworld tips and tricks column
//

import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.MemoryImageSource;
import java.io.FileInputStream;
import java.io.IOException;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;

//
//really just a collection of methods to read a BMP file
//

public class BMPLoader

{

    // build an int from a byte array - convert little to big endian
    public static int constructInt(byte[] in, int offset) {

        int ret = ((int) in[offset + 3] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 2] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 1] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 0] & 0xff);

        return (ret);

    }

    // build an int from a byte array - convert little to big endian
    // set high order bytes to 0xfff
    public static int constructInt3(byte[] in, int offset) {

        int ret = 0xff;

        ret = (ret << 8) | ((int) in[offset + 2] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 1] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 0] & 0xff);

        return (ret);

    }

    // build an int from a byte array - convert little to big endian
    public static long constructLong(byte[] in, int offset) {

        long ret = ((long) in[offset + 7] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 6] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 5] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 4] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 3] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 2] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 1] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 0] & 0xff);

        return (ret);

    }

    // build an double from a byte array - convert little to big endian
    public static double constructDouble(byte[] in, int offset) {

        long ret = constructLong(in, offset);

        return (Double.longBitsToDouble(ret));

    }

    // build an short from a byte array - convert little to big endian
    public static short constructShort(byte[] in, int offset) {

        short ret = (short) ((short) in[offset + 1] & 0xff);

        ret = (short) ((ret << 8) | (short) ((short) in[offset + 0] & 0xff));

        return (ret);

    }

    // internal class representing a bitmap header structure
    // with code to read it from a file
    static class BitmapHeader {

        public int nsize;

        public int nbisize;

        public int nwidth;

        public int nheight;

        public int nplanes;

        public int nbitcount;

        public int ncompression;

        public int nsizeimage;

        public int nxpm;

        public int nypm;

        public int nclrused;

        public int nclrimp;

        // read in the bitmap header
        public void read(FileInputStream fs) throws IOException

        {

            final int bflen = 14; // 14 byte BITMAPFILEHEADER

            byte bf[] = new byte[bflen];

            fs.read(bf, 0, bflen);

            final int bilen = 40; // 40-byte BITMAPINFOHEADER

            byte bi[] = new byte[bilen];

            fs.read(bi, 0, bilen);

            // Interperet data.
            nsize = constructInt(bf, 2);

            //  System.out.println("File type is :"+(char)bf[0]+(char)bf[1]);
            //  System.out.println("Size of file is :"+nsize);

            nbisize = constructInt(bi, 2);

            //   System.out.println("Size of bitmapinfoheader is :"+nbisize);

            nwidth = constructInt(bi, 4);

            //   System.out.println("Width is :"+nwidth);

            nheight = constructInt(bi, 8);

            //  System.out.println("Height is :"+nheight);

            nplanes = constructShort(bi, 12); //(((int)bi[13]&0xff)<<8) |
            // (int)bi[12]&0xff;

            //  System.out.println("Planes is :"+nplanes);

            nbitcount = constructShort(bi, 14); //(((int)bi[15]&0xff)<<8) |
            // (int)bi[14]&0xff;

            //  System.out.println("BitCount is :"+nbitcount);

            // Look for non-zero values to indicate compression
            ncompression = constructInt(bi, 16);

            //  System.out.println("Compression is :"+ncompression);

            nsizeimage = constructInt(bi, 20);

            //  System.out.println("SizeImage is :"+nsizeimage);

            nxpm = constructInt(bi, 24);

            // System.out.println("X-Pixels per meter is :"+nxpm);

            nypm = constructInt(bi, 28);

            // System.out.println("Y-Pixels per meter is :"+nypm);

            nclrused = constructInt(bi, 32);

            //  System.out.println("Colors used are :"+nclrused);

            nclrimp = constructInt(bi, 36);

            //  System.out.println("Colors important are :"+nclrimp);

        }

    }

    public static Image read(FileInputStream fs)

    {

        try {

            BitmapHeader bh = new BitmapHeader();

            bh.read(fs);

            if (bh.nbitcount == 24)

                return (readMap24(fs, bh));

            if (bh.nbitcount == 32)

                return (readMap32(fs, bh));

            if (bh.nbitcount == 8)

                return (readMap8(fs, bh));

            fs.close();

        } catch (IOException e) {

            // System.out.println("Caught exception in loadbitmap!");
        }

        return (null);

    }

    /**
     *
     * readMap24 internal routine to read the bytes in a 24 bit bitmap
     *
     *
     *
     * Arguments:
     *
     * fs - file stream
     *
     * bh - header struct
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */

    protected static Image readMap32(FileInputStream fs, BitmapHeader bh)
            throws IOException

    {

        Image image;

        // No Palatte data for 24-bit format but scan lines are

        // padded out to even 4-byte boundaries.

        int xwidth = bh.nsizeimage / bh.nheight;

        int ndata[] = new int[bh.nheight * bh.nwidth];

        byte brgb[] = new byte[bh.nwidth * 4 * bh.nheight];

        fs.read(brgb, 0, bh.nwidth * 4 * bh.nheight);

        int nindex = 0;

        for (int j = 0; j < bh.nheight; j++)

        {

            for (int i = 0; i < bh.nwidth; i++)

            {

                ndata[bh.nwidth * (bh.nheight - j - 1) + i] = constructInt3(
                        brgb, nindex);

                nindex += 4;

            }

        }

        image = Toolkit.getDefaultToolkit().createImage

        (new MemoryImageSource(bh.nwidth, bh.nheight,

        ndata, 0, bh.nwidth));

        fs.close();

        return (image);

    }

    /**
     *
     * readMap24 internal routine to read the bytes in a 24 bit bitmap
     *
     *
     *
     * Arguments:
     *
     * fs - file stream
     *
     * bh - header struct
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */

    protected static Image readMap24(FileInputStream fs, BitmapHeader bh)
            throws IOException

    {

        Image image;

        // No Palatte data for 24-bit format but scan lines are

        // padded out to even 4-byte boundaries.

        int npad = (bh.nsizeimage / bh.nheight) - bh.nwidth * 3;

        int ndata[] = new int[bh.nheight * bh.nwidth];

        byte brgb[] = new byte[(bh.nwidth + npad) * 3 * bh.nheight];

        fs.read(brgb, 0, (bh.nwidth + npad) * 3 * bh.nheight);

        int nindex = 0;

        for (int j = 0; j < bh.nheight; j++)

        {

            for (int i = 0; i < bh.nwidth; i++)

            {

                ndata[bh.nwidth * (bh.nheight - j - 1) + i] = constructInt3(
                        brgb, nindex);

                nindex += 3;

            }

            nindex += npad;

        }

        image = Toolkit.getDefaultToolkit().createImage

        (new MemoryImageSource(bh.nwidth, bh.nheight,

        ndata, 0, bh.nwidth));

        fs.close();

        return (image);

    }

    /**
     *
     * readMap8 internal routine to read the bytes in a 8 bit bitmap
     *
     *
     *
     * Arguments:
     *
     * fs - file stream
     *
     * bh - header struct
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */

    protected static Image readMap8(FileInputStream fs, BitmapHeader bh)
            throws IOException

    {

        Image image;

        // Have to determine the number of colors, the clrsused

        // parameter is dominant if it is greater than zero. If

        // zero, calculate colors based on bitsperpixel.

        int nNumColors = 0;

        if (bh.nclrused > 0)

        {

            nNumColors = bh.nclrused;

        }

        else

        {

            nNumColors = (1 & 0xff) << bh.nbitcount;

        }

        //     System.out.println("The number of Colors is"+nNumColors);

        // Some bitmaps do not have the sizeimage field calculated

        // Ferret out these cases and fix 'em.

        if (bh.nsizeimage == 0)

        {

            bh.nsizeimage = ((((bh.nwidth * bh.nbitcount) + 31) & ~31) >> 3);

            bh.nsizeimage *= bh.nheight;

            //          System.out.println("nsizeimage (backup) is"+nsizeimage);

        }

        // Read the palatte colors.

        int npalette[] = new int[nNumColors];

        byte bpalette[] = new byte[nNumColors * 4];

        fs.read(bpalette, 0, nNumColors * 4);

        int nindex8 = 0;

        for (int n = 0; n < nNumColors; n++)

        {

            npalette[n] = constructInt3(bpalette, nindex8);

            nindex8 += 4;

        }

        // Read the image data (actually indices into the palette)

        // Scan lines are still padded out to even 4-byte

        // boundaries.

        int npad8 = (bh.nsizeimage / bh.nheight) - bh.nwidth;

        //    System.out.println("nPad is:"+npad8);

        int ndata8[] = new int[bh.nwidth * bh.nheight];

        byte bdata[] = new byte[(bh.nwidth + npad8) * bh.nheight];

        fs.read(bdata, 0, (bh.nwidth + npad8) * bh.nheight);

        nindex8 = 0;

        for (int j8 = 0; j8 < bh.nheight; j8++)

        {

            for (int i8 = 0; i8 < bh.nwidth; i8++)

            {

                ndata8[bh.nwidth * (bh.nheight - j8 - 1) + i8] =

                npalette[((int) bdata[nindex8] & 0xff)];

                nindex8++;

            }

            nindex8 += npad8;

        }

        image = Toolkit.getDefaultToolkit().createImage

        (new MemoryImageSource(bh.nwidth, bh.nheight,

        ndata8, 0, bh.nwidth));

        return (image);

    }

    /**
     *
     * load method - see read for details
     *
     *
     *
     * Arguments:
     *
     * sdir and sfile are the result of the FileDialog()
     *
     * getDirectory() and getFile() methods.
     *
     *
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */

    public static Image load(String sdir, String sfile) {

        return (load(sdir + sfile));

    }

    /**
     *
     * load method - see read for details
     *
     *
     *
     * Arguments:
     *
     * sdir - full path name
     *
     *
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */

    public static Image load(String sdir)

    {

        try

        {

            FileInputStream fs = new FileInputStream(sdir);

            return (read(fs));

        }

        catch (IOException ex) {

            return (null);

        }

    }

    public static void main(String[] args) throws IOException

    {

        if (args.length == 0) {

            System.out.println("Usage >java BMPLoader ImageFile.bmp");

            System.exit(0);

        }

        FileInputStream in = new FileInputStream(args[0]);

        Image TheImage = read(in);

        JFrame TheFrame = new JFrame(args[0]);

        JLabel TheLabel = new JLabel(new ImageIcon(TheImage));

        TheFrame.getContentPane().add(new JScrollPane(TheLabel));

        TheFrame.setSize(300, 300);

        TheFrame.setVisible(true);

    }
    //end class BMPLoader
}

C语言实现的BMP和JPEG图片的解码

/* 这是read_picture.c 文件的代码 ,主要是对输入的图片的文件(BMP和JPEG类型)进行解码,转换成在LCD中显示的数据; 使用该程序时,要先把jpeglib库文件和头文件放到对...
  • YANGSENG1987
  • YANGSENG1987
  • 2013年08月05日 18:09
  • 3081

【数字图像处理】C++读取、旋转和保存bmp图像文件编程实现

要识别图像中的字符,首先要会处理图像,把图像的信息读出来。这就必须先了解图像的结构,存储方式。清华大学出版的一本《数字图像处理编程入门》给了我不少帮助。第一章的Windows位图和调色板让我对bmp图...
  • ReversalC
  • ReversalC
  • 2014年01月03日 00:08
  • 5101

Android 获取图片资源格式(png、jpeg、gif、bmp、...)

做开发的时候有时候需要获取图片的类型格式,如常见的jpg、png、gif、bmp等图片格式。 那么在Android中如何获得这些图片格式呢? 方法一:通过图片后缀名获得图片格式 大多数方法都是通...
  • zhuwentao2150
  • zhuwentao2150
  • 2016年06月30日 23:26
  • 9531

c 语言读取BMP格式文件源代码

// PrintBMPPixel.c // c 语言读取BMP格式文件源代码 // 可同时处理没有压缩的BMP格式的二值图像, 索引图像, 真彩色图像。 #include #include /...
  • tlh3930101
  • tlh3930101
  • 2011年08月30日 10:15
  • 2847

JAVA 实现jpg/tif/bmp 等图片格式互相转换,解决RenderedOp资源不能释放

需要jai_core.jar和jai_codec.jar包 实现格式转换,但此方法中的RenderedOp资源不能释放,生成之后原图不能删除; public class ImgCast { pu...
  • cai7095576
  • cai7095576
  • 2015年01月30日 13:44
  • 2888

jped图片转bmp格式

  • 2015年01月21日 11:07
  • 8KB
  • 下载

图片格式转换:BMP转JPG

  • 2010年11月30日 22:44
  • 1.27MB
  • 下载

图片转zpl编码的方法,支持bmp、png、jpg等各种格式,分别测试有效

  • 2017年11月12日 14:25
  • 4KB
  • 下载

命令行图片格式转换bmp转jpg

  • 2009年12月15日 22:01
  • 208KB
  • 下载

Zan.Image.Printer 支持pdf转bmp等图片格式

  • 2013年06月14日 11:24
  • 1.25MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java读取BMP格式图片(源代码,转)
举报原因:
原因补充:

(最多只允许输入30个字)