求一个比较好的jpg图片高宽调整代码

onino_info 2008-08-01 12:03:06

以下是我现在使用的一段调整高宽的代码,但是他的效率,实在是,太低了,虽然最后调整后的图片质量很高,但是还是受不了他的效率,请问有没有比较好的且效率很高的代码,或者有关的库?麻烦顺便贴出使用方法,谢谢,谢谢~

package cn.hlgc.util;



import java.awt.image.BufferedImage;



import org.apache.log4j.Logger;



public class ResizePicUtil {

	private int width;

	private int height;

	private int scaleWidth;

	double support = (double) 3.0;

	double PI = (double) 3.14159265358978;

	double[] contrib;

	double[] normContrib;

	double[] tmpContrib;

	int startContrib, stopContrib;

	int nDots;

	int nHalfDots;



	private static Logger logger = Logger.getLogger(ResizePicUtil.class);



	public BufferedImage imageZoomOut(BufferedImage srcBufferImage, int w, int h) {

		width = srcBufferImage.getWidth();

		height = srcBufferImage.getHeight();

		scaleWidth = w;

		logger.info("原图宽度为[" + width + "px]...");

		logger.info("原图高度为[" + height + "px]...");

		if (DetermineResultSize(w, h) == 1) {

			logger.info("不需要将图片进行缩小...");

			return srcBufferImage;

		}

		logger.info("计算缩小图片的宽度和高度...");

		double wh = ((double) width) / ((double) height);

		double hw = ((double) height) / ((double) width);

		if (wh > hw) {

			h = (int) (w * hw);

		} else {

			w = (int) (h * wh);

		}

		logger.info("图片宽度调整为[" + w + "px]...");

		logger.info("图片高度调整为[" + h + "px]...");

		long begin = System.currentTimeMillis();

		CalContrib();

		BufferedImage pbOut = HorizontalFiltering(srcBufferImage, w);

		BufferedImage pbFinalOut = VerticalFiltering(pbOut, h);

		long end = System.currentTimeMillis();

		logger.info("图片高宽调整完毕,耗时[" + (end - begin) + "]毫秒...");

		return pbFinalOut;

	}



	private int DetermineResultSize(int w, int h) {

		double scaleH, scaleV;

		scaleH = (double) w / (double) width;

		scaleV = (double) h / (double) height;

		if (scaleH >= 1.0 && scaleV >= 1.0) {

			return 1;

		}

		return 0;

	}



	private double Lanczos(int i, int inWidth, int outWidth, double Support) {

		double x;



		x = (double) i * (double) outWidth / (double) inWidth;



		return Math.sin(x * PI) / (x * PI) * Math.sin(x * PI / Support)

				/ (x * PI / Support);



	}



	private void CalContrib() {

		nHalfDots = (int) ((double) width * support / (double) scaleWidth);

		nDots = nHalfDots * 2 + 1;

		try {

			contrib = new double[nDots];

			normContrib = new double[nDots];

			tmpContrib = new double[nDots];

		} catch (Exception e) {

			System.out.println("init   contrib,normContrib,tmpContrib" + e);

		}



		int center = nHalfDots;

		contrib[center] = 1.0;



		double weight = 0.0;

		int i = 0;

		for (i = 1; i <= center; i++) {

			contrib[center + i] = Lanczos(i, width, scaleWidth, support);

			weight += contrib[center + i];

		}



		for (i = center - 1; i >= 0; i--) {

			contrib[i] = contrib[center * 2 - i];

		}



		weight = weight * 2 + 1.0;



		for (i = 0; i <= center; i++) {

			normContrib[i] = contrib[i] / weight;

		}



		for (i = center + 1; i < nDots; i++) {

			normContrib[i] = normContrib[center * 2 - i];

		}

	}



	// 处理边缘

	private void CalTempContrib(int start, int stop) {

		double weight = 0;



		int i = 0;

		for (i = start; i <= stop; i++) {

			weight += contrib[i];

		}



		for (i = start; i <= stop; i++) {

			tmpContrib[i] = contrib[i] / weight;

		}



	}



	private int GetRedValue(int rgbValue) {

		int temp = rgbValue & 0x00ff0000;

		return temp >> 16;

	}



