Code Sketch
yoiiiii
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
)
}