How to setup a tile iterator to write to a file? #4080

jonasteuwen · 2024-08-04T14:05:56Z

jonasteuwen
Aug 4, 2024

Previously I have asked #2860 how to setup a tile iterator for low memory saving of a tiff.

Currenty I am using libtiff to write tile-by-tile to a tiff file. However, I'm also using pyvips, so I wanted to replace the libtiff with a more general approach using libvips. I basically now want to have a python iterator which is written tile-by-tile to a tiff file.

Something like this:

class FastTifffileImageWriter(ImageWriter):
    def __init__(self, filename, size, mpp, tile_size=(512, 512), pyramid=False,
                 compression="jpeg", quality=100, metadata=None):
        self.filename = filename
        self.size = size
        self.tile_size = tile_size
        self._writer = FastTiffWriter(
            str(filename),
            (size[1], size[0], size[2] if len(size) > 2 else 1),
            mpp,
            tile_size,
            pyramid,
            compression,
            quality
        )

    def from_tiles_iterator(self, iterator):
        tiles_x = (self.size[1] + self.tile_size[1] - 1) // self.tile_size[1]
        for idx, tile in enumerate(iterator):
            row = (idx // tiles_x) * self.tile_size[0]
            col = (idx % tiles_x) * self.tile_size[1]
            self._writer.write_tile(tile, row, col)

Now, the FastTiffWriter is a C++ class like this:

#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>
#include <pybind11/stl.h>
#include <vips/vips.h>
#include <iostream>
#include <vector>
#include <string>

namespace py = pybind11;

class FastTiffWriter {
public:
    FastTiffWriter(const std::string& filename,
                   std::tuple<int, int, int> size,
                   double mpp,
                   std::tuple<int, int> tile_size = std::make_tuple(512, 512),
                   bool pyramid = false,
                   const std::string& compression = "jpeg",
                   int quality = 100)
        : filename(filename), size(size), mpp(mpp), tile_size(tile_size),
          pyramid(pyramid), compression(compression),
          quality(quality), vips_image(nullptr), target(nullptr) {

        std::cout << "FastTiffWriter constructor started" << std::endl;

        if (VIPS_INIT("fast_tiff_writer")) {
            throw std::runtime_error("Failed to initialize VIPS: " + std::string(vips_error_buffer()));
        }

        VipsForeignTiffCompression vips_compression = VIPS_FOREIGN_TIFF_COMPRESSION_JPEG;
        if (compression == "deflate")
            vips_compression = VIPS_FOREIGN_TIFF_COMPRESSION_DEFLATE;
        else if (compression == "lzw")
            vips_compression = VIPS_FOREIGN_TIFF_COMPRESSION_LZW;

        std::cout << "Creating new VIPS image" << std::endl;
        std::cout << "Size: " << std::get<0>(size) << "x" << std::get<1>(size) << "x" << std::get<2>(size) << std::endl;
        std::cout << "Tile size: " << std::get<0>(tile_size) << "x" << std::get<1>(tile_size) << std::endl;

        // Initialize VIPS image
        vips_image = vips_image_new();
        if (!vips_image) {
            throw std::runtime_error("Failed to create VIPS image: " + std::string(vips_error_buffer()));
        }

        // Initialize image fields
        vips_image->Xsize = std::get<1>(size);
        vips_image->Ysize = std::get<0>(size);
        vips_image->Bands = std::get<2>(size);
        vips_image->BandFmt = VIPS_FORMAT_UCHAR;
        vips_image->Coding = VIPS_CODING_NONE;
        vips_image->Type = VIPS_INTERPRETATION_sRGB;
        vips_image->Xres = 1.0;
        vips_image->Yres = 1.0;

        std::cout << "Setting up tile cache" << std::endl;
        if (vips_tilecache(vips_image, &vips_image,
                           "tile_width", std::get<1>(tile_size),
                           "tile_height", std::get<0>(tile_size),
                           "max_tiles", 1,
                           NULL)) {
            throw std::runtime_error("Failed to set up tile cache: " + std::string(vips_error_buffer()));
        }

        target = vips_target_new_to_file(filename.c_str());
        if (!target) {
            throw std::runtime_error("Failed to create VIPS target: " + std::string(vips_error_buffer()));
        }

        std::cout << "FastTiffWriter setup completed" << std::endl;
    }

    ~FastTiffWriter() {
        // Save the final TIFF image
        finalize_tiff();

        // Free resources
        if (vips_image) {
            g_object_unref(vips_image);
        }
        if (target) {
            g_object_unref(target);
        }
        vips_shutdown();
    }

    void write_tile(py::array_t<uint8_t> tile, int row, int col) {
        py::buffer_info buf = tile.request();
        int height = buf.shape[0];
        int width = buf.shape[1];
        int bands = buf.ndim > 2 ? buf.shape[2] : 1;

        std::cout << "Writing tile at (" << row << ", " << col << ")" << std::endl;

        VipsImage *tile_image = vips_image_new_from_memory(buf.ptr, buf.size * buf.itemsize,
                                                           width, height, bands, VIPS_FORMAT_UCHAR);
        if (!tile_image) {
            throw std::runtime_error("Failed to create tile image: " + std::string(vips_error_buffer()));
        }

        if (vips_draw_image(vips_image, tile_image, col, row, NULL) != 0) {
            g_object_unref(tile_image);
            throw std::runtime_error("Failed to draw tile: " + std::string(vips_error_buffer()));
        }

        g_object_unref(tile_image);
        std::cout << "Tile written successfully" << std::endl;
    }


private:
    std::string filename;
    std::tuple<int, int, int> size;
    double mpp;
    std::tuple<int, int> tile_size;
    bool pyramid;
    std::string compression;
    int quality;
    VipsImage *vips_image;
    VipsTarget *target;

    void finalize_tiff() {
        if (vips_image && target) {
            std::cout << "Finalizing TIFF save" << std::endl;
            VipsForeignTiffCompression vips_compression = VIPS_FOREIGN_TIFF_COMPRESSION_JPEG;
            if (compression == "deflate")
                vips_compression = VIPS_FOREIGN_TIFF_COMPRESSION_DEFLATE;
            else if (compression == "lzw")
                vips_compression = VIPS_FOREIGN_TIFF_COMPRESSION_LZW;

            if (vips_tiffsave_target(vips_image, target,
                                     "tile", TRUE,
                                     "tile_width", std::get<1>(tile_size),
                                     "tile_height", std::get<0>(tile_size),
                                     "compression", vips_compression,
                                     "Q", quality,
                                     "pyramid", pyramid,
                                     NULL)) {
                std::cerr << "Final TIFF save failed: " << vips_error_buffer() << std::endl;
                throw std::runtime_error(vips_error_buffer());
            }

            std::cout << "TIFF save completed successfully" << std::endl;
        }
    }
};

PYBIND11_MODULE(fast_tiff_writer, m) {
    py::class_<FastTiffWriter>(m, "FastTiffWriter")
        .def(py::init<const std::string&, std::tuple<int, int, int>, double, std::tuple<int, int>, bool,
                      const std::string&, int&>())
        .def("write_tile", &FastTiffWriter::write_tile);
}

(I have edited the post after asking ChatGPT for advice)

This hangs indefinitely at writing the tile vips_draw_image, this seems to result from my lack of understanding how I can handle the image so it gets data tile-by-tile and I'm able to write it this way.

How should you in general handle a tile-by-tile image?

jcupitt · 2024-08-04T16:29:55Z

jcupitt
Aug 4, 2024
Maintainer

Hello @jonasteuwen,

Sorry, this won't work, the libvips design isn't really compatible with iterators. The libvips maintainers have talked about adding something like this several times, and (from memory) the current pipedream proposal would be for something like (using python for brevity):

def generate_tile(region, left, top, width, height):
    """write pixels into region for this area
    """

image = pyvips.Image.new_from_generator(generate_tile, 
                                        width=1000, height=1000, bands=3, 
                                        format="uchar", interpretation="srgb")
image.write_to_file("something.tiff")

But no one's done the work yet.

3 replies

jcupitt Aug 4, 2024
Maintainer

If you're using C/C++ you can do something like that now, of course, by writing a libvips operator. For example:

https://github.com/libvips/libvips/blob/master/examples/my-add.c

The new SDF operators are very simple:

https://github.com/libvips/libvips/blob/master/libvips/create/sdf.c

jonasteuwen Aug 4, 2024
Author

Thanks @jcupitt. So I assume when you say "do it from C/C++" this means I can't use this write_tile function above and it has to be completely in C++?

jcupitt Aug 4, 2024
Maintainer

You could call back into python from your C++ generate function, though it might be a little slow. You'd need to be a bit cautious around threading too, of course.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

How to setup a tile iterator to write to a file? #4080

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{editor}}'s edit

{{editor}}'s edit

Uh oh!

Replies: 1 comment 3 replies

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Uh oh!

How to setup a tile iterator to write to a file? #4080

Uh oh!

Uh oh!

jonasteuwen Aug 4, 2024

Replies: 1 comment · 3 replies

Uh oh!

jcupitt Aug 4, 2024 Maintainer

Uh oh!

jcupitt Aug 4, 2024 Maintainer

Uh oh!

jonasteuwen Aug 4, 2024 Author

Uh oh!

jcupitt Aug 4, 2024 Maintainer

jonasteuwen
Aug 4, 2024

Replies: 1 comment 3 replies

jcupitt
Aug 4, 2024
Maintainer

jcupitt Aug 4, 2024
Maintainer

jonasteuwen Aug 4, 2024
Author

jcupitt Aug 4, 2024
Maintainer