Pi-Powered Infinite Art Frame (Kotlin on Raspberry Pi)¶

plugins {
    kotlin("jvm") version "1.9.23"
    id("com.github.johnrengelman.shadow") version "8.1.1"
    application
}

repositories { mavenCentral() }

dependencies {
    implementation(kotlin("stdlib"))
    implementation("io.ktor:ktor-server-netty:2.3.11")
    implementation("io.ktor:ktor-server-core:2.3.11")
    implementation("io.ktor:ktor-server-content-negotiation:2.3.11")
    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.11")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
}

application { mainClass.set("artframe.MainKt") }

// Params.kt
package artframe

import java.util.concurrent.atomic.AtomicReference
import kotlinx.serialization.Serializable

@Serializable
data class ArtParams(
    val seed: Long       = 42L,
    val palette: String  = "dawn",
    val speedSeconds: Int = 10,
    val paletteMix: Float = 0.0f,  // 0.0 = current palette, 1.0 = next
)

// Thread-safe holder — renderer and HTTP handler share this reference
val PARAMS = AtomicReference(ArtParams())

// TimePhase.kt
package artframe

import java.time.LocalTime

enum class Phase { DAWN, DAY, DUSK, NIGHT }

fun currentPhase(): Phase {
    val h = LocalTime.now().hour
    return when {
        h in 5..8   -> Phase.DAWN
        h in 9..17  -> Phase.DAY
        h in 18..21 -> Phase.DUSK
        else         -> Phase.NIGHT
    }
}

fun phaseToDefaultPalette(p: Phase) = when(p) {
    Phase.DAWN  -> "dawn"
    Phase.DAY   -> "daylight"
    Phase.DUSK  -> "ember"
    Phase.NIGHT -> "midnight"
}

// Renderer.kt
package artframe

import artframe.Algorithms.drawFlowField
import java.awt.RenderingHints
import java.awt.image.BufferedImage
import java.io.File
import java.nio.file.Files
import java.nio.file.StandardCopyOption
import javax.imageio.ImageIO

object Renderer {
    private const val W = 1920; private const val H = 1080
    private val outDir = File("/tmp/artframe").also { it.mkdirs() }

    fun render(params: ArtParams) {
        // headless = no display required
        System.setProperty("java.awt.headless", "true")

        val img = BufferedImage(W, H, BufferedImage.TYPE_INT_RGB)
        val g = img.createGraphics().apply {
            setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
        }

        drawFlowField(g, W, H, params)  // your algorithm here
        g.dispose()

        // Atomic write: temp → rename
        val tmp  = File(outDir, "next.png")
        val dest = File(outDir, "latest.png")
        ImageIO.write(img, "PNG", tmp)
        Files.move(tmp.toPath(), dest.toPath(), StandardCopyOption.ATOMIC_MOVE,
                   StandardCopyOption.REPLACE_EXISTING)
    }
}

// Algorithms.kt — partial snippet
package artframe

import artframe.Palette.colorForPalette
import java.awt.BasicStroke
import java.awt.Graphics2D
import kotlin.math.*
import kotlin.random.Random

object Algorithms {
    fun drawFlowField(g: Graphics2D, w: Int, h: Int, params: ArtParams) {
        val rng = Random(params.seed)
        val pal = colorForPalette(params.palette)

        g.color = pal.background
        g.fillRect(0, 0, w, h)
        g.stroke = BasicStroke(1.2f)

        val step = 12; val len = 40; val angScale = 0.004f
        for (sy in 0 until h step step) {
            for (sx in 0 until w step step) {
                var x = sx.toFloat(); var y = sy.toFloat()
                val alpha = (rng.nextFloat() * 180 + 40).toInt()
                g.color = java.awt.Color(pal.strokes[rng.nextInt(pal.strokes.size)].rgb
                    .let { java.awt.Color(it) }.let {
                        java.awt.Color(it.red, it.green, it.blue, alpha)
                    })
                for (s in 0..len) {
                    val angle = sin(x * angScale + params.seed * 0.001f) *
                                cos(y * angScale) * PI.toFloat() * 2f
                    val nx = x + cos(angle) * step * 0.4f
                    val ny = y + sin(angle) * step * 0.4f
                    g.drawLine(x.toInt(), y.toInt(), nx.toInt(), ny.toInt())
                    x = nx; y = ny
                    if (x < 0 || x >= w || y < 0 || y >= h) break
                }
            }
        }
    }
}

// Api.kt
package artframe

import io.ktor.server.application.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json

fun startApi() = embeddedServer(Netty, port = 8080) {
    routing {
        get("/status") {
            call.respondText(Json.encodeToString(PARAMS.get()),
                             contentType = io.ktor.http.ContentType.Application.Json)
        }
        post("/palette/{name}") {
            val name = call.parameters["name"] ?: "dawn"
            PARAMS.updateAndGet { it.copy(palette = name) }
            call.respondText("palette set to $name")
        }
        post("/seed/{n}") {
            val n = call.parameters["n"]?.toLongOrNull() ?: return@post
            PARAMS.updateAndGet { it.copy(seed = n) }
            call.respondText("seed set to $n")
        }
        post("/speed/{f}") {
            val f = call.parameters["f"]?.toIntOrNull() ?: return@post
            PARAMS.updateAndGet { it.copy(speedSeconds = f.coerceIn(1, 3600)) }
            call.respondText("speed set to ${f}s")
        }
    }
}.start(wait = false)

// Main.kt
package artframe

import kotlinx.coroutines.*

fun main() {
    println("Pi Art Frame starting…")
    startApi()

    runBlocking {
        // Phase-sync: update palette once per minute based on time of day
        launch {
            while (true) {
                val phase = currentPhase()
                val target = phaseToDefaultPalette(phase)
                PARAMS.updateAndGet { it.copy(palette = target) }
                delay(60_000)
            }
        }

        // Render loop
        while (true) {
            val params = PARAMS.get()
            try {
                Renderer.render(params)
                // Drift seed slightly each frame for organic variation
                PARAMS.updateAndGet { it.copy(seed = it.seed + 1) }
            } catch (e: Exception) {
                System.err.println("Render error: ${e.message}")
            }
            delay(params.speedSeconds * 1000L)
        }
    }
}