/** * Chuyển đổi thành góc bo tròn * * @param bmp * @param roundpx * @return */ public static bitmap converttoroundedcorner(bitmap bmp, float roundpx) { .

  .

        bitmap newbmp = bitmap.createbitmap(bmp.getwidth(), bmp.getwidth(), config.argb_8888); // Lấy canvas canvas = new canvas(newbmp),

        int cuối cùng màu = 0xff424242; sơn cuối cùng sơn = sơn mới(); rect cuối cùng rect = rect mới(0, 0, bmp.getwidth(), bmp.getwidth()); rectf cuối cùng rectf = rectf(rect) mới,

        paint.setantialias(true); canvas.drawargb(0, 0, 0, 0); paint.setcolor(color); // Nếu tham số thứ hai và thứ ba giống nhau, một góc của hình tròn sẽ được vẽ, nếu không, một góc của hình elip sẽ được vẽ canvas.drawroundrect(rectf, roundpx, roundpx, paint),

        paint.setxfermode(new porterduffxfermode(mode.src_in)); canvas.drawbitmap(bmp, rect, rect, paint),

        trả về newbmp; }.

/** * Chuyển đổi ảnh màu thành ảnh đen trắng * * @param bitmap * @return Trả về ảnh bitmap đã chuyển đổi */ public static bitmap converttoblackwhite(bitmap bmp) { int width = bmp.getwidth(); // Lấy chiều rộng của ảnh bitmap int height = bmp.getheight(); // Lấy chiều cao của ảnh bitmap.

  .

        int[] pixel = new int[width * height]; // Tạo một mảng pixel dựa trên kích thước của ảnh bitmap.

        bmp.getpixels(pixel, 0, chiều rộng, 0, 0, chiều rộng, chiều cao); int alpha = 0xff << 24; đối với (int i = 0; i < chiều cao; i++) { đối với (int j = 0; j < chiều rộng; j++) { int grey = pixel[chiều rộng * i + j],

                int đỏ = ((xám & 0x00ff0000) >> 16); int xanh lá cây = ((xám & 0x0000ff00) >> 8); int xanh lam = (xám & 0x000000ff),

                xám = (int) (đỏ * 0,3 + xanh lá cây * 0,59 + xanh lam * 0,11); xám = alpha | (xám << 16) | (xám << 8) | xám; pixel[chiều rộng * i + j] = xám; } } bitmap newbmp = bitmap.createbitmap(chiều rộng, chiều cao, config.rgb_565); newbmp.setpixels(pixel, 0, chiều rộng, 0, 0, chiều rộng, chiều cao); trả về newbmp; } .

/** * Làm mờ theo chuẩn Gauss * * @param bmp * @return */ public static bitmap converttoblur(bitmap bmp) { // Ma trận Gauss int[] gauss = new int[] { 1, 2, 1, 2, 4, 2, 1, 2, 1 },

  .

        int width = bmp.getwidth(); int height = bmp.getheight(); bitmap newbmp = bitmap.createbitmap(width, height, bitmap.config.rgb_565),

        số nguyên pixr = 0; số nguyên pixg = 0; số nguyên pixb = 0,

        int pixcolor = 0,

        int newr = 0; int newg = 0; int newb = 0,

        int delta = 16; // Giá trị càng nhỏ thì hình ảnh càng sáng và giá trị càng lớn thì hình ảnh càng tối.

        int idx = 0; int[] pixel = new int[chiều rộng * chiều cao]; bmp.getpixels(pixel, 0, chiều rộng, 0, 0, chiều rộng, chiều cao); đối với (int i = 1, chiều dài = chiều cao - 1; i < chiều dài; i++) { đối với (int k = 1, len = chiều rộng - 1; k < len; k++) { idx = 0; đối với (int m = -1; m <= 1; m++) { đối với (int n = -1; n <= 1; n++) { pixcolor = pixel[(i + m) * chiều rộng + k + n]; pixr = màu.đỏ(pixcolor); pixg = màu.xanh lá cây(pixcolor); pixb = màu.xanh lam(pixcolor),

                        newr = newr + pixr * gauss[idx]; newg = newg + pixg * gauss[idx]; newb = newb + pixb * gauss[idx]; idx++; } } .

                newr /= delta; newg /= delta; newb /= delta,

                newr = math.min(255, math.max(0, newr)); newg = math.min(255, math.max(0, newg)); newb = math.min(255, math.max(0, newb)),

                pixel[i * chiều rộng + k] = color.argb(255, newr, newg, newb),

                newr = 0; newg = 0; newb = 0; } } .

        newbmp.setpixels(pixel, 0, chiều rộng, 0, 0, chiều rộng, chiều cao),

        trả về newbmp; }.

