Add resizing function for images in ndarray.

Author: Iainmon

bridge/include/bridge.h

@@ -33,6 +33,7 @@ float* unsafe(const float* arr);
 bridge_tensor_t load_tensor_from_file(const uint8_t* file_path);
 bridge_tensor_t load_tensor_dict_from_file(const uint8_t* file_path,const uint8_t* tensor_key);
 bridge_tensor_t load_run_model(const uint8_t* model_path, bridge_tensor_t input);
+bridge_tensor_t resize(bridge_tensor_t input,int height,int width);
 
 
 int baz(void);

bridge/lib/bridge.cpp

@@ -206,6 +206,94 @@ extern "C" bridge_tensor_t max_pool2d(
     return torch_to_bridge(output);
 }
 
+/*
+
+ * Resize the last two dimensions of a tensor, mimicking torchvision.transforms.Resize.
+ *
+ *  • Works with 2‑D (H,W), 3‑D (C,H,W or N,H,W), 4‑D (N,C,H,W) … tensors – any rank ≥ 2.  
+ *  • Leading dimensions are preserved; only the final H × W are resized.  
+ *  • Defaults match torchvision: bilinear for floating tensors, align_corners=false.  
+ *
+ * @param input          Tensor on CPU or CUDA.
+ * @param new_h          Target height.
+ * @param new_w          Target width.
+ * @param mode           Interpolation mode (“bilinear”, “nearest”, “bicubic”, …).
+ * @param align_corners  Forwarded to F::interpolate (ignored for “nearest”).
+ * @return               Tensor with shape …, new_h, new_w and same dtype / device.
+
+inline torch::Tensor resize_tensor_last2(
+        const torch::Tensor& input,
+        int64_t              new_h,
+        int64_t              new_w,
+        const std::string&   mode           = "bilinear",
+        bool                 align_corners  = false) {
+
+    // Keep dtype/device; cast to float if interpolate needs it
+    const bool need_cast = !input.is_floating_point() && mode != "nearest";
+    auto x = need_cast ? input.to(torch::kFloat32) : input;
+    x = x.contiguous();                         // guarantees a re‑view is safe
+
+    // Collapse every axis except the last two into a single batch dimension.
+    const int64_t h  = x.size(-2);
+    const int64_t w  = x.size(-1);
+    const int64_t flat = x.numel() / (h * w);   // product of leading dims
+
+    auto x4d = x.view({flat, 1, h, w});         // N=flat, C=1, H, W
+
+    // Interpolate – equivalent to torchvision.transforms.Resize for tensors.
+    auto y4d = torch::nn::functional::interpolate(
+        x4d,
+        torch::nn::functional::InterpolateFuncOptions()
+            .size(std::vector<int64_t>{new_h, new_w})
+            .mode(mode)
+            .align_corners(align_corners));
+
+    // Restore the original leading shape.
+    std::vector<int64_t> out_shape(input.sizes().begin(), input.sizes().end() - 2);
+    out_shape.push_back(new_h);
+    out_shape.push_back(new_w);
+
+    auto y = y4d.view(out_shape);
+    return need_cast ? y.to(input.scalar_type()) : y;
+}
+*/
+extern "C" bridge_tensor_t resize(
+    bridge_tensor_t input,
+    int height,
+    int width
+) {
+    auto image = bridge_to_torch(input);
+
+    // auto output = resize_tensor_last2(image, height, width);
+    
+    // at::Tensor output = at::upsample_bilinear2d(t_input.unsqueeze(0), {height, width}, false);
+    if (image.dim() == 3) {
+        auto output = torch::nn::functional::interpolate(
+            image.unsqueeze(0),
+            torch::nn::functional::InterpolateFuncOptions()
+            .size(std::vector<int64_t>({ height, width }))
+            .mode(torch::kBilinear)
+            .align_corners(false)
+        ).squeeze(0);
+        return torch_to_bridge(output);
+    } else if (image.dim() == 4) {
+        auto output = torch::nn::functional::interpolate(
+            image,
+            torch::nn::functional::InterpolateFuncOptions()
+            .size(std::vector<int64_t>({ height, width }))
+            .mode(torch::kBilinear)
+            .align_corners(false)
+        );
+        return torch_to_bridge(output);
+    } else {
+        std::cerr << "Unsupported tensor dimension: " << image.dim() << std::endl;
+        std::cerr.flush();
+        std::cout << "Unsupported tensor dimension: " << image.dim() << std::endl;
+        std::cout.flush();
+        return input; // Return the original tensor if the dimension is unsupported
+    }
+}
+
 
 // extern "C"
 

clib/Makefile

@@ -11,5 +11,8 @@ proc main(args: [] string) {
     writeln("Loaded image: ", args[1]);
     writeln("Image shape: ", image.shape);
 
+    image = image.resize(224,224);
+    writeln("Resized image: ", image.shape);
+
     image.saveImage("test.jpg");
 }