A prototype implementation of gradient mapping (https://bjango.com/articles/gradientmaps/) on Android.

GradientMap.kt

/*
 *  Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the
 * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

package com.example.gradientmap

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Canvas
import android.graphics.drawable.BitmapDrawable
import android.graphics.drawable.Drawable
import android.os.Build.VERSION.SDK_INT
import android.os.Build.VERSION_CODES.KITKAT
import android.os.Trace
import android.support.annotation.ColorInt
import android.support.annotation.DrawableRes

/**
 * See https://bjango.com/articles/gradientmaps/
 */
object GradientMap {

    private const val ROW_STEPS = 10

    fun of(source: Bitmap, gradient: Gradient): Bitmap {
        if (SDK_INT >= KITKAT) Trace.beginSection("Gradient")

        val width = source.width
        val dest = Bitmap.createBitmap(width, source.height, Bitmap.Config.ARGB_8888)
        val row = IntArray(width * ROW_STEPS)
        val steps = Math.ceil(source.height / ROW_STEPS.toDouble()).toInt()

        for (rowStep in 0 until steps) {
            source.getPixels(row, 0, width, 0, rowStep * ROW_STEPS, width, ROW_STEPS)
            for (i in 0 until row.size) {
                row[i] = gradient.map(row[i])
            }
            dest.setPixels(row, 0, width, 0, rowStep * ROW_STEPS, width, ROW_STEPS)
        }

        if (SDK_INT >= KITKAT) Trace.endSection()
        return dest
    }

    fun of(context: Context, @DrawableRes resId: Int, gradient: Gradient): Bitmap {
        return of(BitmapFactory.decodeResource(context.resources, resId), gradient)

    }

    fun of(drawable: Drawable, gradient: Gradient): Bitmap {
        val source = if (drawable is BitmapDrawable) {
            drawable.bitmap
        } else {
            Bitmap.createBitmap(drawable.intrinsicWidth, drawable.intrinsicHeight,
                    Bitmap.Config.ARGB_8888).apply {
                drawable.setBounds(0, 0, width, height)
                drawable.draw(Canvas(this))
            }
        }
        return of(source, gradient)
    }
}

class Gradient private constructor(private val colors: FloatArray, private val offsets: FloatArray) {
    class Builder {
        private var stops = mutableListOf<ColorStop>()

        fun addStop(@ColorInt color: Int, offset: Float): Builder {
            stops.add(ColorStop.of(color, offset.coerceIn(0.0f, 1.0f)))
            return this
        }

        fun build(): Gradient {
            if (stops.size < 2) throw IllegalArgumentException("Gradient requires 2 or more colors")
            val sortedStops = mutableListOf<ColorStop>()
            sortedStops.addAll(stops.sortedBy(ColorStop::offset))

            // check that offsets 0.0 & 1.0 have been provided
            // else clamp with the lowest/highest offset colors
            if (sortedStops[0].offset > 0.0) {
                sortedStops.add(0, sortedStops[0].copy(offset = 0.0f))
            }
            if (stops[stops.size - 1].offset < 1.0) {
                sortedStops.add(sortedStops[stops.size - 1].copy(offset = 1.0f))
            }

            return Gradient(
                    sortedStops.flatMap { listOf(it.r, it.g, it.b) }.toFloatArray(),
                    sortedStops.map(ColorStop::offset).toFloatArray())
        }
    }

    private data class ColorStop(val r: Float, val g: Float, val b: Float, val offset: Float) {
        companion object {
            fun of(color: Int, offset: Float): ColorStop {
                // store color stops in linear space
                val r: Float = ((color shr 16) and 0xff) / 255.0f
                val g: Float = ((color shr  8) and 0xff) / 255.0f
                val b: Float = ((color       ) and 0xff) / 255.0f
                return ColorStop(r * r, g * g, b * b, offset)
            }
        }
    }

    @ColorInt
    fun map(@ColorInt color: Int): Int {
        val offset = calculateLuminance(color)

        // calculate which color stops this offset sits between
        var index1 = 0
        val end = offsets.size - 1
        while (index1 < end && offsets[index1] < offset) { index1++ }
        index1 = (index1 - 1).coerceAtLeast(0)
        val index2 = (index1 + 1).coerceAtMost(end)

        val offset1 = offsets[index1]
        val offset2 = offsets[index2]

        val fraction = (offset - offset1) / (offset2 - offset1)
        val color1 = index1 * 3
        val color2 = index2 * 3

        // calculate the color at the fraction between the color stops
        return lerp(fraction,
                colors[color1], colors[color1 + 1], colors[color1 + 2],
                colors[color2], colors[color2 + 1], colors[color2 + 2])
    }

    private fun calculateLuminance(@ColorInt color: Int): Float {
        return rgbToLuminance(
                (color shr 16) and 0xff,
                (color shr  8) and 0xff,
                (color       ) and 0xff)
    }

    @Suppress("NOTHING_TO_INLINE")
    private inline fun rgbToLuminance(r: Int, g: Int, b: Int): Float {
        // convert to XYZ color space & return the Y component
        return rgbToLinear(r) * 0.2126f + rgbToLinear(g) * 0.7152f + rgbToLinear(b) * 0.0722f
    }

    @Suppress("NOTHING_TO_INLINE")
    private inline fun rgbToLinear(srgb: Int): Float {
        val linear = srgb / 255.0f
        // approximate linear conversion using x^2
        return linear * linear
    }

    private fun lerp(fraction: Float,
                     startR: Float, startG: Float, startB: Float,
                     endR: Float, endG: Float, endB: Float): Int {
        var r = startR + fraction * (endR - startR)
        var g = startG + fraction * (endG - startG)
        var b = startB + fraction * (endB - startB)

        // approximate conversion back from linear using sqrt
        r = Math.sqrt(r.toDouble()).toFloat() * 255.0f
        g = Math.sqrt(g.toDouble()).toFloat() * 255.0f
        b = Math.sqrt(b.toDouble()).toFloat() * 255.0f

        return 0xff000000.toInt() or (Math.round(r) shl 16) or (Math.round(g) shl 8) or Math.round(b)
    }
}

MainActivity.kt

/*
 *  Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the
 * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

package com.example.gradientmap

import android.graphics.Color
import android.os.Bundle
import android.support.v7.app.AppCompatActivity
import android.widget.ImageView

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val iv = findViewById<ImageView>(R.id.image)
        val bmp = GradientMap.of(this, R.drawable.ball,
                Gradient.Builder()
                        .addStop(Color.RED, 0.0f)
                        .addStop(Color.YELLOW, 1.0f)
                        .build())
        iv.setImageBitmap(bmp)
    }
}

screenshot.png