Building OpenCV code using Bazel

Related searches

What is the best way to build C++ code that uses the OpenCV library using Bazel? I.e., what would the BUILD rules look like?

Bazel.io has docs for external dependencies but it's not very clear.

There are a couple of options. The easiest way is probably to install locally in the way the OpenCV site recommends:

git clone https://github.com/Itseez/opencv.git
cd opencv/
mkdir build install
cd build
cmake -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=/path/to/opencv/install ..
make install

Then add the following to your WORKSPACE file:

new_local_repository(
    name = "opencv",
    path = "/path/to/opencv/install",
    build_file = "opencv.BUILD",
)

Create opencv.BUILD in the same directory as WORKSPACE with the following:

cc_library(
    name = "opencv",
    srcs = glob(["lib/*.so*"]),
    hdrs = glob(["include/**/*.hpp"]),
    includes = ["include"],
    visibility = ["//visibility:public"], 
    linkstatic = 1,
)

Then your code can depend on @opencv//:opencv to link in the .so's under lib/ and reference the headers under include/.

However, this isn't very portable. If you want a portable solution (and you're feeling ambitious), you could add the OpenCV git repo to your workspace and download & build it. Something like:

# WORKSPACE
new_git_repository(
    name = "opencv",
    remote = "https://github.com/Itseez/opencv.git",
    build_file = "opencv.BUILD",
    tag = "3.1.0",
)

And make opencv.BUILD something like:

cc_library(
    name = "core",
    visibility = ["//visibility:public"],
    srcs = glob(["modules/core/src/**/*.cpp"]),
    hdrs = glob([
        "modules/core/src/**/*.hpp", 
        "modules/core/include/**/*.hpp"]
    ) + [":module-includes"],
)

genrule(
    name = "module-includes",
    cmd = "echo '#define HAVE_OPENCV_CORE' > $@",
    outs = ["opencv2/opencv_modules.hpp"],
)

...

Then your code could depend on more specific targets, e.g., @opencv//:core.

As a third option, you declare both cmake and OpenCV in your WORKSPACE file and use a genrule to run cmake on OpenCV from within Bazel.

