防爆ExdCT等級劃分

Ⅰ 吉利繽越有哪幾個配置

吉利賓越提供了1.0T與1.5T的兩款三缸發動機，其中1.5T的發動機由吉利和沃共同研發，在吉利博Irui上面已經使用多時。

200T 手動射手版

繽越的全系最低配版本，在配置方面是已經較為足夠了，日常的代步使用勉強可以，只是作為屈指可數一款1.0T 6MT的動力組合，還是建議考慮1.5T的版本吧。

260T 7DCT獵手版

相較於射手版在價格上貴了1萬元，增加了一些車載互聯網的配置，不過無鑰匙進入、自動恆溫空調、PM2.5、自動大燈就被減少了。雖然說這些配置的實用性都非常的不錯，但考慮到車輛的易駕性及中控的好用程度，還是比較推薦預算不足的消費者購買。

運動款 260T DCT Battle版

作為全系的頂配版本，基本上是能給到的配置也都是給到了，特別是在行車的方面，簡直是全副武裝，值得一提的是該版本配有可以通過手機遙控的T-BOX系統，要是預算充足的消費者，這個版本的運動款還是最值得入手購買的。

Ⅱ wow Damage_EX和DCT兩個插件哪個好點

SDCT是王道。當然，自己看得順眼用得習慣才是最重要的。

Ⅲ java裡面獲得圖像像素後怎麼做dct變換

private void setAlpha(ByteArrayOutputStream os) {

try {
ImageIcon imageIcon = new ImageIcon(os.toByteArray());
BufferedImage bufferedImage = new BufferedImage(imageIcon.getIconWidth(),imageIcon.getIconHeight()
, BufferedImage.TYPE_4BYTE_ABGR);
Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics();
g2D.drawImage(imageIcon.getImage(), 0, 0,
imageIcon.getImageObserver());
//循環每一個像素點，改變像素點的Alpha值
int alpha = 100;
for (int j1 = bufferedImage.getMinY(); j1 < bufferedImage.getHeight(); j1++) {
for (int j2 = bufferedImage.getMinX(); j2 < bufferedImage.getWidth(); j2++) {
int rgb = bufferedImage.getRGB(j2, j1);
rgb = ( (alpha + 1) << 24) | (rgb & 0x00ffffff);
bufferedImage.setRGB(j2, j1, rgb);
}
}
g2D.drawImage(bufferedImage, 0, 0, imageIcon.getImageObserver());

//生成圖片為PNG
ImageIO.write(bufferedImage, "png", new File(圖片路徑));
}
catch (Exception e) {
e.printStackTrace();
}
}

使用JAVA對圖片進行效果變換（第二幅圖覆蓋第一幅圖的像素並顯示）
一提到JAVA，談論最多的就是JSP/SERVLET/J2EE之類的，但對於用JAVA對圖片進行效果變換，到論壇里看了看，關於這方面的話題並不多，網上關於圖像效果處理的文章也並不豐富，於是在自己摸索了幾天，並且參考了AnfyJava(專業級的JAVA效果生成器)後，我用輕量級控制項寫了一個(AnfyJava繼承的是Applet，Applet是java.awt包中的，屬於重量級控制項，SUN現在推薦使用swing來編寫圖形程序，因此，我用的是JApplet)。
其實，用JAVA做圖像效果和其它語言在本質上並沒有什麼區別，只不過在實現起來有所不同罷了，下面我就把我在項目中處理的經驗與大家分享一下吧。
圖像的變換，實際上就是把兩幅圖片的內容進行某些運算，生成新的圖像，然後顯示出來，最終實現從一幅圖片到另一幅圖片的過度效果。變換的具體過程如下：

在上面的過程中，圖片A和B的尺寸最好保持一致，如果不一致的話，可能要做一些額外的處理，在此，我選用的圖片A和B的尺寸是一致的。
首先，我們將其當作一個Applet來寫，由於Applet的局限性，不可以直接使用File類來讀取圖像文件，因此，我們只能通過如下方法來獲取圖像文件。
URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();
URL url = urlLoader.findResource("imagea.gif");
Image image = Toolkit.getDefaultToolkit().getImage(url);
當我們獲得了圖像後，可以通過java.awt.image.PixelGrabber包中的PixelGrabber方法來將圖像中的像素信息完全讀取出來，其用法如下：
PixelGrabber(Image img, int x, int y, int w, int h, int[] pix, int off, int scansize)
其中img是要讀取的圖像，x/y是要讀取圖像中的左上角坐標，w/h分別是從x/y開始起的距離，其實x,y,w,h就是一個矩形，pix是保存像素的數組，off是讀取圖像時開始的位置，scansize是指掃描的寬度，一般來說和w相等。
int width = image.getWidth();
int height = image.getHeight();
int size = width * height;
int[] pixels = new int[size];
pixelgrabber = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width);
try {
pixelgrabber.grabPixels(); //讀取像素入數組
}
catch (InterruptedException _ex) {}
由於像素信息是由alpha,red,green,blue組成的，其格式為

