Added weather image generation

.gitignore

@@ -4,3 +4,4 @@
 /bot.properties
 /bot.properties.debug
 /lets-plot-images
+/weather-*.png

src/main/kotlin/com/sirekanyan/andersrobot/AndersController.kt

@@ -2,9 +2,12 @@ package com.sirekanyan.andersrobot
 
 import com.sirekanyan.andersrobot.api.Forecast
 import com.sirekanyan.andersrobot.api.WeatherApi
+import com.sirekanyan.andersrobot.extensions.logError
 import com.sirekanyan.andersrobot.extensions.sendPhoto
 import com.sirekanyan.andersrobot.extensions.sendText
 import com.sirekanyan.andersrobot.extensions.sendWeather
+import com.sirekanyan.andersrobot.image.generateImage
+import com.sirekanyan.andersrobot.image.plotForecast
 import com.sirekanyan.andersrobot.repository.CityRepository
 import com.sirekanyan.andersrobot.repository.supportedLanguages
 import jetbrains.letsPlot.export.ggsave
@@ -13,6 +16,7 @@ import org.telegram.telegrambots.meta.api.objects.Update
 import org.telegram.telegrambots.meta.bots.AbsSender
 import java.io.File
 import java.util.*
+import javax.imageio.ImageIO
 
 private const val DEFAULT_CITY_ID = 524901L // Moscow
 
