/**
* Assert that two bitmaps are equal.
*
* @param Bitmap b1 the first bitmap which needs to compare.
* @param Bitmap b2 the second bitmap which needs to compare.
*/
public static void assertEquals(Bitmap b1, Bitmap b2) {
if (b1 == b2) {
return;
}
if (b1 == null || b2 == null) {
Assert.fail("the bitmaps are not equal");
}
// b1 and b2 are all not null.
if (b1.getWidth() != b2.getWidth()
|| b1.getHeight() != b2.getHeight()
|| b1.getConfig() != b2.getConfig()) {
Assert.fail("the bitmaps are not equal");
}
int w = b1.getWidth();
int h = b1.getHeight();
int s = w * h;
int[] pixels1 = new int[s];
int[] pixels2 = new int[s];
b1.getPixels(pixels1, 0, w, 0, 0, w, h);
b2.getPixels(pixels2, 0, w, 0, 0, w, h);
for (int i = 0; i < s; i++) {
if (pixels1[i] != pixels2[i]) {
Assert.fail("the bitmaps are not equal");
}
}
}
private static Bitmap getWhiteSheep(File inputDir) {
File alreadyThere = new File(inputDir, "mob/sheep_0.png");
if (alreadyThere.exists()) {
return BitmapFactory.decodeFile(alreadyThere.getAbsolutePath());
}
File topHalf = new File(inputDir, "mob/sheep.png");
if (!topHalf.exists()) {
topHalf = new File(inputDir, "entity/sheep/sheep.png");
}
// We have to build this one by hand
File bottomHalf = new File(inputDir, "mob/sheep_fur.png");
if (!bottomHalf.exists()) {
bottomHalf = new File(inputDir, "entity/sheep/sheep_fur.png");
}
if (!topHalf.exists() || !bottomHalf.exists()) {
return null;
}
Bitmap topHalfBitmap = BitmapFactory.decodeFile(topHalf.getAbsolutePath());
Bitmap bottomHalfBitmap = BitmapFactory.decodeFile(bottomHalf.getAbsolutePath());
Bitmap finalBitmap =
Bitmap.createBitmap(
topHalfBitmap.getWidth(), topHalfBitmap.getHeight() * 2, Bitmap.Config.ARGB_8888);
int[] pixels = new int[topHalfBitmap.getWidth() * topHalfBitmap.getHeight()];
topHalfBitmap.getPixels(
pixels,
0,
topHalfBitmap.getWidth(),
0,
0,
topHalfBitmap.getWidth(),
topHalfBitmap.getHeight());
finalBitmap.setPixels(
pixels,
0,
topHalfBitmap.getWidth(),
0,
0,
topHalfBitmap.getWidth(),
topHalfBitmap.getHeight());
bottomHalfBitmap.getPixels(
pixels,
0,
topHalfBitmap.getWidth(),
0,
0,
topHalfBitmap.getWidth(),
topHalfBitmap.getHeight());
finalBitmap.setPixels(
pixels,
0,
topHalfBitmap.getWidth(),
0,
topHalfBitmap.getHeight(),
topHalfBitmap.getWidth(),
topHalfBitmap.getHeight());
return finalBitmap;
}
/*Obtenemos la projección inversa a partir del bitmap*/
public static synchronized int[] setBckHistogram(Bitmap image) {
int width = image.getWidth(), height = image.getHeight(); // Obtenemos la dimensiones
int pos = 0,
gray = 0,
imPix = 0; // Constantes de posición y de la escala de grises y almacenador del pixel.
int[] imPixels = new int[width * height]; // Generamos un buffer de la imagen;
image.getPixels(
imPixels, 0, width, 0, 0, width,
height); // Obtenemos la imagen en el buffer a partir del bitmap
// Recorremos la imagen de arriba a abajo y de izquierda a derecha.
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++) {
pos = x + (y * width); // Obtenemos la posición del pixel en el array.
imPix = imPixels[pos]; // Almacenamos el valor del pixel n.
gray =
(((imPix >> 16) & 0xFF) + ((imPix >> 8) & 0xFF) + ((imPix >> 0) & 0xFF))
/ 3; // Obtenemos la escala en grises.
// Binarizamos.
if (gray < 50) gray = 255;
else gray = 0;
imPixels[pos] =
0xFF000000 | gray << 16 | gray << 8 | gray; // Almacenamos la proyección inversa.
}
return imPixels; // Regresamos un vector que contiene los pixeles binarizados.
}
public static Bitmap applySaturationFilter(Bitmap source, int level) {
// get image size
int width = source.getWidth();
int height = source.getHeight();
int[] pixels = new int[width * height];
float[] HSV = new float[3];
// get pixel array from source
source.getPixels(pixels, 0, width, 0, 0, width, height);
int index = 0;
// iteration through pixels
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
// get current index in 2D-matrix
index = y * width + x;
// convert to HSV
Color.colorToHSV(pixels[index], HSV);
// increase Saturation level
HSV[1] *= level;
HSV[1] = (float) Math.max(0.0, Math.min(HSV[1], 1.0));
// take color back
pixels[index] |= Color.HSVToColor(HSV);
}
}
// output bitmap
Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
return bmOut;
}
/** Generate a direct RGB {@link ByteBuffer} from a {@link Bitmap}. */
private static ByteBuffer convertToRGB(Bitmap argbBitmap) {
// TODO: Optimize this.
int width = argbBitmap.getWidth();
int height = argbBitmap.getHeight();
ByteBuffer buf = ByteBuffer.allocateDirect(BYTES_PER_RGB_PIX * width * height);
int[] pixelRow = new int[width];
byte[] finalRow = new byte[BYTES_PER_RGB_PIX * width];
for (int i = 0; i < height; i++) {
argbBitmap.getPixels(
pixelRow, /*offset*/
0, /*stride*/
width, /*x*/
0, /*y*/
i,
/*width*/ width, /*height*/
1);
for (int j = 0; j < width; j++) {
colorToRgb(pixelRow[j], j * BYTES_PER_RGB_PIX, /*out*/ finalRow);
}
buf.put(finalRow);
}
buf.rewind();
return buf;
}
/** Factory function to load a texture from the APK. */
public static Texture loadTextureFromApk(String fileName, AssetManager assets) {
InputStream inputStream = null;
try {
inputStream = assets.open(fileName, AssetManager.ACCESS_BUFFER);
BufferedInputStream bufferedStream = new BufferedInputStream(inputStream);
Bitmap bitMap = BitmapFactory.decodeStream(bufferedStream);
int[] data = new int[bitMap.getWidth() * bitMap.getHeight()];
bitMap.getPixels(data, 0, bitMap.getWidth(), 0, 0, bitMap.getWidth(), bitMap.getHeight());
// Convert:
byte[] dataBytes = new byte[bitMap.getWidth() * bitMap.getHeight() * 4];
for (int p = 0; p < bitMap.getWidth() * bitMap.getHeight(); ++p) {
int colour = data[p];
dataBytes[p * 4] = (byte) (colour >>> 16); // R
dataBytes[p * 4 + 1] = (byte) (colour >>> 8); // G
dataBytes[p * 4 + 2] = (byte) colour; // B
dataBytes[p * 4 + 3] = (byte) (colour >>> 24); // A
}
Texture texture = new Texture();
texture.mWidth = bitMap.getWidth();
texture.mHeight = bitMap.getHeight();
texture.mChannels = 4;
texture.mData = dataBytes;
return texture;
} catch (IOException e) {
DebugLog.LOGE("Failed to log texture '" + fileName + "' from APK");
DebugLog.LOGI(e.getMessage());
return null;
}
}
// ==============================================================================
public final int[] renderGlyph(
char glyph, Paint paint, android.graphics.Matrix matrix, Rect bounds) {
Path p = new Path();
paint.getTextPath(String.valueOf(glyph), 0, 1, 0.0f, 0.0f, p);
RectF boundsF = new RectF();
p.computeBounds(boundsF, true);
matrix.mapRect(boundsF);
boundsF.roundOut(bounds);
bounds.left--;
bounds.right++;
final int w = bounds.width();
final int h = bounds.height();
Bitmap bm = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
Canvas c = new Canvas(bm);
matrix.postTranslate(-bounds.left, -bounds.top);
c.setMatrix(matrix);
c.drawPath(p, paint);
final int sizeNeeded = w * h;
if (cachedRenderArray.length < sizeNeeded) cachedRenderArray = new int[sizeNeeded];
bm.getPixels(cachedRenderArray, 0, w, 0, 0, w, h);
bm.recycle();
return cachedRenderArray;
}
@Override
public void run() {
int w = getWidth();
int h = getHeight();
float wipeArea = 0;
float totalArea = w * h;
Bitmap bitmap = mBitmap;
int[] mPixels = new int[w * h];
// 获取bitmap的所有像素信息
bitmap.getPixels(mPixels, 0, w, 0, 0, w, h);
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++) {
int index = i + j * w;
if (mPixels[index] == 0) {
wipeArea++;
}
}
// 计算已扫区域所占的比例
if (wipeArea > 0 && totalArea > 0) {
int percent = (int) (wipeArea * 100 / totalArea);
Log.v("czm", "percent=" + percent);
if (percent > 70) {
// 清除图层区域
mCompleted = true;
postInvalidate();
}
}
};
/** Copy the heightmap data into a vertex buffer object. */
private float[] loadBitmapData(Bitmap bitmap) {
final int[] pixels = new int[width * height];
bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
bitmap.recycle();
final float[] heightmapVertices = new float[width * height * POSITION_COMPONENT_COUNT];
int offset = 0;
for (int row = 0; row < height; row++) {
for (int col = 0; col < width; col++) {
// The heightmap will lie flat on the XZ plane and centered
// around (0, 0), with the bitmap width mapped to X and the
// bitmap height mapped to Z, and Y representing the height. We
// assume the heightmap is grayscale, and use the value of the
// red color to determine the height.
final float xPosition = (((float) col / (float) (width - 1)) - 0.5f) * 20;
final float yPosition =
((float) Color.red(pixels[(row * height) + col]) / (float) 255) * 1f;
final float zPosition = (((float) row / (float) (height - 1)) - 0.5f) * 20;
heightmapVertices[offset++] = xPosition;
heightmapVertices[offset++] = yPosition;
heightmapVertices[offset++] = zPosition;
}
}
return heightmapVertices;
}
@Override
public Bitmap filter(Bitmap bitmap) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Logger.v(name + ", multiplier: " + multiplier + ", divider: " + divider + ", bias: " + bias);
if (bitmap == null || divider == 0 || (multiplier == 1 && divider == 1 && bias == 0)) {
Logger.e("parameter error (bitmap null, divider is zero, or given filter has no effect)");
return null;
}
int[] bitmapBytes = new int[width * height];
bitmap.getPixels(bitmapBytes, 0, width, 0, 0, width, height);
int color;
for (int i = 0; i < bitmapBytes.length; i++) {
color = bitmapBytes[i];
bitmapBytes[i] =
Color.rgb(
forcepin(0, r(color) * multiplier / divider + bias, 255),
forcepin(0, g(color) * multiplier / divider + bias, 255),
forcepin(0, b(color) * multiplier / divider + bias, 255));
}
return Bitmap.createBitmap(bitmapBytes, width, height, bitmap.getConfig());
}
@Override
public void run(Canvas canvas, Bitmap bitmap) {
setChanged();
notifyStatus(NOTIFY_STATES.COMMAND_STARTED);
if (mClickedPixel == null) {
setChanged();
notifyStatus(NOTIFY_STATES.COMMAND_FAILED);
return;
}
int colorToReplace = bitmap.getPixel(mClickedPixel.x, mClickedPixel.y);
int pixels[] = new int[bitmap.getWidth() * bitmap.getHeight()];
bitmap.getPixels(pixels, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
QueueLinearFloodFiller.floodFill(
pixels,
bitmap.getWidth(),
bitmap.getHeight(),
mClickedPixel,
colorToReplace,
mPaint.getColor(),
SELECTION_THRESHOLD);
bitmap.setPixels(pixels, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
setChanged();
notifyStatus(NOTIFY_STATES.COMMAND_DONE);
}
@Override
public void run(Canvas canvas, Bitmap bitmap) {
notifyStatus(NOTIFY_STATES.COMMAND_STARTED);
if (mClickedPixel == null) {
setChanged();
notifyStatus(NOTIFY_STATES.COMMAND_FAILED);
return;
}
if (PaintroidApplication.savedPictureUri == null
&& PaintroidApplication.commandManager.getNumberOfCommands()
== EMPTY_COMMAND_LIST_LENGTH + 1) {
canvas.drawColor(mPaint.getColor());
Log.w(PaintroidApplication.TAG, "Fill Command color: " + mPaint.getColor());
} else {
int colorToReplace = bitmap.getPixel(mClickedPixel.x, mClickedPixel.y);
int pixels[] = new int[bitmap.getWidth() * bitmap.getHeight()];
bitmap.getPixels(pixels, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
QueueLinearFloodFiller.floodFill(
pixels,
bitmap.getWidth(),
bitmap.getHeight(),
mClickedPixel,
colorToReplace,
mPaint.getColor(),
SELECTION_THRESHOLD);
bitmap.setPixels(pixels, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
}
notifyStatus(NOTIFY_STATES.COMMAND_DONE);
}
public RGBLuminanceSource(Bitmap bitmap) {
super(bitmap.getWidth(), bitmap.getHeight());
int width = bitmap.getWidth();
int height = bitmap.getHeight();
int[] pixels = new int[width * height];
bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
// In order to measure pure decoding speed, we convert the entire image
// to a greyscale array
// up front, which is the same as the Y channel of the
// YUVLuminanceSource in the real app.
luminances = new byte[width * height];
for (int y = 0; y < height; y++) {
int offset = y * width;
for (int x = 0; x < width; x++) {
int pixel = pixels[offset + x];
int r = (pixel >> 16) & 0xff;
int g = (pixel >> 8) & 0xff;
int b = pixel & 0xff;
if (r == g && g == b) {
// Image is already greyscale, so pick any channel.
luminances[offset + x] = (byte) r;
} else {
// Calculate luminance cheaply, favoring green.
luminances[offset + x] = (byte) ((r + g + g + b) >> 2);
}
}
}
}
public static Bitmap applySnowEffect(Bitmap source) {
// get image size
int width = source.getWidth();
int height = source.getHeight();
int[] pixels = new int[width * height];
// get pixel array from source
source.getPixels(pixels, 0, width, 0, 0, width, height);
// random object
Random random = new Random();
int R, G, B, index = 0, thresHold = 50;
// iteration through pixels
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
// get current index in 2D-matrix
index = y * width + x;
// get color
R = Color.red(pixels[index]);
G = Color.green(pixels[index]);
B = Color.blue(pixels[index]);
// generate threshold
thresHold = random.nextInt(COLOR_MAX);
if (R > thresHold && G > thresHold && B > thresHold) {
pixels[index] = Color.rgb(255, 255, 255);
}
}
}
// output bitmap
Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
return bmOut;
}
// 版画效果函数
public static Bitmap changeToBlock(Bitmap bitmap) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
int dst[] = new int[width * height];
bitmap.getPixels(dst, 0, width, 0, 0, width, height);
int iPixel = 0;
int i, j, color, pos;
for (j = 0; j < height; j++) {
for (i = 0; i < width; i++) {
pos = j * width + i;
color = dst[pos];
int avg = (Color.red(color) + Color.green(color) + Color.blue(color)) / 3;
if (avg >= 100) iPixel = 255;
else iPixel = 0;
dst[pos] = Color.rgb(iPixel, iPixel, iPixel);
}
}
Bitmap bmpReturn = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
bmpReturn.setPixels(dst, 0, width, 0, 0, width, height);
return bmpReturn;
}
public RGBLuminanceSource(Bitmap bitmap) {
super(bitmap.getWidth(), bitmap.getHeight());
// 得到图片的宽高
int width = bitmap.getWidth();
int height = bitmap.getHeight();
// 得到图片的像素
int[] pixels = new int[width * height];
//
bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
// 为了测量纯解码速度,我们将整个图像灰度阵列前面,这是一样的通道
// YUVLuminanceSource在现实应用。
// 得到像素大小的字节数
luminances = new byte[width * height];
// 得到图片每点像素颜色
for (int y = 0; y < height; y++) {
int offset = y * width;
for (int x = 0; x < width; x++) {
int pixel = pixels[offset + x];
int r = (pixel >> 16) & 0xff;
int g = (pixel >> 8) & 0xff;
int b = pixel & 0xff;
// 当某一点三种颜色值相同时，相应字节对应空间赋值为其值
if (r == g && g == b) {
luminances[offset + x] = (byte) r;
}
// 其它情况字节空间对应赋值为：
else {
luminances[offset + x] = (byte) ((r + g + g + b) >> 2);
}
}
}
}
/**
* Get the white icon corresponding to a poiType.
*
* @param poiType the PoiType or null for notes.
* @return The white icon.
*/
public Drawable getIconWhite(PoiType poiType) {
Bitmap myBitmap =
BitmapFactory.decodeResource(
context.getResources(),
poiType == null ? R.drawable.open_book : getIconDrawableId(poiType));
myBitmap = myBitmap.copy(myBitmap.getConfig(), true);
int[] allpixels = new int[myBitmap.getHeight() * myBitmap.getWidth()];
myBitmap.getPixels(
allpixels, 0, myBitmap.getWidth(), 0, 0, myBitmap.getWidth(), myBitmap.getHeight());
for (int i = 0; i < myBitmap.getHeight() * myBitmap.getWidth(); i++) {
if (allpixels[i] != 0) {
int A = Color.alpha(allpixels[i]);
// inverting byte for each R/G/B channel
int R = 255 - Color.red(allpixels[i]);
int G = 255 - Color.green(allpixels[i]);
int B = 255 - Color.blue(allpixels[i]);
// set newly-inverted pixel to output image
allpixels[i] = Color.argb(A, R, G, B);
}
}
myBitmap.setPixels(
allpixels, 0, myBitmap.getWidth(), 0, 0, myBitmap.getWidth(), myBitmap.getHeight());
return new BitmapDrawable(context.getResources(), myBitmap);
}
public void loadFromCroppedColorArray(int x, int y, int width, int height) {
int[] pixels = new int[width * height];
mOriginalBitmap.getPixels(pixels, 0, width, x, y, width, height);
CloseableReference<Bitmap> bitmapRef =
mBitmapFactory.createBitmap(pixels, width, height, mOriginalBitmap.getConfig());
setImageBitmap(bitmapRef);
checkValid(bitmapRef, Bitmap.createBitmap(pixels, width, height, mOriginalBitmap.getConfig()));
}
/**
* Fast Gaussian blurring algorithm source:
* https://github.com/patrickfav/BlurTestAndroid/blob/master/BlurBenchmark/src/main/java/at/favre/app/blurbenchmark/blur/algorithms/GaussianFastBlur.java
*/
@NonNull
public static Bitmap applyFastGaussianBlurToBitmap(@NonNull Bitmap mutableBitmap, int radius) {
int w = mutableBitmap.getWidth();
int h = mutableBitmap.getHeight();
int[] pixels = new int[w * h];
mutableBitmap.getPixels(pixels, 0, w, 0, 0, w, h);
for (int r = radius; r >= 1; r /= 2) {
for (int i = r; i < h - r; i++) {
for (int j = r; j < w - r; j++) {
int tl = pixels[(i - r) * w + j - r];
int tr = pixels[(i - r) * w + j + r];
int tc = pixels[(i - r) * w + j];
int bl = pixels[(i + r) * w + j - r];
int br = pixels[(i + r) * w + j + r];
int bc = pixels[(i + r) * w + j];
int cl = pixels[i * w + j - r];
int cr = pixels[i * w + j + r];
pixels[(i * w) + j] =
0xFF000000
| (((tl & 0xFF)
+ (tr & 0xFF)
+ (tc & 0xFF)
+ (bl & 0xFF)
+ (br & 0xFF)
+ (bc & 0xFF)
+ (cl & 0xFF)
+ (cr & 0xFF))
>> 3)
& 0xFF
| (((tl & 0xFF00)
+ (tr & 0xFF00)
+ (tc & 0xFF00)
+ (bl & 0xFF00)
+ (br & 0xFF00)
+ (bc & 0xFF00)
+ (cl & 0xFF00)
+ (cr & 0xFF00))
>> 3)
& 0xFF00
| (((tl & 0xFF0000)
+ (tr & 0xFF0000)
+ (tc & 0xFF0000)
+ (bl & 0xFF0000)
+ (br & 0xFF0000)
+ (bc & 0xFF0000)
+ (cl & 0xFF0000)
+ (cr & 0xFF0000))
>> 3)
& 0xFF0000;
}
}
}
mutableBitmap.setPixels(pixels, 0, w, 0, 0, w, h);
return mutableBitmap;
}
public static int[] getPixelsARGB_8888(final Bitmap pBitmap) {
final int w = pBitmap.getWidth();
final int h = pBitmap.getHeight();
final int[] pixelsARGB_8888 = new int[w * h];
pBitmap.getPixels(pixelsARGB_8888, 0, w, 0, 0, w, h);
return pixelsARGB_8888;
}
public static Bitmap sharpenImageAmeliorate(Bitmap bmp) {
if (ImageCache.get("sharpenImageAmeliorate") != null) {
return ImageCache.get("sharpenImageAmeliorate");
}
int[] laplacian = new int[] {-1, -1, -1, -1, 9, -1, -1, -1, -1};
int width = bmp.getWidth();
int height = bmp.getHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
int pixR = 0;
int pixG = 0;
int pixB = 0;
int pixColor = 0;
int newR = 0;
int newG = 0;
int newB = 0;
int idx = 0;
float alpha = 0.3F;
int[] pixels = new int[width * height];
bmp.getPixels(pixels, 0, width, 0, 0, width, height);
for (int i = 1, length = height - 1; i < length; i++) {
for (int k = 1, len = width - 1; k < len; k++) {
idx = 0;
for (int m = -1; m <= 1; m++) {
for (int n = -1; n <= 1; n++) {
pixColor = pixels[(i + n) * width + k + m];
pixR = Color.red(pixColor);
pixG = Color.green(pixColor);
pixB = Color.blue(pixColor);
newR = newR + (int) (pixR * laplacian[idx] * alpha);
newG = newG + (int) (pixG * laplacian[idx] * alpha);
newB = newB + (int) (pixB * laplacian[idx] * alpha);
idx++;
}
}
newR = Math.min(255, Math.max(0, newR));
newG = Math.min(255, Math.max(0, newG));
newB = Math.min(255, Math.max(0, newB));
pixels[i * width + k] = Color.argb(255, newR, newG, newB);
newR = 0;
newG = 0;
newB = 0;
}
}
bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
ImageCache.put("sharpenImageAmeliorate", bitmap);
return bitmap;
}
public void getRGB(
final int[] rgbData,
final int offset,
final int scanlength,
final int x,
final int y,
final int width,
final int height) {
bitmap.getPixels(rgbData, offset, scanlength, x, y, width, height);
}
/** アプリ一覧で、あるアプリがクリックされたときのアクションです。 */
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
final AppInfo appInfo = (AppInfo) parent.getItemAtPosition(position);
BitmapDrawable icon = (BitmapDrawable) appInfo.getIcon();
final Bitmap bmp = Bitmap.createBitmap(320, 320, Config.ARGB_8888);
final Canvas canvas = new Canvas(bmp);
Paint paint = new Paint();
paint.setDither(true);
canvas.drawBitmap(
((BitmapDrawable) icon).getBitmap(),
null,
new Rect(0, 0, bmp.getWidth() - 1, bmp.getHeight() - 1),
paint);
final int[] pixels = new int[320 * 320];
bmp.getPixels(pixels, 0, 320, 0, 0, 320, 320);
// Random Dithering で二値化する
final Random rand = new Random();
for (int i = 0; i < pixels.length; i++) {
final int p = pixels[i];
// y=0.587*g+0.299*r+0.114b
final int y =
Color.green(p) * 587 / 1000 //
+ Color.red(p) * 299 / 1000 //
+ Color.blue(p) * 114 / 1000;
final int blackOrWhite = (y < rand.nextInt(256)) ? 0 : 255;
pixels[i] = Color.argb(0xff, blackOrWhite, blackOrWhite, blackOrWhite);
}
// 二値化されたデータを印刷用ラスターデータに変換する
// TODO 二値化の際に変換も一緒に行ったほうが効率的
final int bmpWidth = bmp.getWidth();
final int bmpHeight = bmp.getHeight();
final int black = Color.argb(0xff, 0, 0, 0);
byte[][] rasterData = new byte[bmpWidth][];
for (int w = 0; w < rasterData.length; w++) {
final byte[] line = new byte[4 /*印刷されない領域分*/ + bmp.getHeight() / 8];
int d = 0;
for (int h = 0; h < bmpHeight; h++) {
final int index = h * bmpWidth + w;
d <<= 1;
d += (pixels[index] == black ? 1 : 0);
if (h % 8 == 7) {
line[4 + h / 8] = (byte) d;
}
}
rasterData[w] = line;
}
final Intent intent = new Intent(this, PrintActivity.class);
intent.putExtra("data", rasterData);
startActivity(intent);
}
public void loadFromColorArray() {
int[] pixels = new int[mOriginalWidth * mOriginalHeight];
mOriginalBitmap.getPixels(pixels, 0, mOriginalWidth, 0, 0, mOriginalWidth, mOriginalHeight);
CloseableReference<Bitmap> bitmapRef =
mBitmapFactory.createBitmap(
pixels, mOriginalWidth, mOriginalHeight, mOriginalBitmap.getConfig());
setImageBitmap(bitmapRef);
checkValid(
bitmapRef,
Bitmap.createBitmap(pixels, mOriginalWidth, mOriginalHeight, mOriginalBitmap.getConfig()));
}
void initializeSoftCursor() {
Bitmap bm = BitmapFactory.decodeResource(getResources(), R.drawable.cursor);
int w = bm.getWidth();
int h = bm.getHeight();
int[] tempPixels = new int[w * h];
bm.getPixels(tempPixels, 0, w, 0, 0, w, h);
// Set cursor rectangle as well.
bitmapData.setCursorRect(pointer.mouseX, pointer.mouseY, w, h, 0, 0);
// Set softCursor to whatever the resource is.
bitmapData.setSoftCursor(tempPixels);
bm.recycle();
}
public static Bitmap sunshine(Bitmap bmp, int centerX, int centerY) {
final int width = bmp.getWidth();
final int height = bmp.getHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
int pixR = 0;
int pixG = 0;
int pixB = 0;
int pixColor = 0;
int newR = 0;
int newG = 0;
int newB = 0;
int radius = Math.min(centerX, centerY);
final float strength = 150F;
int[] pixels = new int[width * height];
bmp.getPixels(pixels, 0, width, 0, 0, width, height);
int pos = 0;
for (int i = 1, length = height - 1; i < length; i++) {
for (int k = 1, len = width - 1; k < len; k++) {
pos = i * width + k;
pixColor = pixels[pos];
pixR = Color.red(pixColor);
pixG = Color.green(pixColor);
pixB = Color.blue(pixColor);
newR = pixR;
newG = pixG;
newB = pixB;
int distance = (int) (Math.pow((centerY - i), 2) + Math.pow(centerX - k, 2));
if (distance < radius * radius) {
int result = (int) (strength * (1.0 - Math.sqrt(distance) / radius));
newR = pixR + result;
newG = pixG + result;
newB = pixB + result;
}
newR = Math.min(255, Math.max(0, newR));
newG = Math.min(255, Math.max(0, newG));
newB = Math.min(255, Math.max(0, newB));
pixels[pos] = Color.argb(255, newR, newG, newB);
}
}
bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
return bitmap;
}
public Bitmap getResBitmapMutable(Resources res, int bmpResId) {
Options opts = new Options();
opts.inDither = false;
Bitmap b = BitmapFactory.decodeResource(res, bmpResId, opts);
int w = b.getWidth();
int h = b.getHeight();
Bitmap mutable = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
int[] pixels = new int[w * h];
b.getPixels(pixels, 0, w, 0, 0, w, h);
mutable.setPixels(pixels, 0, w, 0, 0, w, h);
return mutable;
}
private static void updateForView(final RFBClient client, View view) {
view.setDrawingCacheEnabled(true);
// view.destroyDrawingCache();
// view.buildLayer();
// Bitmap bm = Bitmap.createBitmap( view.getMeasuredWidth(), view.getMeasuredHeight(),
// Bitmap.Config.ARGB_8888);
// Canvas c = new Canvas(bm);
// view.invalidate();
// view.forceLayout();
// view.layout(0, 0, view.getLayoutParams().width, view.getLayoutParams().height);
// view.draw(c);
//
// view.getDrawingCache();
Bitmap cache = view.getDrawingCache();
// Canvas renderC = new Canvas(cache);
// view.destroyDrawingCache();
// view.layout(0, 0, cache.getWidth(), cache.getHeight());
// view.draw(renderC);
// view.buildDrawingCache(false);
int[] location = new int[2];
view.getLocationOnScreen(location);
int[] pixels = new int[cache.getWidth() * cache.getHeight()];
cache.getPixels(
pixels,
0,
cache.getWidth(),
view.getLeft(),
view.getTop(),
cache.getWidth(),
cache.getHeight());
Rect rect =
Rect.encode(
client.getPreferredEncoding(),
pixels,
client.getPixelFormat(),
cache.getWidth(),
view.getLeft(),
view.getTop(),
cache.getWidth(),
cache.getHeight());
rect.transform(location[0], location[1]);
Rect[] rects = {rect};
try {
client.writeFrameBufferUpdate(rects);
} catch (IOException e) {
Log.e("RemoteDisplay", "error while sending update rect", e);
}
}
@Override
public void run() {
for (int x = mCurrentX; x < mMaxX; x++) {
mCallback.run();
for (int y = mCurrentY; y < mMaxY; y++) {
int tileindex =
mRenderer.findBestFit(
mRenderer.mColors[x][y], x, y, mRenderer.mTileCountX, mRenderer.mTileCountY);
String path = mRenderer.mTileList.get(tileindex).getFilePath();
int[] tilepixels;
if (mRenderer.mExportedTiles.containsKey(path)) {
tilepixels = mRenderer.mExportedTiles.get(path);
} else {
tilepixels = new int[mRenderer.mTileWidth * mRenderer.mTileHeight];
Bitmap origtile;
if (mRenderer.mTileList.get(tileindex).isInternal()) {
origtile =
BitmapFactory.decodeResource(
mRenderer.mBasecontext.getResources(), Integer.parseInt(path));
} else {
origtile = BitmapFactory.decodeFile(path);
}
if (origtile == null) {
System.out.println("Bild nicht vorhanden: " + path);
continue;
}
Bitmap tile =
Bitmap.createScaledBitmap(
origtile, mRenderer.mTileWidth, mRenderer.mTileHeight, false);
// origtile.recycle();
tile.getPixels(
tilepixels,
0,
mRenderer.mTileWidth,
0,
0,
mRenderer.mTileWidth,
mRenderer.mTileHeight);
mRenderer.mExportedTiles.put(path, tilepixels);
}
// System.out.println("current: x=" +x +" y="+y);
mRenderer.setPixels(tilepixels, x, y);
}
}
mCallback.run();
}
void addPngTexture(String fn, int kind, boolean transparentWhite) {
InputStream istr;
Bitmap bitmap = null;
try {
istr = assets.open(fn);
bitmap = BitmapFactory.decodeStream(istr);
int w = bitmap.getWidth();
int h = bitmap.getHeight();
int[] pixels = new int[h * w];
bitmap.getPixels(pixels, 0, w, 0, 0, w, h);
GameLibJNIWrapper.add_intarr_texture(w, h, pixels, kind, transparentWhite);
} catch (IOException e) {
// handle exception
}
}