Android中借助OpenCV将PNG从Java类传递至Native类的最优方案

Hey there! Let's walk through the most reliable way to get your 4-channel PNGs from the assets folder to the native layer, perform alpha blending with OpenCV, and keep that critical alpha channel intact. I’ll break this down step by step with code tailored to your setup.

Prerequisites #

First, make sure OpenCV is properly integrated into your project:

• Import the OpenCV 4.1.0 SDK as a module in Android Studio.
• Add the OpenCV module dependency to your app’s build.gradle file.
• Enable NDK support in your app’s build.gradle (set ndkVersion and configure externalNativeBuild if using CMake).

Step 1: Load PNG from Assets to Bitmap (Preserve Alpha) #

We need to read the PNG into an Android Bitmap that retains all 4 channels. Use Bitmap.Config.ARGB_8888—this is non-negotiable, as it stores alpha, red, green, and blue components each in 8 bits.

private Bitmap loadPngFromAssets(String filename) throws IOException {
    AssetManager assetManager = getAssets();
    InputStream is = assetManager.open(filename);
    // Decode with ARGB_8888 to keep the alpha channel
    Bitmap bitmap = BitmapFactory.decodeStream(is, null, new BitmapFactory.Options() {
        {
            inPreferredConfig = Bitmap.Config.ARGB_8888;
        }
    });
    is.close();
    return bitmap;
}

Repeat this for both PNG images you want to blend.

Step 2: Convert Bitmap to OpenCV Mat (4-Channel) #

OpenCV’s Mat needs to be in the correct format to hold 4 channels. Converting an ARGB_8888 Bitmap will create a CV_8UC4 Mat (8-bit unsigned, 4 channels), but note the channel order is BGRA (not ARGB like Android’s Bitmap—this matters for blending logic later).

// Convert Bitmap to OpenCV Mat
Mat srcMat = new Mat();
Utils.bitmapToMat(bitmap, srcMat);
// srcMat is now of type CV_8UC4 (BGRA)

Step 3: Pass Mat to Native Layer #

The simplest way to pass a Mat to native code is using its native object pointer. OpenCV’s Mat class has a nativeObj field (long type) that points to the underlying C++ Mat instance.

Java Native Method Declaration #

Add this to your Java class:

public native void performAlphaBlending(long mat1Addr, long mat2Addr, long dstMatAddr);

CMakeLists.txt Configuration #

Ensure your CMakeLists.txt links against OpenCV libraries:

cmake_minimum_required(VERSION 3.4.1)

# Adjust this path to match your OpenCV SDK location
set(OpenCV_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../opencv-4.1.0-android-sdk/sdk/native/jni)
find_package(OpenCV REQUIRED)

add_library(
             native-lib
             SHARED
             native-lib.cpp )

target_link_libraries(
                       native-lib
                       ${OpenCV_LIBS}
                       log )

Step 4: Alpha Blending in Native Code #

In your C++ code, retrieve the Mat instances from the pointers, then perform alpha blending. The standard formula accounts for per-pixel alpha:
dst_pixel = (src1_pixel * src1_alpha + src2_pixel * (1 - src1_alpha)) / combined_alpha

Here’s an optimized implementation using OpenCV matrix operations (faster than pixel-wise iteration):

#include <jni.h>
#include <opencv2/opencv.hpp>

using namespace cv;

extern "C" JNIEXPORT void JNICALL
Java_com_your_package_YourClass_performAlphaBlending(
        JNIEnv* env,
        jobject /* this */,
        jlong mat1Addr,
        jlong mat2Addr,
        jlong dstMatAddr) {

    // Get Mat instances from addresses
    Mat& src1 = *(Mat*)mat1Addr;
    Mat& src2 = *(Mat*)mat2Addr;
    Mat& dst = *(Mat*)dstMatAddr;

    // Validate input images
    if (src1.size() != src2.size() || src1.type() != CV_8UC4 || src2.type() != CV_8UC4) {
        __android_log_print(ANDROID_LOG_ERROR, "NativeBlend", "Images must be same size and 4-channel");
        return;
    }

    dst.create(src1.size(), CV_8UC4);

    // Split channels into B, G, R, A
    vector<Mat> src1_chans, src2_chans, dst_chans;
    split(src1, src1_chans);
    split(src2, src2_chans);

    // Convert alpha channels to float (0-1 range)
    Mat alpha1 = src1_chans[3] / 255.0f;
    Mat alpha2 = src2_chans[3] / 255.0f;
    Mat combined_alpha = alpha1 + alpha2.mul(1 - alpha1);

    // Blend each color channel
    for (int i = 0; i < 3; i++) {
        dst_chans.push_back((src1_chans[i].mul(alpha1) + src2_chans[i].mul(alpha2.mul(1 - alpha1))).div(combined_alpha));
    }
    // Add combined alpha channel back
    dst_chans.push_back(combined_alpha * 255);

    // Merge channels into final destination Mat
    merge(dst_chans, dst);
}

Step 5: Convert Back to Bitmap and Display #

After blending, convert the resulting Mat back to an Android Bitmap (still preserving alpha):

// Create a Bitmap with ARGB_8888 config
Bitmap resultBitmap = Bitmap.createBitmap(dstMat.cols(), dstMat.rows(), Bitmap.Config.ARGB_8888);
Utils.matToBitmap(dstMat, resultBitmap);

// Display the result in an ImageView
imageView.setImageBitmap(resultBitmap);

Critical Tips to Avoid Issues #

• Channel Order: Android uses ARGB, OpenCV uses BGRA for 4-channel Mats. The code above handles this by working with the split channels directly.
• Memory Management: Always call mat.release() when you’re done with a Mat to prevent memory leaks.
• Image Sizes: If your input images are different sizes, resize one using Imgproc.resize() before blending.
• Performance: The matrix operation approach is much faster than pixel-wise loops, especially for large images.

内容的提问来源于stack exchange，提问作者thadaThada