android圖形圖像處理

A. 為什麼 iOS 和 android 在圖形性能方面的差別那麼大

ios和android在圖形性能方面的差別大的原因是：
ios的整體硬體配置比android手機高出很多，所以在圖形性能和游戲處理上面會更有優勢。
ios的底層是c語言，android的是使用java語言開發的，c語言在底層圖像處理方面更具優勢。

B. android開發中怎麼繪制圖形

在你制圖之前，你必須初始化和載入你計劃要繪制的形狀。你要在內存和處理速率的渲染器中的onSurfaceCreated()方法對形狀初始化，除非在程序執行的過程中，形狀的結構（原始坐標）發生了變化。

public void onSurfachttp://wiki.eoeandroid.com/Drawing_ShapeseCreated(GL10 unused, EGLConfig config) {

...

// initialize a triangle

mTriangle = new Triangle();

// initialize a square

mSquare = new Square();

}

繪制形狀

使用OpenGL ES 2.0繪制形狀需要大量的代碼，因為你需要提供大量的圖像渲染器管道的細節。具體地，你需要定義： * 頂點著色器（Vertex Shader） - OpenGL ES圖像中渲染形狀頂點的代碼 * 片斷著色器（Fragment Shader） - OpenGL ES渲染形狀表面顏色與紋理的代碼 * 程序（Program） - 包含了你想要用來繪制形狀的著色器的OpenGL ES對象 你需要至少一個頂點著色器來繪制圖像，一個片斷著色器去給圖像著色。這些著色器必須被定義和添加到一個OpenGL ES程序中，它將會在繪制形狀時被用到。下面是一個基本的定義著色器的例子：

private final String vertexShaderCode =

"attribute vec4 vPosition;" +

"void main() {" +

" gl_Position = vPosition;" +

"}";

private final String fragmentShaderCode =

"precision mediump float;" +

"uniform vec4 vColor;" +

"void main() {" +

" gl_FragColor = vColor;" +

"}";

包含了OpenGL著色語言（GLSL）的著色器在被OpenGL ES環境使用之前，必須先被定義。你可以在渲染類中創建一個實用的方法來定義這些著色器：

public static int loadShader(int type, String shaderCode){

// create a vertex shader type (GLES20.GL_VERTEX_SHADER)

// or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)

int shader = GLES20.glCreateShader(type);

// add the source code to the shader and compile it

GLES20.glShaderSource(shader, shaderCode);

GLES20.glCompileShader(shader);

return shader;

}

為了繪制形狀，你必須編寫著色器的代碼，並把它們添加到OpenGL ES程序對象中，與程序連接起來。你可以在繪制對象的構造器做這些事情，這樣它就會只運行一次。

備註：定義OpenGL ES著色器並於程序連接，需要消耗大量的CPU周期和處理時間，所以你要避免重復做這個動作。如果你想要獲取執行期間著色器的內容，你可以在建立代碼使它們只建立一次，並存儲起來在後面用。

public Triangle() {

...

int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);

int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

mProgram = GLES20.glCreateProgram(); // create empty OpenGL ES Program

GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program

GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program

GLES20.glLinkProgram(mProgram); // creates OpenGL ES program executables

}

事情進展到此，你可以在實際中調用繪制圖形方法了。使用OpenGL ES制圖時，需要你指定幾個參數，來告訴渲染器管道要畫什麼和怎樣畫。既然形狀會影響到繪制的情況，所以最好的辦法就是給形狀類添加它們各自的邏輯。 可以建立draw()的方法來繪制形狀。下面的例子就設定了形狀的頂點著色器的位置和片段著色器的顏色值，然後就執行繪制的函數方法。

public void draw() {

// Add program to OpenGL ES environment

GLES20.glUseProgram(mProgram);

// get handle to vertex shader's vPosition member

mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");

// Enable a handle to the triangle vertices

GLES20.glEnableVertexAttribArray(mPositionHandle);

// Prepare the triangle coordinate data

GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX,

GLES20.GL_FLOAT, false,

vertexStride, vertexBuffer);

// get handle to fragment shader's vColor member

mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");

// Set color for drawing the triangle

GLES20.glUniform4fv(mColorHandle, 1, color, 0);

// Draw the triangle

GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);

// Disable vertex array

GLES20.glDisableVertexAttribArray(mPositionHandle);

}

只要你代碼齊全，你只需要調用渲染器 onDrawFrame()方法中的draw()方法來繪制圖像。當應用程序運行起來時，應該會得到以下這樣的結果：

