氛围灯动态屏保取色方案一

眼看着你们堕落 發表於 2025-10-16 15:28:00

氛围灯并不支持所有的颜色，只能支持256色，所以在取到图片颜色后需要根据结果颜色去跟氛围灯所支持的256色对比，取最接近的结果色，然后同步到氛围灯显示
<h4>取色流程</h4>
取色需要用到原生 Palette.from(bitmap).generate() 方法，通过量化算法分析位图的像素颜色分布，提取最具代表性的颜色组合，也有异步获取方法，下面方法都处于子线程，所以这里直接使用同步方法
查看 androidx.palette.graphics.Palette 源码可以得知，该方法默认提取16种颜色样本
<img src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016142207533-1863067305.png">
需要确保取色精准度，16可能错过次要但视觉显著的颜色，过高又会导致耗时，所以这里使用24
针对原图还需要缩放处理，但是不宜过度，否则对准确度会有影响，这里对2560分辨率的图片缩小三分之一处理
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_15a20326-c575-4430-8fd9-151c999bca8f" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_15a20326-c575-4430-8fd9-151c999bca8f" class="cnblogs_code_hide">
<pre>private val mWidth = ScreenUtils.getScreenWidth() / 2
private val mHeight = ScreenUtils.getScreenHeight() / 2

Glide.with(Utils.getApp())
 .asBitmap()
 .load(new File(path))
 .override(width, height)
 .centerCrop()
 .skipMemoryCache(true)
 .diskCacheStrategy(DiskCacheStrategy.NONE)
 .submit(width, height)
 .get();</pre>