/** * Hiệu ứng phác thảo * * @param bmp * @return */ public static bitmap converttosketch(bitmap bmp) { int pos, row, col, clr; int width = bmp.getwidth(); int height = bmp.getheight(); int[] pixsrc = new int[width * height]; int[] pixnvt = new int[width * height]; // Đầu tiên xử lý các pixel của hình ảnh thành màu xám rồi phủ định chúng bmp.getpixels(pixsrc, 0, width, 0, 0, width, height),

  .

        đối với (hàng = 0; hàng < chiều cao; hàng++) { đối với (cột = 0; cột < chiều rộng; cột++) { pos = hàng * chiều rộng + cột; pixsrc[pos] = (màu.đỏ(pixsrc[pos]) + màu.xanh lá cây(pixsrc[pos]) + màu.xanh lam(pixsrc[pos])) / 3; pixnvt[pos] = 255 - pixsrc[pos]; } } .

        // Làm mờ Gaussian các điểm ảnh đảo ngược. Có thể thiết lập cường độ. Nó được thiết lập tạm thời là 5.0 gaussgray(pixnvt, 5.0, 5.0, width, height),

        // Phép toán khác biệt giữa màu thang độ xám và điểm ảnh mờ đối với (hàng = 0; hàng < chiều cao; hàng++) { đối với (cột = 0; cột < chiều rộng; cột++) { pos = hàng * chiều rộng + cột,

                clr = pixsrc[vị trí] << 8; clr /= 256 - pixnvt[vị trí]; clr = math.min(clr, 255),

                pixsrc[pos] = color.rgb(clr, clr, clr); } } bmp.setpixels(pixsrc, 0, chiều rộng, 0, 0, chiều rộng, chiều cao),

        trả về bmp,

    }.

    private static int gaussgray(int[] psrc, double horz, double vert, int width, int height) { int[] dst, src; double[] n_p, n_m, d_p, d_m, bd_p, bd_m; double[] val_p, val_m; int i, j, t, k, row, col, terms; int[] initial_p, initial_m; double std_dev; int row_stride = width; int max_len = math.max(width, height); int sp_p_idx, sp_m_idx, vp_idx, vm_idx,

        val_p = double mới[max_len]; val_m = double mới[max_len],

        n_p = đôi mới[5]; n_m = đôi mới[5]; d_p = đôi mới[5]; d_m = đôi mới[5]; bd_p = đôi mới[5]; bd_m = đôi mới[5],

        src = int mới[max_len]; dst = int mới[max_len],

        initial_p = int mới[4]; initial_m = int mới[4],

        // Hướng dọc nếu (vert > 0.0) { vert = math.abs(vert) + 1.0; std_dev = math.sqrt(-(vert * vert) / (2 * math.log(1.0 / 255.0))),

            // Khởi tạo hằng số findconstants(n_p, n_m, d_p, d_m, bd_p, bd_m, std_dev),

            đối với (col = 0; col < chiều rộng; col++) { đối với (k = 0; k < chiều dài tối đa; k++) { val_m[k] = val_p[k] = 0; } .

                đối với (t = 0; t < chiều cao; t++) { src[t] = psrc[t * row_stride + col]; } .

                sp_p_idx = 0; sp_m_idx = chiều cao - 1; vp_idx = 0; vm_idx = chiều cao - 1,

                initial_p[0] = src[0]; initial_m[0] = src[chiều cao - 1],

                đối với (hàng = 0; hàng < chiều cao; hàng++) { các điều khoản = (hàng < 4) ? hàng : 4,

                    đối với (i = 0; i <= các số hạng; i++) { val_p[vp_idx] += n_p[i] * src[sp_p_idx - i] - d_p[i] * val_p[vp_idx - i]; val_m[vm_idx] += n_m[i] * src[sp_m_idx + i] - d_m[i] * val_m[vm_idx + i]; } đối với (j = i; j <= 4; j++) { val_p[vp_idx] += (n_p[j] - bd_p[j]) * initial_p[0]; val_m[vm_idx] += (n_m[j] - bd_m[j]) * initial_m[0]; } .

                    sp_p_idx++; sp_m_idx--; vp_idx++; vm_idx--; }.

                chuyển gausspixels(val_p, val_m, dst, 1, chiều cao),

                đối với (t = 0; t < chiều cao; t++) { psrc[t * khoảng cách hàng + cột] = dst[t]; } } } .

        // Hướng ngang nếu (horz > 0.0) { horz = math.abs(horz) + 1.0,

            nếu (horz != vert) { std_dev = math.sqrt(-(horz * horz) / (2 * math.log(1.0 / 255.0))),

                // Khởi tạo hằng số findconstants(n_p, n_m, d_p, d_m, bd_p, bd_m, std_dev); }.

            đối với (hàng = 0; hàng < chiều cao; hàng++) { đối với (k = 0; k < chiều dài tối đa; k++) { val_m[k] = val_p[k] = 0; } .

                đối với (t = 0; t < chiều rộng; t++) { src[t] = psrc[hàng * khoảng cách hàng + t]; }.

                sp_p_idx = 0; sp_m_idx = chiều rộng - 1; vp_idx = 0; vm_idx = chiều rộng - 1,

                initial_p[0] = src[0]; initial_m[0] = src[chiều rộng - 1],

                đối với (col = 0; col < chiều rộng; col++) { các điều khoản = (col < 4) ? col : 4,

                    đối với (i = 0; i <= các số hạng; i++) { val_p[vp_idx] += n_p[i] * src[sp_p_idx - i] - d_p[i] * val_p[vp_idx - i]; val_m[vm_idx] += n_m[i] * src[sp_m_idx + i] - d_m[i] * val_m[vm_idx + i]; } đối với (j = i; j <= 4; j++) { val_p[vp_idx] += (n_p[j] - bd_p[j]) * initial_p[0]; val_m[vm_idx] += (n_m[j] - bd_m[j]) * initial_m[0]; } .

                    sp_p_idx++; sp_m_idx--; vp_idx++; vm_idx--; }.

                transfergausspixels(val_p, val_m, dst, 1, chiều rộng),

                đối với (t = 0; t < chiều rộng; t++) { psrc[hàng * khoảng cách hàng + t] = dst[t]; } } } .

        trả về 0; } .

    private static void transfergausspixels(double[] src1, double[] src2, int[] dest, int bytes, int width) { int i, j, k, b; int bend = bytes * width; double sum,

        i = j = k = 0; đối với (b = 0; b < uốn cong; b++) { tổng = src1[i++] + src2[j++],

            nếu (tổng > 255) tổng = 255; nếu không nếu (tổng < 0) tổng = 0,

            đích[k++] = (int) tổng; } } .

    private static void findconstants(double[] n_p, double[] n_m, double[] d_p, double[] d_m, double[] bd_p, double[] bd_m, double std_dev) { double div = math.sqrt(2 * 3.141593) * std_dev; double x0 = -1.783 / std_dev; double x1 = -1.723 / std_dev; double x2 = 0.6318 / std_dev; double x3 = 1.997 / std_dev; double x4 = 1.6803 / div; double x5 = 3.735 / div; double x6 = -0.6803 / div; double x7 = -0.2598 / div; int i,

        sin (x2) - x7 * math.cos (x2) * math.sin (x3)) + x6 * math.exp (2 * x0) + x4 * math.exp (2 * x1) p (x0) * (x5 * math.sin (x2) - (2 * x6 + x4) * math.cos (x2)); sin (x3)) + x6 * math.exp (2 * x0) + x4 * math.exp (2 * x1)); (x7 * toán.sin(x3) - x6 * toán.cos(x3)) + toán.exp(x0 + 2 * x1) * (x5 * toán.sin(x2) - x4 * toán.cos(x2))); n_p[4] = 0,0,

        (x0 + 2 * x1) - 2 * toán.cos(x3) * toán.exp(x1 + 2 * x0); d_p[4] = toán.exp(2 * x0 + 2 * x1),

        đối với (i = 0; i <= 4; i++) { d_m[i] = d_p[i]; } .

        n_m[0] = 0,0; đối với (i = 1; i <= 4; i++) { n_m[i] = n_p[i] - d_p[i] * n_p[0]; } .

        tổng_n_p, tổng_n_m, tổng_d; tổng_a, b,

        tổng_n_p = 0,0; tổng_n_m = 0,0; tổng_d = 0,0,

        đối với (i = 0; i <= 4; i++) { tổng_n_p += n_p[i]; tổng_n_m += n_m[i]; tổng_d += d_p[i]; } .

        a = tổng_n_p / (1,0 + tổng_d); b = tổng_n_m / (1,0 + tổng_d),

        đối với (i = 0; i <= 4; i++) { bd_p[i] = d_p[i] * a; bd_m[i] = d_m[i] * b; } } .

