Weighted bitmap addition

kylecorry31 · kylecorry31 · commit 0dcf88ae389e · 2024-12-22T09:15:00.000-05:00
Signed-off-by: Kyle Corry &lt;kylecorry31@gmail.com&gt;
diff --git a/bitmaps/src/androidTest/java/com/kylecorry/andromeda/bitmaps/WeightedAddTest.kt b/bitmaps/src/androidTest/java/com/kylecorry/andromeda/bitmaps/WeightedAddTest.kt
@@ -0,0 +1,50 @@
+package com.kylecorry.andromeda.bitmaps
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class WeightedAddTest {
+
+
+    @Test
+    fun weightedAdd() {
+        val ones = createBitmap()
+        val expected1 = createBitmap()
+        val expected2 = createBitmap()
+        val expected3 = createBitmap()
+
+        for (i in 0 until ones.width) {
+            for (j in 0 until ones.height) {
+                ones.setPixel(i, j, Color.rgb(1, 1, 1))
+                expected1.setPixel(i, j, Color.rgb(2, 2, 2))
+                expected2.setPixel(i, j, Color.argb(0, 0, 0, 0))
+                expected3.setPixel(i, j, Color.rgb(2, 2, 2))
+            }
+        }
+
+        val result1 = Toolkit.weightedAdd(ones, ones, 1f, 1f, false)
+        val result2 = Toolkit.weightedAdd(ones, ones, 1f, -3f, false)
+        val result3 = Toolkit.weightedAdd(ones, ones, 1f, -3f, true)
+
+        bitmapEquals(expected1, result1)
+        bitmapEquals(expected2, result2)
+        bitmapEquals(expected3, result3)
+    }
+
+    private fun bitmapEquals(bitmap1: Bitmap, bitmap2: Bitmap) {
+        assertEquals(bitmap1.width, bitmap2.width)
+        assertEquals(bitmap1.height, bitmap2.height)
+
+        for (i in 0 until bitmap1.width) {
+            for (j in 0 until bitmap1.height) {
+                assertEquals(bitmap1.getPixel(i, j), bitmap2.getPixel(i, j))
+            }
+        }
+    }
+
+    private fun createBitmap(width: Int = 100, height: Int = 100): Bitmap {
+        return Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    }
+}
diff --git a/bitmaps/src/main/cpp/CMakeLists.txt b/bitmaps/src/main/cpp/CMakeLists.txt
@@ -94,6 +94,7 @@ add_library(# Sets the name of the library.
         Moment.cpp
         BlobFinder.cpp
         GrayLevelCovarianceMatrix.cpp
+        WeightedAdd.cpp
         ${ASM_SOURCES})
 
 # Searches for a specified prebuilt library and stores the path as a
diff --git a/bitmaps/src/main/cpp/JniEntryPoints.cpp b/bitmaps/src/main/cpp/JniEntryPoints.cpp
@@ -521,6 +521,39 @@ Java_com_kylecorry_andromeda_bitmaps_Toolkit_nativeThresholdBitmap(
                        channel, restrict.get());
 }
 