</div>
View Code</div>
对氛围灯的256色进行缓存处理，先新建 color_rgb_256.json 文件，将rgb色值保存，用于后续转换对比
<img alt="image" width="223" height="224" loading="lazy" src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016144020263-1440713970.png">
初始化时解析成hsv缓存到本地集合中
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_c53a3954-1333-4736-8984-db32011f318f" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_c53a3954-1333-4736-8984-db32011f318f" class="cnblogs_code_hide">
<pre> private fun saveHsvColor(): MutableList<HsvColor> {
 log("saveHsvColor")
 val hsvList = mutableListOf<HsvColor>()
 runCatching {
 val assetManager = Utils.getApp().assets
 val file = assetManager.open("color_rgb_256.json")
 val jsonStr = file.bufferedReader().readText()
 file.close()
 val bean = Gson().fromJson(jsonStr, AmbientLightList::class.java)
 val hsvColors = FloatArray(3)
 for (i in 0 until bean.list.size) {
 bean.list.apply {
 val myColor = Color.rgb(r, g, b)
 Color.colorToHSV(myColor, hsvColors)
 hsvList.add(HsvColor(hsvColors[0], hsvColors, hsvColors))
 }
 }
 val json = Gson().toJson(hsvList)
 log("saveHsvColor hsvListSize=${hsvList.size}")
 SharedPreferencesUtils.setRGB256HsvColor(Utils.getApp(), json)
 }.getOrElse {
 Log.e(TAG, "saveHsvColor Exception ${it.message}")
 }
 return hsvList
}</pre>
</div>
View Code</div>
此文件颜色不会变，所以不用重复操作，判断首次转换就行
<div class="cnblogs_code"><img id="code_img_closed_f2110559-8c58-472f-af08-95a0aeac29ba" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_f2110559-8c58-472f-af08-95a0aeac29ba" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_f2110559-8c58-472f-af08-95a0aeac29ba" class="cnblogs_code_hide">
<pre>private fun initHsvColor() {
 if (hsvTableList.isEmpty()) {
 runCatching {
 val json = SharedPreferencesUtils.getRGB256HsvColor(Utils.getApp())
 val listType = object : TypeToken<MutableList<HsvColor>>() {}.type
 Gson().fromJson<MutableList<HsvColor>>(json, listType)?.let {
 hsvTableList.addAll(it)
 log("initHsvColor xml list size=${hsvTableList.size}")
 }
 }.getOrElse {
 Log.e(TAG, "initHsvColor Exception ${it.message}")
 }
 }
 if (hsvTableList.isEmpty()) {
 saveHsvColor().let {
 if (it.isNotEmpty()) {
 hsvTableList.addAll(it)
 }
 }
 log("initHsvColor json list size=${hsvTableList.size}")
 }
}</pre>
</div>
View Code</div>
耗时操作需要放在子线程
<div class="cnblogs_code"><img id="code_img_closed_c3370a14-cd58-4c4d-bb8e-8e5d657299c2" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_c3370a14-cd58-4c4d-bb8e-8e5d657299c2" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_c3370a14-cd58-4c4d-bb8e-8e5d657299c2" class="cnblogs_code_hide">
<pre> @JvmStatic
fun init() {
 log("$TAG init")
 scope.launch(Dispatchers.IO) {
 hsvTableList.clear()
 initHsvColor()
 }
}</pre>
</div>
View Code</div>
后面对图片进行取色，见下面方案
取色后，跟256色进行就近查找，所以需要转换成hsv，取 hue 进行对比
<div class="cnblogs_code"><img id="code_img_closed_bb0ddb00-736a-4189-b450-c75bba04bb67" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_bb0ddb00-736a-4189-b450-c75bba04bb67" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_bb0ddb00-736a-4189-b450-c75bba04bb67" class="cnblogs_code_hide">
<pre>private fun findColor(bgHue: Float): ColorTipBean {
 if (hsvTableList.isEmpty()) {
 Log.w(TAG, "findColor hsvList is null")
 return ColorTipBean(Color.WHITE)
 }
 var result = hsvTableList
 var minDiff = abs(result.hue - bgHue)
 for (i in 0 until hsvTableList.size) {
 val currentDiff = abs(hsvTableList.hue - bgHue)
 if (currentDiff < minDiff) {
 minDiff = currentDiff
 result = hsvTableList
 }
 }
 log("findColor bgHue=$bgHue,result=$result")
 return ColorTipBean(
 Color.HSVToColor(floatArrayOf(result.hue, result.saturation, result.value))
 )
}</pre>
</div>
View Code</div>
拿到结果后，通过信号下设到氛围灯显示
<h3>准确度</h3>
想要达到联动效果，需要确保取色结果的准确度，原生方案使用 getDominantColor 直接获取主色，但是大部分结果差异较大，下面提供了几种方案对比
<h4>方案一：</h4>
通过原生提供的方法直接获取图片主色
<div class="cnblogs_code"><img id="code_img_closed_3dffb8a4-b933-425b-a0be-be9ed65f1ef9" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_3dffb8a4-b933-425b-a0be-be9ed65f1ef9" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_3dffb8a4-b933-425b-a0be-be9ed65f1ef9" class="cnblogs_code_hide">
<pre>Palette.from(newMap).generate().apply {
 val dominantColor = getDominantColor(Color.WHITE)
 val hsvColorArray = FloatArray(3)
 val hsv = colorToHSV(dominantColor, hsvColorArray)
 Log.d(TAG, "dominantColor $dominantColor hsv $hsv")
 result.fill(hsv)
}</pre>
</div>
View Code</div>
getDominantColor 方法直接取的 mDominantSwatch.getRgb
<div class="cnblogs_code"><img id="code_img_closed_c2a1a4e8-764f-46d7-be90-198d4f455c4d" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_c2a1a4e8-764f-46d7-be90-198d4f455c4d" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_c2a1a4e8-764f-46d7-be90-198d4f455c4d" class="cnblogs_code_hide">
<pre> /**
* Returns the color of the dominant swatch from the palette, as an RGB packed int.
*
* @param defaultColor value to return if the swatch isn't available
* @see #getDominantSwatch()
*/
@ColorInt
public int getDominantColor(@ColorInt int defaultColor) {
 return mDominantSwatch != null ? mDominantSwatch.getRgb() : defaultColor;
}</pre>
</div>
View Code</div>
而 mDominantSwatch 则根据色块 population 排序的结果
<div class="cnblogs_code"><img id="code_img_closed_3e510bb7-6cc6-428e-9e33-693ca2a01527" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_3e510bb7-6cc6-428e-9e33-693ca2a01527" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_3e510bb7-6cc6-428e-9e33-693ca2a01527" class="cnblogs_code_hide">
<pre> Palette(List<Swatch> swatches, List<Target> targets) {
 mSwatches = swatches;
 mTargets = targets;

 mUsedColors = new SparseBooleanArray();
 mSelectedSwatches = new ArrayMap<>();

 mDominantSwatch = findDominantSwatch();
}

