Code Sketch


yoii black image genratio
By: Mhalsakant School
// ======================================================
// TURTLE REALISTIC B&W DRAWER V6
// CLIPBOARD IMAGE -> GRAYSCALE -> KOJO SOURCE CODE
// ======================================================

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 = 180
val CONTRAST = 1.18
val GRAY_STEP = 8

// ======================================================
// MAIN PROGRAM
// ======================================================

try {

    // READ CLIPBOARD IMAGE

    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 code 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!")
        }

        // ==================================================
        // RESIZE IMAGE
        // ==================================================

        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()

        // ==================================================
        // AUTOMATIC BLACK AND WHITE CONVERSION
        // ==================================================

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

        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

                // RGB TO GRAYSCALE

                val brightness =
                    0.299 * r +
                    0.587 * g +
                    0.114 * b

                // CONTRAST ENHANCEMENT

                val enhanced =
                    (brightness - 128.0) * CONTRAST + 128.0

                val clamped = math.max(
                    0.0,
                    math.min(255.0, enhanced)
                )

                // 33 SHADES OF BLACK AND WHITE

                val shade = math.max(
                    0,
                    math.min(
                        255,
                        ((clamped + GRAY_STEP / 2.0) /
                            GRAY_STEP).toInt * GRAY_STEP
                    )
                )

                grayData(y * w + x) = shade.toByte
            }
        }

        // ==================================================
        // ENCODE GRAYSCALE IMAGE
        // ==================================================

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

        // ==================================================
        // GENERATE COMPLETE KOJO SOURCE
        // ==================================================

        val code = new StringBuilder

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

        def number(n: Double): String = {
            java.lang.Double.toString(n)
        }

        emit("// ========================================")
        emit("// TURTLE REALISTIC BLACK AND WHITE DRAWING")
        emit("// AUTOMATIC GRAYSCALE IMAGE CONVERSION")
        emit("// GENERATED KOJO SCALA SOURCE")
        emit("// ========================================")

        emit("")

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

        emit("")

        emit("val IMAGE_W = " + w)
        emit("val IMAGE_H = " + h)

        emit("")

        // SPLIT DATA INTO SAFE SOURCE CHUNKS

        emit("val encodedGray = 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 grayData = java.util.Base64.getDecoder.decode(encodedGray)"
        )

        emit("")

        // ==================================================
        // CANVAS DIMENSIONS
        // ==================================================

        emit("val cb = canvasBounds")

        emit(
            "val aspect = IMAGE_W.toDouble / IMAGE_H"
        )

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

        emit(
            "val drawW = math.min(maxW, maxH * aspect)"
        )

        emit("val drawH = drawW / aspect")

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

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

        emit("")

        emit("val stepX = drawW / IMAGE_W")
        emit("val stepY = drawH / IMAGE_H")

        emit("")

        // ==================================================
        // READ PIXEL SHADE
        // ==================================================

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

        emit(
            "    grayData(y * IMAGE_W + x) & 255"
        )

        emit("}")

        emit("")

        // ==================================================
        // TURTLE DRAWING ENGINE
        // ==================================================

        emit("// REALISTIC GRAYSCALE DRAWING")

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

        emit("var totalStrokes = 0")

        emit("var previousShade = -1")

        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 shade = getShade(x, y)")

        emit("        var end = x + 1")

        // JOIN NEIGHBOURING SIMILAR SHADE AREAS

        emit("        while (")

        emit("            end < IMAGE_W &&")

        emit("            getShade(end, y) == shade")

        emit("        ) {")

        emit("            end += 1")

        emit("        }")

        emit("")

        // AUTOMATIC GRAYSCALE PEN COLOUR

        emit("        if (shade != previousShade) {")

        emit(
            "            setPenColor(Color(shade, shade, shade))"
        )

        emit("            previousShade = shade")

        emit("        }")

        emit("")

        // TURTLE DRAWING

        emit("        penUp()")

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

        emit("        penDown()")

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

        emit("")

        emit("        penUp()")

        emit("        totalStrokes += 1")

        emit("        x = end")

        emit("    }")

        emit("")

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

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

        emit("    }")

        emit("}")

        emit("")

        emit("penUp()")
        emit("invisible()")

        emit(
            "println(\"BLACK AND WHITE DRAWING COMPLETED!\")"
        )

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

        val finalCode = code.toString

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

        SwingUtilities.invokeLater(
            new Runnable {

                override def run(): Unit = {

                    val frame = new JFrame(
                        "TURTLE REALISTIC B&W - GENERATED CODE"
                    )

                    frame.setDefaultCloseOperation(
                        WindowConstants.DISPOSE_ON_CLOSE
                    )

                    val area = new JTextArea(finalCode)

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

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

                    val scroll = new JScrollPane(area)

                    val copyButton = new JButton(
                        "COPY FULL B&W TURTLE 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,
                                    "B&W CODE COPIED!\n\n" +
                                    "Open NEW Kojo Script.\n" +
                                    "Press CTRL + V.\n" +
                                    "Press RUN."
                                )
                            }
                        }
                    )

                    val info = new JLabel(
                        " Image: " + w + " x " + h +
                        " | Grayscale | " +
                        "33 tonal shades"
                    )

                    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("B&W IMAGE CONVERSION COMPLETED")
        println("================================")

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

        println("Grayscale shades: 33")

        println("Generated code ready!")

    }

} catch {

    case e: Exception =>

        println("GENERATOR ERROR:")
        println(e.toString)

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