+extern "C" JNIEXPORT void JNICALL Java_com_kylecorry_andromeda_bitmaps_Toolkit_nativeWeightedAdd(
+        JNIEnv *env, jobject /*thiz*/, jlong native_handle, jbyteArray input_array1,
+        jbyteArray input_array2,
+        jbyteArray output_array, jint size_x, jint size_y, jfloat weight1, jfloat weight2,
+        jboolean absolute, jobject restriction) {
+    RenderScriptToolkit *toolkit = reinterpret_cast<RenderScriptToolkit *>(native_handle);
+    RestrictionParameter restrict{env, restriction};
+
+    ByteArrayGuard input1{env, input_array1};
+    ByteArrayGuard input2{env, input_array2};
+    ByteArrayGuard output{env, output_array};
+
+    toolkit->weightedAdd(input1.get(), input2.get(), output.get(), size_x, size_y, weight1, weight2,
+                         absolute,
+                         restrict.get());
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_kylecorry_andromeda_bitmaps_Toolkit_nativeWeightedAddBitmap(
+        JNIEnv *env, jobject /*thiz*/, jlong native_handle, jobject input_bitmap1,
+        jobject input_bitmap2, jobject output_bitmap, jfloat weight1, jfloat weight2,
+        jboolean absolute, jobject restriction) {
+    RenderScriptToolkit *toolkit = reinterpret_cast<RenderScriptToolkit *>(native_handle);
+    RestrictionParameter restrict{env, restriction};
+    BitmapGuard input1{env, input_bitmap1};
+    BitmapGuard input2{env, input_bitmap2};
+    BitmapGuard output{env, output_bitmap};
+
+    toolkit->weightedAdd(input1.get(), input2.get(), output.get(), input1.width(), input1.height(),
+                         weight1, weight2,
+                         absolute, restrict.get());
+}
+
 extern "C" JNIEXPORT void JNICALL Java_com_kylecorry_andromeda_bitmaps_Toolkit_nativeMinMax(
         JNIEnv *env, jobject /*thiz*/, jlong native_handle, jbyteArray input_array,
         jfloatArray output_array, jint size_x,
diff --git a/bitmaps/src/main/cpp/RenderScriptToolkit.h b/bitmaps/src/main/cpp/RenderScriptToolkit.h
@@ -464,6 +464,21 @@ namespace renderscript {
                        float threshold, bool binary, uint8_t channel,
                        const Restriction *restriction);
 
+        /**
+         * Add two images together with a weight.
+         * @param input1 The buffer of the first image.
+         * @param input2 The buffer of the second image.
+         * @param output The buffer that receives the sum.
+         * @param sizeX The width of both buffers, as a number of 4 byte cells.
+         * @param sizeY The height of both buffers, as a number of 4 byte cells.
+         * @param weight1 The weight of the first image.
+         * @param weight2 The weight of the second image.
+         * @param absolute Whether to take the absolute value of the sum.
+         * @param restriction When not null, restricts the operation to a 2D range of pixels.
+         */
+        void weightedAdd(const uint8_t *input1, const uint8_t *input2, uint8_t *output,
+                         size_t sizeX, size_t sizeY, float weight1, float weight2, bool absolute,
+                         const Restriction *restriction);
 
         /**
          * Find the minimum or maximum value in an image.
diff --git a/bitmaps/src/main/cpp/WeightedAdd.cpp b/bitmaps/src/main/cpp/WeightedAdd.cpp
@@ -0,0 +1,122 @@
+#include <cstdint>
+
+#include "RenderScriptToolkit.h"
+#include "TaskProcessor.h"
+#include "Utils.h"
+
+#define LOG_TAG "renderscript.toolkit.WeightedAdd"
+
+namespace renderscript {
+
+    class WeightedAddTask : public Task {
+        const uchar4 *mIn1;
+        const uchar4 *mIn2;
+        uchar4 *mOut;
+        float mWeight1;
+        float mWeight2;
+        bool mAbsolute;
+
+        // Process a 2D tile of the overall work. threadIndex identifies which thread does the work.
+        void processData(int threadIndex, size_t startX, size_t startY, size_t endX,
+                         size_t endY) override;
+
+    public:
+        WeightedAddTask(const uint8_t *input1, const uint8_t *input2, uint8_t *output, size_t sizeX,
+                        size_t sizeY,
+                        float weight1, float weight2, bool absolute,
+                        const Restriction *restriction)
+                : Task{sizeX, sizeY, 4, true, restriction},
+                  mIn1{reinterpret_cast<const uchar4 *>(input1)},
+                  mIn2{reinterpret_cast<const uchar4 *>(input2)},
+                  mOut{reinterpret_cast<uchar4 *>(output)},
+                  mWeight1{weight1},
+                  mWeight2{weight2},
+                  mAbsolute{absolute} {}
+    };
+
+    void
+    WeightedAddTask::processData(int /* threadIndex */, size_t startX, size_t startY, size_t endX,
+                                 size_t endY) {
+        for (size_t y = startY; y < endY; y++) {
+            size_t offset = mSizeX * y + startX;
+            const uchar4 *in1 = mIn1 + offset;
+            const uchar4 *in2 = mIn2 + offset;
+            uchar4 *out = mOut + offset;
+            for (size_t x = startX; x < endX; x++) {
+                auto v1 = *in1;
+                double r1 = v1.r;
+                double g1 = v1.g;
+                double b1 = v1.b;
+                double a1 = v1.a;
+
+                auto v2 = *in2;
+                double r2 = v2.r;
+                double g2 = v2.g;
+                double b2 = v2.b;
+                double a2 = v2.a;
+
+                double r3 = r1 * mWeight1 + r2 * mWeight2;
+                double g3 = g1 * mWeight1 + g2 * mWeight2;
+                double b3 = b1 * mWeight1 + b2 * mWeight2;
+                double a3 = a1 * mWeight1 + a2 * mWeight2;
+                if (mAbsolute) {
+                    r3 = std::abs(r3);
+                    g3 = std::abs(g3);
+                    b3 = std::abs(b3);
+                    a3 = std::abs(a3);
+                }
+
+                // Clamp
+                if (r3 > 255) {
+                    r3 = 255;
+                } else if (r3 < 0) {
+                    r3 = 0;
+                }
+
+                if (g3 > 255) {
+                    g3 = 255;
+                } else if (g3 < 0) {
+                    g3 = 0;
+                }
+
+                if (b3 > 255) {
+                    b3 = 255;
+                } else if (b3 < 0) {
+                    b3 = 0;
+                }
+
+                if (a3 > 255) {
+                    a3 = 255;
+                } else if (a3 < 0) {
+                    a3 = 0;
+                }
+
+                *out = {static_cast<uint8_t>(r3), static_cast<uint8_t>(g3),
+                        static_cast<uint8_t>(b3),
+                        static_cast<uint8_t>(a3)};
+
+                in1++;
+                in2++;
+                out++;
+            }
+        }
+    }
+
+    void
+    RenderScriptToolkit::weightedAdd(const uint8_t *input1, const uint8_t *input2, uint8_t *output,
+                                     size_t sizeX,
+                                     size_t sizeY,
+                                     float weight1, float weight2, bool absolute,
+                                     const Restriction *restriction) {
+#ifdef ANDROID_RENDERSCRIPT_TOOLKIT_VALIDATE
+        if (!validRestriction(LOG_TAG, sizeX, sizeY, restriction)) {
+            return;
+        }
+#endif
+
+        WeightedAddTask task(input1, input2, output, sizeX, sizeY, weight1, weight2, absolute,
+                             restriction);
+        processor->doTask(&task);
+    }
+
+}  // namespace renderscript
diff --git a/bitmaps/src/main/java/com/kylecorry/andromeda/bitmaps/BitmapUtils.kt b/bitmaps/src/main/java/com/kylecorry/andromeda/bitmaps/BitmapUtils.kt
@@ -178,8 +178,12 @@ object BitmapUtils {
         return Toolkit.convolve(this, kernel)
     }
 
