println(s"P6 $width $height 255 ")

println(s"P6 $width $height 255 ")

if (args.length == 0) {
            new CardRaytracer(System.out).process()
            val res = (System.currentTimeMillis()-begin)/1000
            System.err.println(s"Elapsed time : $res sec\n")
            System.exit(1)
        } else if (args.length == 1) {
            def os = new FileOutputStream(args(0))
            new CardRaytracer(os).process()
            val res = (System.currentTimeMillis()-begin)/1000
            System.err.println(s"Elapsed time : $res sec\n")
            os.close()
            System.exit(2)
        } else if (args.length == 3) {
            def os = new FileOutputStream(args(0))
            new CardRaytracer(os, args(1).toInt, args(2).toInt).process()
            val res = (System.currentTimeMillis()-begin)/1000
            System.err.println(s"Elapsed time : $res sec\n")
            os.close()
            System.exit(2)
        }

class CardRaytracer(out_arg:io.OutputStream,width_arg:Int,height_arg:Int) {

    var out:OutputStream = out_arg
    var width:  Int      = width_arg
    var height: Int      = height_arg

    val WIDTH       = 512
    val HEIGHT      = 512
    val SUB_SAMPLES = 64

    .............


    def this(out2:OutputStream) {
        // TODO: Fix the constants usage
        // this(out2,WIDTH,HEIGHT)
        this(out2,512,512)
    }

}

  implicit class IntToBase( val digits:String ) extends AnyVal {
    def base(b:Int) = Integer.parseInt( digits, b )
    def b = base(2)
    def o = base(8)
    def x = base(16)
  }

    val G = Array(
      "00111100011100010010".b,
      "01000100100000010100".b,
      "01000100100000011000".b,
      "00111100111110010100".b,
      "00000100100010010010".b,
      "00000100100010010001".b,
      "00111000011100010000".b,
      "00000000000000010000".b,
      "00000000000000010000".b
    )

for (k <- (0 to 18).reverse) {
    for (j <- (0 to 8).reverse) {
          if ((G(j) & 1 << k) != 0) {
              .......

for (k <- (0 to 18).reverse ; j <- (0 to 8).reverse; if (G(j) & 1 << k) != 0) {
   ....
}

import java.io.{OutputStream, PrintWriter, FileOutputStream}
import System.out
import System.err
import java.util.Random

object Main {

  def main(args: Array[String]): Unit = {
    // println(s"Scala version : ${util.Properties.versionString}")

    val begin = System.currentTimeMillis
    def stream:OutputStream = new FileOutputStream("img/image1.ppm")
    new CardRaytracer(stream).process
    stream.close
    val res = (System.currentTimeMillis - begin) / 1000
    err.println(s"Elapsed time : $res sec\n")
    System.exit(1)
}}

  
class CardRaytracer(outputStream_arg:io.OutputStream, width_arg:Int, height_arg:Int) {

    var     outputStream:OutputStream    = outputStream_arg
    lazy val printWriter:PrintWriter     = new PrintWriter(outputStream)

    var width:  Int      = width_arg
    var height: Int      = height_arg

    def this(stream_arg:OutputStream) {
        this(stream_arg,WIDTH,HEIGHT)
    }

 def process() {
    printWriter.println(s"P3 $width $height 255 ")
    var g: Vector = !CAMERA_DEST_VECTOR
    var a: Vector = !(Z_ORTHO_VECTOR ^ g) * .002
    var b: Vector = !(g ^ a) * .002
    var c: Vector = (a + b) * -256.0 + g
    var cnt:Int = 0
    // TODO: During loop the PPM file contains data
    for (y <- (0 until height).reverse; x <- (0 until width).reverse) {
      var p: Vector = COLOR_DARK_GRAY_VECTOR
      /*for (r <- 0 until SUB_SAMPLES) {
        var t: Vector = a * (Random - 0.5) * 99.0 + b * (Random - 0.5) * 99.0
        p = sampler(
          CAMERA_ASPECT_VECTOR + t,
          !(t * -1 + (a * (Random + x) + b * (y + Random) + c) * 16)
        ) * 3.5 + p
      }*/
      var R: Int = p.x.toInt
      var G: Int = p.y.toInt
      var B: Int = p.z.toInt
      printWriter.println(s"$R $G $B")
      cnt = cnt + 1
    }
    printWriter.flush
    System.out.println(s"OK cnt = $cnt")
    // TODO: But after exit process file is empty
  }