	private int GetGreenValue(int rgbValue) {

		int temp = rgbValue & 0x0000ff00;

		return temp >> 8;

	}



	private int GetBlueValue(int rgbValue) {

		return rgbValue & 0x000000ff;

	}



	private int ComRGB(int redValue, int greenValue, int blueValue) {



		return (redValue << 16) + (greenValue << 8) + blueValue;

	}



	// 行水平滤波

	private int HorizontalFilter(BufferedImage bufImg, int startX, int stopX,

			int start, int stop, int y, double[] pContrib) {

		double valueRed = 0.0;

		double valueGreen = 0.0;

		double valueBlue = 0.0;

		int valueRGB = 0;

		int i, j;



		for (i = startX, j = start; i <= stopX; i++, j++) {

			valueRGB = bufImg.getRGB(i, y);



			valueRed += GetRedValue(valueRGB) * pContrib[j];

			valueGreen += GetGreenValue(valueRGB) * pContrib[j];

			valueBlue += GetBlueValue(valueRGB) * pContrib[j];

		}



		valueRGB = ComRGB(Clip((int) valueRed), Clip((int) valueGreen),

				Clip((int) valueBlue));

		return valueRGB;



	}



	// 图片水平滤波

	private BufferedImage HorizontalFiltering(BufferedImage bufImage, int iOutW) {

		int dwInW = bufImage.getWidth();

		int dwInH = bufImage.getHeight();

		int value = 0;

		BufferedImage pbOut = new BufferedImage(iOutW, dwInH,

				BufferedImage.TYPE_INT_RGB);



		for (int x = 0; x < iOutW; x++) {



			int startX;

			int start;

			int X = (int) (((double) x) * ((double) dwInW) / ((double) iOutW) + 0.5);

			int y = 0;



			startX = X - nHalfDots;

			if (startX < 0) {

				startX = 0;

				start = nHalfDots - X;

			} else {

				start = 0;

			}



			int stop;

			int stopX = X + nHalfDots;

			if (stopX > (dwInW - 1)) {

				stopX = dwInW - 1;

				stop = nHalfDots + (dwInW - 1 - X);

			} else {

				stop = nHalfDots * 2;

			}



			if (start > 0 || stop < nDots - 1) {

				CalTempContrib(start, stop);

				for (y = 0; y < dwInH; y++) {

					value = HorizontalFilter(bufImage, startX, stopX, start,

							stop, y, tmpContrib);

					pbOut.setRGB(x, y, value);

				}

			} else {

				for (y = 0; y < dwInH; y++) {

					value = HorizontalFilter(bufImage, startX, stopX, start,

							stop, y, normContrib);

					pbOut.setRGB(x, y, value);

				}

			}

		}



		return pbOut;



	}



	private int VerticalFilter(BufferedImage pbInImage, int startY, int stopY,

			int start, int stop, int x, double[] pContrib) {

		double valueRed = 0.0;

		double valueGreen = 0.0;

		double valueBlue = 0.0;

		int valueRGB = 0;

		int i, j;



		for (i = startY, j = start; i <= stopY; i++, j++) {

			valueRGB = pbInImage.getRGB(x, i);



			valueRed += GetRedValue(valueRGB) * pContrib[j];

			valueGreen += GetGreenValue(valueRGB) * pContrib[j];

			valueBlue += GetBlueValue(valueRGB) * pContrib[j];

		}



		valueRGB = ComRGB(Clip((int) valueRed), Clip((int) valueGreen),

				Clip((int) valueBlue));

		return valueRGB;



	}



