Libvips cropping

build.sbt

@@ -126,6 +126,7 @@ lazy val commonLib = project("common-lib").settings(
     // declare explicit dependency on desired version of aws sdk v2 bedrock runtime
     "software.amazon.awssdk" % "bedrockruntime" % awsSdkV2Version,
     "software.amazon.awssdk" % "s3vectors" % awsSdkV2Version,
+    "com.adobe.xmp" % "xmpcore" % "6.1.11",
     ws,
     "org.testcontainers" % "testcontainers-elasticsearch" % "2.0.2" % Test,
   ),

common-lib/src/main/scala/com/gu/mediaservice/lib/imaging/im4jwrapper/ImageMagick.scala

@@ -87,14 +87,6 @@ object ImageMagick extends GridLogging {
     op
   }
 
-  def runConvertCmd(op: IMOperation, useImageMagick: Boolean)(implicit logMarker: LogMarker): Future[Unit] = {
-    Stopwatch.async(s"Using ${if(useImageMagick) "imagemagick" else "graphicsmagick"} for imaging conversion operation '$op'") {
-      Future {
-        new ConvertCmd(!useImageMagick).run(op)
-      }
-    }
-  }
-
   def runIdentifyCmd(op: IMOperation, useImageMagick: Boolean)(implicit logMarker: LogMarker): Future[List[String]] = {
     Stopwatch.async(s"Using ${if (useImageMagick) "imagemagick" else "graphicsmagick"} for imaging identification operation '$op'") {
       Future {

common-lib/src/test/resources/schaik.com_pngsuite/README.md

@@ -0,0 +1,25 @@
+Test PNG images
+===============
+
+These images are taken from http://www.schaik.com/pngsuite/pngsuite_bas_png.html
+
+     basn0g08 - 8 bit (256 level) grayscale 
+     basn2c08 - 3x8 bits rgb color 
+     basn3p08 - 8 bit (256 color) paletted 
+     basn6a08 - 3x8 bits rgb color + 8 bit alpha-channel 
+
+LICENCE
+-------
+
+At the time of downloading these images the licence file at http://www.schaik.com/pngsuite/PngSuite.LICENSE contained the following text:
+
+```
+PngSuite
+--------
+
+Permission to use, copy, modify and distribute these images for any
+purpose and without fee is hereby granted.
+
+
+(c) Willem van Schaik, 1996, 2011
+``` 

common-lib/src/test/scala/com/gu/mediaservice/lib/imaging/ImageOperationsTest.scala

@@ -1,20 +1,19 @@
 package com.gu.mediaservice.lib.imaging
 
+import app.photofox.vipsffm.jextract.VipsRaw
 import app.photofox.vipsffm.{VImage, Vips}
-import app.photofox.vipsffm.Vips
 import com.gu.mediaservice.lib.BrowserViewableImage
 import com.gu.mediaservice.lib.logging.{LogMarker, MarkerMap}
-import com.gu.mediaservice.model.{Bounds, Dimensions, ImageMetadata, Instance, Jpeg, OrientationMetadata, Png, Tiff}
-import org.scalatest.time.{Millis, Span}
+import com.gu.mediaservice.model._
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.funspec.AnyFunSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.time.{Millis, Span}
 
 import java.io.File
+import java.lang.foreign.Arena
 import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.{Await, Future}
-import scala.concurrent.duration.{Duration, SECONDS}
+import scala.concurrent.Future
 
 // This test is disabled for now as it doesn't run on our CI environment, because GraphicsMagick is not present...
 class ImageOperationsTest extends AnyFunSpec with Matchers with ScalaFutures {
@@ -24,6 +23,12 @@ class ImageOperationsTest extends AnyFunSpec with Matchers with ScalaFutures {
   implicit override val patienceConfig: PatienceConfig = PatienceConfig(timeout = Span(1000, Millis), interval = Span(25, Millis))
   implicit val logMarker: LogMarker = MarkerMap()
 
+  private val metadata = ImageMetadata(
+    credit = Some("Tony McCrae"),
+    copyright = Some("Eel Pie Consulting Ltd"),
+    suppliersReference = Some("eelpie-123")
+  )
+
   describe("thumbnail") {
     it("should write thumbnail to output file") {
       val image = fileAt("IMG_4403.jpg")
@@ -99,6 +104,118 @@ class ImageOperationsTest extends AnyFunSpec with Matchers with ScalaFutures {
     }
   }
 
+  describe("resize") {
+    it("should output resized image to file in chosen format") {
+      implicit val arena: Arena = Arena.ofShared()
+      val fullSizedImage = VImage.newFromFile(arena, fileAt("IMG_4403.jpg").getAbsolutePath)
+      val imageOperations = new ImageOperations("")
+
+      val outputFile = new File("/Users/tony/Desktop/out5.jpg")
+
+      val eventuallyResized = imageOperations.resizeImageVips(fullSizedImage, Dimensions(1000, 800), 95, outputFile, Jpeg)
+
+      whenReady(eventuallyResized) { resized =>
+        arena.close()
+        resized.isFile should be(true)
+      }
+    }
+
+    it("render LAB colour spaces correctly in sRGB") {
+      implicit val arena: Arena = Arena.ofShared
+      val imageOperations = new ImageOperations("")
+
+      val fullSizedImage = VImage.newFromFile(arena, fileAt("halfdome_LAB.tif").getAbsolutePath)
+      val outputFile = new File("/Users/tony/Desktop/out6.jpg")
+
+      val eventuallyResized = imageOperations.resizeImageVips(fullSizedImage, Dimensions(800, 600), 95, outputFile, Jpeg)
+
+      whenReady(eventuallyResized) { resized =>
+        arena.close()
+        resized.isFile should be(true)
+      }
+    }
+
+    it("render LAB colour spaces correctly as PNG") {
+      implicit val arena: Arena = Arena.ofShared
+      val imageOperations = new ImageOperations("")
+
+      val fullSizedImage = VImage.newFromFile(arena, fileAt("halfdome_LAB.tif").getAbsolutePath)
+      val outputFile = new File("/Users/tony/Desktop/out7.png")
+
+      val eventuallyResized = imageOperations.resizeImageVips(fullSizedImage, Dimensions(800, 600), 95, outputFile, Png)
+
+      whenReady(eventuallyResized) { resized =>
+        arena.close()
+        resized.isFile should be(true)
+      }
+    }
+
+    it("render LAB 16 bit colour spaces correctly") {
+      implicit val arena: Arena = Arena.ofShared
+      val imageOperations = new ImageOperations("")
+
+      val fullSizedImage = VImage.newFromFile(arena, fileAt("halfdome_LAB16.tif").getAbsolutePath)
+      val outputFile = new File("/Users/tony/Desktop/out8.jpg")
+
+      val eventuallyResized = imageOperations.resizeImageVips(fullSizedImage, Dimensions(800, 600), 95, outputFile, Jpeg)
+
+      whenReady(eventuallyResized) { resized =>
+        arena.close()
+        resized.isFile should be(true)
+      }
+    }
+
+    it("render PNG with alpha correctly") {
+      implicit val arena: Arena = Arena.ofShared
+      val imageOperations = new ImageOperations("")
+
+      val image = fileAt("with-alpha.png")
+      val fullSizedImage = VImage.newFromFile(arena, image.getAbsolutePath)
+      val outputFile = new File("/Users/tony/Desktop/resized-png-with-alpha.png")
+
+      val eventuallyResized = imageOperations.resizeImageVips(fullSizedImage, Dimensions(800, 600), 95, outputFile, Png)
+
+      whenReady(eventuallyResized) { resized =>
+        arena.close()
+        resized.isFile should be(true)
+      }
+    }
+
+    it("render LAB TIFF with alpha correctly") {
+      implicit val arena: Arena = Arena.ofShared
+      val imageOperations = new ImageOperations("")
+
+      val image = fileAt("lab8-with-alpha.tif")
+      val fullSizedImage = VImage.newFromFile(arena, image.getAbsolutePath)
+      val outputFile = new File("/Users/tony/Desktop/out13.jpg")
+
+      val eventuallyResized = imageOperations.resizeImageVips(fullSizedImage, Dimensions(800, 600), 95, outputFile, Jpeg)
+
+      whenReady(eventuallyResized) { resized =>
+        arena.close()
+        resized.isFile should be(true)
+      }
+    }
+  }
+
+  describe("alpha") {
+    it("should return false for RGB for a Jpeg with no alpha") {
+      implicit val arena: Arena = Arena.ofShared
+      val image =  VImage.newFromFile(arena, fileAt("rgb-wo-profile.jpg").getAbsolutePath)
+      val hasAlpha = ImageOperations.hasAlpha(image)
+      arena.close()
+      hasAlpha should be(false)
+    }
+
+    it("should return true for PNG with alpha") {
+      implicit val arena: Arena = Arena.ofShared
+      val image = VImage.newFromFile(arena, fileAt("with-alpha.png").getAbsolutePath)
+      val hasAlpha = ImageOperations.hasAlpha(image)
+      arena.close()
+      hasAlpha should be(true)
+    }
+  }
+
   describe("identifyColourModel") {
     it("should return RGB for a JPG image with RGB image data and no embedded profile") {
       val image = fileAt("rgb-wo-profile.jpg")
@@ -230,7 +347,93 @@ class ImageOperationsTest extends AnyFunSpec with Matchers with ScalaFutures {
     }
   }
 
-  // TODO: test cropImage and its conversions
+  describe("graphic detection") {
+    it("should return not graphic for true colour jpeg") {
+      val arena = Arena.ofConfined
+      val image = VImage.newFromFile(arena, fileAt("exif-orientated-no-rotation.jpg").getAbsolutePath)
+      ImageOperations.isGraphicVips(image)(arena) should be(false)
+      arena.close()
+    }
+
+    it("should return is graphic for depth 2 tiff") {
+      val arena = Arena.ofConfined
+      val image = VImage.newFromFile(arena, fileAt("flower.tif").getAbsolutePath)
+      ImageOperations.isGraphicVips(image)(arena) should be(true)
+      arena.close()
+    }
+
+    it("should return is graphic for depth 4 png with alpha") {
+      val arena = Arena.ofConfined
+      val image = VImage.newFromFile(arena, fileAt("schaik.com_pngsuite/tbbn0g04.png").getAbsolutePath)
+      ImageOperations.isGraphicVips(image)(arena) should be(true)
+      arena.close()
+    }
+
+    it("should return is graphic for depth 8 indexed png") {
+      val arena = Arena.ofConfined
+      val image = VImage.newFromFile(arena, fileAt("schaik.com_pngsuite/basn3p08.png").getAbsolutePath)
+      ImageOperations.isGraphicVips(image)(arena) should be(true)
+      arena.close()
+    }
+
+  }
+
+  describe("cropping") {
+    val operations = new ImageOperations("")
+
+    it("should create unscaled master crop to resize from full sized images") {
+      implicit val arena: Arena = Arena.ofConfined
+      //val fullsizedImage = fileAt("Lab 16bpc (7d0b7c7b8e890d7e5d369093aa437bd833e20f71).tiff")
+      val fullsizedImage = fileAt("IMG_4403.jpg")
+      val metadata = ImageMetadata()
+
+      val masterCrop = operations.cropImageVips(fullsizedImage, Bounds(100, 100, 2000, 2400), metadata, None)
+
+      val outputFile = new File("/Users/tony/Desktop/master.jpg")
+      operations.saveImageToFile(masterCrop, Jpeg, 95, outputFile, keep = Some(VipsRaw.VIPS_FOREIGN_KEEP_XMP))
+      arena.close()
+    }
+
+    it("should create unscaled master crop from CMYK full sized image") {
+      implicit val arena: Arena = Arena.ofConfined
+      val fullsizedImage = fileAt("CMYK-with-profile.jpg")
+      val metadata = ImageMetadata()
+
+      val masterCrop = operations.cropImageVips(fullsizedImage, Bounds(100, 100, 2000, 2400), metadata, None)
+
+      val outputFile = new File("/Users/tony/Desktop/master-from-cmyk.jpg")
+      operations.saveImageToFile(masterCrop, Jpeg, 95, outputFile, keep = Some(VipsRaw.VIPS_FOREIGN_KEEP_XMP))
+
+      arena.close()
+    }
+
+    it("should create files foreach crop size") {
+      implicit val arena: Arena = Arena.ofShared()
+      val fullsizedImage = fileAt("CMYK-with-profile.jpg")
+      val metadata = ImageMetadata()
+
+      val masterCrop = operations.cropImageVips(fullsizedImage, Bounds(100, 100, 3000, 2000), metadata, None)
+      val landscapeCropSizingWidths = Seq(
+        Dimensions(140, 100),
+        Dimensions(320, 200),
+        Dimensions(800, 600),
+        Dimensions(1000, 1200),
+        Dimensions(2000, 3000),
+      )
+      implicit val i: Instance = Instance("id")
+
+      val eventualCrops = operations.createCrops(masterCrop, landscapeCropSizingWidths.toList, "test-image-id",
+        Bounds(0, 0, 1000, 1200),
+        Jpeg,
+        new File("/Users/tony/tmp/crops"),
+        75
+      )
+
+      whenReady(eventualCrops) { crops =>
+        arena.close()
+      }
+    }
+  }
 
   def fileAt(resourcePath: String): File = {
     new File(getClass.getResource(s"/$resourcePath").toURI)

container-images/jdk-vips/Dockerfile

@@ -39,8 +39,6 @@ RUN rm /tmp/vips-8.18.4.tar.xz
 RUN rm -r /tmp/vips-8.18.4/
 
 RUN apt -y --no-install-suggests install \
-  pngquant \
-  libimage-exiftool-perl \
   libjemalloc-dev \
   graphicsmagick \
   graphicsmagick-imagemagick-compat