Is there an option to use vips_thumbnail() without loading a VImage first?

[StefanOltmann]

Hi,

I read that vips_thumbnail_image() is not recommended according to the docs.

Can I use the vips_thumbnail() or vips_thumbnail_source() without loading a VImage first, like making these functions static?

See https://www.libvips.org/API/current/libvips-resample.html#vips-thumbnail

I'm trying to increase the quality of the output here:
https://github.com/StefanOltmann/thumbnail-fixer/blob/main/src/main/kotlin/util/VipsUtil.kt

Kind regards,

Stefan

[lopcode]

Working on it in #129 - just needed an excuse to get it over the line. I'll push it out as 1.4.0 in a few hours 🙂

[lopcode]

Hey @sven42 - sorry I'm not quite following. The signature of logmat is:

public static VImage logmat(Arena arena, double sigma, double minAmpl, VipsOption... args) throws VipsError

Are you referring to the Arena input parameter? It's required to make the libvips operation call. The operation doesn't require an image input (and just provides an image output), so it makes sense that it's static. Here's an example of using Vips.run to get a suitable arena:

Vips.run((arena -> {
    var image = VImage.logmat(arena, ...)
}));

Does that help?

[sven42]

Hello @lopcode,

Yes, sorry, I was referring to Arena.
And sorry again for not reading the comments for the method: logmat generates a mask instead of applying a laplace operator on an image (via its arena, but arena instead does not seem to be bound to a single image).

I am trying to implement a perceptive hash for images and tried different java libs for preprocessing (boofcv, javacv, jhlabs): vips-ffm was the fastest in my small benchmark (opencv was second, but the difference is significant for my purpose).

In this context: How do I get the pixel values from a VImage into a flat array for further calculations?

Thank you for your help,
Sven.

[lopcode]

@sven42 Great to hear that your benchmarks showed vips-ffm coming first 😄 Happy to help out.

I think there are two things that might help to understand:

• Arena is a memory management concept from the Java "foreign function and memory" API. It lets me specify a scope, and be told when it closes. vips-ffm uses this Arena tell libvips when to set reference counts to zero, so that it can automatically free the native memory used to perform operations on images. So, a VImage should only exist for as long as the scope it has a reference to (i.e., for as long as the Vips.run { scope exists)
• If you're trying to build an image processing pipeline, I would first look at the libvips documentation, figure out what primitives you're going to use, and then figure out how that translates in to vips-ffm code. I think manually operating on pixel values is going to be the hardest path, so worth checking if libvips has a built-in operation for the stages you want

If you can figure out the libvips operations you want, I might be able to help you figure out how that translates in to vips-ffm code.

[lopcode]

@sven42 Did you end up finding what you needed?

[sven42]

Hello @lopcode

So far I am doing the preprocessing with vips but then I use VImage.writeToStream() and read this via ImageIo.read() to get a BufferedImage from which I am able to get the GrayScala-LuminanceValues I need for calculating the hashes:

Scala code:

object VipsImageExtension {

  extension (image: VImage) {


    def grayScaleLuminanceValues(): Array[Double] = {
      asBufferedImage() match {
        case Left(e)              => throw e
        case Right(bufferedImage) =>
          // For each pixel compute luminance Y = 0.299R + 0.587G + 0.114B
          val w   = bufferedImage.getWidth
          val h   = bufferedImage.getHeight
          val out = Array.ofDim[Double](w * h)

          val raster = bufferedImage.getRaster
          val pixels = Array.ofDim[Int](3) // R,G,B
          var idx    = 0
          for { y <- 0 until h; x <- 0 until w } {
            raster.getPixel(x, y, pixels)
            out(idx) = luminance(pixels)
            idx += 1
          }
          out
      }
    }

    private def luminance(pixels: Array[Int]): Double = {
      val r = pixels(0)
      val g = pixels(1)
      val b = pixels(2)
      0.299 * r + 0.587 * g + 0.114 * b
    }
  }
}

Would be nice to do this directly, however, since the images are quite small at this stage, it does not matter too much I guess.

I still need to do some benchmarking to see if my implementation is good in speed and quality (compared to JImageHash and the Hashes build into OpenCV)