aquascape.drawing.diagramToPicture.scala Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2023 Zainab Ali
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package aquascape.drawing

import cats.*
import cats.syntax.all.*
import doodle.algebra.*
import doodle.core.*
import doodle.syntax.all.*

object Picture
    extends BaseConstructor
    with ShapeConstructor
    with TextConstructor {
  type Algebra = Path & Layout & Size & Style & Text &
    doodle.algebra.Transform & Shape & Debug
}
type Picture[A] = doodle.algebra.Picture[Picture.Algebra, A]

// TODO: Raise a bug in doodle for tailRecM
private def foldLeftM[A, B, F[_]: Monad](
    as: List[A]
)(b: B)(f: (B, A) => F[B]): F[B] =
  as match {
    case h :: t => foldLeftM(t)(b)(f).flatMap(f(_, h))
    case Nil    => b.pure[F]
  }

object DiagramToPicture {
  // Draw an arrow in the Y direction, with the origin at the base of the arrow
  private def arrow(config: Config)(length: Int): Picture[Unit] = {
    val l = length.abs
    val arrowheadHalfHeight = config.arrowBaseHalfWidth
    val arrowheadHeight = arrowheadHalfHeight * 2
    val arrowHead = Picture
      .triangle(config.arrowBaseHalfWidth * 2, arrowheadHeight)
      .originAt(0.0, arrowheadHalfHeight)
      .at(0.0, l)
    OpenPath.empty.lineTo(0, l).path.on(arrowHead)
  }

  private[drawing] def start(config: Config): Picture[Unit] = Picture
    .circle(config.arrowBaseWidth)
    .strokeColor(config.startDotColor)
    .fillColor(config.startDotColor)
    .at(
      config.progressPaddingLeft + config.arrowBaseHalfWidth,
      0
    )

  private[drawing] def pull(
      config: Config,
      progressOffset: Int,
      i: Item.Pull
  ): Picture[Unit] = {
    arrow(config)((i.from - i.to).abs * config.stageHeight - 5)
      // Position the base of the arrow
      .at(
        progressOffset + config.arrowBaseHalfWidth,
        i.from * config.stageHeight
      )
      .strokeColor(config.pullColor)
      .fillColor(config.pullColor)
  }

  private[drawing] def done(
      config: Config,
      progressOffset: Int,
      i: Item.Done
  ): Picture[Unit] = {
    val text = Picture
      // Draw text centered around (0.0, 0.0)
      .text("✔")
      .font(config.font)
    val length = i.from - i.to
    text.width.flatMap { width =>
      // Draw an arrow upwards
      arrow(config)(length * config.stageHeight - 5)
        // Reflect in the X axis such that the arrow head is in negative Y
        .verticalReflection
        // Move the origin to the centre of the arrow line.
        .originAt(0.0, -(length * config.stageHeight - 5).abs * 0.5)
        .beside(text)
        // Position the origin at the top
        .originAt(
          -((width / 2.0)),
          (length * config.stageHeight + 5).abs * 0.5
        )
        // Position the base of the arrow at the "from" stage
        .at(
          progressOffset + config.arrowBaseHalfWidth,
          i.from * config.stageHeight
        )
        .strokeColor(config.doneColor)
        .fillColor(config.doneColor)
    }
  }

  private[drawing] def pullToOutput(
      config: Config,
      progressOffset: Int,
      offsets: Map[Int, Int],
      from: Int,
      pullProgress: Int
  ): Picture[Unit] = {
    val pullOffset = offsets(pullProgress)
    OpenPath.empty
      .moveTo(
        pullOffset + config.arrowBaseHalfWidth,
        from * config.stageHeight - 5
      )
      .lineTo(
        progressOffset + config.arrowBaseHalfWidth,
        from * config.stageHeight - 5
      )
      .path
  }

  private[drawing] def output(
      config: Config,
      progressOffset: Int,
      i: Item.Output
  ): Picture[Unit] = {
    val length = (i.from - i.to).abs
    val text = Picture
      // Draw text centered around (0.0, 0.0)
      .text(i.value)
      .font(config.font)
      .strokeColor(config.outputColor)
    text.width.flatMap { width =>
      // Draw an arrow upwards
      arrow(config)(length * config.stageHeight - 5)
        // Reflect in the X axis such that the arrow head is in negative Y
        .verticalReflection
        // Move the origin to the centre of the arrow line.
        .originAt(0.0, -(length * config.stageHeight - 5).abs * 0.5)
        // Position "beside" the text. The origin is at the centre X and 0Y.
        .beside(text)
        // Position the origin at the top left
        .originAt(
          -(config.arrowBaseHalfWidth + (width / 2.0)),
          (length * config.stageHeight + 5).abs * 0.5
        )
        .at(progressOffset, i.from * config.stageHeight)
        .strokeColor(config.outputColor)
        .fillColor(config.outputColor)
    }
  }