@Nullable
private Swatch findDominantSwatch() {
 int maxPop = Integer.MIN_VALUE;
 Swatch maxSwatch = null;
 for (int i = 0, count = mSwatches.size(); i < count; i++) {
 Swatch swatch = mSwatches.get(i);
 if (swatch.getPopulation() > maxPop) {
 maxSwatch = swatch;
 maxPop = swatch.getPopulation();
 }
 }
 return maxSwatch;
}</pre>
</div>
View Code</div>
假设氛围灯需要多个取色，可以直接从 mSwatches 颜色集合中按 population 排序获取
<img alt="image" width="377" height="198" loading="lazy" src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016141056588-972744233.png">
Swatch 代表的颜色在图片中的权重占比（多个小红点可能被聚类到同一个红色 Swatch）
经自测验证，改方案准确度不够，偏差较大，特别是在氛围灯所支持的256色中，查找出的相近结果出入较大，整体准确度不够
因为实际环境中无法看到氛围灯（车机上效果），所以在左上角显示测试结果，方便查看
<img src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016150025255-182630436.png">
图片中，左上角测试区域，中间上面是图片主色，下面是通过主色映射的氛围灯颜色，很显然跟图片差异较大
<h4>方案二：</h4>
在原生基础上使用饱和度跟亮度参与计算，避免过暗或过亮的颜色
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_64baff5c-ae02-4899-8be8-d0490fefe5f5" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_64baff5c-ae02-4899-8be8-d0490fefe5f5" class="cnblogs_code_hide">
<pre>fun getPerceptuallyDominantColor(bitmap: Bitmap): Int {
 val palette = Palette.from(bitmap).maximumColorCount(24).clearFilters().generate()
 val swatches = palette.swatches
 if (swatches.isEmpty()) return Color.WHITE

 var bestSwatch: Swatch? = null
 var maxScore = 0f

 for (swatch in swatches) {
 val hsl = swatch.getHsl()
 val saturation = hsl // 饱和度 (0-1)
 val luminance = hsl // 亮度 (0-1)
 val population = swatch.population

 // 评分公式：人口占比 * 饱和度 * 亮度因子
 // 亮度因子确保避免过暗或过亮的颜色（0.1-0.9为理想范围）
 val luminanceFactor = 1f - abs(luminance - 0.5f) * 1.8f
 val score = population * saturation * luminanceFactor

 if (score > maxScore) {
 maxScore = score
 bestSwatch = swatch
 }
 }

 return bestSwatch?.rgb ?: palette.getDominantColor(Color.WHITE)
}</pre>
</div>
View Code</div>
该方案将纯黑白色过滤（实际图片中纯黑白色占比很少，但是很印象色块，容易出现误差），同时避免了过亮的颜色，更突出我们肉眼看到的颜色
<h4>其它方案：</h4>
1、在方案二的基础上，加入色相，改进计算公式
2、调整图片，缩小区域，针对中心区域进行取色
3、自定义过滤器，针对业务情况单独处理某些图片
比如，可以针对纯黑白占比大于30%的进行过滤，否则不过滤
<div class="cnblogs_code"><img id="code_img_closed_e8fcd774-d24d-4d2f-ac2e-8ccab14089b1" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_e8fcd774-d24d-4d2f-ac2e-8ccab14089b1" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_e8fcd774-d24d-4d2f-ac2e-8ccab14089b1" class="cnblogs_code_hide">
<pre>private fun isClear(bitmap: Bitmap): Boolean {
 val totalPixels = bitmap.width * bitmap.height
 var blackCount = 0.0
 var whiteCount = 0.0
 for (x in 0 until bitmap.width) {
 for (y in 0 until bitmap.height) {
 val pixel = bitmap
 if (pixel == Color.BLACK) {
 blackCount++
 }
 if (pixel == Color.WHITE) {
 whiteCount++
 }
 }
 }
 val blackRatio = blackCount / totalPixels
 val whiteRatio = whiteCount / totalPixels
 val isClear = blackRatio > 0.3 || whiteRatio > 0.3
 Log.d(TAG, "isClear=$isClear totalPixels=$totalPixels,blackCount=$blackCount, blackRatio=${String.format("%.2f", blackRatio)},whiteRatio=${String.format("%.2f", whiteRatio)}")
 return isClear
}</pre>
</div>
View Code</div>
但需要慎重，会提高计算耗时
<img alt="image" loading="lazy" src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016151606229-937694496.png">
<img src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016151644417-751285326.png">
<img src="https://img2024.cnblogs.com/blog/583064/202510/583064-20251016151706917-686998766.png">
左上角，上面的方格代表直接从图片中读取的色值，下面的方格是映射后的色值，最左边的是方案二，中间的是方案一，右边的是替补方案
结论图片不多展示，经过大量图片验证，准确度最高的是方案二
<div class="cnblogs_code"><img id="code_img_closed_fbc1df53-69d0-45c4-aecd-b5044ff547c3" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_fbc1df53-69d0-45c4-aecd-b5044ff547c3" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_fbc1df53-69d0-45c4-aecd-b5044ff547c3" class="cnblogs_code_hide">
<pre>import android.graphics.Bitmap
import android.graphics.Color
import android.util.Log
import androidx.palette.graphics.Palette
import androidx.palette.graphics.Palette.Swatch
import com.blankj.utilcode.util.GsonUtils
import com.blankj.utilcode.util.ScreenUtils
import com.blankj.utilcode.util.Utils