C. 為什麼就算配置很高的 Android 手機玩游戲感覺畫面也沒有 iPhone ...

這是兩者的系統架構不同導致。
首先是iOS對屏幕反應的優先順序是最高的（Touch-Media-Service-Core架構），也就是說用戶只要碰了屏幕，系統最優先去處理屏幕顯示，然後才是其他。而安卓則是傳統的Application-Framework-Library(JAVA虛擬機)-Kernal架構，圖形圖像處理在Library這層，優先順序不是那麼高。如果系統負荷較高，則無暇顧及用戶觸摸的反應。
其次是iOS對圖像的各種特效處理（放大、縮小、旋轉、滾動等）都是基於GPU硬體加速的，與APP無關。這是APPLE採用封閉式硬體的優勢。而安卓為了適應不同的手機硬體，做不到這點，很多APP的圖形特效都靠APP自己去進行軟體渲染，效率低。最新的4.1已經改進，但也無法做到所有特效都靠GPU硬體加速。
最後就是安卓的JAVA虛擬機：相對iOS的Objectiv-C，JAVA天生運行效率低下，需要佔用大量內存來換取執行速度，而不定期的內存自動回收機制，直接導致安卓界面的卡頓現象，無論如何優化也不可能改掉。2.3版安卓就是為改善此設計而發布：引入了一種新的並行內存回收機制來減輕這種卡頓影響，但也僅僅是減輕，而無法徹底消除。也因此2.3版成為安卓重要的里程碑。
作者：Benjamin

D. android 圖像處理 用什麼庫

沒有，只有GPU

E. android studio中有沒有圖像處理技術

Android Studio 是一個Android開發環境，基於IntelliJ IDEA. 類似 Eclipse ADT，Android Studio 提供了集成的 Android 開發工具用於開發和調試。

F. android怎麼用paint實現圖像的漸變出現

在android.graphics中提供了有關Gradient字樣的類，例如LinearGradient線性漸變、 RadialGradient徑向漸變和SweepGradient角度漸變三種，他們的基類為android.graphics.Shader。為了演 示圖像漸變效果，下面給出一個簡單的實例。

一、LinearGradient線性漸變
在android平台中提供了兩種重載方式來實例化該類分別為，他們的不同之處為參數中第一種方法可以用顏色數組，和位置來實現更細膩的過渡效果， 比如顏 色采樣int[] colors數組中存放20種顏色，則漸變將會逐一處理。而第二種方法參數僅為起初顏色color0和最終顏色color1。

LinearGradient(float x0, float y0, float x1, float y1, int[] colors, float[] positions, Shader.TileMode tile)

LinearGradient(float x0, float y0, float x1, float y1, int color0, int color1, Shader.TileMode tile)

使用實例如下：

Paint p=new Paint();
LinearGradient lg=new LinearGradient(0,0,100,100,Color.RED,Color.BLUE,Shader.TileMode.MIRROR); //參數一為漸變起初點坐標x位置，參數二為y軸位置，參數三和四分辨對應漸變終點，最後參數為平鋪方式，這里設置為鏡像
剛才已經講到Gradient是基於Shader類，所以我們通過Paint的setShader方法來設置這個漸變，代碼如下：

p.setShader(lg);
canvas.drawCicle(0,0,200,p); //參數3為畫圓的半徑，類型為float型。
二、RadialGradient鏡像漸變
有了上面的基礎，我們一起來了解下徑向漸變。和上面參數唯一不同的是，徑向漸變第三個參數是半徑，其他的和線性漸變相同。

RadialGradient(float x, float y, float radius, int[] colors, float[] positions, Shader.TileMode tile)

RadialGradient(float x, float y, float radius, int color0, int color1, Shader.TileMode tile)

三、SweepGradient角度漸變
對於一些3D立體效果的漸變可以嘗試用角度漸變來完成一個圓錐形，相對來說比上面更簡單，前兩個參數為中心點，然後通過載入的顏色來平均的漸變渲染。

SweepGradient(float cx, float cy, int[] colors, float[] positions) //對於最後一個參數SDK上的描述為May be NULL. The relative position of each corresponding color in the colors array, beginning with 0 and ending with 1.0. If the values are not monotonic, the drawing may proce unexpected results. If positions is NULL, then the colors are automatically spaced evenly.，所以建議使用下面的重載方法，本方法一般為NULL即可。

SweepGradient(float cx, float cy, int color0, int color1)

