androidbitmap透明

‘壹’ android UI中添加一张图片如何将这张图片中某一部分设为透明的

可以利用canvas画布类，这个类的具体方法可以参看官方api。
http://developer.android.com/reference/android/graphics/Canvas.html
思路如下：对你图片做一些处理，例如让上部分完全显示，让下部分半透明。
1、先将你的原图转化为位图Bitmap；
2、先创建canvas画布，大小就是你原图片大小；
3、创建画笔paint类，设置画笔属性透明度，颜色等；
4、使用canvas类的drawBitmap(int[] colors, int offset, int stride, int x, int y, int width, int height, boolean hasAlpha, Paint paint) 函数，去创建。具体还是看api。
5、canvas.save（）；

总结：canvas画图不要以为有多难的，理论就是，拿着怎么样（paint属性）的笔（paint），在怎么样（canvas的属性，如大小等）的画布（canvas）上，画怎么样（canvas的drawBitmap函数）的图形。

回答完毕，希望有用，学习无限。

‘贰’ Android Bitmap详解

Bitmap是Android系统中图像处理的最重要类之一。用它可以获取图像信息，对图像进行剪切、旋转、缩放等操作，并可以指定格式保存图像文件。

以in开头的都是设置属性值，以out开头的都是获取属性值。

Bitmap的加载获取方式主要有有从Resource资源加载、本地SD卡加载及网络加载等方式。

使用BitmapFactory.decodeResource方式加载图片如果要经过缩放，该缩放是在java层进行的，效率比较低，会消耗java层的内存，因此如果大量使用会导致OOM。

BitmapFactory.decodeStream一般用于二进制文件图片的读取。

从网络加载图片本质上也是从网络读取图片数据流，通过BitmapFactory.decodeStream方式加载图片。

其他的转换就不一一列举了，不能直接转换的可以间接进行转换。

在拍照上传图片过程中，我们可能会遇到上传的图片被旋转了，需要给他复原进行旋转。

获取图片的旋转角度：

‘叁’ android 文本框中 加入多个bitmap图片, 点击bitmap 弹出对话框 该怎么写呢 是不是要获取透明的焦点

最简单的办法是，重写一个文本框，bitmap的显示采用imageSpan的方式设置到文本中，点击弹出对话框采用获取点击时触摸的文本的位置判断为在图片位置即弹出对话框。

‘肆’ android 如何创建一张透明bitmap

使用一张全透明的PNG图片作为drawable，将它转换为bitmap即可。

‘伍’ android中，如何用canvas绘制透明

第一种思路是通过对Bitmap进行操作，将Bitmap的像素值get到一个int[]数组里，因为在android里Bitmap通常是ARGB8888格式，所以最高位就是A通道的值，对齐进行改变后再新建一个Bitmap即可。
第二种思路是通过设置canvas的paint的透明度，然后通过canvas.drawBitmap()来改变View的透明度。
Paint .setAlpha(0);

‘陆’ Android Bitmap理解

参考：
Android Bitmap 详解：关于 Bitamp 你所要知道的一切

Android Bitmap（位图）详解

图片是由大量且有限个数的像素点组成。把一张图片通过bitmap的方式创建到内存中，实际上就是在内存中创建了一个叫做Bitmap的对象，然后把 图片所有像素 解码后的数据存放在Bitmap对象里面，Bitmap就拥有了图片的宽高，透明度，颜色值等数据。所以Bitmap的创建是通过BitmapFactory.decodeXxx()。

Config是Bitmap类中的枚举类。像素由ARGB四个颜色通道组成。Config描述位图中像素的存储方式。 这里的存储方式，无非就是对颜色通道和用多大的容器（bit）来存储的排列组合。所以config会影响图片透明度，占用内存大小，保存成文件的大小，图片质量。
Config的字母表示该配置存储的像素的颜色通道，数字表示对应通道的数据用多少位来存储。

ALPHA_8：表示只存储alpha通道，使用8bit（1字节）的内存（容器）来存储一个像素。
RGB_565：表示存储RGB三个通道，分别使用5bit，6bit，5bit的内存（容器）来存储一个像素。
ARGB_4444：表示存储ARGB四个通道，每个通道都是以4bit的内存（容器）来存储一个像素。
ARGB_8888：表示存储ARGB四个通道，每个通道都是以8bit的内存（容器）来存储一个像素。

所以，ARGB_8888配置占用内存最大，图片质量最高。
图片压缩的一个思路就是降低图片的配置。

总内存 = 宽的像素数 × 高的像素数 × 每个像素点占用的大小
注：
1 byte = 8 bit
1 KB = 1024 byte

‘柒’ Android bitmap alpha 什么是图片的alpha值,alpha值有什么作用

这个指的就是透明度，android里面xml是八位16进制数表示，譬如#ff123a11 前两位是透明度,后六位是颜色数值，也可以直接使用后6位，这样前两位的数值就默认为ff即为白色，前两位就是alpha值

‘捌’ android 实现毛玻璃透明效果有几种方法

1、如果系统的api在16以上，可以使用系统提供的方法直接处理图片