  private[drawing] def eval(
      config: Config,
      progressOffset: Int,
      totalNumStages: Int,
      i: Item.Eval
  ): Picture[Unit] = {
    val box = Picture
      .text(i.value)
      .font(config.font)
      .strokeColor(config.evalColor)
      .fillColor(config.evalColor)
    (box.width, box.height).flatMapN { (width, height) =>
      val effectBox = box
        .on(
          Picture
            .rectangle(
              width = width + config.textBoxPaddingWidth,
              height = height + config.textBoxPaddingHeight
            )
            .fillColor(Color.white)
        )
        .strokeColor(config.evalColor)
        .originAt(-width / 2.0, 0.0)
      val margin = Picture
        .circle(
          diameter = width + 4 * config.textBoxPaddingWidth
        )
        .noStroke
        .noFill
      effectGridLine(config, totalNumStages)
        .beside(effectBox)
        .beside(effectGridLine(config, totalNumStages))
        .on(margin)
        .at(
          progressOffset + config.arrowBaseWidth + config.textBoxPaddingWidth,
          -1 * config.stageHeight
        )
    }
  }
  private[drawing] def error(
      config: Config,
      progressOffset: Int,
      i: Item.Error
  ): Picture[Unit] = {
    val length = (i.from - i.to).abs
    val text = Picture
      // Draw text centered around (0.0, 0.0)
      .text(i.value)
      .font(config.font)
      .strokeColor(config.errorColor)
    text.width.flatMap { width =>
      // Draw an arrow upwards
      arrow(config)(length * config.stageHeight - 5)
        // Reflect in the X axis such that the arrow head is in negative Y
        .verticalReflection
        // Move the origin to the centre of the arrow line.
        .originAt(0.0, -(length * config.stageHeight - 5).abs * 0.5)
        // Position "beside" the text. The origin is at the centre X and 0Y.
        .beside(text)
        // Position the origin at the top left
        .originAt(
          -(config.arrowBaseHalfWidth + (width / 2.0)),
          (length * config.stageHeight + 5).abs * 0.5
        )
        .at(progressOffset, i.from * config.stageHeight)
        .strokeColor(config.errorColor)
        .fillColor(config.errorColor)
    }
  }

  private[drawing] def time(
      config: Config,
      progressOffset: Int,
      totalNumStages: Int,
      i: Item.Time
  ): Picture[Unit] = {
    val box = Picture
      .text(s"${i.value}s")
      .font(config.font)
      .strokeColor(config.timeColor)
      .fillColor(config.timeColor)
    (box.width, box.height).flatMapN { (width, height) =>
      val circle = box.on(
        Picture
          .circle(
            diameter = width + 2 * config.textBoxPaddingWidth
          )
          .strokeColor(config.timeColor)
          .fillColor(Color.white)
      )
      val margin = Picture
        .circle(
          diameter = width + 4 * config.textBoxPaddingWidth
        )
        .noStroke
        .noFill
      effectGridLine(config, totalNumStages)
        .beside(circle)
        .beside(effectGridLine(config, totalNumStages))
        .on(margin)
        .originAt(-(width + 4 * config.textBoxPaddingWidth) / 2.0, 0.0)
        .at(
          progressOffset,
          -1 * config.stageHeight
        )
    }
  }

  private def effectGridLine(
      config: Config,
      totalNumStages: Int
  ): Picture[Unit] = {
    // val line =
    OpenPath.empty
      .lineTo(0, (1 + totalNumStages) * config.stageHeight)
      .path
      .strokeColor(config.gridLineColor)
      .strokeDash(config.gridLineStrokeDash.map(_.toDouble))
  }