/** * Làm sắc nét hình ảnh (biến đổi Laplace) * * @param bmp * @return */ public static bitmap sharpenimageameliorate(bitmap bmp) { .

  .

        // Ma trận Laplacian int[] laplacian = new int[] { -1, -1, -1, -1, 9, -1, -1, -1, -1, -1, -1 },

        int width = bmp.getwidth(); int height = bmp.getheight(); bitmap bitmap = bitmap.createbitmap(width, height, bitmap.config.rgb_565),

        số nguyên pixr = 0; số nguyên pixg = 0; số nguyên pixb = 0,

        int pixcolor = 0,

        int newr = 0; int newg = 0; int newb = 0,

        int idx = 0; float alpha = 0,3f; int[] pixel = new int[chiều rộng * chiều cao]; bmp.getpixels(pixel, 0, chiều rộng, 0, 0, chiều rộng, chiều cao); đối với (int i = 1, chiều dài = chiều cao - 1; i < chiều dài; i++) { đối với (int k = 1, len = chiều rộng - 1; k < len; k++) { idx = 0; đối với (int m = -1; m <= 1; m++) { đối với (int n = -1; n <= 1; n++) { pixcolor = pixel[(i + n) * chiều rộng + k + m]; pixr = màu.đỏ(pixcolor); pixg = màu.xanh lá cây(pixcolor); pixb = màu.xanh lam(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)),

                pixel[i * chiều rộng + k] = color.argb(255, newr, newg, newb); newr = 0; newg = 0; newb = 0; } } .

        bitmap.setpixels(pixel, 0, chiều rộng, 0, 0, chiều rộng, chiều cao); trả về bitmap; }.