	private BufferedImage VerticalFiltering(BufferedImage pbImage, int iOutH) {

		int iW = pbImage.getWidth();

		int iH = pbImage.getHeight();

		int value = 0;

		BufferedImage pbOut = new BufferedImage(iW, iOutH,

				BufferedImage.TYPE_INT_RGB);



		for (int y = 0; y < iOutH; y++) {



			int startY;

			int start;

			int Y = (int) (((double) y) * ((double) iH) / ((double) iOutH) + 0.5);



			startY = Y - nHalfDots;

			if (startY < 0) {

				startY = 0;

				start = nHalfDots - Y;

			} else {

				start = 0;

			}



			int stop;

			int stopY = Y + nHalfDots;

			if (stopY > (int) (iH - 1)) {

				stopY = iH - 1;

				stop = nHalfDots + (iH - 1 - Y);

			} else {

				stop = nHalfDots * 2;

			}



			if (start > 0 || stop < nDots - 1) {

				CalTempContrib(start, stop);

				for (int x = 0; x < iW; x++) {

					value = VerticalFilter(pbImage, startY, stopY, start, stop,

							x, tmpContrib);

					pbOut.setRGB(x, y, value);

				}

			} else {

				for (int x = 0; x < iW; x++) {

					value = VerticalFilter(pbImage, startY, stopY, start, stop,

							x, normContrib);

					pbOut.setRGB(x, y, value);

				}

			}



		}



		return pbOut;



	}



	int Clip(int x) {

		if (x < 0)

			return 0;

		if (x > 255)

			return 255;

		return x;

	}



}

...全文

1412 14 打赏收藏转发到动态举报

写回复

用AI写文章

14 条回复

切换为时间正序

请发表友善的回复…

发表回复

CrazyBugCoder 2012-08-31

打赏
举报

同志们，测试了下，读写图片,ImageIO的效率忒低了
package com.test;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.imageio.ImageIO;

public class TestImageIO {
public void useImageIO()throws IOException {
File f=new File("ad01.jpg");
File f2=new File("test.jpg");
int numRead=0;
byte[] b=new byte[2048];
FileOutputStream fou=new FileOutputStream(f2);
FileInputStream fin=new FileInputStream(f);
long start=System.currentTimeMillis();
for(int i=0;i<100;i++){
BufferedImage bi=ImageIO.read(f);
ImageIO.write(bi, "jpg", fou);
}
long end=System.currentTimeMillis();
b=null;
System.out.println("imageio use time:"+(end-start));

}
public void useFileStream()throws IOException {
File f=new File("ad01.jpg");
File f2=new File("test.jpg");
int numRead=0;
byte[] b=new byte[2048];
FileOutputStream fou=new FileOutputStream(f2);
FileInputStream fin=new FileInputStream(f);
long start=System.currentTimeMillis();
for(int i=0;i<100;i++){
while((numRead=fin.read(b))>0){
fou.write(b, 0, numRead);
}
}
long end=System.currentTimeMillis();
b=null;
System.out.println("filestream use time:"+(end-start));
}
public static void main(String[] args) throws IOException {
TestImageIO tii=new TestImageIO();
tii.useFileStream();
tii.useImageIO();
//ImageIO 1203 1140 1218 1172 2260
//FileStram 0 16 0 0 0
}
}

ocelight 2008-08-04

打赏
举报

我之前一直都用这个啊很OK啊。
是不是格式读的不对
不同的格式要用不同的流读。



   //JAI API支持以下几种图像文件格式:BMP,JEPG,PNG,PNM,TIFF.

        

        //TIFF格式的例子

        OutputStream os = new FileOutputStream("E:\\vladstudio_5000.tiff");

        TIFFEncodeParam param = new TIFFEncodeParam();

        ImageEncoder enc = ImageCodec.createImageEncoder("tiff", os, param);

        enc.encode(out);

        stream.close();

        os.close();



        //BMP格式的例子

        OutputStream os1 = new FileOutputStream("E:\\vladstudio_5000.bmp");

        BMPEncodeParam param1 = new BMPEncodeParam();

        ImageEncoder enc1 = ImageCodec.createImageEncoder("BMP", os1, param1);

        enc1.encode(out);

        os.close();

        

         //JEPG格式的例子

        OutputStream os2 = new FileOutputStream("E:\\vladstudio_5000.jpg");

        JPEGEncodeParam param2 = new JPEGEncodeParam();

        ImageEncoder enc2 = ImageCodec.createImageEncoder("jpeg", os2, param2);

        enc2.encode(out);

        os.close();

顺带说一句其实JAVA自己图像处理类也很快，我之前用过性能比JAI要好，但是由于出来出来的图片发黄发黑就放弃了。

关于awt包下处理图片的方法也贴一份给你吧