  private[drawing] def finished(
      config: Config,
      progressOffset: Int,
      i: Item.Finished
  ): Picture[Unit] = {
    val color = if (i.errored) config.errorColor else config.startDotColor
    val innerCircle = Picture
      .circle(config.arrowBaseWidth * 0.6)
      .strokeColor(color)
      .fillColor(color)
    val outerCircle =
      Picture
        .circle(config.arrowBaseWidth)
        .strokeColor(color)
        .fillColor(Color.white)
    val text = Picture
      .text(i.value)
      .font(config.font)
      .strokeColor(color)
      .fillColor(color)
    text.width.flatMap { width =>
      innerCircle
        .on(outerCircle)
        .beside(text.originAt(-width / 2 - config.arrowBaseHalfWidth, 0))
        .originAt(-width / 2 - config.arrowBaseHalfWidth, 0)
        .at(
          progressOffset + config.arrowBaseHalfWidth,
          i.at * config.stageHeight
        )
    }
  }

  // TODO: Draw different lines when a stage is done. E.g on "repeat"
  private def stageLine(
      config: Config,
      diagramWidth: Int,
      index: Int
  ): Picture[Unit] = {
    OpenPath.empty
      .lineTo(diagramWidth, 0)
      .path
      .strokeColor(config.gridLineColor)
      .strokeDash(config.gridLineStrokeDash.map(_.toDouble))
      .at(0, index * config.stageHeight)
  }

  private[drawing] def label(
      config: Config,
      diagramWidth: Int
  )(text: String, index: Int): Picture[Unit] = {
    def labelDimensions(config: Config, text: String): Picture[(Int, Int)] = {
      val box = Picture
        .text(text)
        .font(config.font)
      (box.width.map(_.toInt), box.height.map(_.toInt)).tupled
    }

    labelDimensions(config, text).flatMap { (width, height) =>
      val labelBoxWidth = width + config.labelPaddingWidth
      Picture
        .text(text)
        .fillColor(config.labelColor)
        .on(
          Picture.rectangle(
            width = labelBoxWidth,
            height = height + config.labelPaddingHeight
          )
        )
        .at(-labelBoxWidth / 2, index * config.stageHeight)
        .font(config.font)
        .strokeColor(config.stageColor)
        .on(stageLine(config, diagramWidth, index))
    }
  }
}
private[drawing] def diagramToPicture(
    config: Config
)(diagram: Diagram): Picture[Unit] = {
  val totalNumStages: Int = diagram.items.collect { case i: Item.Pull =>
    i.to
  }.max

  def picture(
      item: Item,
      progressOffset: Int,
      offsets: Map[Int, Int]
  ): Picture[Unit] = {
    item match {
      case i: Item.Pull =>
        // Draw an arrow upwards
        DiagramToPicture.pull(config, progressOffset, i)
      case i: Item.Done =>
        val done = DiagramToPicture.done(config, progressOffset, i)
        val pullToOutput = DiagramToPicture.pullToOutput(
          config,
          progressOffset,
          offsets,
          i.from,
          i.pullProgress
        )
        done.on(pullToOutput)
      case i: Item.Output =>
        val output = DiagramToPicture.output(config, progressOffset, i)
        val pullToOutput = DiagramToPicture.pullToOutput(
          config,
          progressOffset,
          offsets,
          i.from,
          i.pullProgress
        )
        output.on(pullToOutput)
      case i: Item.Eval =>
        DiagramToPicture.eval(config, progressOffset, totalNumStages, i)
      case i: Item.Time =>
        DiagramToPicture.time(config, progressOffset, totalNumStages, i)
      case i: Item.Error =>
        val error = DiagramToPicture.error(config, progressOffset, i)
        val pullToOutput = DiagramToPicture.pullToOutput(
          config,
          progressOffset,
          offsets,
          i.from,
          i.pullProgress
        )
        error.on(pullToOutput)
      case i: Item.Finished =>
        DiagramToPicture.finished(config, progressOffset, i)
    }
  }
  foldLeftM(diagram.items.zipWithIndex.reverse)(
    (
      config.progressPaddingLeft,
      Map.empty[Int, Int],
      List.empty[Picture[Unit]]
    )
  )((b, item) =>
    (b, item) match {
      case ((progressOffset, offsets, pics), (i, idx)) =>
        val pic = picture(i, progressOffset, offsets)
        pic.width.map { nextOffset =>
          val nextOffsets = offsets + ((idx, progressOffset))
          (nextOffset.toInt, nextOffsets, pic :: pics)
        }
    }
  )
    .flatMap { case (progressOffset, offsets, pictures: List[Picture[Unit]]) =>
      (pictures ++ List(
        DiagramToPicture.start(config)
      ) ++ diagram.labels.zipWithIndex.map(
        DiagramToPicture.label(config, progressOffset)
      )).reduce(_ on _)
    }
}