ashnarayan13/opencv_bazel: Building OpenCV project with Bazel, What is the best way to build C++ code that uses the OpenCV library using Bazel ? I.e., what would the BUILD rules look like? Bazel.io has docs for external� Are there any plans of providing Bazel build rules for the Opencv score code? save cancel. Comments. 1. Here is link: bazel opencv. supra56 (Oct 1 '17)

I succeed with @kristina's first option.

  1. Install opencv:

    git clone https://github.com/Itseez/opencv.git
    
    cd opencv/
    
    mkdir build install
    
    cd build
    
    cmake -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=/usr/local ..
    
    make install
    
  2. Change WORKSPACE file (at tensorflow/WORKSPACE cloned from github)

    new_local_repository(
    
    name = "opencv",
    
    path = "/usr/local",
    
    build_file = "opencv.BUILD",
    
    )
    
  3. Make opencv.BUILD file at the same place as WORKSPACE file:

    cc_library(
    
    name = "opencv",
    
    srcs = glob(["lib/*.so*"]),
    
    hdrs = glob(["include/**/*.hpp"]),
    
    includes = ["include"],
    
    visibility = ["//visibility:public"], 
    
    linkstatic = 1,
    
    )
    
  4. You may have to config the opencv libs path:

a. Make sure you have /etc/ld.so.conf.d/opencv.conf file with content:

    /usr/local/lib

b. Run the command:

    sudo ldconfig -v

Building OpenCV code using Bazel, How to. In the WORKSPACE file, change the path of the OpenCV to your system path. Build the project using bazel build //main:main. To run the demo file bazel-bin/main/main /path/to/image. Building OpenCV code using Bazel. 5. How to resolve bazel “undeclared inclusion(s)” error? 1. Dispatching C++ generated files into srcs and hdrs. 6.

This is what I did for OpenCV 2.4.13.2, core/ only. This approach goes from the opencv source, which is adapted from the accepted answer above by @kristina.

The first thing is to add the http_archive for the opencv 2.4 release:

# OpenCV 2.4.13.2
new_http_archive(
    name = "opencv2",
    url = "https://github.com/opencv/opencv/archive/2.4.13.2.zip",
    build_file = "third_party/opencv2.BUILD",
    strip_prefix = "opencv-2.4.13.2",
)

And then, add the file third_party/opencv2.BUILD as:

cc_library(
    name = "dynamicuda",
    hdrs = glob([
        "modules/dynamicuda/include/**/*.hpp",
    ]),
    includes = [
        "modules/dynamicuda/include"
    ],
)

cc_library(
    name = "core",
    visibility = ["//visibility:public"],
    srcs = glob(["modules/core/src/**/*.cpp"]),
    hdrs = glob([
        "modules/core/src/**/*.hpp",
        "modules/core/include/**/*.hpp",
     ]) + [
        ":module_includes",
        ":cvconfig",
        ":version_string",
    ],
    copts = [
        "-Imodules/dynamicuda/include",
    ],
    # Note that opencv core requires zlib and pthread to build.
    linkopts = ["-pthread", "-lz"],
    includes = [
        "modules/core/include",
    ],
    deps = [
        ":dynamicuda",
    ],
)

genrule(
    name = "module_includes",
    cmd = "echo '#define HAVE_OPENCV_CORE' > $@",
    outs = ["opencv2/opencv_modules.hpp"],
)

genrule(
    name = "cvconfig",
    outs = ["cvconfig.h"],
    cmd = """
cat > $@ <<"EOF"
// JPEG-2000
#define HAVE_JASPER

// IJG JPEG
#define HAVE_JPEG

// PNG
#define HAVE_PNG

// TIFF
#define HAVE_TIFF

// Compile for 'real' NVIDIA GPU architectures
#define CUDA_ARCH_BIN ""

// NVIDIA GPU features are used
#define CUDA_ARCH_FEATURES ""

// Compile for 'virtual' NVIDIA PTX architectures
#define CUDA_ARCH_PTX ""
EOF"""
)

genrule(
    name = "version_string",
    outs = ["version_string.inc"],
    cmd = """
cat > $@ <<"EOF"
"\\n"
)

Note that I did not put anything in the version_string.inc. It is just a C++ string literal which does not affect the functionality of OpenCV. If you are really interested in this file see this example.

After this you should be able to add target with dependencies on @opencv2//:core.

bazel for opencv, What is the best way to build C++ code that uses the OpenCV library using Bazel ? I.e., what would the BUILD rules look like?Bazel.io has docs� What is the best way to build C++ code that uses the dlib library using Bazel? I.e., what would the BUILD rules look like? I tried following the answer for OpenCV as follows, but had no luck:

Here is an up2date solution that works with the current set of bazel(v3.1.0). In this little project i wanted to build a C++ program that depends on the newest openCV release (4.3.0), but only on a selected set of modules (core,highgui,imgcodecs,imgproc).

No local installed openCV required, bazel loads the needed files from github (although it works even when there is an old version of openCV installed):

Content of /WORKSPACE file:

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

all_content = """filegroup(name = "all", srcs = glob(["**"]), visibility = ["//visibility:public"])"""

http_archive(
    name = "opencv",
    build_file_content = all_content,
    strip_prefix = "opencv-4.3.0",
    urls = ["https://github.com/opencv/opencv/archive/4.3.0.zip"],
)

http_archive(
    name = "rules_foreign_cc",
    strip_prefix = "rules_foreign_cc-master",
    url = "https://github.com/bazelbuild/rules_foreign_cc/archive/master.zip",
)

load("@rules_foreign_cc//:workspace_definitions.bzl", "rules_foreign_cc_dependencies")

rules_foreign_cc_dependencies()

Content of /BUILD file:

load("@rules_foreign_cc//tools/build_defs:cmake.bzl", "cmake_external")

cmake_external(
    name = "opencv",
    cmake_options = [
        "-GNinja",
        "-DBUILD_LIST=core,highgui,imgcodecs,imgproc",
    ],
    lib_source = "@opencv//:all",
    make_commands = [
        "ninja",
        "ninja install",
    ],
    out_include_dir = "include/opencv4",
    shared_libraries = [
        "libopencv_core.so",
        "libopencv_highgui.so",
        "libopencv_imgcodecs.so",
        "libopencv_imgproc.so",
    ],
    visibility = ["//visibility:public"],
)

And finally, your target that depends on opencv, in my case a file /opencv/BUILD:

cc_binary(
    name = "opencv",
    srcs = ["opencv.cpp"],
    data = [
      "LinuxLogo.jpg",
      "WindowsLogo.jpg",
    ],
    deps = ["//:opencv"],
)

If you want to try it out, here is the rest: blackliner/automata

git clone https://github.com/blackliner/automata.git
cd automata
bazel build ...

OpenCV's native build system consists of nearly 200 cmake files with over 20,000 total lines of code, plus assorted helper scripts and that we will be using later on are generated as part of the bazel build process, we need to� Rules for building C/C++ projects using foreign build systems inside Bazel projects. This is not an officially supported Google product (meaning, support and/or new releases may be limited.) Bazel versions compatibility. Works with Bazel after 0.23 without any flags. News. March 2019: Support for versions earlier then 0.22 was removed.

Here's a simple demo of OpenCV & C++ built with Bazel: https://github.com/jcju/opencv_bazel_win

You may set up the OpenCV path in WORKSPACE and run:

bazel run //src:main

You now know the basics of building a C++ project with Bazel. Next, read up on the most common C++ build use cases. Then, check out the following: External Dependencies to learn more about working with local and remote repositories. The other rules to learn more about Bazel. The Java build tutorial to get started with building Java applications

Bazel supports building Android apps using the Android rules. This tutorial is intended for Windows, macOS and Linux users and does not require experience with Bazel or Android app development. You do not need to write any Android code in this tutorial.

Intel Threading Building Blocks is used inside OpenCV for parallel code snippets. Using this will make sure that the OpenCV library will take advantage of all the cores you have in your system's CPU. Using this will make sure that the OpenCV library will take advantage of all the cores you have in your system's CPU.

Building Isaac Applications¶ This tutorial will guide you through the process of creating robotics apps with Isaac SDK, using OpenCV edge detection processing of video input as an example. This tutorial will guide you through the following steps: Using Isaac SDK to display a USB camera feed.

Comments
  • Thanks so much! I went with the easiest option (the first one). Some minor corrections if anyone is using OpenCV 3.1.0: cc_library( name = "opencv", srcs = glob([ "lib/*.so*" ]), hdrs = glob([ "include/**/*.hpp" ]), includes = [ "include" ], visibility = [ "//visibility:public" ], linkstatic = 1, )
  • @kristina the second solution is not portable neither. there is a lot of missing files that are generated when running cmake, not only opencv_modules.hpp
  • @Ghilas I think you are missing what I meant by "portable:" if your build works for you, you can hand it to your coworker and it'll work on their machine, too. If the build doesn't expose the artifacts you need, it's not a portability problem.
  • @kristina The code in opencv.BUILD don't work as is, even if my code only needs @opencv/:core, that's what I meant. I've found a more complete code here that works. Now the only thing that I'm looking for is how to expose the JNI functions of OpenCV as I use the library from Java too. Any Idea ?
  • @kristina on mac I'm getting a linker error like this. Any idea? Undefined symbols for architecture x86_64: "cv::Mat::deallocate()", referenced from ...
  • How do I include int my BUILD file?
  • Make sure to get the .h files too. Not sure how this worked for others. This is what my build looked like: package(default_visibility = ["//visibility:public"]) cc_library( name = "opencv", srcs = glob(["lib/*.so*"]), hdrs = glob([ "include/opencv2/**/*.h", "include/opencv2/**/*.hpp", ]), strip_include_prefix = "include", linkstatic = 1, visibility = ["//visibility:public"], )
  • Humm, when I do this i'm still getting tons on undefined reference/ In my deps, I added @opencv. if I do @opencv//:core bazel cries with not defined
  • Tried to use it under Windows 10 with CMake 3.17.2 building for Visual Studio 2019 Win64 (i.e. cmake_options=[-G"Visual Studio 16 2019" -A"Win64"], make_commands = ["MSBuild.exe INSTALL.vcxproj"]). Does not work with PowerShell. Switched to MSys2 shell - does also not work - I guess this was tested using Linux?
  • Ok, wait, CMake? This is about using Bazel instead of CMake. What exactly did you try to do? And yes, i used Ubuntu 18.04 LTS.
  • cmake_external calls CMake. I used Bazel 3.1.0 to test it under Windows 10. But cmake_external works currently not for Powershell since it uses bash scripts. Even on msys2 shell I run into problems...
  • I tested it on Window 10 x64+ Powershell + Bazel 3.1.0 - linkstatic = 1 has no effect. I can compile my OpenCV code, but when running it complains about mission OpenCV DLLs.