-    fun Bitmap.gray(): Bitmap {
-        return Toolkit.colorMatrix(this, Toolkit.greyScaleColorMatrix)
+    fun Bitmap.gray(average: Boolean = false, inPlace: Boolean = false): Bitmap {
+        return Toolkit.colorMatrix(
+            this,
+            if (average) Toolkit.averageColorMatrix else Toolkit.greyScaleColorMatrix,
+            inPlace = inPlace
+        )
     }
 
     fun Bitmap.histogram(): IntArray {
@@ -384,6 +388,16 @@ object BitmapUtils {
         )
     }
 
+    fun Bitmap.add(
+        bitmap: Bitmap,
+        selfWeight: Float = 1f,
+        otherWeight: Float = 1f,
+        absolute: Boolean = false,
+        inPlace: Boolean = false
+    ): Bitmap {
+        return Toolkit.weightedAdd(this, bitmap, selfWeight, otherWeight, absolute, inPlace)
+    }
+
     private fun quantize(arr: ByteArray, bins: Int) {
         if (bins >= 256 || bins <= 0) {
             return
diff --git a/bitmaps/src/main/java/com/kylecorry/andromeda/bitmaps/Toolkit.kt b/bitmaps/src/main/java/com/kylecorry/andromeda/bitmaps/Toolkit.kt