package com.mop.pushmail.adapter.image;



import java.io.*;

import java.awt.*;

import java.awt.image.*;

import java.awt.Graphics;

import java.awt.color.ColorSpace;

import javax.imageio.ImageIO;



public class ImageCut {



    /**

     * 缩放图像

     * 

     * @param srcImageFile

     *            源图像文件地址

     * @param result

     *            缩放后的图像地址

     * @param scale

     *            缩放比例

     * @param flag

     *            缩放选择:true 放大; false 缩小;

     */

    public static void scale(String srcImageFile, String result, int scale,

            boolean flag) {

        try {

            BufferedImage src = ImageIO.read(new File(srcImageFile)); // 读入文件

            int width = src.getWidth(); // 得到源图宽

            int height = src.getHeight(); // 得到源图长

            if (flag) {

                // 放大

                width = width * scale;

                height = height * scale;

            } else {

                // 缩小

                width = width / scale;

                height = height / scale;

//      width=128;

//      height=160;

            }

            Image image = src.getScaledInstance(width, height,

                    Image.SCALE_DEFAULT);

            BufferedImage tag = new BufferedImage(width, height,

                    BufferedImage.TYPE_INT_RGB);

            Graphics g = tag.getGraphics();

            g.drawImage(image, 0, 0, null); // 绘制缩小后的图

            g.dispose();

            ImageIO.write(tag, "JPEG", new File(result));// 输出到文件流

        } catch (IOException e) {

            e.printStackTrace();

        }

    }



    /**

     * 图像切割

     * 

     * @param srcImageFile

     *            源图像地址

     * @param descDir

     *            切片目标文件夹

     * @param destWidth

     *            目标切片宽度

     * @param destHeight

     *            目标切片高度

     */

    public static void cut(String srcImageFile, String descDir, int destWidth,

            int destHeight) {

        try {

            Image img;

            ImageFilter cropFilter;

            // 读取源图像

            BufferedImage bi = ImageIO.read(new File(srcImageFile));

            int srcWidth = bi.getHeight(); // 源图宽度

            int srcHeight = bi.getWidth(); // 源图高度

            if (srcWidth > destWidth && srcHeight > destHeight) {

                Image image = bi.getScaledInstance(srcWidth, srcHeight,

                        Image.SCALE_DEFAULT);

                destWidth = 200; // 切片宽度

                destHeight = 150; // 切片高度

                int cols = 0; // 切片横向数量

                int rows = 0; // 切片纵向数量

                // 计算切片的横向和纵向数量

                if (srcWidth % destWidth == 0) {

                    cols = srcWidth / destWidth;

                } else {

                    cols = (int) Math.floor(srcWidth / destWidth) + 1;

                }

                if (srcHeight % destHeight == 0) {

                    rows = srcHeight / destHeight;

                } else {

                    rows = (int) Math.floor(srcHeight / destHeight) + 1;

                }

                // 循环建立切片

                // 改进的想法:是否可用多线程加快切割速度

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

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

                        // 四个参数分别为图像起点坐标和宽高

                        // 即: CropImageFilter(int x,int y,int width,int height)

                        cropFilter = new CropImageFilter(j * 200, i * 150,

                                destWidth, destHeight);

                        img = Toolkit.getDefaultToolkit().createImage(

                                new FilteredImageSource(image.getSource(),

                                cropFilter));

                        BufferedImage tag = new BufferedImage(destWidth,

                                destHeight, BufferedImage.TYPE_INT_RGB);

                        Graphics g = tag.getGraphics();

                        g.drawImage(img, 0, 0, null); // 绘制缩小后的图

                        g.dispose();

                        // 输出为文件

                        ImageIO.write(tag, "JPEG", new File(descDir + "pre_map_" + i + "_" + j + ".jpg"));

                    }

                }

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }



    /**

     * 图像类型转换

     * GIF->JPG GIF->PNG PNG->JPG PNG->GIF(X)

     */