复制代码代码如下:

if (VERSION.SDK_INT > 16) {
Bitmap bitmap = sentBitmap.(sentBitmap.getConfig(), true);

final RenderScript rs = RenderScript.create(context);
final Allocation input = Allocation.createFromBitmap(rs, sentBitmap, Allocation.MipmapControl.MIPMAP_NONE,
Allocation.USAGE_SCRIPT);
final Allocation output = Allocation.createTyped(rs, input.getType());
final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
script.setRadius(radius /* e.g. 3.f */);
script.setInput(input);
script.forEach(output);
output.To(bitmap);
return bitmap;
}

2、 如果Api条件不满足，可以使用如下方法

复制代码代码如下:

@SuppressLint("NewApi")
public static Bitmap fastblur(Context context, Bitmap sentBitmap, int radius) {

Bitmap bitmap = sentBitmap.(sentBitmap.getConfig(), true);
if (radius < 1) {
return (null);
}
int w = bitmap.getWidth();
int h = bitmap.getHeight();
int[] pix = new int[w * h];
// Log.e("pix", w + " " + h + " " + pix.length);
bitmap.getPixels(pix, 0, w, 0, 0, w, h);
int wm = w - 1;
int hm = h - 1;
int wh = w * h;
int div = radius + radius + 1;
int r[] = new int[wh];
int g[] = new int[wh];
int b[] = new int[wh];
int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
int vmin[] = new int[Math.max(w, h)];
int divsum = (div + 1) >> 1;
divsum *= divsum;
int temp = 256 * divsum;
int dv[] = new int[temp];
for (i = 0; i < temp; i++) {
dv[i] = (i / divsum);
}
yw = yi = 0;
int[][] stack = new int[div][3];
int stackpointer;
int stackstart;
int[] sir;
int rbs;
int r1 = radius + 1;
int routsum, goutsum, boutsum;
int rinsum, ginsum, binsum;
for (y = 0; y < h; y++) {
rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
for (i = -radius; i <= radius; i++) {
p = pix[yi + Math.min(wm, Math.max(i, 0))];
sir = stack[i + radius];
sir[0] = (p & 0xff0000) >> 16;
sir[1] = (p & 0x00ff00) >> 8;
sir[2] = (p & 0x0000ff);
rbs = r1 - Math.abs(i);
rsum += sir[0] * rbs;
gsum += sir[1] * rbs;
bsum += sir[2] * rbs;
if (i > 0) {
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
} else {
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
}
}
stackpointer = radius;
for (x = 0; x < w; x++) {
r[yi] = dv[rsum];
g[yi] = dv[gsum];
b[yi] = dv[bsum];
rsum -= routsum;
gsum -= goutsum;
bsum -= boutsum;
stackstart = stackpointer - radius + div;
sir = stack[stackstart % div];
routsum -= sir[0];
goutsum -= sir[1];
boutsum -= sir[2];
if (y == 0) {
vmin[x] = Math.min(x + radius + 1, wm);
}
p = pix[yw + vmin[x]];
sir[0] = (p & 0xff0000) >> 16;
sir[1] = (p & 0x00ff00) >> 8;
sir[2] = (p & 0x0000ff);
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
rsum += rinsum;
gsum += ginsum;
bsum += binsum;
stackpointer = (stackpointer + 1) % div;
sir = stack[(stackpointer) % div];
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
rinsum -= sir[0];
ginsum -= sir[1];
binsum -= sir[2];
yi++;
}
yw += w;
}
for (x = 0; x < w; x++) {
rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
yp = -radius * w;
for (i = -radius; i <= radius; i++) {
yi = Math.max(0, yp) + x;
sir = stack[i + radius];
sir[0] = r[yi];
sir[1] = g[yi];
sir[2] = b[yi];
rbs = r1 - Math.abs(i);
rsum += r[yi] * rbs;
gsum += g[yi] * rbs;
bsum += b[yi] * rbs;
if (i > 0) {
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
} else {
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
}
if (i < hm) {
yp += w;
}
}
yi = x;
stackpointer = radius;
for (y = 0; y < h; y++) {
// Preserve alpha channel: ( 0xff000000 & pix[yi] )
pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
rsum -= routsum;
gsum -= goutsum;
bsum -= boutsum;
stackstart = stackpointer - radius + div;
sir = stack[stackstart % div];
routsum -= sir[0];
goutsum -= sir[1];
boutsum -= sir[2];
if (x == 0) {
vmin[y] = Math.min(y + r1, hm) * w;
}
p = x + vmin[y];
sir[0] = r[p];
sir[1] = g[p];
sir[2] = b[p];
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
rsum += rinsum;
gsum += ginsum;
bsum += binsum;
stackpointer = (stackpointer + 1) % div;
sir = stack[stackpointer];
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
rinsum -= sir[0];
ginsum -= sir[1];
binsum -= sir[2];
yi += w;
}
}
// Log.e("pix", w + " " + h + " " + pix.length);
bitmap.setPixels(pix, 0, w, 0, 0, w, h);
return (bitmap);
}