prpy 0.2.4__tar.gz → 0.2.6__tar.gz

{prpy-0.2.4 → prpy-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prpy
-Version: 0.2.4
+Version: 0.2.6
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License
@@ -36,10 +36,12 @@ Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: flake8; extra == "test"
 
-[![Tests](https://github.com/prouast/prpy/actions/workflows/main.yml/badge.svg)](https://github.com/prouast/prpy/actions/workflows/main.yml)
 
 # prpy
 
+[![Tests](https://github.com/prouast/prpy/actions/workflows/main.yml/badge.svg)](https://github.com/prouast/prpy/actions/workflows/main.yml)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/prpy?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pip%20downloads)](https://pypi.org/project/prpy/)
+
 A collection of Python utilities for signal, image, and video processing.
 It contains subpackages for working with `numpy`, `ffmpeg`, `tensorflow`, and `torch`.
 

{prpy-0.2.4 → prpy-0.2.6}/README.md

@@ -1,7 +1,9 @@
-[![Tests](https://github.com/prouast/prpy/actions/workflows/main.yml/badge.svg)](https://github.com/prouast/prpy/actions/workflows/main.yml)
 
 # prpy
 
+[![Tests](https://github.com/prouast/prpy/actions/workflows/main.yml/badge.svg)](https://github.com/prouast/prpy/actions/workflows/main.yml)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/prpy?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pip%20downloads)](https://pypi.org/project/prpy/)
+
 A collection of Python utilities for signal, image, and video processing.
 It contains subpackages for working with `numpy`, `ffmpeg`, `tensorflow`, and `torch`.
 

{prpy-0.2.4 → prpy-0.2.6}/prpy/ffmpeg/readwrite.py

@@ -170,8 +170,8 @@ def _ffmpeg_output_to_numpy(
     r: int,
     fps: Union[float, int, None],
     n: int,
-    w: int,
-    h: int,
+    w: Union[int, np.int64],
+    h: Union[int, np.int64],
     scale: Union[tuple, int, None] = None,
     crf: Union[int, None] = None,
     pix_fmt: str = 'bgr24',
@@ -203,8 +203,8 @@ def _ffmpeg_output_to_numpy(
   assert isinstance(r, int)
   assert fps is None or isinstance(fps, (float, int))
   assert isinstance(n, int)
-  assert isinstance(w, int)
-  assert isinstance(h, int)
+  assert isinstance(w, (int, np.int64))
+  assert isinstance(h, (int, np.int64))
   assert crf is None or isinstance(crf, int)
   assert isinstance(pix_fmt, str)
   assert isinstance(dim_deltas, tuple) and len(dim_deltas) == 3 and all(isinstance(i, int) for i in dim_deltas)

prpy-0.2.6/prpy/helpers.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2024 Philipp Rouast
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import argparse
+
+def str2bool(v):
+  """Boolean type for argparse"""
+  if isinstance(v, bool):
+     return v
+  if v.lower() in ('yes', 'true', 't', 'y', '1'):
+    return True
+  elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+    return False
+  else:
+    raise argparse.ArgumentTypeError('Boolean value expected.')
+  

{prpy-0.2.4 → prpy-0.2.6}/prpy/numpy/image.py

@@ -19,8 +19,11 @@
 # SOFTWARE.
 
 import numpy as np
+import logging
 from typing import Union
 
+from .image_ops import resample_bilinear_op, resample_box_op, reduce_roi_op
+
 def crop_slice_resize(
     inputs: np.ndarray,
     target_size: Union[int, tuple, list], 
@@ -34,17 +37,18 @@ def crop_slice_resize(
   """Crop, slice, and resize image(s) with all same settings.
 
   Args:
-    inputs: The inputs as uint8 shape (h, w, 3) or (n_frames, h, w, 3)
+    inputs: The inputs of shape (h, w, 3) or (n_frames, h, w, 3)
     target_size: The target size; scalar or (H, W) if preserve_aspect_ratio=False
     roi: The region of interest in format (x0, y0, x1, y1). Use None to keep all.
     target_idxs: The frame indices to be used. Use None to keep all.
-    preserve_aspect_ratio: Preserve the aspect ratio?
+    preserve_aspect_ratio: Preserve the aspect ratio? (must be False for library=prpy)
     keepdims: If True, always keep n_frames dim. Otherwise, may drop n_frames dim.
-    library: The library to use. `cv2` or `PIL` (return np ndarray), or `tf` (returns tf Tensor)
+    library: The library to use: `cv2`, `PIL`, `prpy` (return np.ndarray), or `tf` (returns tf.Tensor)
+      prpy is experimental and only supports bilinear scale_algorithm.
     scale_algorithm: The algorithm used for scaling.
       Supports: bicubic, bilinear, area (not for PIL!), lanczos. Default: bicubic
   Returns:
-    result: The processed frame(s) as float32 shape (h, w, 3) or (n_frames, h, w, 3)
+    result: The processed frame(s) of shape (h_new, w_new, 3) or (n_frames_new, h_new, w_new, 3)
   """
   assert isinstance(inputs, np.ndarray) and (len(inputs.shape) == 3 or len(inputs.shape) == 4)
   assert isinstance(target_size, int) or (isinstance(target_size, (tuple, list)) and len(target_size) == 2 and all(isinstance(i, int) for i in target_size))
@@ -86,9 +90,9 @@ def crop_slice_resize(
     # No resizing necessary
     if library == 'tf':
       import tensorflow as tf
-      out = tf.convert_to_tensor(inputs, dtype=tf.float32)
+      out = tf.convert_to_tensor(inputs)
     else:
-      out = inputs.astype(np.float32) 
+      out = inputs
   else:
     # Resize to out_size
     if library == 'tf':
@@ -127,6 +131,17 @@ def crop_slice_resize(
       out_size = (out_size[1], out_size[0])
       out = np.asarray([
         cv2.resize(src=f, dsize=out_size, interpolation=library_algorithm) for f in inputs])
+    elif library == 'prpy':
+      if preserve_aspect_ratio:
+        raise ValueError("preserve_aspect_ratio=True is not supported for library=prpy")
+      if scale_algorithm == 'bilinear':
+        if inputs.shape[1] / target_height > 2 and inputs.shape[2] / target_width > 2:
+          logging.debug("Switching from bilinear to box by default because we are downsampling significantly.")
+          out = resample_box(im=inputs, size=(target_height, target_width))
+        else:
+          out = resample_bilinear(im=inputs, size=(target_height, target_width))
+      else:
+        raise ValueError("Scaling algorithm {} is not supported by {}".format(scale_algorithm, library))
     else:
       raise ValueError("Library {} not supported".format(library))
   if keepdims and len(out.shape) == 3 and len(inputs_shape) == 4:
@@ -139,3 +154,50 @@ def crop_slice_resize(
     if out.shape[0] == 1:
       out = squeeze(out, axis=0)
   return out
+
+def resample_bilinear(
+    im: np.ndarray,
+    size: Union[int, tuple]
+  ):
+  """Compute bilinear resampling with batch dimension
+  
+  Args:
+    im: The image(s) to be resized. Shape (n, h, w, c) or (h, w, c)
+    size: The new size either as scalar or (new_h, new_w)
+  Returns:
+    out: The resized image(s). Shape (n, new_h, new_w, c) or (new_h, new_w, c)
+  """
+  if isinstance(size, int): size = (size, size)
+  return resample_bilinear_op(im, size)
+
+def resample_box(
+    im: np.ndarray,
+    size: Union[int, tuple]
+  ):
+  """Compute box resampling with batch dimension
+
+  - Note: This implementation only works for downsampling at least 2x in each dimension
+    I.e., h/new_h >= 2 and w/new_w >= 2
+  
+  Args:
+    im: The image(s) to be resized. Shape (n, h, w, c) or (h, w, c)
+    size: The new size either as scalar or (new_h, new_w)
+  Returns:
+    out: The resized image(s). Shape (n, new_h, new_w, c) or (new_h, new_w, c)
+  """
+  if isinstance(size, int): size = (size, size)
+  return resample_box_op(im, size)
+
+def reduce_roi(
+    video: np.ndarray,
+    roi: np.ndarray
+  ) -> np.ndarray:
+  """Reduce the spatial dimensions of a video by mean using ROI.
+
+  Args:
+    video: The video to be reduced. Shape (n, h, w, 3)
+    roi: The roi in form (x0, y0, x1, y1). Shape (n, 4) 
+  Returns:
+    out: The reduced vals. Shape (n, 3)
+  """
+  return reduce_roi_op(video, roi)

prpy-0.2.6/prpy/numpy/image_ops.c

@@ -0,0 +1,332 @@
+// Copyright (c) 2024 Philipp Rouast
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <Python.h>
+#include <numpy/arrayobject.h>
+
+#define DIV_ROUND_CLOSEST(n, d) ((((n) < 0) == ((d) < 0)) ? (((n) + (d)/2)/(d)) : (((n) - (d)/2)/(d)))
+
+static PyObject*
+resample_bilinear_op(PyObject* self, PyObject* args) {
+  PyArrayObject* input_array;
+  PyObject* size_tuple;
+  int new_height, new_width;
+
+  // Parse the arguments
+  if (!PyArg_ParseTuple(args, "O!O", &PyArray_Type, &input_array, &size_tuple)) {
+    return NULL;
+  }
+
+  // Convert the size tuple to new_height and new_width
+  if (!PyArg_ParseTuple(size_tuple, "ii", &new_height, &new_width)) {
+    return NULL;
+  }
+
+  // Check input array type and dimensions
+  if (PyArray_NDIM(input_array) != 4 || PyArray_TYPE(input_array) != NPY_UINT8 || PyArray_DIM(input_array, 3) != 3) {
+      PyErr_SetString(PyExc_ValueError, "Input array must be 4-dimensional with shape (n, h, w, 3) and of type uint8.");
+    return NULL;
+  }
+
+  // Get pointers to the data
+  unsigned char* input_data = (unsigned char*)PyArray_DATA(input_array);
+
+  // Get the dimensions of the input array
+  npy_intp* dims = PyArray_DIMS(input_array);
+  int n_frames = dims[0];
+  int height = dims[1];
+  int width = dims[2];
+
+  // Get the strides
+  npy_intp* input_strides = PyArray_STRIDES(input_array);
+
+  // Precompute the positions and weights
+  int pos[new_width][new_height][2];
+  int weights[new_width][new_height][2][2];
+  for (int y = 0; y < new_height; ++y) {
+    for (int x = 0; x < new_width; ++x) {
+      // Determine the position of the current pixel in the input image
+      float src_x = (x * (width - 1)) / (float)(new_width - 1);
+      float src_y = (y * (height - 1)) / (float)(new_height - 1);
+      // The four neighboring pixels
+      int x0 = (int)src_x;
+      int y0 = (int)src_y;
+      // Calculate the weights for each pixel
+      float dx = src_x - x0;
+      float dy = src_y - y0;
+      float dx1 = 1.0f - dx;
+      float dy1 = 1.0f - dy;
+      // Store the positions
+      pos[x][y][0] = x0;
+      pos[x][y][1] = y0;
+      // Store the weights
+      weights[x][y][0][0] = dx1 * dy1 * 256.0f;
+      weights[x][y][0][1] = dx  * dy1 * 256.0f;
+      weights[x][y][1][0] = dx1 * dy  * 256.0f;
+      weights[x][y][1][1] = dx  * dy  * 256.0f;
+    }
+  }
+
+  // Create an output array
+  npy_intp output_dims[4] = {n_frames, new_height, new_width, 3};
+  PyArrayObject* output_array_np = (PyArrayObject*)PyArray_EMPTY(4, output_dims, NPY_UINT8, 0);
+  if (output_array_np == NULL) {
+    return NULL;
+  }
+
+  // Get a pointer to the output data
+  unsigned char* output_data = (unsigned char*)PyArray_DATA(output_array_np);
+
+  // Resample each frame
+  for (int i = 0; i < n_frames; ++i) {
+    // Extract the current frame
+    unsigned char* current_frame = input_data + i * input_strides[0];
+    // Resize the frame using bilinear resampling
+    for (int y = 0; y < new_height; ++y) {
+      for (int x = 0; x < new_width; ++x) {
+        unsigned char* p1 = current_frame + pos[x][y][1] * input_strides[1] + pos[x][y][0] * input_strides[2];
+        unsigned char* p2 = p1 + input_strides[2];
+        unsigned char* p3 = p1 + input_strides[1];
+        unsigned char* p4 = p3 + input_strides[2];
+        
+        // Calculate the weighted sum of pixels (for each color channel)
+        int outr = p1[0] * weights[x][y][0][0] + p2[0] * weights[x][y][0][1] + 
+                   p3[0] * weights[x][y][1][0] + p4[0] * weights[x][y][1][1];
+        int outg = p1[1] * weights[x][y][0][0] + p2[1] * weights[x][y][0][1] + 
+                   p3[1] * weights[x][y][1][0] + p4[1] * weights[x][y][1][1];
+        int outb = p1[2] * weights[x][y][0][0] + p2[2] * weights[x][y][0][1] + 
+                   p3[2] * weights[x][y][1][0] + p4[2] * weights[x][y][1][1];
+        // Save
+        int idx = i * new_height * new_width * 3 + y * new_width * 3 + x * 3;
+        output_data[idx + 0] = (unsigned char)(outr >> 8);
+        output_data[idx + 1] = (unsigned char)(outg >> 8);
+        output_data[idx + 2] = (unsigned char)(outb >> 8);
+      }
+    }
+  }
+
+  Py_INCREF(output_array_np);
+  return (PyObject*)output_array_np;
+}
+
+static PyObject*
+resample_box_op(PyObject* self, PyObject* args) {
+  PyArrayObject* input_array;
+  PyObject* size_tuple;
+  int new_height, new_width;
+
+  // Parse the arguments
+  if (!PyArg_ParseTuple(args, "O!O", &PyArray_Type, &input_array, &size_tuple)) {
+    return NULL;
+  }
+
+  // Convert the size tuple to new_height and new_width
+  if (!PyArg_ParseTuple(size_tuple, "ii", &new_height, &new_width)) {
+    return NULL;
+  }
+
+  // Check input array type and dimensions
+  if (PyArray_NDIM(input_array) != 4 || PyArray_TYPE(input_array) != NPY_UINT8 || PyArray_DIM(input_array, 3) != 3) {
+    PyErr_SetString(PyExc_ValueError, "Input array must be 4-dimensional with shape (n, h, w, 3) and of type uint8.");
+    return NULL;
+  }
+
+  // Get pointers to the data
+  unsigned char* input_data = (unsigned char*)PyArray_DATA(input_array);
+
+  // Get the dimensions of the input array
+  npy_intp* dims = PyArray_DIMS(input_array);
+  int n_frames = dims[0];
+  int height = dims[1];
+  int width = dims[2];
+
+  // Make sure that we are downsampling
+  if (height / new_height < 2 || width / new_width < 2) {
+    PyErr_SetString(PyExc_ValueError, "This implementation of box resampling can only be used for downsampling.");
+    return NULL;
+  }
+
+  // Get the strides
+  npy_intp* input_strides = PyArray_STRIDES(input_array);
+
+  // Create an output array
+  npy_intp output_dims[4] = {n_frames, new_height, new_width, 3};
+  PyArrayObject* output_array_np = (PyArrayObject*)PyArray_EMPTY(4, output_dims, NPY_UINT8, 0);
+  if (output_array_np == NULL) {
+    return NULL;
+  }
+
+  // Get a pointer to the output data
+  unsigned char* output_data = (unsigned char*)PyArray_DATA(output_array_np);
+
+  // Precompute start and end indices for rows and columns and num_pixels
+  int start_x[new_width];
+  int end_x[new_width];
+  int start_y[new_height];
+  int end_y[new_height];
+  int num_pixels_[new_width][new_height];
+  for (int x = 0; x < new_width; ++x) {
+    start_x[x] = DIV_ROUND_CLOSEST(x * width, new_width);
+    end_x[x] = DIV_ROUND_CLOSEST((x + 1) * width, new_width);
+  }
+  for (int y = 0; y < new_height; ++y) {
+    start_y[y] = DIV_ROUND_CLOSEST(y * height, new_height);
+    end_y[y] = DIV_ROUND_CLOSEST((y + 1) * height, new_height);
+    for (int x = 0; x < new_width; ++x) {
+      num_pixels_[x][y] = (end_y[y] - start_y[y]) * (end_x[x] - start_x[x]);
+    }
+  }
+
+  // Resample each frame
+  for (int i = 0; i < n_frames; ++i) {
+    // Extract the current frame
+    unsigned char* current_frame = input_data + i * input_strides[0];
+    // Resize the frame using box resampling (average pooling)
+    for (int y = 0; y < new_height; ++y) {
+      for (int x = 0; x < new_width; ++x) {
+        // Compute the mean of pixels in the input image block
+        int sum_r = 0, sum_g = 0, sum_b = 0;
+        for (int src_y = start_y[y]; src_y < end_y[y]; ++src_y) {
+          for (int src_x = start_x[x]; src_x < end_x[x]; ++src_x) {
+            unsigned char* pixel = current_frame + src_y * input_strides[1] + src_x * input_strides[2];
+            sum_r += pixel[0];
+            sum_g += pixel[1];
+            sum_b += pixel[2];
+          }
+        }
+        // Calculate the average value of the pixels
+        int num_pixels = num_pixels_[x][y];
+        unsigned char avg_r = (unsigned char)(sum_r / num_pixels);
+        unsigned char avg_g = (unsigned char)(sum_g / num_pixels);
+        unsigned char avg_b = (unsigned char)(sum_b / num_pixels);
+        // Save the average value to the output image
+        int idx = i * new_height * new_width * 3 + y * new_width * 3 + x * 3;
+        output_data[idx + 0] = avg_r;
+        output_data[idx + 1] = avg_g;
+        output_data[idx + 2] = avg_b;
+      }
+    }
+  }
+
+  Py_INCREF(output_array_np);
+  return (PyObject*)output_array_np;
+}
+
+static PyObject*
+reduce_roi_op(PyObject* self, PyObject* args) {
+  PyArrayObject* input_array_video;
+  PyArrayObject* input_array_roi;
+
+  // Parse the arguments
+  if (!PyArg_ParseTuple(args, "O!O!", &PyArray_Type, &input_array_video, &PyArray_Type, &input_array_roi)) {
+    return NULL;
+  }
+
+  // Check input video array type and dimensions
+  if (PyArray_NDIM(input_array_video) != 4 || PyArray_TYPE(input_array_video) != NPY_UINT8 || PyArray_DIM(input_array_video, 3) != 3) {
+    PyErr_SetString(PyExc_ValueError, "Input video array must be 4-dimensional with shape (n, h, w, 3) and of type uint8.");
+    return NULL;
+  }
+
+  // Check input roi array type and dimensions
+  if (PyArray_NDIM(input_array_roi) != 2 || PyArray_TYPE(input_array_roi) != NPY_INT64 || PyArray_DIM(input_array_roi, 1) != 4 || PyArray_DIM(input_array_roi, 0) != PyArray_DIM(input_array_video, 0)) {
+    PyErr_SetString(PyExc_ValueError, "Input roi array must be 2-dimensional with shape (n, 4) and of type int64. First dim must match first dim of video array.");
+    return NULL;
+  }
+
+  // Get pointers to the data
+  unsigned char* video_data = (unsigned char*)PyArray_DATA(input_array_video);
+  npy_int64* roi_data = (npy_int64*)PyArray_DATA(input_array_roi);
+
+  // Get the strides
+  npy_intp* video_strides = PyArray_STRIDES(input_array_video);
+  npy_intp* roi_strides = PyArray_STRIDES(input_array_roi);
+
+  // Get the dimensions of the input video array
+  npy_intp* video_dims = PyArray_DIMS(input_array_video);
+  int n_frames = video_dims[0];
+
+  // Create an output array
+  npy_intp output_dims[2] = {n_frames, 3};
+  PyArrayObject* output_array_np = (PyArrayObject*)PyArray_EMPTY(2, output_dims, NPY_FLOAT32, 0);
+  if (output_array_np == NULL) {
+    return NULL;
+  }
+  // Get a pointer to the output data
+  float* output_data = (float*)PyArray_DATA(output_array_np);
+  
+  // Reduce each frame
+  for (int i = 0; i < n_frames; ++i) {
+    // Extract the current frame
+    unsigned char* current_frame_video = video_data + i * video_strides[0];
+    npy_int64* current_frame_roi = roi_data + i * 4; // TODO: Why doesn't roi_strides[0] work?
+    // Compute the mean of pixels within the ROI
+    int sum_r = 0, sum_g = 0, sum_b = 0;
+    int x0 = current_frame_roi[0];
+    int y0 = current_frame_roi[1];
+    int x1 = current_frame_roi[2];
+    int y1 = current_frame_roi[3];
+    for (int src_y = y0; src_y < y1; ++src_y) {
+      for (int src_x = x0; src_x < x1; ++src_x) {
+        unsigned char* pixel = current_frame_video + src_y * video_strides[1] + src_x * video_strides[2];
+        sum_r += pixel[0];
+        sum_g += pixel[1];
+        sum_b += pixel[2];
+      }
+    }
+    // Calculate the average value of the pixels
+    int num_pixels = (y1 - y0) * (x1 - x0);
+    float avg_r = sum_r / (float)num_pixels;
+    float avg_g = sum_g / (float)num_pixels;
+    float avg_b = sum_b / (float)num_pixels;
+    // Save the average value to the output image
+    int idx = i * 3;
+    output_data[idx + 0] = avg_r;
+    output_data[idx + 1] = avg_g;
+    output_data[idx + 2] = avg_b;
+  }
+
+  Py_INCREF(output_array_np);
+  return (PyObject*)output_array_np;
+}
+
+static PyMethodDef image_ops_methods[] = {
+    {"resample_bilinear_op", resample_bilinear_op, METH_VARARGS, PyDoc_STR("Resize video frames using bilinear resampling.")},
+    {"resample_box_op", resample_box_op, METH_VARARGS, PyDoc_STR("Resize video frames using box resampling.")},
+    {"reduce_roi_op", reduce_roi_op, METH_VARARGS, PyDoc_STR("Reduce spatial dimensions of video by mean using ROI.")},
+    {NULL, NULL, 0, NULL} /* Sentinel */
+};
+
+PyDoc_STRVAR(image_ops_doc,
+"Image ops implemented in C.");
+
+static struct PyModuleDef image_ops = {
+  PyModuleDef_HEAD_INIT,
+  "image_ops",
+  image_ops_doc,
+  -1,
+  image_ops_methods
+};
+
+PyMODINIT_FUNC
+PyInit_image_ops(void) {
+  import_array();
+  return PyModule_Create(&image_ops);
+}

{prpy-0.2.4 → prpy-0.2.6}/prpy/numpy/metric.py

@@ -135,11 +135,12 @@ def cor(
 def snr(
     f_true: np.ndarray,
     y_pred: np.ndarray,
-    f_s: float,
+    f_s: Union[float, int],
     f_res: float,
-    tol: float = .1,
-    f_min: float = .5,
-    f_max: float = 4.):
+    tol: Union[float, int] = .1,
+    f_min: Union[float, int] = .5,
+    f_max: Union[float, int] = 4.
+  ):
   """Signal-to-noise ratio
   Args:
     f_true: The true frequencies. Shape (b,) or ()
@@ -152,11 +153,15 @@ def snr(
   Returns:
     snr: The signal to noise ratio. Shape (b,) or ()
   """
-  assert isinstance(f_s, float)
+  assert isinstance(f_s, (float, int))
   assert isinstance(f_res, float)
-  assert isinstance(tol, float)
-  assert isinstance(f_min, float)
-  assert isinstance(f_max, float)
+  assert isinstance(tol, (float, int))
+  assert isinstance(f_min, (float, int))
+  assert isinstance(f_max, (float, int))
+  f_s = float(f_s)
+  tol = float(tol)
+  f_min = float(f_min)
+  f_max = float(f_max)
   f_true = np.asarray(f_true)
   y_pred = np.asarray(y_pred)
   assert len(y_pred.shape) == 1 or len(y_pred.shape) == 2

{prpy-0.2.4 → prpy-0.2.6}/prpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prpy
-Version: 0.2.4
+Version: 0.2.6
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License
@@ -36,10 +36,12 @@ Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: flake8; extra == "test"
 
-[![Tests](https://github.com/prouast/prpy/actions/workflows/main.yml/badge.svg)](https://github.com/prouast/prpy/actions/workflows/main.yml)
 
 # prpy
 
+[![Tests](https://github.com/prouast/prpy/actions/workflows/main.yml/badge.svg)](https://github.com/prouast/prpy/actions/workflows/main.yml)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/prpy?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pip%20downloads)](https://pypi.org/project/prpy/)
+
 A collection of Python utilities for signal, image, and video processing.
 It contains subpackages for working with `numpy`, `ffmpeg`, `tensorflow`, and `torch`.
 

{prpy-0.2.4 → prpy-0.2.6}/prpy.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ setup.py
 .github/workflows/main.yml
 prpy/__init__.py
 prpy/constants.py
+prpy/helpers.py
 prpy.egg-info/PKG-INFO
 prpy.egg-info/SOURCES.txt
 prpy.egg-info/dependency_links.txt
@@ -16,11 +17,15 @@ prpy/ffmpeg/__init__.py
 prpy/ffmpeg/probe.py
 prpy/ffmpeg/readwrite.py
 prpy/ffmpeg/utils.py
+prpy/numpy/.DS_Store
 prpy/numpy/__init__.py
 prpy/numpy/face.py
 prpy/numpy/image.py
+prpy/numpy/image_ops.c
+prpy/numpy/image_ops.cpython-310-darwin.so
 prpy/numpy/metric.py
 prpy/numpy/signal.py
+prpy/numpy/spam.cpython-310-darwin.so
 prpy/numpy/stride_tricks.py
 prpy/tensorflow/__init__.py
 prpy/tensorflow/image.py

{prpy-0.2.4 → prpy-0.2.6}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=61", "setuptools-scm"]
+requires = ["setuptools>=61", "setuptools-scm", "numpy"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -34,4 +34,7 @@ test = ["pytest", "flake8"]
 Repository = "https://github.com/prouast/prpy.git"
 Issues = "https://github.com/prouast/prpy/issues"
 
+[tools.setuptools]
+packages = ["prpy"]
+
 [tool.setuptools_scm]

prpy-0.2.6/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup, Extension
+import numpy as np
+
+setup(
+  ext_modules=[
+        Extension(
+            name="prpy.numpy.image_ops",
+            sources=["prpy/numpy/image_ops.c"],
+            include_dirs=[np.get_include()]
+        ),
+    ]
+)

{prpy-0.2.4 → prpy-0.2.6}/tests/test_numpy_image.py

@@ -19,6 +19,8 @@
 # SOFTWARE.
 
 from prpy.numpy.image import crop_slice_resize
+from prpy.numpy.image import resample_bilinear, resample_box
+from prpy.numpy.image import reduce_roi
 
 import numpy as np
 import pytest
@@ -29,12 +31,14 @@ import tensorflow as tf
 @pytest.mark.parametrize("roi", [(2, 2, 7, 7), [2, 2, 7, 7], None])
 @pytest.mark.parametrize("target_idxs", [None, [0, 2], (0, 2), np.asarray([0, 2])])
 @pytest.mark.parametrize("preserve_aspect_ratio", [True, False])
-@pytest.mark.parametrize("library", ["cv2", "tf", "PIL"])
+@pytest.mark.parametrize("library", ["cv2", "tf", "PIL", "prpy"])
 @pytest.mark.parametrize("scale_algorithm", ["bicubic", "area", "lanczos", "bilinear"])
 @pytest.mark.parametrize("keepdims", [True, False])
 def test_crop_slice_resize(target_size, n_frames, roi, target_idxs, preserve_aspect_ratio, library, scale_algorithm, keepdims):
   if (n_frames is None and target_idxs is not None) or \
-     (library == "PIL" and scale_algorithm == "area"):
+     (library == "PIL" and scale_algorithm == "area") or \
+     (library == "prpy" and scale_algorithm in ["bicubic", "area", "lanczos"]) or \
+     (library == "prpy" and preserve_aspect_ratio):
     pytest.skip("Skip because parameter combination does not work")
   if n_frames is None:
     images_in = np.random.uniform(size=(8, 12, 3), low=0, high=255)
@@ -74,3 +78,41 @@ def test_crop_slice_resize_retinaface():
     inputs=images_in, target_size=224, roi=(0, 0, 480, 640), target_idxs=None,
     library='tf', preserve_aspect_ratio=True, keepdims=True, scale_algorithm='bicubic')
   assert images_out.shape == (1, 224, 224, 3)
+
+@pytest.mark.parametrize("n_frames", [1, 3])
+@pytest.mark.parametrize("size", [4, 12, (12, 16)])
+def test_resample_bilinear(n_frames, size):
+  # Note: Only tests for correct shape, not for correct pixel vals
+  im = np.random.uniform(size=(n_frames, 8, 12, 3), low=0, high=255).astype(np.uint8)
+  out = resample_bilinear(im=im, size=size)
+  if isinstance(size, int): size = (size, size)
+  assert out.shape == (n_frames, size[0], size[1], 3)
+
+@pytest.mark.parametrize("n_frames", [1, 3])
+@pytest.mark.parametrize("size", [4, (2, 3)])
+def test_resample_box(n_frames, size):
+  # Note: Only tests for correct shape, not for correct pixel vals
+  im = np.random.uniform(size=(n_frames, 8, 12, 3), low=0, high=255).astype(np.uint8)
+  out = resample_box(im=im, size=size)
+  if isinstance(size, int): size = (size, size)
+  assert out.shape == (n_frames, size[0], size[1], 3)
+
+def test_resample_box_only_downsampling():
+  im = np.random.uniform(size=(3, 8, 12, 3), low=0, high=255).astype(np.uint8)
+  with pytest.raises(Exception):
+    _ = resample_box(im=im, size=5)
+
+@pytest.mark.parametrize("scenario", [(1, [[2, 3, 4, 7]]),
+                                      (3, [[3, 4, 7, 12], [3, 5, 7, 12], [3, 5, 6, 10]])])
+def test_reduce_roi(scenario):
+  n_frames = scenario[0]
+  roi = np.asarray(scenario[1])
+  video = np.random.uniform(size=(n_frames, 12, 8, 3), low=0, high=255).astype(np.uint8)
+  out = reduce_roi(video=video, roi=roi)
+  exp = np.asarray([np.mean(video[i, roi[i,1]:roi[i,3], roi[i,0]:roi[i,2]], axis=(0,1)) for i in range(n_frames)])
+  assert out.shape == (n_frames, 3)
+  np.testing.assert_allclose(
+    out,
+    exp,
+    atol=1e-4, rtol=1e-4)
+  

{prpy-0.2.4 → prpy-0.2.6}/tests/test_numpy_metric.py

@@ -56,8 +56,12 @@ def test_cor(shape):
     np.testing.assert_allclose(out, np.corrcoef(y_true, y_pred)[0,1])
 
 @pytest.mark.parametrize("shape", [(6,), (10, 6)])
-def test_snr(shape):
+@pytest.mark.parametrize("f_s", [5., 5])
+@pytest.mark.parametrize("tol", [.2, 1])
+@pytest.mark.parametrize("f_min", [.5, 1])
+@pytest.mark.parametrize("f_max", [4, 4.])
+def test_snr(shape, f_s, tol, f_min, f_max):
   f_true = np.random.uniform(size=shape[:-1])
   y_pred = np.random.uniform(size=shape)
-  out = snr(f_true, y_pred, f_s=5., f_res=.1)
+  out = snr(f_true, y_pred, f_s=f_s, f_res=.1, tol=tol, f_min=f_min, f_max=f_max)
   assert out.shape == shape[:-1]

prpy-0.2.4/setup.py

@@ -1,3 +0,0 @@
-from setuptools import setup
-
-setup()