1. TextureStereogram

TextureStereogram

Creates simple stereogram based on a very tall tiled texture rendered using:

1. Random plasma initialization
2. Standard VGG16 layers
3. Operators constraining and enhancing style
4. Progressive resolution increase
5. View layer to enforce tiling
6. Final rendering process combining the texture with a depth map to produce a stereogram

Code from TextureStereogram.scala:76 executed in 0.00 seconds (0.000 gc):

      implicit val _ = log
      // First, basic configuration so we publish to our s3 site
      log.setArchiveHome(URI.create(s"s3://$s3bucket/${getClass.getSimpleName.stripSuffix("$")}/${log.getId}/"))
      log.onComplete(() => upload(log): Unit)
      // Fetch image (user upload prompt) and display a rescaled copy
      log.out(log.jpg(ImageArtUtil.load(log, styleUrl, (maxWidth * Math.sqrt(magnification)).toInt), "Input Style"))
      // Render and display the depth map
      val depthImage = depthMap((maxHeight * maxAspect).toInt, maxHeight, text)
      log.out(log.jpg(depthImage.toImage, "Depth Map"))
      val canvas = new AtomicReference[Tensor](null)
  
      // Renders the sterogram
      def rendered = {
        val input = canvas.get()
        if (null == input) input else {
          Tensor.fromRGB(stereoImage(depthImage, input, depthFactor))
        }
      }
  
      // Tiling layer used by the optimization engine.
      // Expands the canvas by a small amount, using tile wrap to draw in the expanded boundary.
      def tiled(dims: Seq[Int]) = {
        val padding = Math.min(256, Math.max(16, dims(0) / 2))
        new ImgViewLayer(dims(0) + padding, dims(1) + padding, true)
          .setOffsetX(-padding / 2).setOffsetY(-padding / 2)
      }
  
      // Execute the main process while registered with the site index
      val registration = registerWithIndexJPG(rendered)
      try {
        // Display the stereogram
        withMonitoredJpg(() => rendered.toImage) {
          // Display an additional single tile of the texture canvas
          withMonitoredJpg(() => Option(canvas.get()).map(_.toRgbImage).orNull) {
            log.subreport("Painting", (sub: NotebookOutput) => {
              texture(maxHeight.toDouble / maxWidth, initUrl, canvas, new VisualStyleNetwork(
                styleLayers = List(
                  // We select all the lower-level layers to achieve a good balance between speed and accuracy.
                  VGG16.VGG16_0,
                  VGG16.VGG16_1a,
                  VGG16.VGG16_1b1,
                  VGG16.VGG16_1b2,
                  VGG16.VGG16_1c1,
                  VGG16.VGG16_1c2,
                  VGG16.VGG16_1c3
                ),
                styleModifiers = List(
                  // These two operators are a good combination for a vivid yet accurate style
                  new GramMatrixEnhancer(),
                  new MomentMatcher()
                ),
                styleUrl = List(styleUrl),
                magnification = magnification,
                viewLayer = tiled
              ), new BasicOptimizer {
                override val trainingMinutes: Int = 60
                override val trainingIterations: Int = 30
                override val maxRate = 1e9
              }, new GeometricSequence {
                override val min: Double = minWidth
                override val max: Double = maxWidth
                override val steps = 2
              }.toStream.map(_.round.toDouble))(sub)
              null
            })
            uploadAsync(log)
          }(log)
        }
        null
      } finally {
        registration.foreach(_.stop()(s3client, ec2client))
      }
    }

Returns:

    <function0>

Subreport: Painting