    public static void convert(String source, String result) {

        try {

            File f = new File(source);

            f.canRead();

            f.canWrite();

            BufferedImage src = ImageIO.read(f);

            ImageIO.write(src, "JPG", new File(result));

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }



    /**

     * 彩色转为黑白

     * 

     * @param source

     * @param result

     */

    public static void gray(String source, String result) {

        try {

            BufferedImage src = ImageIO.read(new File(source));

            ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);

            ColorConvertOp op = new ColorConvertOp(cs, null);

            src = op.filter(src, null);

            ImageIO.write(src, "JPEG", new File(result));

        } catch (IOException e) {

            e.printStackTrace();

        }

    }



    /**

     * @param args

     */

    public static void main(String[] args) {



    }

}

onino_info 2008-08-01

打赏
举报

[hlgc] 12:09:13,218 [INFO] cn.hlgc.util.ResizePicUtil - 原图宽度为[2841px]...
[hlgc] 12:09:13,218 [INFO] cn.hlgc.util.ResizePicUtil - 原图高度为[2131px]...
[hlgc] 12:09:13,218 [INFO] cn.hlgc.util.ResizePicUtil - 计算缩小图片的宽度和高度...
[hlgc] 12:09:13,218 [INFO] cn.hlgc.util.ResizePicUtil - 图片宽度调整为[200px]...
[hlgc] 12:09:13,218 [INFO] cn.hlgc.util.ResizePicUtil - 图片高度调整为[150px]...
[hlgc] 12:22:41,312 [INFO] cn.hlgc.util.ResizePicUtil - 图片高宽调整完毕,耗时[808094]毫秒...

调整一张4402KB的照片用了808秒- -汗~

onino_info 2008-08-01

打赏
举报

厄.....继续等待.....

qlrhoo 2008-08-01

打赏
举报

帮你顶一下

onino_info 2008-08-01

打赏
举报

在代码里面加入

static {

		System.setProperty("com.sun.media.jai.disableMediaLib", "true");

	}

解决了上面的错误,但是,请问,为什么输出的文件的大小为0KB,且没有任何内容~?

onino_info 2008-08-01

打赏
举报

实在是....哎....发现用JAI的没有原生方法用纯JAVA那个效率也是....太低啊..算了...继续用我发的那个方法吧....结了~

sagezk 2008-08-01

打赏
举报

用 java.awt.Image 类的方法：

public Image getScaledInstance(int width, int height, int hints)
创建此图像的缩放版本。返回一个新的 Image 对象，默认情况下，该对象按指定的 width 和 height 呈现图像。即使已经完全加载了初始源图像，新的 Image 对象也可以被异步加载。
如果 width 或 height 为负数，则替换该值以维持初始图像尺寸的高宽比。如果 width 和 height 都为负，则使用初始图像尺寸。
参数：
width - 将图像缩放到的宽度。
height - 将图像缩放到的高度。
hints - 指示用于图像重新取样的算法类型的标志。
返回：
图像的缩放版本。

onino_info 2008-08-01

打赏
举报

在代码里面加入

static {

		System.setProperty("com.sun.media.jai.disableMediaLib", "true");

	}

解决了上面的错误,但是,请问,为什么输出的文件的大小为0KB,且没有任何内容~?

onino_info 2008-08-01

打赏
举报

