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);
}