//设置package包名称以及导入依赖的类
package jerimum

import java.awt.{ Graphics2D, RenderingHints }

import scala.collection.SortedMap

import br.edu.ifrn.potigol.Potigolutil.Inteiro

object Desenho {
  private[this] val vazia = SortedMap[Inteiro, List[Graphics2D => Unit]]()
  private[this] var camadas = vazia
  private[this] def todos = camadas.values.flatten

  private[this] val rh = new RenderingHints(
    RenderingHints.KEY_TEXT_ANTIALIASING,
    RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB)

  def desenhe(g: Graphics2D): Unit = {
    g match {
      case g: Graphics2D =>
        g.setRenderingHints(rh)
    }
    todos.foreach(f => f(g))
    camadas = vazia
  }

  def incluir(z: Inteiro, funcao: Graphics2D => Unit) = {
    camadas += z -> (funcao :: camadas.getOrElse(z, Nil))
  }
} 

//设置package包名称以及导入依赖的类
package com.loopfor.pi

import java.awt.{AlphaComposite, Color, Font, RenderingHints}
import java.awt.image.BufferedImage
import java.io.File
import javax.imageio.ImageIO
import scala.io.Source

object Pi {
  private val Rows = 500
  private val Cols = 2000
  private val Watermark = "?"

  def main(args: Array[String]): Unit = {
    val lines = Source.fromFile("pi-formatted.txt").getLines

    // Calculate width and height of single row of digits.
    val font = new Font("Source Code Pro", Font.PLAIN, 10)
    var gr = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB).createGraphics()
    val (width, height) = try {
      gr.setFont(font)
      val metrics = gr.getFontMetrics
      (metrics.stringWidth("0" * Cols), metrics.getHeight * Rows)
    } finally
      gr.dispose()

    val image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB)

    // Render all digits.
    gr = image.createGraphics()
    gr.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)
    gr.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
    gr.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY)
    gr.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE)
    gr.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON)
    gr.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR)
    gr.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY)
    gr.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE)
    gr.setFont(font)
    gr.setColor(Color.BLACK)
    lines.foldLeft(0) { (r, line) =>
      gr.drawString(line, 0, (r + 1) * gr.getFontMetrics.getAscent)
      r + 1
    }

    // Render the Pi symbol overlay.
    gr.setFont(new Font("Symbol", Font.PLAIN, 6000))
    gr.setColor(Color.BLUE)
    gr.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, 0.8F))
    val bounds = gr.getFontMetrics.getStringBounds(Watermark, gr)
    val x = (width - bounds.getWidth) / 2
    val y = -bounds.getY - (height - bounds.getHeight) / 2
    gr.drawString(Watermark, x.toInt, y.toInt)
    gr.dispose()

    ImageIO.write(image, "PNG", new File("pi-poster.png"))
  }
} 

//设置package包名称以及导入依赖的类
package de.htwg.se.scala_risk.view
import java.awt.Image
import java.awt.image.BufferedImage
import java.awt.RenderingHints

object Scale {
  def getScaledImage(srcImg: Image, w: Int, h: Int): BufferedImage = {
    val resizedImg = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
    val g2 = resizedImg.createGraphics();

    g2.setRenderingHint(
      RenderingHints.KEY_INTERPOLATION,
      RenderingHints.VALUE_INTERPOLATION_BILINEAR
    );
    g2.drawImage(srcImg, 0, 0, w, h, null);
    g2.dispose();
    return resizedImg;
  }
}