到此，希望大家對圖像特效處理有了一定的認識，了解這些對打好Android游戲開發的基礎很有好處。
轉載

G. 請問誰能告訴我，學習安卓開發的話都要學哪些內容嗎需要HTML，javaWEB，CSS之類的嗎

學習安卓開發的話一般會涉及一部分Java的知識，但是Javaweb和HTML以及CSS屬於前端部分的知識，一般涉及的會比較少。安卓開發一般學習的內容有以下：

一、Android基礎課程

• Java基礎/高級編程

• 面向對象編程

• Java異常處理

• Java編程API

• 數據結構及演算法

• 文件IO編程

• Java多線程編程

• Java網路編程

二、Android應用開發

• Android開發入門

• Android Activity與UI控制項

• Android多線程編程

• Android數據存儲

• Android網路編程

• Android圖形圖像處理

• Android系統服務

• APP美化和系統優化

三、Android游戲開發

• 游戲開發基礎

• View和SurfaceView

• 手勢識別及感測器開發

• 碰撞檢測、物理引擎、游戲資源調試

• Cocos2D-x

• 3D游戲及Open GI技術

• 動作游戲設計

• 游戲圖層處理

• 游戲性能優化

四、Android底層開發

• Android源碼結構

• Android源碼編譯環境搭建

• Android源碼下載方法

• JNI，GPS框架，HAL

• Camera框架，Sensor框架，Ril框架

H. android圖像處理 為什麼我這段代碼圖像顯示不出來我輸入的是只有黑白兩色的圖像

調用例子
resultBitmap = (Bitmap) intent.getParcelableExtra("resultBitmap");
// 圖片與處理
BitmapFilter bitmapFilter = new BitmapFilter(resultBitmap);
bitmapFilter.changeGrey();
resultBitmap = bitmapFilter.getBitmap();

以下是BitmapFilter
package com.example.androcr;

import android.graphics.Bitmap;
import android.graphics.Color;

