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中图像处理问题，很难

不是一点的麻烦，机器学习加主动轮廓模型或许可以。