因此，我們可以將顏色分解成單獨的RGB信息
int alpha = (pixel >> 24) & 0xff;
int red = (pixel >> 16) & 0xff;
int green = (pixel >> 8) & 0xff;
int blue = (pixel) & 0xff;
假如要實現顯示圖片A後，圖片B由上至下展開，則可以每次將圖片A中的一行像素替換為B中的相應行，然後生成新的像素信息：
圖像A的像素數組 圖像B的像素數組

old = pixelA; //保存圖片A的像素信息
oldR = redA; //保存圖片A的R信息
oldG = greenA; //保存圖片A的G信息
oldB = blueA; //保存圖片A的B信息
for (int i = 0; i < width; i++) {//line為行數
oldR[line * width + i] = redA [line * width + i];
oldG[line * width + i] = greenA [line * width + i];
oldB[line * width + i] = blueA [line * width + i];
old[line * width + i] = oldR[line * width + i] << 16 + oldG[line * width + i] << 8 + oldB[line * width + i];
}
當生成新的像素信息後，可以通過java.awt.image.MemoryImageSource包中的MemoryImageSource(int w, int h, ColorModel cm, int[] pix, int off, int scan)方法將像素數組對應到圖像，並且可以用newPixels()方法來生成新的圖像(具體用法可以參考JAVA API DOC)。
memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,
new DirectColorModel(24, 0xff0000, 0x00ff00, 0x0000ff), blocks, 0, imageWidth);
//檢查java版本
String javaVersion;
try {
javaVersion = System.getProperty("java.version");
}
catch (SecurityException _ex) {
javaVersion = "unk";
}
if (!javaVersion.startsWith("1.0")) { //jdk1.1以上的版本才支持此方法
try {
memoryimagesource.setAnimated(true);
memoryimagesource.setFullBufferUpdates(true);
imageBuf = createImage(memoryimagesource);
memoryimagesource.newPixels();//生成新的圖像
}
catch (NoSuchMethodError _ex) {
System.out.println("unknow java version!");
}
}
到此，新的圖像已經產生，只需要輸出到屏幕即可。
在此，需要注意以下幾個問題：
1、由於Applet讀取的圖像文件可以比較大，對於速度較慢的網路，可能會造成圖像未讀取完全就開始進行變換，因此，建議使用MediaTracker方法來保證圖像能被順利載入。
2、 在顯示的時候，為了避免閃爍，可以採用雙緩沖的方法。
3、 由於在某此高速計算機上，生成新的像素可以非常快，為了避免速度過快而造成效果並不明顯，可以加以適當的延時處理。
4、 為了保證效果的平滑，我們特地開辟了非常大的數組來保存像素/RGB信息，這是以空間換時間的做法。
完整的源程序附下(在jdk1.4/2k Server/RedHat9下運行通過，所用機器為P4 2.4G/512M)
package pic;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
public class effect
extends JApplet
implements Runnable {
//定義變數
Toolkit toolkit;
int totalBlocks = 0; //圖像被分解成的塊數，默認為 寬X高
int[] blocks; //保存塊數的信息
Image[] bufferImage = new Image[2]; //屏幕上的圖形緩沖
VolatileImage offScreenImage;
Image imageBuf; //保存圖片緩沖區內容
Graphics2D offScreenGraphics;
Thread thread;
MediaTracker mediaTracker;
boolean[] isImageReady; //圖片是否已經裝載
MemoryImageSource memoryimagesource;
int imageWidth, imageHeight; //圖像的寬及高
int[] pixelA, pixelB;
int[] redA, greenA, blueA, redB, greenB, blueB;
public effect() throws HeadlessException {
bufferImage[0] = getImage("a.jpg");
bufferImage[1] = getImage("b.jpg");
if ( (bufferImage[0].getWidth(this) != bufferImage[1].getWidth(this)) ||
(bufferImage[0].getHeight(this) != bufferImage[1].getHeight(this))) {
System.out.println("圖像尺寸不一致！");
return;
}
toolkit = getToolkit();
imageWidth = bufferImage[0].getWidth(this);
imageHeight = bufferImage[0].getHeight(this);
totalBlocks = imageWidth * imageHeight; //計算分解的塊數
blocks = new int[totalBlocks];
pixelA = new int[totalBlocks];
pixelB = new int[totalBlocks];
redA = new int[totalBlocks];
greenA = new int[totalBlocks];
blueA = new int[totalBlocks];
redB = new int[totalBlocks];
greenB = new int[totalBlocks];
blueB = new int[totalBlocks];
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gd.getDefaultConfiguration();
offScreenImage = gc.createCompatibleVolatileImage(imageWidth, imageHeight); //創建圖像緩沖
offScreenGraphics = offScreenImage.createGraphics(); //取得緩沖的graphics對象
}
public void init() {
getImagePixels(bufferImage[0], pixelA);
getImagePixels(bufferImage[1], pixelB);
for (int i = 0; i < totalBlocks; i++) {
blocks[i] = pixelA[i]; //保存圖像A的像素信息
redA[i] = pixelA[i] & 0xff0000; //保存圖像B的red值
greenA[i] = pixelA[i] & 0x00ff00; //保存圖像B的green值
blueA[i] = pixelA[i] & 0x0000ff; //保存圖像B的blue值
redB[i] = pixelB[i] & 0xff0000; //保存圖像B的red值
greenB[i] = pixelB[i] & 0x00ff00; //保存圖像B的green值
blueB[i] = pixelB[i] & 0x0000ff; //保存圖像B的blue值
}
prepareImagePixels(); //將像素信息還原為圖像
}
public void run() {
//檢查java版本
String javaVersion;
try {
javaVersion = System.getProperty("java.version");
}
catch (SecurityException _ex) {
javaVersion = "unk";
}
if (javaVersion.startsWith("1.0")) {
System.out.println("require java 1.1 or later version!");
return;
}
try { //暫停3秒鍾後等待效果開始
thread.sleep(3000l);
}
catch (InterruptedException ex1) {
}
int line = 0;
Thread currentThread = Thread.currentThread();
while (line < imageHeight && thread == currentThread) {
for (int i = 0; i < imageWidth; i++) {
int offset = line * imageWidth + i;
blocks[offset] = pixelB[offset]; //與下一被注釋的語句作用相同
//blocks[offset] = redB[offset] | greenB[offset] | blueB[offset];
}
memoryimagesource.newPixels(); //生成新的圖像
line++;
repaint();
//適當延時
try {
thread.sleep(20l);
}
catch (InterruptedException ex) {
}
}
}
public void paint(Graphics g) {
if (offScreenGraphics != null) { //保證在destory()時不引發異常
offScreenGraphics.drawImage(imageBuf, 0, 0, this);
g.drawImage(offScreenImage, 0, 0, this);
}
}
public void start() {
if (thread == null) {
thread = new Thread(this);
thread.start();
}
}
public void stop() {
thread = null;
}
public final void update(Graphics g) {
paint(g);
}
public void destroy() {
if (offScreenImage != null) {
offScreenImage.flush();
}
offScreenImage = null;
if (offScreenGraphics != null) {
offScreenGraphics.dispose();
}
offScreenGraphics = null;
System.gc();
}
Image getImage(String filename) {
URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();
URL url = null;
Image image = null;
url = urlLoader.findResource(filename);
image = Toolkit.getDefaultToolkit().getImage(url);
MediaTracker mediatracker = new MediaTracker(this);
try {
mediatracker.addImage(image, 0);
mediatracker.waitForID(0);
}
catch (InterruptedException _ex) {
image = null;
}
if (mediatracker.isErrorID(0)) {
image = null;
}
return image;
}
private boolean getImagePixels(Image image, int pixels[]) {
PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, imageWidth,
imageHeight, pixels,
0, imageWidth);
try {
pixelgrabber.grabPixels();
}
catch (InterruptedException _ex) {
return false;
}
return true;
}
void prepareImagePixels() {
memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,
new DirectColorModel(24, 0xff0000,
0x00ff00, 0x0000ff), blocks, 0, imageWidth);
try {
memoryimagesource.setAnimated(true);
memoryimagesource.setFullBufferUpdates(true);
imageBuf = createImage(memoryimagesource);
memoryimagesource.newPixels(); //生成新的圖像
}
catch (NoSuchMethodError _ex) {
}
}
public int getWidth() {
return imageWidth;
}
public int getHeight() {
return imageHeight;
}
public static void main(String args[]) {
JFrame frame = new JFrame("Demo");
effect e = new effect();
e.init();
e.start();
frame.getContentPane().setLayout(new BorderLayout());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setResizable(false);
frame.getContentPane().add(e);
frame.setSize(new Dimension(e.getWidth() + 6, e.getHeight() + 20));
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
frame.setLocation( (screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
frame.show();
}
}
新建一個HTML文件，加入以下語句可作為Applet(其中width/height分別是圖片的高和寬)：

作為應用程序運行的時候，在命令行輸入：
java pic.effect

Ⅳ 捷途乂90頂配自動檔

摘要 親