Pranay Code Review

python/CMakeLists.txt

@@ -9,6 +9,10 @@ find_package(Python2 COMPONENTS Development)
 file(GLOB LIGHTDB_CORE_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/../core/*/include/")
 include_directories(${LIGHTDB_CORE_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${Python2_INCLUDE_DIRS})
 
+# Include ipp
+include_directories(/opt/intel/ipp/include)
+link_directories(/opt/intel/ipp/lib/intel64)
+
 # Include python header files
 file(GLOB LIGHTDB_PYTHON_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/../python/include")
 include_directories(${LIGHTDB_PYTHON_INCLUDE_DIRS})
@@ -28,5 +32,6 @@ add_library(pylightdb SHARED ${LIGHTDB_PYTHON_SOURCES})
 target_compile_options(pylightdb PRIVATE "-fvisibility=default")
 
 target_link_libraries(pylightdb ${Boost_LIBRARIES} ${Python2_LIBRARIES} lightdb_shared)
-target_link_libraries(pylightdb opencv_core)
+#target_link_libraries(pylightdb ${Boost_LIBRARIES} ${Python2_LIBRARIES} ${LIGHTDB_LIB_DEPENDENCIES} lightdb_protobuf lightdb_shared)
+target_link_libraries(pylightdb opencv_core ippi ippcc boost_numpy)
 set_target_properties(pylightdb PROPERTIES PREFIX "")

python/include/PythonGreyscale.h

@@ -0,0 +1,47 @@
+#ifndef LIGHTDB_PYTHON_GREYSCALE_H
+#define LIGHTDB_PYTHON_GREYSCALE_H
+
+#include "Functor.h"
+
+
+namespace lightdb::python {
+    class PythonGreyscale :  public lightdb::functor::unaryfunctor {
+        class CPU : public lightdb::functor::unaryfunction {
+        public:
+            explicit CPU(PyObject* const callable, const bool deterministic=true)
+                : lightdb::functor::unaryfunction(lightdb::physical::DeviceType::CPU,
+                                                  lightdb::Codec::raw(),
+                                                  deterministic),
+                  callable_(callable)
+            { 
+                CHECK_NOTNULL(callable);
+                callable->ob_refcnt++; 
+            }
+
+            void Allocate(const unsigned int height, const unsigned int width, const unsigned int channels) {
+                if (rgbSize_ != channels * height * width) {
+                    frameSize_ = height * width;
+                    rgbSize_ = channels * frameSize_;
+                    rgb_.resize(rgbSize_);
+                    mask_.resize(rgbSize_);
+                }
+            }
+
+            lightdb::shared_reference<lightdb::LightField> operator()(lightdb::LightField& field) override;
+
+        private:
+            PyObject* const callable_;
+            unsigned int kernelSize_;
+            unsigned int rgbSize_;
+            unsigned int frameSize_;
+            std::vector<unsigned char> rgb_;
+            std::vector<unsigned char> mask_;   
+        };
+
+    public:
+        explicit PythonGreyscale(PyObject* const callable, const bool deterministic=true) : functor::unaryfunctor("Greyscale", CPU(callable, deterministic)) {}      
+    };
+
+}
+
+#endif //LIGHTDB__PYTHON_GREYSCALE_H

python/src/Module.cc

@@ -1,5 +1,6 @@
 #include "PythonLightField.h"
 #include "PythonGeometry.h"
+#include "PythonGreyscale.h"
 #include <boost/python.hpp>
 
 
@@ -81,7 +82,8 @@ namespace lightdb::python {
 
         boost::python::class_<lightdb::functor::naryfunctor<1>>("UnaryFunctor", boost::python::no_init);
         boost::python::class_<class lightdb::Greyscale, boost::python::bases<lightdb::functor::unaryfunctor>>("Greyscale");
-
+        boost::python::class_<PythonGreyscale, boost::shared_ptr<PythonGreyscale>, boost::python::bases<lightdb::functor::unaryfunctor>>("PythonGreyscale", boost::python::init<PyObject*>())
+                .def(boost::python::init<PyObject*, bool>());
         boost::python::class_<typename lightdb::options<>>("PyOptions", boost::python::no_init);
     };
 } // namespace Python

python/src/PythonGreyscale.cc

@@ -0,0 +1,47 @@
+#include <boost/python/numpy.hpp>
+#include <iostream>
+#include <vector>
+#include "PythonGreyscale.h"
+#include "npp.h"
+#include "ipp.h"
+#include "Format.h"
+
+namespace np = boost::python::numpy;
+
+namespace lightdb::python {
+    shared_reference <LightField> PythonGreyscale::CPU::operator()(LightField &input) {
+        np::initialize();
+        const auto channels = 3u;
+        auto &data = dynamic_cast<lightdb::physical::CPUDecodedFrameData&>(input);
+        lightdb::physical::CPUDecodedFrameData output(data.configuration(), data.geometry());
+
+         for(auto& frame: data.frames()) {
+            Allocate(frame->height(), frame->width(), channels);
+            IppiSize size{static_cast<int>(frame->width()), static_cast<int>(frame->height())};
+            auto y_in = reinterpret_cast<const unsigned char*>(frame->data().data());
+            auto uv_in = y_in + frameSize_;
+            output.frames().emplace_back(LocalFrameReference::make<LocalFrame>(*frame, frame->data().size(), lightdb::video::Format::nv12()));
+            auto y_out = output.frames().back()->data().data();
+            auto uv_out = y_out + frameSize_;
+
+            // NV12 -> RGB
+            CHECK_EQ(ippiYCbCr420ToRGB_8u_P2C3R((Ipp8u*)y_in, frame->width(), (Ipp8u*)uv_in, frame->width(), rgb_.data(), channels * frame->width(), size), ippStsNoErr);
+
+            // RGB --> Numpy 
+            np::dtype dtype = np::dtype::get_builtin<unsigned char>();
+            np::ndarray py_array = np::from_data(
+                                        rgb_.data(), 
+                                        dtype, 
+                                        boost::python::make_tuple(channels, frame->width(), frame->height()),
+                                        boost::python::make_tuple(1 , sizeof(unsigned char) * channels, sizeof(unsigned char) * channels * frame->width()),
+                                        boost::python::object());
+
+            np::ndarray swap = py_array.transpose();
+            boost::python::call<void>(callable_, swap); 
+
+            // RGB -> NV12
+            CHECK_EQ(ippiRGBToYCbCr420_8u_C3P2R(rgb_.data(), channels * frame->width(), (Ipp8u*)y_out, frame->width(), (Ipp8u*)uv_out, frame->width(), size), ippStsNoErr);                     
+        }
+        return output;
+    }
+}

python/test/test.py

@@ -1,5 +1,13 @@
-import pytest
-import pylightdb as db 
+import pylightdb
+from pylightdb import *
 
-def scan_test():
-    PythonLightField pydb = db.Scan()
+x  = SpatiotemporalRange(0,0)
+y  = SpatiotemporalRange(0,0)
+z  = SpatiotemporalRange(0,0)
+vol = Volume(x,y,z)
+geo = EquirectangularGeometry(2,1)
+env = LocalEnvironment()
+optimizer = HeuristicOptimizer(env)
+coordinator = Coordinator()
+query = Load("/home/pranay99/lightdb/test/resources/test-pattern.h264", {"Volume":vol, "Projection":geo}).Save("/home/pranay99/test.mp4")
+coordinator.Execute(query.query(), optimizer)

python/test/testGrey.py

@@ -0,0 +1,22 @@
+import pylightdb
+import numpy as np
+import cv2 as cv
+from PIL import Image
+from pylightdb import *
+
+x  = SpatiotemporalRange(0,0)
+y  = SpatiotemporalRange(0,0)
+z  = SpatiotemporalRange(0,0)
+vol = Volume(x,y,z)
+geo = EquirectangularGeometry(0,0)
+env = LocalEnvironment()
+optimizer = HeuristicOptimizer(env)
+coordinator = Coordinator()
+def rgb2gray(rgb):
+  rgb_weights = [0.2989, 0.5870, 0.1140]
+  grayscale_image = np.dot(rgb[...,:3], rgb_weights)
+  rgb[:,:,:] = grayscale_image[:,:,np.newaxis]
+  return rgb
+grey = PythonGreyscale(rgb2gray)
+query = Load("/home/pranay99/colorsrc.h264", {"Volume":vol, "Projection":geo}).Map(grey).Save("/home/pranay99/lambdaTest.h264")
+coordinator.Execute(query.query(), optimizer)

test/CMakeLists.txt

@@ -35,6 +35,10 @@ get_property(LIGHTDB_INCLUDES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INC
 string(REPLACE ";" "|" LIGHTDB_INCLUDES_STRING "${LIGHTDB_INCLUDES}")
 
 foreach(LIGHTDB_PLUGIN_DIR ${LIGHTDB_PLUGIN_DIRS})
+    message("Lightdb plugin dir: ${LIGHTDB_PLUGIN_DIR}")
+    message("CMAKE_CURRENT_BINARY_DIR: ${CMAKE_CURRENT_BINARY_DIR}")
+    message("LIGHTDB_PLUGIN_DIR: ${LIGHTDB_PLUGIN_DIR}")
+    message("CMAKE_SOURCE_DIR: ${CMAKE_SOURCE_DIR}")
     if (IS_DIRECTORY ${LIGHTDB_PLUGIN_DIR})
         get_filename_component(LIGHTDB_PLUGIN_NAME ${LIGHTDB_PLUGIN_DIR} NAME_WE)
         string(TOLOWER "${LIGHTDB_PLUGIN_DIR}/cmake-build-${CMAKE_BUILD_TYPE}" LIGHTDB_PLUGIN_BINARY_DIR)

test/src/execution/SelectionTests.cc

@@ -86,6 +86,21 @@ TEST_F(SelectionTestFixture, testSelectPhi) {
     EXPECT_EQ(remove(Resources.out.hevc), 0);
 }
 
+TEST_F(SelectionTestFixture, testSelectPhi2) {
+    auto query = Load("/home/maureen/lightdb/cmake-build-debug-remote/test/resources/red10/stream0.h264")
+            .Select(PhiRange{0, rational_times_real({1, 4}, PI)})
+            .Encode()
+            .Save("/home/maureen/encoded0.hevc");
+
+    Coordinator().execute(query);
+
+    EXPECT_VIDEO_VALID(Resources.out.hevc);
+    EXPECT_VIDEO_FRAMES(Resources.out.hevc, Resources.red10.frames);
+    EXPECT_VIDEO_RESOLUTION(Resources.out.hevc, Resources.red10.height / 4, Resources.red10.width);
+    EXPECT_VIDEO_RED(Resources.out.hevc);
+    EXPECT_EQ(remove(Resources.out.hevc), 0);
+}
+
 TEST_F(SelectionTestFixture, testSelectTheta) {
     REQUIRE_GPU();
 
@@ -156,6 +171,15 @@ TEST_F(SelectionTestFixture, testTemporalThetaSelect) {
     EXPECT_EQ(remove(Resources.out.hevc), 0);
 }
 
+TEST_F(SelectionTestFixture, testPythonQuery) {
+    auto query = Load("/home/maureen/lightdb/test/resources/tiles/tile-6.hevc")
+                .Select(PhiRange{0, rational_times_real({3, 4}, PI)})
+                .Encode()
+                .Save("/home/maureen/selected-tile-6-test.hevc");
+
+    Coordinator().execute(query);
+}
+
 TEST_F(SelectionTestFixture, testDegenerateTimeSelect) {
     REQUIRE_GPU();
 

test/src/execution/UDFTests.cc

@@ -27,7 +27,7 @@ TEST_F(UDFTestFixture, testGreyscale) {
     auto query = Scan(Resources.red10.name)
                     .Map(lightdb::Greyscale)
                     .Encode()
-                    .Save(Resources.out.hevc);
+                    .Save("/home/maureen/grey_test.hevc");
 
     Coordinator().execute(query);