@@ -85,9 +89,16 @@ class AndersController(
     private fun showWeather(chatId: Long, language: String?) {
         val dbCities = repository.getCities(chatId)
         val cities = dbCities.ifEmpty { listOf(DEFAULT_CITY_ID) }
-        val temperatures = api.getWeathers(cities, language)
-        check(temperatures.isNotEmpty())
-        sender.sendText(chatId, temperatures.joinToString("\n") { it.format() })
+        val weathers = api.getWeathers(cities, language)
+        check(weathers.isNotEmpty())
+        try {
+            val file = File("weather-$chatId.png")
+            ImageIO.write(generateImage(weathers), "png", file)
+            sender.sendPhoto(chatId, file)
+        } catch (exception: Exception) {
+            sender.logError("Cannot send image to $chatId", exception)
+            sender.sendText(chatId, weathers.joinToString("\n") { it.format() })
+        }
     }
 
     private fun showForecast(chatId: Long, forecast: Forecast, locale: Locale) {

src/main/kotlin/com/sirekanyan/andersrobot/api/Weather.kt

@@ -1,30 +1,54 @@
 package com.sirekanyan.andersrobot.api
 
+import com.sirekanyan.andersrobot.image.FileProvider
+import com.sirekanyan.andersrobot.image.ImageProvider
 import kotlinx.serialization.Serializable
+import java.awt.Color
+import java.awt.image.BufferedImage
 import java.io.File
 import kotlin.math.roundToInt
 
+const val WIDTH = 504
+const val HEIGHT = 64
+private val fileProvider = FileProvider("webp")
+private val imageProvider = ImageProvider("png", WIDTH, HEIGHT)
+private val lightBackgroundIds = setOf(210, 212, 221, 504, 611, 701, 711, 721, 731, 800, 803, 902, 903)
+
 @Serializable
 data class Weather(
     val main: MainInfo,
     val id: Long,
     val name: String,
     val sys: System,
-    val weather: List<Condition>
+    val weather: List<Condition>,
 ) {
 
+    val temperature: String
+        get() = "${main.temp.roundToInt()}°C"
+
+    private val primaryCondition: Condition?
+        get() = weather.firstOrNull()
+
     @Serializable
     data class System(val country: String = "")
 
     @Serializable
     data class Condition(val id: Int)
 
-    fun findImageFile(): File? {
-        val w = weather.firstOrNull() ?: return null
-        return File("data/${w.id}.webp").takeIf { it.exists() }
+    fun findStickerFile(): File? {
+        val id = primaryCondition?.id ?: return null
+        return fileProvider.findFile(id)
+    }
+
+    fun findBackgroundImage(): BufferedImage? {
+        val id = primaryCondition?.id ?: return null
+        return imageProvider.findImage(id)
     }
 
     fun format(): String =
-        "$name ${main.temp.roundToInt()}°C"
+        "$name $temperature"
+
+    fun getTextColor(): Color =
+        if (primaryCondition?.id in lightBackgroundIds) Color.BLACK else Color.WHITE
 
 }

src/main/kotlin/com/sirekanyan/andersrobot/extensions/AbsSender.kt

@@ -19,10 +19,10 @@ fun AbsSender.sendPhoto(chatId: Long, file: File): Message =
     execute(SendPhoto().setChatId(chatId).setPhoto(file))
 
 fun AbsSender.sendWeather(chatId: Long, weather: Weather) {
-    weather.findImageFile()?.let { icon ->
+    weather.findStickerFile()?.let { icon ->
         sendSticker(chatId, icon)
     }
-    sendText(chatId, weather.format())
+    sendText(chatId, "${weather.name} ${weather.temperature}")
 }
 
 private fun AbsSender.sendSticker(chatId: Long, file: File) {

src/main/kotlin/com/sirekanyan/andersrobot/extensions/Map.kt

@@ -0,0 +1,17 @@
+package com.sirekanyan.andersrobot.extensions
+
+import kotlin.math.absoluteValue
+
+fun <T> Map<Int, T>.getClosest(k: Int): T? {
+    var resultKey: Int? = null
+    var resultDiff = Int.MAX_VALUE
+    for (key in keys.sorted()) {
+        val diff = (key - k).absoluteValue
+        if (diff <= resultDiff) {
+            resultKey = key
+            resultDiff = diff
+        }
+    }
+    println("Using $resultKey instead of $k")
+    return get(resultKey)
+}

src/main/kotlin/com/sirekanyan/andersrobot/image/FileProvider.kt

@@ -0,0 +1,19 @@
+package com.sirekanyan.andersrobot.image
+
+import com.sirekanyan.andersrobot.extensions.getClosest
+import java.io.File
+import java.io.FilenameFilter
+
+class FileProvider(extension: String) {
+
+    private val fileRegex = Regex("\\d{3}.$extension")
+    private val fileFilter = FilenameFilter { _, name -> name.matches(fileRegex) }
+    private val files: Map<Int, File> =
+        checkNotNull(File("data").listFiles(fileFilter))
+            .associateBy({ it.nameWithoutExtension.toInt() }, { it })
+
+    fun getFiles(): Map<Int, File> = files
+
+    fun findFile(key: Int): File? = files[key] ?: files.getClosest(key)
+
+}

src/main/kotlin/com/sirekanyan/andersrobot/LetsPlot.kt → src/main/kotlin/com/sirekanyan/andersrobot/image/ForecastPlotter.kt

@@ -1,4 +1,4 @@
-package com.sirekanyan.andersrobot
+package com.sirekanyan.andersrobot.image
 
 import com.sirekanyan.andersrobot.api.Forecast
 import jetbrains.datalore.base.values.Color

src/main/kotlin/com/sirekanyan/andersrobot/image/ImageGenerator.kt

@@ -0,0 +1,64 @@
+package com.sirekanyan.andersrobot.image
+
+import com.sirekanyan.andersrobot.api.HEIGHT
+import com.sirekanyan.andersrobot.api.WIDTH
+import com.sirekanyan.andersrobot.api.Weather
+import java.awt.Font
+import java.awt.Font.TRUETYPE_FONT
+import java.awt.FontMetrics
+import java.awt.Graphics2D
+import java.awt.RenderingHints.KEY_TEXT_ANTIALIASING
+import java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON
+import java.awt.image.BufferedImage
+import java.awt.image.BufferedImage.TYPE_INT_RGB
+import java.io.File
+
+private const val PADDING = 24
+private val montserratFont = Font.createFont(TRUETYPE_FONT, File("data/Montserrat-Light.ttf"))
+private val cityFont = montserratFont.deriveFont(32f)
+private val tempFont = montserratFont.deriveFont(42f)
+
+fun generateImage(weathers: List<Weather>): BufferedImage {
+    val image = BufferedImage(WIDTH, HEIGHT * weathers.size, TYPE_INT_RGB)
+    val graphics = image.createGraphics()
+    graphics.setRenderingHint(KEY_TEXT_ANTIALIASING, VALUE_TEXT_ANTIALIAS_ON)
+    graphics.drawWeatherImages(weathers)
+    graphics.dispose()
+    return image
+}
+
+private fun Graphics2D.drawWeatherImages(weathers: List<Weather>) {
+    weathers.forEachIndexed { index, weather ->
+        weather.findBackgroundImage()?.let { image ->
+            drawWeatherImage(index, image)
+        }
+        drawWeatherText(index, weather)
+    }
+}
+
+private fun Graphics2D.drawWeatherImage(index: Int, image: BufferedImage) {
+    drawImage(image, 0, HEIGHT * index, null)
+}
+
+private fun Graphics2D.drawWeatherText(index: Int, weather: Weather) {
+    color = weather.getTextColor()
+    font = cityFont
+    drawCityText(index, weather.name)
+    font = tempFont
+    drawTempText(index, weather.temperature)
+}
+
+private fun Graphics2D.drawCityText(index: Int, text: String) {
+    val x = PADDING
+    val y = fontMetrics.textY(index)
+    drawString(text, x, y)
+}
+
+private fun Graphics2D.drawTempText(index: Int, text: String) {
+    val x = WIDTH - PADDING - fontMetrics.stringWidth(text)
+    val y = fontMetrics.textY(index)
+    drawString(text, x, y)
+}
+
+private fun FontMetrics.textY(index: Int): Int =
+    (HEIGHT - height) / 2 + ascent + HEIGHT * index

src/main/kotlin/com/sirekanyan/andersrobot/image/ImageProvider.kt

@@ -0,0 +1,21 @@
+package com.sirekanyan.andersrobot.image
+
+import com.sirekanyan.andersrobot.extensions.getClosest
+import java.awt.image.BufferedImage
+import javax.imageio.ImageIO
+
+class ImageProvider(extension: String, width: Int, height: Int) {
+
+    private val fileProvider = FileProvider(extension)
+    private val images: Map<Int, BufferedImage> =
+        fileProvider.getFiles()
+            .mapValues { (_, file) -> ImageIO.read(file) }
+            .onEach { (id, image) ->
+                checkNotNull(image) { "Cannot read image $id.$extension" }
+                check(image.width == width) { "Wrong image width for $id" }
+                check(image.height == height) { "Wrong image height for $id" }
+            }
+
+    fun findImage(key: Int): BufferedImage? = images[key] ?: images.getClosest(key)
+
+}

src/test/kotlin/com/sirekanyan/andersrobot/MapTest.kt

@@ -0,0 +1,44 @@
+package com.sirekanyan.andersrobot
+
+import com.sirekanyan.andersrobot.extensions.getClosest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class MapTest {
+
+    @Test
+    fun getClosestTest0() {
+        assertEquals(null, mapOf<Int, String>().getClosest(0))
+    }
+
+    @Test
+    fun getClosestTest1() {
+        assertEquals("zero", mapOf(0 to "zero").getClosest(0))
+    }
+
+    @Test
+    fun getClosestTest2() {
+        assertEquals("zero", mapOf(0 to "zero").getClosest(1))
+    }
+
+    @Test
+    fun getClosestTest3() {
+        assertEquals("two", mapOf(0 to "zero", 2 to "two").getClosest(1))
+    }
+
+    @Test
+    fun getClosestTest4() {
+        assertEquals("two", mapOf(2 to "two", 0 to "zero").getClosest(1))
+    }
+
+    @Test
+    fun getClosestTest5() {
+        assertEquals("zero", mapOf(0 to "zero", 3 to "three").getClosest(1))
+    }
+
+    @Test
+    fun getClosestTest6() {
+        assertEquals("three", mapOf(0 to "zero", 3 to "three").getClosest(2))
+    }
+
+}