/**
* 圖像預處理類
* @author Administrator
*/
public class BitmapFilter {

private Bitmap bitmap;
private int iw;
private int ih;
private int[] pixels;

public BitmapFilter(Bitmap bitmap) {
this.bitmap = bitmap;
this.iw = bitmap.getWidth();
this.ih = bitmap.getHeight();
pixels = new int[iw * ih];
// 將bitmap轉化為pixel數組
bitmap.getPixels(pixels, 0, iw, 0, 0, iw, ih);
}

public Bitmap getBitmap() {
// 將pixel數組轉化為bitmap
bitmap = Bitmap.createBitmap(pixels, iw, ih, Bitmap.Config.ARGB_8888);
return bitmap;
}

/**
* 圖像的二值化
*/
public void changeGrey() {
// 選取的閾值
int grey = 120;
int pixel;
int alpha, red, green, blue;
for (int i = 0; i < iw * ih; i++) {
pixel = pixels[i];
alpha = Color.alpha(pixel);
red = Color.red(pixel);
green = Color.green(pixel);
blue = Color.blue(pixel);
red = (red > grey) ? 255 : 0;
green = (green > grey) ? 255 : 0;
blue = (blue > grey) ? 255 : 0;
pixels[i] = alpha << 24 | red << 16 | green << 8 | blue;
}
}

/**
* 圖像的銳化
*/
public void sharp() {
// 像素中間變數
int tempPixels[] = new int[iw * ih];
for (int i = 0; i < iw * ih; i++) {
tempPixels[i] = pixels[i];
}
int alpha;
int red6, red5, red8, sharpRed;
int green5, green6, green8, sharpGreen;
int blue5, blue6, blue8, sharpBlue;
for (int i = 1; i < ih - 1; i++) {
for (int j = 1; j < iw - 1; j++) {
alpha = Color.alpha(pixels[i * iw + j]);
// 對圖像進行尖銳化
// 銳化red
red6 = Color.red(pixels[i * iw + j + 1]);
red5 = Color.red(pixels[i * iw + j]);
red8 = Color.red(pixels[(i + 1) * iw + j]);
sharpRed = Math.abs(red6 - red5) + Math.abs(red8 - red5);
// 銳化green
green5 = Color.green(pixels[i * iw + j]);
green6 = Color.green(pixels[i * iw + j + 1]);
green8 = Color.green(pixels[(i + 1) * iw + j]);
sharpGreen = Math.abs(green6 - green5)
+ Math.abs(green8 - green5);
// 銳化blue
blue5 = Color.blue(pixels[i * iw + j]);
blue6 = Color.blue(pixels[i * iw + j + 1]);
blue8 = Color.blue(pixels[(i + 1) * iw + j]);
sharpBlue = Math.abs(blue6 - blue5)
+ Math.abs(blue8 - blue5);
// 處理顏色溢出
if (sharpRed > 255)
sharpRed = 255;
if (sharpGreen > 255)
sharpGreen = 255;
if (sharpBlue > 255)
sharpBlue = 255;
tempPixels[i * iw + j] = alpha << 24 | sharpRed << 16
| sharpGreen << 8 | sharpBlue;
}
}
pixels = tempPixels;
}

/**
* 中值濾波
*/
public void median() {
// 對圖像進行中值濾波
int alpha, red, green, blue;
int red4, red5, red6;
int green4, green5, green6;
int blue4, blue5, blue6;
for (int i = 1; i < ih - 1; i++) {
for (int j = 1; j < iw - 1; j++) {
// alpha值保持不變
alpha = Color.alpha(pixels[i * iw + j]);
// 處理red分量
red4 = Color.red(pixels[i * iw + j - 1]);
red5 = Color.red(pixels[i * iw + j]);
red6 = Color.red(pixels[i * iw + j + 1]);
// 水平方向進行中值濾波
if (red4 >= red5) {
if (red5 >= red6) {
red = red5;
} else {
if (red4 >= red6) {
red = red6;
} else {
red = red4;
}
}
} else {
if (red4 > red6) {
red = red4;
} else {
if (red5 > red6) {
red = red6;
} else {
red = red5;
}
}
}
// 處理green分量
green4 = Color.green(pixels[i * iw + j - 1]);
green5 = Color.green(pixels[i * iw + j]);
green6 = Color.green(pixels[i * iw + j + 1]);
// 水平方向進行中值濾波
if (green4 >= green5) {
if (green5 >= green6) {
green = green5;
} else {
if (green4 >= green6) {
green = green6;
} else {
green = green4;
}
}
} else {
if (green4 > green6) {
green = green4;
} else {
if (green5 > green6) {
green = green6;
} else {
green = green5;
}
}
}
// 處理blue分量
blue4 = Color.blue(pixels[i * iw + j - 1]);
blue5 = Color.blue(pixels[i * iw + j]);
blue6 = Color.blue(pixels[i * iw + j + 1]);
// 水平方向進行中值濾波
if (blue4 >= blue5) {
if (blue5 >= blue6) {
blue = blue5;
} else {
if (blue4 >= blue6) {
blue = blue6;
} else {
blue = blue4;
}
}
} else {
if (blue4 > blue6) {
blue = blue4;
} else {
if (blue5 > blue6) {
blue = blue6;
} else {
blue = blue5;
}
}
}
pixels[i * iw + j] = alpha << 24 | red << 16 | green << 8
| blue;
}
}
}

/**
* 圖像的平滑
*/
public void smooth() {
int[] tempPixels = new int[iw * ih];
//圖像的平滑
int min = -1000;
int max = 1000;
for (int i = 0; i < ih; i++) {
for (int j = 0; j < iw; j++) {
if (i == 0 || i == 1 || i == ih - 1 || i == ih - 2 || j == 0
|| j == 1 || j == iw - 1 || j == iw - 2) {
tempPixels[i * iw + j] = pixels[i * iw + j];
} else {
// 中心的九個像素點
float average = (
pixels[i * iw + j]
+ pixels[i * iw + j - 1]
+ pixels[i * iw + j + 1]
+ pixels[(i - 1) * iw + j]
+ pixels[(i - 1) * iw + j - 1]
+ pixels[(i - 1) * iw + j + 1]
+ pixels[(i + 1)]
+ pixels[(i + 1) * iw + j]
+ pixels[(i + 1) * iw + j - 1]
) / 9;
tempPixels[i * iw + j] = (int) (average);
}
if (tempPixels[i * iw + j] < min)
min = tempPixels[i * iw + j];
if (tempPixels[i * iw + j] > max)
max = tempPixels[i * iw + j];
}
}
for (int i = 0; i < iw * ih; i++) {
tempPixels[i] = (tempPixels[i] - min) * 255 / (max - min);
}
pixels = tempPixels;
}

}

I. Android圖像處理軟體

有，而且就有android版本的photoshop，可以大概的處理圖像，但是如果是精細處理建議用電腦

J. android中圖像處理問題，很難

不是一點的麻煩，機器學習加主動輪廓模型或許可以。