Median line

[cassiobruzasco]

hello @riggaroo
How are you doing?
This repo was really useful for me and helped accomplish my goals, thank you very much for that.
I wonder if you could help me on my next step:
I need to create a median line in my graph, the line would start at the beguinning of the graph and has the height of the median value and go to the end of the graph in a straigh line matter.
Any way you could give me a hand with this?

my current code:

Spacer(
                modifier = Modifier
                    .fillMaxHeight()
                    .weight(1f)
                    .aspectRatio(3 / 1.4f)
                    .drawWithCache {
                        val paths = generateSmoothPaths(list, size)
                        val linePath = paths.first
                        val medianLine = paths.second
                        val gradientPath = Path()
                        gradientPath.addPath(linePath)
                        gradientPath.lineTo(size.width, size.height)
                        gradientPath.lineTo(0f, size.height)
                        gradientPath.close()
                        val gradientBrush = Brush.verticalGradient(
                            listOf(LineGraphGradientStart, LineGraphGradientEnd)
                        )

                        onDrawBehind {
                            drawPath(linePath, Blue2, style = Stroke(2.dp.toPx()))
                            drawPath(gradientPath, brush = gradientBrush, style = Fill)
                            drawPath(
                                medianLine,
                                Blue2,
                                style = Stroke(
                                    2.dp.toPx(),
                                    pathEffect = PathEffect.dashPathEffect(
                                        floatArrayOf(40f, 20f),
                                        0f
                                    )
                                )
                            )

                            val verticalLines = list.size
                            val verticalSize = size.width / (verticalLines + 1)
                            repeat(verticalLines) { i ->
                                val startX = verticalSize * (i + 1)
                                drawLine(
                                    Grey4,
                                    start = Offset(startX, 0f),
                                    end = Offset(startX, size.height),
                                    strokeWidth = 2f,
                                    alpha = 0.3f
                                )
                            }
                        }
                    }
            )
            
            private fun med(list: List<BigDecimal>) = list.sorted().let {
    if (it.size % 2 == 0) {
        (it[it.size / 2] + it[(it.size - 1) / 2]).divide(BigDecimal(2))
    } else {
        it[it.size / 2]
    }
}

private fun generateSmoothPaths(data: List<Balance>, size: Size): Pair<Path, Path> {
    val path = Path()
    val medianPath = Path()
    val median = med(data.map { it.amount })
    val numberEntries = data.size - 1
    val weekWidth = size.width / numberEntries

    val max = data.maxBy { it.amount }
    val min = data.minBy { it.amount }
    val range = max.amount - min.amount
    val heightPxPerAmount = size.height / range.toFloat()

    data.forEachIndexed { i, balance ->
        if (i == 0) {
            path.moveTo(
                0f,
                size.height - (balance.amount - min.amount).toFloat() *
                    heightPxPerAmount
            )
        }

        val balanceX = i * weekWidth
        val balanceY = size.height - (balance.amount - min.amount).toFloat() *
            heightPxPerAmount
        path.lineTo(
            balanceX,
            balanceY
        )

        if (balance.amount == median) {
            repeat(data.size) {
                medianPath.lineTo(balanceX, balanceY)
            }
        }

    }
    return Pair(path, medianPath)
}