Add image(buffer, size) API

c/image_c_api.cxx

@@ -72,6 +72,25 @@ f3d_image_t* f3d_image_new_path(const char* path)
   return reinterpret_cast<f3d_image_t*>(img);
 }
 
+//----------------------------------------------------------------------------
+f3d_image_t* f3d_image_new_stream(unsigned char* byte, unsigned int size)
+{
+
+  f3d::image* img = nullptr;
+
+  try
+  {
+    img = new f3d::image(reinterpret_cast<std::byte*>(byte), static_cast<size_t>(size));
+  }
+  catch (const f3d::image::read_exception& e)
+  {
+    std::cerr << "Error loading image: " << e.what() << "\n";
+    return nullptr;
+  }
+
+  return reinterpret_cast<f3d_image_t*>(img);
+}
+
 //----------------------------------------------------------------------------
 void f3d_image_delete(f3d_image_t* img)
 {

c/image_c_api.h

@@ -57,6 +57,15 @@ extern "C"
    */
   F3D_EXPORT f3d_image_t* f3d_image_new_path(const char* path);
 
+  /**
+   * @brief Create a new image object from a stream
+   *
+   * The returned image must be deleted with f3d_image_delete().
+   *
+   * @return Pointer to the newly created image object, NULL on failure
+   */
+  F3D_EXPORT f3d_image_t* f3d_image_new_stream(unsigned char* buffer, unsigned int size);
+
   /**
    * @brief Delete an image object
    * @param img Pointer to the image object to be deleted

c/testing/test_image.c

@@ -72,11 +72,28 @@ int test_image()
     return 1;
   }
 
+  f3d_image_t* temp_image_stream = f3d_image_new_stream(tempBuffer, 0);
+  if (temp_image_stream != NULL){
+    return 1;
+  }
+
   unsigned int buffer_size;
   unsigned char* buffer = f3d_image_save_buffer(img, PNG, &buffer_size);
   if (buffer)
   {
-    f3d_image_free_buffer(buffer);
+    f3d_image_t* image_stream = f3d_image_new_stream(buffer, buffer_size);
+
+    if (image_stream)
+    {
+      double stream_error = f3d_image_compare(img, image_stream);
+      f3d_image_free_buffer(buffer);
+      f3d_image_delete(image_stream);
+
+      if (stream_error != 0)
+      {
+        return 1;
+      }
+    }
   }
 
   const char* tmp_path = "/tmp/f3d_test_image.png";

java/F3DImageBindings.cxx

@@ -19,6 +19,16 @@ extern "C"
     return reinterpret_cast<jlong>(img);
   }
 
+  JNIEXPORT jlong JAVA_BIND(Image, nativeCreateFromStream)(
+    JNIEnv* env, jclass, jbyteArray buffer, jint size)
+  {
+    jbyte* bufferData = env->GetByteArrayElements(buffer, nullptr);
+
+    f3d::image* img =
+      new f3d::image(reinterpret_cast<std::byte*>(bufferData), static_cast<size_t>(size));
+    return reinterpret_cast<jlong>(img);
+  }
+
   JNIEXPORT jlong JAVA_BIND(Image, nativeCreate)(
     JNIEnv* env, jclass, jint width, jint height, jint channelCount, jint type)
   {

java/Image.java

@@ -55,6 +55,10 @@ public Image(int width, int height, int channelCount) {
         this(width, height, channelCount, ChannelType.BYTE);
     }
 
+    public Image(byte[] buffer, int size){
+        mNativeAddress = nativeCreateFromStream(buffer, size);
+    }
+
     Image(long nativeAddress) {
         mNativeAddress = nativeAddress;
     }
@@ -233,5 +237,6 @@ public void delete() {
 
     private static native long nativeCreateFromFile(String filePath);
     private static native long nativeCreate(int width, int height, int channelCount, int type);
+    private static native long nativeCreateFromStream(byte[] buffer, int size);
     private static native void nativeDestroy(long nativeAddress);
 }

java/testing/TestImage.java

@@ -27,7 +27,7 @@ public static void main(String[] args) {
     img1.save(tmpPath + "test.jpg", Image.SaveFormat.JPG);
 
     img1.saveBuffer();
-    img1.saveBuffer(Image.SaveFormat.PNG);
+    byte[] img1Buffer = img1.saveBuffer(Image.SaveFormat.PNG);
 
     img1.setMetadata("key1", "value1");
     img1.getMetadata("key1");
@@ -47,8 +47,12 @@ public static void main(String[] args) {
         .setMetadata("author", "F3D")
         .save(tmpPath + "chained.png");
 
+    Image img4 = new Image(img1Buffer, img1Buffer.length);
+    img4.compare(img1);
+
     img1.delete();
     img2.delete();
     img3.delete();
+    img4.delete();
   }
 }

library/public/image.h

@@ -73,6 +73,7 @@ class F3D_EXPORT image
   image& operator=(const image& img) noexcept;
   image(image&& img) noexcept;
   image& operator=(image&& img) noexcept;
+  image(std::byte* byte, std::size_t size);
   ///@}
 
   ///@{ @name Operators

library/src/config.cxx

@@ -0,0 +1,10 @@
+#include "config.h"
+
+namespace f3d::detail
+{
+const std::string LibVersion = "";          // Version is synchronized with F3D
+const std::string LibVersionFull = ""; // Version is synchronized with F3D
+const std::string LibBuildSystem = "Darwin ";
+const std::string LibBuildDate = "";
+const std::string LibCompiler = "AppleClang 17.0.0.17000604";
+}

library/src/image.cxx

@@ -11,6 +11,7 @@
 #include <vtkImageReader2Collection.h>
 #include <vtkImageReader2Factory.h>
 #include <vtkJPEGWriter.h>
+#include <vtkMemoryResourceStream.h>
 #include <vtkPNGReader.h>
 #include <vtkPNGWriter.h>
 #include <vtkPointData.h>
@@ -33,6 +34,7 @@
 #include <sstream>
 #include <string>
 #include <unordered_map>
+#include <iostream> //debug
 
 namespace fs = std::filesystem;
 
@@ -258,6 +260,72 @@ image& image::operator=(image&& img) noexcept
   return *this;
 }
 
+image::image(std::byte* buffer, std::size_t size)
+  : Internals(new image::internals())
+{
+  detail::init::initialize();
+
+  try
+  {
+    if (buffer == nullptr)
+    {
+      delete this->Internals;
+      throw read_exception("Cannot read image from buffer: Buffer is empty");
+    }
+
+    vtkNew<vtkMemoryResourceStream> stream;
+    stream->SetBuffer(buffer, size);
+
+    vtkNew<vtkImageReader2Collection> collection;
+    vtkImageReader2Factory::GetRegisteredReaders(collection);
+    collection->InitTraversal();
+    vtkImageReader2* reader = collection->GetNextItem();
+
+    int bestScore = -1;
+    vtkImageReader2* bestReader = nullptr;
+
+    while (reader != nullptr)
+    {
+      int score = reader->CanReadFile(stream);
+      if (score > bestScore)
+      {
+        bestReader = reader;
+        bestScore = score;
+      }
+
+      reader = collection->GetNextItem();
+    }
+
+    if (bestScore <= 0)
+    {
+      delete this->Internals;
+      throw read_exception("Cannot read image from buffer");
+    }
+
+    bestReader->SetStream(stream);
+    bestReader->Update();
+    this->Internals->Image = bestReader->GetOutput();
+
+    vtkPNGReader* pngReader = vtkPNGReader::SafeDownCast(bestReader);
+    if (pngReader != nullptr)
+    {
+      this->Internals->ReadPngMetadata(pngReader);
+    }
+
+    if (!this->Internals->Image)
+    {
+      delete this->Internals;
+      throw read_exception("Cannot read image from buffer");
+    }
+  }
+
+  catch (const fs::filesystem_error& ex)
+  {
+    delete this->Internals;
+    throw read_exception(std::string("Cannot read image from buffer: ") + ex.what());
+  }
+}
+
 //----------------------------------------------------------------------------
 std::vector<std::string> image::getSupportedFormats()
 {

library/testing/TestSDKImage.cxx

@@ -113,6 +113,17 @@ int TestSDKImage([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
   test("check 32-bits HDR image channel type size", hdrImg.getChannelTypeSize(), 4u);
   hdrImg.save(tmpDir + "/TestSDKImage32hdr.tif", f3d::image::SaveFormat::TIF);
 
+  // check reading stream
+  std::vector<unsigned char> buffer = generated.saveBuffer();
+  std::byte* bufferData = reinterpret_cast<std::byte*>(buffer.data());
+  f3d::image bufferImage(bufferData, buffer.size());
+  // std::cerr << generated.compare(bufferImage) << "\n";
+  test("check loading stream from image reader", generated.compare(bufferImage), 0.0); // not 1e-14?
+
+  // // check reading invalid stream
+  test.expect<f3d::image::read_exception>(
+    "read invalid image stream", [&]() { f3d::image invalidImgStream(nullptr, 10); });
+
 #if F3D_MODULE_EXR
   // check reading EXR
   f3d::image exrImg(testingDir + "/data/kloofendal_43d_clear_1k.exr");

python/F3DPythonBindings.cxx

@@ -121,6 +121,11 @@ PYBIND11_MODULE(pyf3d, module)
     .def(py::init<>())
     .def(py::init<const std::filesystem::path&>())
     .def(py::init<unsigned int, unsigned int, unsigned int, f3d::image::ChannelType>())
+    .def(py::init([](py::bytes buffer, size_t size){
+      std::string bufferStr = buffer;
+      std::byte* byte = reinterpret_cast<std::byte*>(bufferStr.data());
+      return f3d::image(byte, size);
+    }))
     .def(py::self == py::self)
     .def(py::self != py::self)
     .def_static("supported_formats", &f3d::image::getSupportedFormats)

python/testing/test_image.py

@@ -65,6 +65,13 @@ def test_save_buffer(f3d_engine: f3d.Engine):
     assert buffer.startswith(b"\x89PNG")
     assert img._repr_png_() == buffer
 
+def test_loading_stream(f3d_engine: f3d.Engine):
+    img = f3d_engine.window.render_to_image(True)
+    buffer = img.save_buffer(f3d.Image.SaveFormat.PNG)
+
+    stream_image = f3d.Image(buffer, len(buffer))
+    assert stream_image == img
+
 
 def test_formats(f3d_engine: f3d.Engine):
     formats = f3d.Image.supported_formats()

webassembly/F3DEmscriptenBindings.cxx

@@ -191,6 +191,7 @@ EMSCRIPTEN_BINDINGS(f3d)
     .constructor<>()
     .constructor<const std::string&>()
     .constructor<unsigned int, unsigned int, unsigned int, f3d::image::ChannelType>()
+    .constructor<std::byte* buffer, std::size_t size>()
     .function("equals", &f3d::image::operator==)
     .function(
       "getNormalizedPixel", +[](const f3d::image& img, int x, int y) -> emscripten::val