import com.google.gson.Gson
import com.google.gson.annotations.SerializedName
import com.google.gson.reflect.TypeToken

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
import java.util.Collections
import java.util.concurrent.CopyOnWriteArrayList
import kotlin.math.abs
import kotlin.math.sqrt
import androidx.core.graphics.get

object AmbientLightColorPickManager {

private const val TAG = "AmbientLightColorPickManager"

private var scope = MainScope()
private val mWidth = ScreenUtils.getScreenWidth() / 2
private val mHeight = ScreenUtils.getScreenHeight() / 2
private val hsvTableList = mutableListOf<HsvColor>()
private val hueList = CopyOnWriteArrayList<FloatArray>()
private val test1List = CopyOnWriteArrayList<FloatArray>()
private val test2List = CopyOnWriteArrayList<FloatArray>()
private val test3List = CopyOnWriteArrayList<FloatArray>()
var test1Listener: ((Int, Int, Int) -> Unit)? = null
var test2Listener: ((Int, Int, Int) -> Unit)? = null

@JvmStatic
fun init() {
 log("$TAG init")
 scope.launch(Dispatchers.IO) {
 hsvTableList.clear()
 initHsvColor()
 }
}

private fun initHsvColor() {
 if (hsvTableList.isEmpty()) {
 runCatching {
 val json = SharedPreferencesUtils.getRGB256HsvColor(Utils.getApp())
 val listType = object : TypeToken<MutableList<HsvColor>>() {}.type
 Gson().fromJson<MutableList<HsvColor>>(json, listType)?.let {
 hsvTableList.addAll(it)
 log("initHsvColor xml list size=${hsvTableList.size}")
 }
 }.getOrElse {
 Log.e(TAG, "initHsvColor Exception ${it.message}")
 }
 }
 if (hsvTableList.isEmpty()) {
 saveHsvColor().let {
 if (it.isNotEmpty()) {
 hsvTableList.addAll(it)
 }
 }
 log("initHsvColor json list size=${hsvTableList.size}")
 }
}

/** 将本地rgb色值转换成hsv保存到本地 */
private fun saveHsvColor(): MutableList<HsvColor> {
 log("saveHsvColor")
 val hsvList = mutableListOf<HsvColor>()
 runCatching {
 val assetManager = Utils.getApp().assets
 val file = assetManager.open("color_rgb_256.json")
 val jsonStr = file.bufferedReader().readText()
 file.close()
 val bean = Gson().fromJson(jsonStr, AmbientLightList::class.java)
 val hsvColors = FloatArray(3)
 for (i in 0 until bean.list.size) {
 bean.list.apply {
 val myColor = Color.rgb(r, g, b)
 Color.colorToHSV(myColor, hsvColors)
 hsvList.add(HsvColor(hsvColors[0], hsvColors, hsvColors))
 }
 }
 val json = Gson().toJson(hsvList)
 log("saveHsvColor hsvListSize=${hsvList.size}")
 SharedPreferencesUtils.setRGB256HsvColor(Utils.getApp(), json)
 }.getOrElse {
 Log.e(TAG, "saveHsvColor Exception ${it.message}")
 }
 return hsvList
}

/** 设置氛围灯 */
@JvmStatic
fun setAmbientLight(displayId: Int, index: Int) {
 if (displayId != DisplayParameter.DISPLAY_CSD.displayId) return
 log("setAmbientLight displayId=$displayId")
 scope.launch(Dispatchers.IO) {
 if (hueList.isEmpty()) {
 Log.w(TAG, "setAmbientLight hueList is null")
 return@launch
 }
 if (index < 0 || index >= hueList.size) {
 Log.w(TAG, "setAmbientLight 索引异常")
 return@launch
 }
 // 氛围灯取色
 setBytesFunctionValue(index)
 }
}

@JvmStatic
fun switchLight(isOn: Boolean) {
 log("switchLight isOn=$isOn")

}

private fun findColor(bgHue: Float): ColorTipBean {
 if (hsvTableList.isEmpty()) {
 Log.w(TAG, "findColor hsvList is null")
 return ColorTipBean(Color.WHITE)
 }
 var result = hsvTableList
 var minDiff = abs(result.hue - bgHue)
 for (i in 0 until hsvTableList.size) {
 val currentDiff = abs(hsvTableList.hue - bgHue)
 if (currentDiff < minDiff) {
 minDiff = currentDiff
 result = hsvTableList
 }
 }
 log("findColor bgHue=$bgHue,result=$result")
 return ColorTipBean(
 Color.HSVToColor(floatArrayOf(result.hue, result.saturation, result.value))
 )
}

/** 初始化资源 */
@JvmStatic
fun loadData(displayId: Int, pictures: List<String>) {
 if (displayId != DisplayParameter.DISPLAY_CSD.displayId) return
 log("loadData pictures size=${pictures.size} pictures $pictures")
 hueList.clear()
 test1List.clear()
 test2List.clear()
 test3List.clear()
 for ((index, picture) in pictures.withIndex()) {
 runCatching {
 val bitmap = GlideCacheUtils.loadImageAsBitmap(picture, mWidth, mHeight)
 testGenerate(bitmap)
 val result = generate(bitmap)
 hueList.add(result)
 log("loadData add index=$index,colors=${GsonUtils.toJson(result)}")
 }.getOrElse {
 Log.e(TAG, "loadData exception ${it.message}")
 }
 }
 log("loadData hueList size=${hueList.size}")
}

private fun setFunctionValue(functionId: Int, value: Int, zone: Int) {
 try {
 AdapterCarManager.iCarFunction.setFunctionValue(functionId, zone, value)
 } catch (e: Exception) {
 Log.e(TAG, "setFunctionValue Exception $e")
 }
}

private fun setBytesFunctionValue(index: Int) {
 try {
 test1Listener?.invoke(
 Color.HSVToColor(test1List),
 Color.HSVToColor(test2List),
 Color.HSVToColor(test3List),
 )
 test2Listener?.invoke(
 findColor(test1List[0]).colorTip,
 findColor(test2List[0]).colorTip,
 findColor(test3List[0]).colorTip,
 )
 } catch (e: Exception) {
 Log.e(TAG, "setBytesFunctionValue Exception $e")
 }
}

private fun getColors(list: FloatArray): ByteArray {
 val result = mutableListOf<ColorTipBean>()
 list.forEach {
 result.add(findColor(it))
 }
 val json = GsonUtils.toJson(LightColorBean(result).list)
 log("setBytesFunctionValue json=$json")
 return json.toByteArray()
}

private fun generate(newMap: Bitmap): FloatArray {
 val result = FloatArray(3)
 Log.w(TAG, "------generate start")
 val dominantColor = getPerceptuallyDominantColor(newMap)
 val hsvColorArray = FloatArray(3)
 val hsv = colorToHSV(dominantColor, hsvColorArray)
 result.fill(hsv)
 Log.d(TAG, "dominantColor $dominantColor, hsv ${GsonUtils.toJson(hsvColorArray)}")
 return result
}

private fun testGenerate(newMap: Bitmap) {
 // 评分公式
 val dominantColor1 = getPerceptuallyDominantColor(newMap)
 val hsvColorArray1 = FloatArray(3)
 colorToHSV(dominantColor1, hsvColorArray1)
 test1List.add(hsvColorArray1)

 // 主色
 Palette.from(newMap).maximumColorCount(24).clearFilters().generate().apply {
 val hsvColorArray2 = FloatArray(3)
 val dominantColor2 = getDominantColor(Color.WHITE)
 colorToHSV(dominantColor2, hsvColorArray2)
 test2List.add(hsvColorArray2)
 }

 // 评分优化公式
 val dominantColor3 = getPerceptuallyDominantColor1(newMap)
 val hsvColorArray3 = FloatArray(3)
 colorToHSV(dominantColor3, hsvColorArray3)
 test3List.add(hsvColorArray3)
}

fun getPerceptuallyDominantColor(bitmap: Bitmap): Int {
 val palette = Palette.from(bitmap).maximumColorCount(24).clearFilters().generate()
 val swatches = palette.swatches
 if (swatches.isEmpty()) return Color.WHITE

 var bestSwatch: Swatch? = null
 var maxScore = 0f

 for (swatch in swatches) {
 val hsl = swatch.getHsl()
 val saturation = hsl // 饱和度 (0-1)
 val luminance = hsl // 亮度 (0-1)
 val population = swatch.population

 // 评分公式：人口占比 * 饱和度 * 亮度因子
 // 亮度因子确保避免过暗或过亮的颜色（0.1-0.9为理想范围）
 val luminanceFactor = 1f - abs(luminance - 0.5f) * 1.8f
 val score = population * saturation * luminanceFactor

 if (score > maxScore) {
 maxScore = score
 bestSwatch = swatch
 }
 }

 return bestSwatch?.rgb ?: palette.getDominantColor(Color.WHITE)
}

private fun isClear(bitmap: Bitmap): Boolean {
 val totalPixels = bitmap.width * bitmap.height
 var blackCount = 0.0
 var whiteCount = 0.0
 for (x in 0 until bitmap.width) {
 for (y in 0 until bitmap.height) {
 val pixel = bitmap
 if (pixel == Color.BLACK) {
 blackCount++
 }
 if (pixel == Color.WHITE) {
 whiteCount++
 }
 }
 }
 val blackRatio = blackCount / totalPixels
 val whiteRatio = whiteCount / totalPixels
 val isClear = blackRatio > 0.3 || whiteRatio > 0.3
 Log.d(TAG, "isClear=$isClear totalPixels=$totalPixels,blackCount=$blackCount, blackRatio=${String.format("%.2f", blackRatio)},whiteRatio=${String.format("%.2f", whiteRatio)}")
 return isClear
}

private fun calculateSwatchScore(
 hue: Float,
 saturation: Float,
 luminance: Float,
 population: Float
): Float {
 // 1. 人口权重 (标准化)
 val populationWeight = population / 1000000f

 // 2. 饱和度权重 - 适度重视但不过度
 val saturationWeight = sqrt(saturation) // 使用平方根降低过高饱和度的优势

 // 3. 亮度权重 - 偏好中等亮度范围
 val luminanceWeight = when {
 luminance < 0.15f -> 0.2f// 太暗的惩罚
 luminance > 0.85f -> 0.3f// 太亮的惩罚
 else -> 1.0f - abs(luminance - 0.5f) * 1.5f
 }

 // 4. 色相权重 - 可选：降低过于鲜艳的红色/蓝色的优势
 val hueWeight = when {
 // 红色范围 (330-30度)
 (hue >= 330f || hue <= 30f) -> 0.8f
 // 蓝色范围 (210-270度)
 hue in 210f..270f -> 0.9f
 else -> 1.0f
 }

 return populationWeight * saturationWeight * luminanceWeight * hueWeight
}

fun getPerceptuallyDominantColor1(bitmap: Bitmap): Int {
 val palette = Palette.from(bitmap)
 .maximumColorCount(24)
 .clearFilters()
 .generate()

 val swatches = palette.swatches
 if (swatches.isEmpty()) return Color.WHITE

 var bestSwatch: Swatch? = null
 var maxScore = 0f

 for (swatch in swatches) {
 val hsl = swatch.hsl
 val hue = hsl // 色相 (0-360)
 val saturation = hsl // 饱和度 (0-1)
 val luminance = hsl // 亮度 (0-1)
 val population = swatch.population.toFloat()
 // 改进的评分公式
 val score = calculateSwatchScore(hue, saturation, luminance, population)
 if (score > maxScore) {
 maxScore = score
 bestSwatch = swatch
 }
 }

 return bestSwatch?.rgb ?: palette.getDominantColor(Color.WHITE)
}

private fun colorToHSV(rgb: Int, hsvColorArray: FloatArray): Float {
 Color.colorToHSV(rgb, hsvColorArray)
 return hsvColorArray
}

private fun log(str: String) = Log.d(TAG, str)

data class LightColorBean(
 val list: List<ColorTipBean>
)

data class ColorTipBean(
 @SerializedName("ColorTip")
 var colorTip: Int,
)

}</pre>
</div>
View Code</div>
  
来源：https://www.cnblogs.com/LiuZhen/p/19145784

頁: [1]

琼殿技术论坛's Archiver

氛围灯动态屏保取色方案一