谢楼上,我下载了JAR包,运行了一下,出错了- -
郁闷啊~
start:1217581512453
Error: Could not find mediaLib accelerator wrapper classes. Continuing in pure Java mode.
Occurs in: com.sun.media.jai.mlib.MediaLibAccessor
java.lang.NoClassDefFoundError: com/sun/medialib/mlib/Image
at com.sun.media.jai.mlib.MediaLibAccessor$1.run(MediaLibAccessor.java:248)
at java.security.AccessController.doPrivileged(Native Method)
at com.sun.media.jai.mlib.MediaLibAccessor.setUseMlib(MediaLibAccessor.java:245)
at com.sun.media.jai.mlib.MediaLibAccessor.useMlib(MediaLibAccessor.java:177)
at com.sun.media.jai.mlib.MediaLibAccessor.isMediaLibCompatible(MediaLibAccessor.java:357)
at com.sun.media.jai.mlib.MediaLibAccessor.isMediaLibCompatible(MediaLibAccessor.java:315)
at com.sun.media.jai.mlib.MlibConvolveRIF.create(MlibConvolveRIF.java:47)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at javax.media.jai.FactoryCache.invoke(FactoryCache.java:122)
at javax.media.jai.OperationRegistry.invokeFactory(OperationRegistry.java:1674)
at javax.media.jai.ThreadSafeOperationRegistry.invokeFactory(ThreadSafeOperationRegistry.java:473)
at javax.media.jai.registry.RIFRegistry.create(RIFRegistry.java:332)
at javax.media.jai.RenderedOp.createInstance(RenderedOp.java:819)
at javax.media.jai.RenderedOp.createRendering(RenderedOp.java:867)
at javax.media.jai.RenderedOp.getRendering(RenderedOp.java:888)
at javax.media.jai.RenderedOp.createInstance(RenderedOp.java:799)
at javax.media.jai.RenderedOp.createRendering(RenderedOp.java:867)
at javax.media.jai.RenderedOp.getRendering(RenderedOp.java:888)
at javax.media.jai.ImageMIPMap.getDownImage(ImageMIPMap.java:401)
at com.sun.media.jai.opimage.RenderableCRIF.createRenderable(RenderableCRIF.java:141)
at com.sun.media.jai.opimage.RenderableCRIF.getBounds2D(RenderableCRIF.java:187)
at javax.media.jai.RenderableOp.getWidth(RenderableOp.java:507)
at javax.media.jai.RenderableOp.createScaledRendering(RenderableOp.java:659)
at cn.hlgc.test.reimg.smallpicture(reimg.java:42)
at cn.hlgc.test.reimg.main(reimg.java:64)

onino_info 2008-08-01

打赏
举报

ocelight 2008-08-01

打赏
举报

我以前做格式转换的时候用过JAI还可以。JAR包在SUN的网站上可以下载到。

package com.mop.pushmail.adapter.image;



import javax.media.jai.operator.*;

import javax.media.jai.iterator.*;

import javax.media.jai.operator.*;

import javax.media.jai.*;

import com.sun.media.jai.codec.*;

import java.awt.image.renderable.*;

import java.awt.image.*;

import java.io.File;

import java.io.FileOutputStream;



public class imgutil {



    public boolean smallpicture(String src, String dest, int w, int h) {

        try {

            ParameterBlockJAI loadPB = new ParameterBlockJAI("fileload");

            loadPB.setParameter("filename", src);

            PlanarImage source = JAI.create("fileload", loadPB);

            int orinWidth = source.getWidth();

            int orinHeigth = source.getHeight();



            int newHeigth = orinHeigth;

            int newWidth = orinWidth;

            //处理图片大小缩放   

            if ((orinHeigth > h) || (orinWidth > w)) {

                if (orinHeigth > orinWidth) {

                    newHeigth = orinHeigth * h / orinHeigth;

                    newWidth = orinWidth * w / orinHeigth;

                } else {

                    newHeigth = orinHeigth * h / orinWidth;

                    newWidth = orinWidth * w / orinWidth;

                }

            }



            ParameterBlock pb = new ParameterBlock();

            pb.addSource(source);

            RenderableImage ren = JAI.createRenderable("renderable", pb);

            PlanarImage dst = (PlanarImage) ren.createScaledRendering(newWidth, newHeigth, null);

            File fout = new File(dest);

            FileOutputStream out = new FileOutputStream(fout);

            JPEGEncodeParam param = new JPEGEncodeParam();

            param.setQuality(0.70f);//设置图片质量   

            //这里你可以选择不同的图片编码，不过gif因为版权问题要压缩成png   

            ImageEncoder encoder = ImageCodec.createImageEncoder("JPEG", out, param);

            encoder.encode(dst);

            out.close();

            return true;

        } catch (Exception e) {

            //e.printStackTrace();   

            return false;

        }

    }

    

      public   static   void   main(String[]   args)   {   

          imgutil im = new imgutil();

          long   s   =   System.currentTimeMillis();   

          System.out.println("start:"   +   s);   

          im.smallpicture("E://vladstudio_5001.tiff","E://2.jpg",200,300);   

          long   e   =   System.currentTimeMillis();   

          System.out.println("end:"   +   e);   

          System.out.println("相差:"   +   (float)(e-s)/1000);   

    

      }   



}