Code Sketch


yoiiiii
By: Mhalsakant School
Category: Programming
// ====================================================
// TURTLE REALISTIC PHOTO DRAWER V5
// FULL RGB COLOUR IMAGE TO KOJO SOURCE CODE
// DIRECT CLIPBOARD - NO UPLOAD
// ====================================================

import java.awt.Toolkit
import java.awt.BorderLayout
import java.awt.Font
import java.awt.datatransfer.DataFlavor
import java.awt.datatransfer.StringSelection
import java.awt.image.BufferedImage

import javax.swing._

// ====================================================
// SETTINGS
// ====================================================

val MAX_SIDE = 240

// ====================================================
// MAIN GENERATOR
// ====================================================

try {

    // GET IMAGE FROM CLIPBOARD

    val clipboard =
        Toolkit.getDefaultToolkit.getSystemClipboard

    val contents = clipboard.getContents(null)

    if (
        contents == null ||
        !contents.isDataFlavorSupported(
            DataFlavor.imageFlavor
        )
    ) {

        JOptionPane.showMessageDialog(
            null,
            "IMAGE NOT FOUND!\n\n" +
            "1. Open your photo in PAINT.\n" +
            "2. Press CTRL + A.\n" +
            "3. Press CTRL + C.\n" +
            "4. Run this generator again."
        )

    } else {

        val original =
            contents.getTransferData(
                DataFlavor.imageFlavor
            ).asInstanceOf[java.awt.Image]

        val icon = new ImageIcon(original)

        val originalW = icon.getIconWidth
        val originalH = icon.getIconHeight

        if (originalW <= 0 || originalH <= 0) {
            throw new Exception("Invalid image!")
        }

        // ============================================
        // HIGH QUALITY RESIZE
        // ============================================

        val ratio = math.min(
            1.0,
            MAX_SIDE.toDouble /
                math.max(originalW, originalH)
        )

        val w = math.max(
            1,
            (originalW * ratio).toInt
        )

        val h = math.max(
            1,
            (originalH * ratio).toInt
        )

        val img = new BufferedImage(
            w,
            h,
            BufferedImage.TYPE_INT_RGB
        )

        val graphics = img.createGraphics()

        graphics.setColor(java.awt.Color.WHITE)

        graphics.fillRect(0, 0, w, h)

        graphics.setRenderingHint(
            java.awt.RenderingHints.KEY_INTERPOLATION,
            java.awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC
        )

        graphics.setRenderingHint(
            java.awt.RenderingHints.KEY_RENDERING,
            java.awt.RenderingHints.VALUE_RENDER_QUALITY
        )

        graphics.drawImage(
            icon.getImage,
            0, 0, w, h,
            null
        )

        graphics.dispose()

        // ============================================
        // PRESERVE FULL RGB COLOURS
        // ============================================

        val rgbData = new Array[Byte](w * h * 3)

        for (y <- 0 until h) {

            for (x <- 0 until w) {

                val rgb = img.getRGB(x, y)

                val r = (rgb >> 16) & 255
                val g = (rgb >> 8) & 255
                val b = rgb & 255

                val k = (y * w + x) * 3

                rgbData(k) = r.toByte
                rgbData(k + 1) = g.toByte
                rgbData(k + 2) = b.toByte
            }
        }

        // ============================================
        // COMPRESS IMAGE DATA
        // ============================================

        val encoded =
            java.util.Base64
                .getEncoder
                .encodeToString(rgbData)

        // ============================================
        // GENERATE KOJO SOURCE CODE
        // ============================================

        val code = new StringBuilder

        def emit(s: String): Unit = {
            code.append(s).append("\n")
        }

        emit("// =======================================")
        emit("// TURTLE REALISTIC FULL COLOUR DRAWING")
        emit("// GENERATED FROM ORIGINAL RGB IMAGE")
        emit("// =======================================")

        emit("")

        emit("cleari()")
        emit("setBackground(white)")
        emit("setSpeed(fast)")
        emit("visible()")

        emit("")

        emit(
            "val IMAGE_W = " + w
        )

        emit(
            "val IMAGE_H = " + h
        )

        emit("")

        // SPLIT DATA INTO SMALL SOURCE STRINGS

        emit("val encodedImage = Array[String](")

        val chunks = encoded.grouped(3000).toArray

        for (i <- chunks.indices) {

            val comma =
                if (i < chunks.length - 1) ","
                else ""

            emit(
                "  \"" + chunks(i) + "\"" + comma
            )
        }

        emit(").mkString")

        emit("")

        emit(
            "val imageData = " +
            "java.util.Base64.getDecoder.decode(encodedImage)"
        )

        emit("")

        // ============================================
        // RGB READER
        // ============================================

        emit(
            "def getPixelColor(x: Int, y: Int): Int = {"
        )

        emit(
            "    val k = (y * IMAGE_W + x) * 3"
        )

        emit(
            "    val r = imageData(k) & 255"
        )

        emit(
            "    val g = imageData(k + 1) & 255"
        )

        emit(
            "    val b = imageData(k + 2) & 255"
        )

        emit(
            "    (r << 16) | (g << 8) | b"
        )

        emit("}")

        emit("")

        // ============================================
        // CANVAS FITTING
        // ============================================

        emit("val cb = canvasBounds")

        emit("val maxW = cb.width * 0.88")
        emit("val maxH = cb.height * 0.88")

        emit(
            "val scale = math.min(" +
            "maxW / IMAGE_W, maxH / IMAGE_H)"
        )

        emit("val drawW = IMAGE_W * scale")
        emit("val drawH = IMAGE_H * scale")

        emit(
            "val left = cb.x + (cb.width - drawW) / 2.0"
        )

        emit(
            "val bottom = cb.y + (cb.height - drawH) / 2.0"
        )

        emit(
            "val stepX = drawW / IMAGE_W"
        )

        emit(
            "val stepY = drawH / IMAGE_H"
        )

        emit("")

        // ============================================
        // COLOUR STROKE DRAWING ENGINE
        // ============================================

        emit(
            "setPenThickness(math.max(1.0, stepY * 1.12))"
        )

        emit("var totalStrokes = 0")

        emit("")

        emit("for (y <- 0 until IMAGE_H) {")

        emit("")

        emit("    var x = 0")

        emit("    val lineY = bottom + drawH - (y + 0.5) * stepY")

        emit("")

        emit("    while (x < IMAGE_W) {")

        emit("")

        emit("        val rgb = getPixelColor(x, y)")

        emit("        var end = x + 1")

        emit("")

        // MERGE IDENTICAL NEIGHBOURING COLOURS

        emit("        while (")

        emit("            end < IMAGE_W &&")

        emit("            getPixelColor(end, y) == rgb")

        emit("        ) {")

        emit("            end += 1")

        emit("        }")

        emit("")

        // EXTRACT RGB

        emit("        val r = (rgb >> 16) & 255")

        emit("        val g = (rgb >> 8) & 255")

        emit("        val b = rgb & 255")

        emit("")

        // APPLY ORIGINAL PHOTO COLOUR

        emit("        setPenColor(Color(r, g, b))")

        emit("")

        emit("        penUp()")

        emit(
            "        setPosition(left + x * stepX, lineY)"
        )

        emit("        penDown()")

        emit(
            "        lineTo(left + end * stepX, lineY)"
        )

        emit("")

        emit("        penUp()")

        emit("")

        emit("        totalStrokes += 1")

        emit("        x = end")

        emit("    }")

        emit("")

        emit("    if (y % 20 == 0) {")

        emit(
            "        println(\"Drawing row: \" + y + \" / \" + IMAGE_H)"
        )

        emit("    }")

        emit("}")

        emit("")

        emit("invisible()")

        emit("println(\"FULL COLOUR DRAWING COMPLETED!\")")

        emit(
            "println(\"Total strokes: \" + totalStrokes)"
        )

        val finalCode = code.toString

        // ============================================
        // SHOW GENERATED CODE WINDOW
        // ============================================

        SwingUtilities.invokeLater(
            new Runnable {

                override def run(): Unit = {

                    val frame = new JFrame(
                        "TURTLE REALISTIC PHOTO - GENERATED CODE"
                    )

                    frame.setDefaultCloseOperation(
                        WindowConstants.DISPOSE_ON_CLOSE
                    )

                    val area = new JTextArea(finalCode)

                    area.setFont(
                        new Font(
                            "Consolas",
                            Font.PLAIN,
                            12
                        )
                    )

                    area.setTabSize(4)
                    area.setEditable(false)

                    val scroll = new JScrollPane(area)

                    val copyButton = new JButton(
                        "COPY FULL REALISTIC COLOUR CODE"
                    )

                    copyButton.addActionListener(
                        new java.awt.event.ActionListener {

                            override def actionPerformed(
                                e: java.awt.event.ActionEvent
                            ): Unit = {

                                val selection =
                                    new StringSelection(area.getText)

                                Toolkit.getDefaultToolkit
                                    .getSystemClipboard
                                    .setContents(selection, null)

                                JOptionPane.showMessageDialog(
                                    frame,
                                    "FULL COLOUR CODE COPIED!\n\n" +
                                    "Open a NEW Kojo script.\n" +
                                    "Press CTRL + V.\n" +
                                    "Press RUN."
                                )
                            }
                        }
                    )

                    val info = new JLabel(
                        " Image: " + w + " x " + h +
                        " | Original RGB colours preserved"
                    )

                    val panel = new JPanel(
                        new BorderLayout()
                    )

                    panel.add(
                        info,
                        BorderLayout.CENTER
                    )

                    panel.add(
                        copyButton,
                        BorderLayout.SOUTH
                    )

                    frame.setLayout(
                        new BorderLayout()
                    )

                    frame.add(
                        scroll,
                        BorderLayout.CENTER
                    )

                    frame.add(
                        panel,
                        BorderLayout.SOUTH
                    )

                    frame.setSize(950, 700)

                    frame.setLocationRelativeTo(null)

                    frame.setVisible(true)
                }
            }
        )

        println("================================")
        println("REALISTIC COLOUR CODE GENERATED")
        println("================================")

        println("Resolution: " + w + " x " + h)

        println("RGB data: " + rgbData.length + " bytes")

        println("Source code ready!")

    }

} catch {

    case e: Exception =>

        println("GENERATOR ERROR:")

        println(e.toString)

        JOptionPane.showMessageDialog(
            null,
            "ERROR:\n" + e.toString
        )
}