Dockerfile.aarch64

# syntax=docker/dockerfile:1

#-- Build configuration --#
# ARCH_CFLAGS is supplied as a compile option
ARG ARCH_CFLAGS="-O2 -mcpu=cortex-a53+crypto"
# AXIS_ARCH is the AXIS platform descriptor
ARG AXIS_ARCH=aarch64
# BUILD_ROOT defines where in the build containers the building takes place
ARG BUILD_ROOT=/build-root
# DOCKERHUB_ARCH is the DockerHub platform descriptor
ARG DOCKERHUB_ARCH=arm64v8
# OPENCV_MODULES defines what OpenCV modules to build
ARG OPENCV_MODULES=core,imgproc,imgcodecs,videoio,objdetect,python3,video
# SDK_ROOT_DIR defines the root directory of the final SDK images
ARG SDK_ROOT_DIR=/axis/
# UBUNTU_ARCH is the Ubuntu platform descriptor
ARG UBUNTU_ARCH=arm64
# TARGET_TOOLCHAIN is the name of the compilation toolchain for the target platform
ARG TARGET_TOOLCHAIN=aarch64-linux-gnu
#CMAKE_TOOLCHAIN_FILE is the name of the CMAKE toolchain folder
ARG CMAKE_TOOLCHAIN_FOLDER=aarch64-gnu
# TARGET_ROOT defines where in the build containers the resulting application is put
ARG TARGET_ROOT=/target-root
# UBUNTU_VERSION defines the ubuntu version of the build and SDK containers
ARG UBUNTU_VERSION=22.04
# UBUNTU_CODENAME should be the ubuntu codename of the UBUNTU_VERSION used, e.g., focal, hirsute, ..
ARG UBUNTU_CODENAME=jammy

#-- Versions of installed packages defined as repository tags --#
ARG NUMPY_VERSION=v1.17.3
ARG CYTHON_VERSION=0.29.36
ARG OPENBLAS_VERSION=v0.3.14
ARG OPENCV_VERSION=4.5.1
ARG PYTHON_VERSION=3.8.8
ARG PYTESSERACT_VERSION=0.3.7
ARG SCIPY_VERSION=v1.7.1
ARG TESSERACT_VERSION=4.1.1
ARG TFSERVING_VERSION=2.9.0

#-- Build parallelization  --#
ARG OPENBLAS_BUILD_CORES=16
ARG OPENCV_BUILD_CORES=16
ARG PYTHON_BUILD_CORES=16
ARG NUMPY_BUILD_CORES=16
ARG SCIPY_BUILD_CORES=16
ARG TESSERACT_BUILD_CORES=16
ARG TENSORFLOW_BUILD_CORES=16
#-- ACAP SDK configuration --#
ARG REPO=axisecp
ARG ACAP_SDK_IMAGE=acap-native-sdk
ARG ACAP_SDK_UBUNTU_VERSION=22.04
ARG ACAP_SDK_VERSION=1.15_rc1
ARG ACAP_SDK_TAG=${ACAP_SDK_VERSION}-${AXIS_ARCH}-ubuntu${ACAP_SDK_UBUNTU_VERSION}

# The ACAP Native SDK is used to get certain libs and headers
FROM ${REPO}/${ACAP_SDK_IMAGE}:${ACAP_SDK_TAG} AS acap-native-sdk
# libs: /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/
# headers: /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/include/

# Create a base image with build tools, env vars, etc.,
FROM ubuntu:${UBUNTU_VERSION} AS build-base

# Setup environment variables
ENV DEBIAN_FRONTEND=noninteractive
ARG BUILD_ROOT
ARG PYTHON_VERSION
ARG TARGET_TOOLCHAIN
ARG TARGET_ROOT
ARG UBUNTU_ARCH
ARG UBUNTU_CODENAME
ARG http_proxy
ARG https_proxy

# To support DOCKER_BUILDKIT=0, base ARGs are converted to ENVs to allow propagation
ENV BUILD_ROOT=$BUILD_ROOT
ENV TARGET_TOOLCHAIN=$TARGET_TOOLCHAIN
ENV TARGET_ROOT=$TARGET_ROOT
ENV UBUNTU_ARCH=$UBUNTU_ARCH
ENV UBUNTU_CODENAME=$UBUNTU_CODENAME
ENV http_proxy=$http_proxy
ENV https_proxy=$https_proxy

# Add source for target arch
RUN echo \
"deb [arch=amd64] http://us.archive.ubuntu.com/ubuntu/ $UBUNTU_CODENAME main restricted universe multiverse\n\
deb [arch=amd64] http://us.archive.ubuntu.com/ubuntu/ $UBUNTU_CODENAME-updates main restricted universe multiverse\n\
deb [arch=amd64] http://us.archive.ubuntu.com/ubuntu/ $UBUNTU_CODENAME-backports main restricted universe multiverse\n\
deb [arch=amd64] http://security.ubuntu.com/ubuntu $UBUNTU_CODENAME-security main restricted universe multiverse\n\
deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports/ $UBUNTU_CODENAME main restricted universe multiverse\n\
deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports/ $UBUNTU_CODENAME-updates main restricted universe multiverse\n\
deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports/ $UBUNTU_CODENAME-backports main restricted universe multiverse\n\
deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports/ $UBUNTU_CODENAME-security main restricted universe multiverse"\
 > /etc/apt/sources.list

# Get crosscompilation toolchain and related packages
RUN dpkg --add-architecture $UBUNTU_ARCH
RUN <<EOF
apt-get update
apt-get install -yf --no-install-recommends \
    autoconf \
    automake \
    autotools-dev \
    build-essential \
    ca-certificates \
    crossbuild-essential-$UBUNTU_ARCH \
    cmake \
    curl \
    gfortran \
    gfortran-$TARGET_TOOLCHAIN \
    git \
    libtool \
    pkg-config \
    python3-dev \
    python3-pip \
    python3-venv \
    wget
update-ca-certificates
apt-get clean
EOF

RUN mkdir -p ${TARGET_ROOT}
RUN mkdir -p ${BUILD_ROOT}

# Save a string of what python major.minor version we're using
# for paths, etc.
RUN echo python${PYTHON_VERSION} | sed 's/\([0-9]\.[0-9]*\)\.\([0-9]*\)/\1/' > /tmp/python_version

# Create a emulated base image with build tools, env vars, etc.,
FROM $DOCKERHUB_ARCH/ubuntu:${UBUNTU_VERSION} as build-base-arm
ARG BUILD_ROOT
ENV DEBIAN_FRONTEND=noninteractive
ARG PYTHON_VERSION
ARG TARGET_TOOLCHAIN
ARG TARGET_ROOT
ARG UBUNTU_ARCH
ARG http_proxy
ARG https_proxy

# To support DOCKER_BUILDKIT=0, base ARGs are converted to ENVs to allow propagation
ENV BUILD_ROOT=$BUILD_ROOT
ENV TARGET_TOOLCHAIN=$TARGET_TOOLCHAIN
ENV TARGET_ROOT=$TARGET_ROOT
ENV UBUNTU_ARCH=$UBUNTU_ARCH
ENV http_proxy=$http_proxy
ENV https_proxy=$https_proxy

# qemu is used to emulate arm
COPY --from=multiarch/qemu-user-static:x86_64-aarch64-6.1.0-8 /usr/bin/qemu-aarch64-static /usr/bin/

RUN <<EOF
apt-get update
apt-get install -y --no-install-recommends \
    build-essential \
    ca-certificates \
    curl \
    gfortran \
    git \
    pkg-config
update-ca-certificates
EOF

RUN mkdir -p ${TARGET_ROOT}
RUN mkdir -p ${BUILD_ROOT}

# Save a string of what python major.minor version we're using
# for paths, etc.
RUN echo python${PYTHON_VERSION} | sed 's/\([0-9]\.[0-9]*\)\.\([0-9]*\)/\1/' > /tmp/python_version

# Crosscompile OpenBLAS
FROM build-base AS build-openblas
ARG ARCH_CFLAGS
ARG OPENBLAS_BUILD_CORES
ARG OPENBLAS_VERSION
WORKDIR ${BUILD_ROOT}
RUN git clone --depth 1 --branch ${OPENBLAS_VERSION}  https://github.com/xianyi/OpenBLAS.git
WORKDIR ${BUILD_ROOT}/OpenBLAS
RUN HAVE_NEON=1 make -j ${OPENBLAS_BUILD_CORES} TARGET=CORTEXA53 CC=$TARGET_TOOLCHAIN-gcc FC=$TARGET_TOOLCHAIN-gfortran HOSTCC=gcc
RUN make install PREFIX=$TARGET_ROOT/usr

# Crosscompile Python
FROM build-base as build-python-cross
ARG ARCH_CFLAGS
ARG PYTHON_VERSION
ARG PYTHON_BUILD_CORES
RUN mkdir -p $BUILD_ROOT/python_deps
WORKDIR /usr/bin
RUN ln -s python3.*[0-9] python

# Need to install python3.8 to build python 3.8
# this should be removed when stepping up to 3.10
RUN <<EOF
apt-get update
apt install software-properties-common -y
add-apt-repository ppa:deadsnakes/ppa -y
apt-get update
apt-get install python3.8 -y
EOF

# Get optional Python module dependencies
RUN apt-get install --reinstall --download-only -o=dir::cache=$BUILD_ROOT/python_deps -y -f \
    libbz2-dev:$UBUNTU_ARCH \
    zlib1g-dev:$UBUNTU_ARCH \
    libffi-dev:$UBUNTU_ARCH \
    libssl-dev:$UBUNTU_ARCH \
    libsqlite3-dev:$UBUNTU_ARCH \
    libreadline6-dev:$UBUNTU_ARCH
WORKDIR $TARGET_ROOT
RUN for f in $BUILD_ROOT/python_deps/archives/*.deb; do dpkg -x $f $TARGET_ROOT; done
RUN <<EOF
mv $TARGET_ROOT/lib/$TARGET_TOOLCHAIN/* $TARGET_ROOT/usr/lib/$TARGET_TOOLCHAIN/
rm -rf $TARGET_ROOT/lib
EOF

# Copy selected libs we need for python compilation
WORKDIR $TARGET_ROOT/usr/lib/$TARGET_TOOLCHAIN/
RUN cp -R libffi* libreadline* libssl* libz* libcrypt* libncurses* libunistring* libidn* libtinfo* libgpm* libbz2* libsqlite3* ..
RUN <<EOF
cp -r $TARGET_ROOT/usr/include/$TARGET_TOOLCHAIN/* $TARGET_ROOT/usr/include/
rm -r $TARGET_ROOT/usr/include/$TARGET_TOOLCHAIN
EOF

# Download Python
RUN curl https://www.python.org/ftp/python/$PYTHON_VERSION/Python-$PYTHON_VERSION.tgz -o $BUILD_ROOT/python.tgz
RUN tar -xf $BUILD_ROOT/python.tgz -C $BUILD_ROOT/
WORKDIR $BUILD_ROOT/Python-$PYTHON_VERSION

# Setup crosscompilation environment
ENV CC=$TARGET_TOOLCHAIN-gcc
ENV CXX=$TARGET_TOOLCHAIN-g++
ENV AR=$TARGET_TOOLCHAIN-ar
ENV LD=$TARGET_TOOLCHAIN-ld
ENV RANLIB=$TARGET_TOOLCHAIN-ranlib
ENV CFLAGS="$ARCH_CFLAGS -I$TARGET_ROOT/usr/include"
ENV CXXFLAGS="$ARCH_CFLAGS -I$TARGET_ROOT/usr/include"
ENV CPPFLAGS="$ARCH_CFLAGS -I$TARGET_ROOT/usr/include"
ENV LDFLAGS="-L/usr/lib/$TARGET_TOOLCHAIN -L$TARGET_ROOT/usr/lib"
RUN ./configure --host=$TARGET_TOOLCHAIN --with-openssl=$TARGET_ROOT/usr \
    --build=x86_64-linux-gnu --prefix=$TARGET_ROOT/usr \
    --enable-shared --disable-ipv6 \
    ac_cv_file__dev_ptmx=no ac_cv_file__dev_ptc=no \
    --with-lto --enable-optimizations \
    --enable-loadable-sqlite-extensions
RUN make HOSTPYTHON=/usr/bin/python3 -j $PYTHON_BUILD_CORES CROSS_COMPILE=$TARGET_TOOLCHAIN CROSS_COMPILE_TARGET=yes
RUN make altinstall HOSTPYTHON=python3 CROSS_COMPILE=$TARGET_TOOLCHAIN CROSS_COMPILE_TARGET=yes prefix=$TARGET_ROOT/usr
WORKDIR $TARGET_ROOT/usr/bin
RUN ln -s python3.*[0-9] python3
RUN <<EOF
mkdir -p $TARGET_ROOT/usr/include/$TARGET_TOOLCHAIN/$(cat /tmp/python_version)
cp -r $TARGET_ROOT/usr/include/$(cat /tmp/python_version)/* $TARGET_ROOT/usr/include/$TARGET_TOOLCHAIN/$(cat /tmp/python_version)
EOF

# Continue Python install with installing
# pip in emulated environment
FROM build-base-arm as build-python
ENV PATH=$TARGET_ROOT/usr/bin:$PATH
ENV LD_LIBRARY_PATH=$TARGET_ROOT/usr/lib:$LD_LIBRARY_PATH
COPY --from=build-python-cross $TARGET_ROOT $TARGET_ROOT
WORKDIR ${BUILD_ROOT}/pip
RUN curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
RUN $TARGET_ROOT/usr/bin/python3 get-pip.py
# Fix to not use static paths to $TARGET_ROOT
RUN sed -i '1s/.*/#!\/usr\/bin\/env python3/g' $TARGET_ROOT/usr/bin/pip*

# Build NumPy with OpenBLAS
# This build is done emulated right now until more work
# has been put in researching how to crosscompile
# python packages
# Building numpy like this vs apt-get shows ~5% lower proc times
# in basic math ops
# Building numpy with OpenBLAS as BLAS/Lapack vs built-in BLAS/Lapack
# shows between 50% to 99% lower proc times depending on the linalg op used
FROM build-base-arm AS build-python-numpy
ARG ARCH_CFLAGS
ARG NUMPY_BUILD_CORES
ARG NUMPY_VERSION
ARG CYTHON_VERSION
ARG SETUPTOOLS_OVERRIDE=setuptools==60.10.0
ENV CFLAGS="$ARCH_CFLAGS"
ENV LD_LIBRARY_PATH=$BUILD_ROOT/usr/lib:$LD_LIBRARY_PATH
ENV NPY_NUM_BUILD_JOBS=$NUMPY_BUILD_CORES
ENV PATH=$BUILD_ROOT/usr/bin:$BUILD_ROOT/usr/local/bin:$PATH
COPY --from=build-openblas $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python $TARGET_ROOT $BUILD_ROOT
WORKDIR $BUILD_ROOT
RUN git clone --depth 1 --branch ${NUMPY_VERSION}  https://github.com/numpy/numpy
WORKDIR $BUILD_ROOT/numpy
RUN <<EOF
cp site.cfg.example site.cfg
echo "[openblas]\n" \
    "libraries = openblas\n" \
    "library_dirs = ${BUILD_ROOT}/usr/lib\n" \
    "include_dirs = ${BUILD_ROOT}/usr/include\n" \
    "[default]\n" \
    "include_dirs = ${BUILD_ROOT}/usr/include\n" \
    "library_dirs = ${BUILD_ROOT}/usr/lib\n" \
    "[lapack]\n" \
    "lapack_libs = openblas\n" \
    "library_dirs = ${BUILD_ROOT}/usr/lib\n" \
    >> site.cfg
EOF
RUN CC="gcc -I$BUILD_ROOT/usr/include -I$BUILD_ROOT/usr/include/$(cat /tmp/python_version) $ARCH_CFLAGS" python3 -m pip install $SETUPTOOLS_OVERRIDE cython==$CYTHON_VERSION
RUN CC="gcc -I$BUILD_ROOT/usr/include -I$BUILD_ROOT/usr/include/$(cat /tmp/python_version) $ARCH_CFLAGS" python3 setup.py config
RUN CC="gcc -I$BUILD_ROOT/usr/include -I$BUILD_ROOT/usr/include/$(cat /tmp/python_version) $ARCH_CFLAGS" python3 -m pip install . -v --prefix=$TARGET_ROOT/usr
RUN mkdir -p ${BUILD_ROOT}/python-numpy-deps
RUN apt-get install --reinstall --download-only -o=dir::cache=${BUILD_ROOT}/python-numpy-deps -y --no-install-recommends \
    libgfortran5
RUN for f in ${BUILD_ROOT}/python-numpy-deps/archives/*.deb; do dpkg -x $f $TARGET_ROOT; done

# Build SciPy with OpenBLAS
FROM build-base-arm AS build-python-scipy
ARG ARCH_CFLAGS
ARG SCIPY_BUILD_CORES
ARG SCIPY_VERSION
ARG CYTHON_VERSION
ENV CC="gcc -I$BUILD_ROOT/usr/include $ARCH_CFLAGS"
ENV CFLAGS="$ARCH_CFLAGS"
ENV LD_LIBRARY_PATH=$BUILD_ROOT/usr/lib:$LD_LIBRARY_PATH
ENV NPY_NUM_BUILD_JOBS=$SCIPY_BUILD_CORES
ENV PATH=$BUILD_ROOT/usr/bin:$BUILD_ROOT/usr/local/bin:$PATH
WORKDIR $BUILD_ROOT
RUN git clone --depth 1 --branch ${SCIPY_VERSION}  https://github.com/scipy/scipy.git
WORKDIR $BUILD_ROOT/scipy
RUN git submodule update --init
COPY --from=build-openblas $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python-numpy $TARGET_ROOT $BUILD_ROOT
ENV LAPACK=${BUILD_ROOT}/usr/lib/libopenblas.so
ENV BLAS=${BUILD_ROOT}/usr/lib/libopenblas.so
RUN python3 -m pip install cython==$CYTHON_VERSION tempita==0.4 pybind11 pythran
#Built wheels externally to speed up the build process, and avoid timeout in dockerhub
RUN curl --remote-name https://acap-wheels.s3.eu-north-1.amazonaws.com/bin/scipy-1.7.1-cp38-cp38-linux_aarch64.whl
COPY checksums/scipy-arm64 .
RUN shasum -a 512 -c scipy-arm64
RUN python3 -m pip install *.whl --prefix=$TARGET_ROOT/usr

# Compile the protofiles natively
FROM build-base AS build-python-tfserving-prestage
ARG TFSERVING_VERSION

WORKDIR ${BUILD_ROOT}

RUN git clone --depth 1 --branch v${TFSERVING_VERSION}  https://github.com/tensorflow/tensorflow.git
RUN git clone --depth 1 --branch ${TFSERVING_VERSION}  https://github.com/tensorflow/serving.git
COPY tfserving/install-tf.sh .

#grpcio-tools contains protoc, which allows to build the pb2.py files in the install-tf.sh script.
#Installing directly grpcio-tools result in an older version of protobuf.
#So we install first the dependencies with the desired version and then grpcio-tool without dependencies.
RUN python3 -m pip install protobuf==4.21.1 six==1.16.0 grpcio==1.46.3
RUN python3 -m pip install --no-dependencies grpcio-tools==1.47.0
RUN <<EOF
chmod +x install-tf.sh
./install-tf.sh ${BUILD_ROOT}/tensorflow ${BUILD_ROOT}/serving $TARGET_ROOT
EOF

# Install the resulting tf-related packages and dependencies
FROM build-base-arm AS build-python-tfserving
COPY tfserving $BUILD_ROOT/tfserving
COPY --from=build-python $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python-numpy $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python-tfserving-prestage $TARGET_ROOT $TARGET_ROOT

WORKDIR $BUILD_ROOT/tfserving
ENV PATH=$BUILD_ROOT/usr/bin:$PATH
ENV LD_LIBRARY_PATH=$BUILD_ROOT/usr/lib:$LD_LIBRARY_PATH
RUN python3 -m pip install . -v --prefix=$TARGET_ROOT/usr

# Due to issues with the public pypi armv7l grpcio wheel, it must be compiled
# for our platform specifically. This is currently quite a lengthy
# operation and therefore handled manually out of build. Subject to change.
#RUN python3 -m pip install --prefix=$TARGET_ROOT/usr protobuf six
#RUN python3 -m pip install --prefix=$TARGET_ROOT/usr --no-deps --no-binary :all: grpcio

# Download precompiled grpc wheel
WORKDIR $BUILD_ROOT/grpcio_whl
RUN python3 -m pip install --prefix=$TARGET_ROOT/usr protobuf six
#Installing with pip on arm64 is fast enough because pypi wheels are compatible
RUN python3 -m pip install --prefix=$TARGET_ROOT/usr grpcio==1.46.3

FROM build-base AS build-python-vdoproto-prestage
COPY vdoproto/* .
RUN python3 -m pip install protobuf==4.21.1 six==1.16.0 grpcio==1.46.3
RUN python3 -m pip install --no-dependencies grpcio-tools==1.47.0
RUN mkdir -p $TARGET_ROOT/usr/lib/$(cat /tmp/python_version)/site-packages
RUN python3 -m grpc_tools.protoc -I . --python_out=$TARGET_ROOT/usr/lib/$(cat /tmp/python_version)/site-packages --grpc_python_out=$TARGET_ROOT/usr/lib/$(cat /tmp/python_version)/site-packages videocapture.proto
RUN cp vdo_proto_utils.py $TARGET_ROOT/usr/lib/$(cat /tmp/python_version)/site-packages

FROM build-base-arm AS build-python-vdoproto
COPY vdoproto $BUILD_ROOT/vdoproto
COPY --from=build-python $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python-numpy $TARGET_ROOT $BUILD_ROOT
COPY --from=build-python-vdoproto-prestage $TARGET_ROOT $TARGET_ROOT
WORKDIR $BUILD_ROOT/vdoproto
ENV PATH=$BUILD_ROOT/usr/bin:$PATH
ENV LD_LIBRARY_PATH=$BUILD_ROOT/usr/lib:$LD_LIBRARY_PATH
RUN python3 -m pip install . -v --prefix=$TARGET_ROOT/usr

# Crosscompile the OCR engine tesseract
FROM build-base AS build-tesseract
ARG ARCH_CFLAGS
ARG TARGET_TOOLCHAIN
ARG TESSERACT_VERSION
ARG TESSERACT_BUILD_CORES
RUN mkdir -p $BUILD_ROOT/tesseract_deps
RUN <<EOF
apt-get update
apt-get install --reinstall --download-only -o=dir::cache=$BUILD_ROOT/tesseract_deps -y -f \
    libleptonica-dev:$UBUNTU_ARCH libicu-dev:$UBUNTU_ARCH libpango1.0-dev:$UBUNTU_ARCH libcairo2-dev:$UBUNTU_ARCH \
    libpng-dev:$UBUNTU_ARCH libjpeg8-dev:$UBUNTU_ARCH libtiff5-dev:$UBUNTU_ARCH libgomp1:$UBUNTU_ARCH
EOF
RUN for f in $BUILD_ROOT/tesseract_deps/archives/*.deb; do dpkg -x $f $TARGET_ROOT; done
RUN <<EOF
cp -r $TARGET_ROOT/lib/* $TARGET_ROOT/usr/lib/
rm -rf $TARGET_ROOT/lib/
EOF
RUN apt-get install --reinstall -y -f \
    libleptonica-dev:$UBUNTU_ARCH libicu-dev:$UBUNTU_ARCH libpango1.0-dev:$UBUNTU_ARCH libcairo2-dev:$UBUNTU_ARCH \
    libpng-dev:$UBUNTU_ARCH libjpeg8-dev:$UBUNTU_ARCH libtiff5-dev:$UBUNTU_ARCH

WORKDIR ${BUILD_ROOT}
RUN git clone --depth 1 --branch ${TESSERACT_VERSION} https://github.com/tesseract-ocr/tesseract.git
WORKDIR ${BUILD_ROOT}/tesseract
ENV LD_LIBRARY_PATH=$TARGET_ROOT/usr/lib:$TARGET_ROOT/usr/lib/$TARGET_TOOLCHAIN:$LD_LIBRARY_PATH
ENV PATH=$TARGET_ROOT/usr/bin:$PATH
ENV CC=${TARGET_TOOLCHAIN}-gcc
ENV CXX=${TARGET_TOOLCHAIN}-g++
ENV CPP=${TARGET_TOOLCHAIN}-g++
ENV CFLAGS="$ARCH_CFLAGS -I$TARGET_ROOT/usr/include"
ENV CXXFLAGS="$ARCH_CFLAGS -I$TARGET_ROOT/usr/include"
ENV CPPFLAGS="$ARCH_CFLAGS -I$TARGET_ROOT/usr/include"
RUN ./autogen.sh
RUN ./configure --prefix=$TARGET_ROOT/usr --host=$TARGET_TOOLCHAIN
RUN make -j ${TESSERACT_BUILD_CORES}
RUN make install
RUN ldconfig

# Get the crosscompiled tesseract package and install the python wrapper
# pytesseract
FROM build-base-arm AS build-python-pytesseract
ARG ARCH_CFLAGS
ARG PYTESSERACT_VERSION
RUN mkdir -p $BUILD_ROOT/pillow_deps
RUN apt-get install --reinstall --download-only -o=dir::cache=$BUILD_ROOT/pillow_deps -y -f libjpeg8-dev
RUN for f in $BUILD_ROOT/pillow_deps/archives/*.deb; do dpkg -x $f $TARGET_ROOT; done
RUN apt-get install -y zlib1g-dev libjpeg8-dev
COPY --from=build-python $TARGET_ROOT $BUILD_ROOT
ENV LD_LIBRARY_PATH=$BUILD_ROOT/usr/lib:$TARGET_ROOT/usr/lib:$LD_LIBRARY_PATH
ENV PATH=$BUILD_ROOT/usr/bin:$TARGET_ROOT/usr/bin:$PATH
RUN CFLAGS="-I$BUILD_ROOT/usr/include -I/$BUILD_ROOT/usr/include/$(cat /tmp/python_version) $ARCH_CFLAGS" python3 -m pip install pytesseract==${PYTESSERACT_VERSION} --prefix=$TARGET_ROOT/usr
COPY --from=build-tesseract $TARGET_ROOT $TARGET_ROOT

# Crosscompile OpenCV with AXIS VDO bindings
FROM build-base AS build-opencv
ARG ARCH_CFLAGS
ARG AXIS_ARCH
ARG OPENCV_BUILD_CORES
ARG OPENCV_MODULES
ARG OPENCV_VERSION
ARG CMAKE_TOOLCHAIN_FOLDER

# Get required packages for both build env and target env
RUN mkdir -p $BUILD_ROOT/opencv_deps
RUN apt-get install --reinstall --download-only -o=dir::cache=$BUILD_ROOT/opencv_deps -y -f libglib2.0-dev:$UBUNTU_ARCH libsystemd0:$UBUNTU_ARCH libgfortran5:$UBUNTU_ARCH
RUN for f in $BUILD_ROOT/opencv_deps/archives/*.deb; do dpkg -x $f $TARGET_ROOT; done
RUN for f in $BUILD_ROOT/opencv_deps/archives/*.deb; do dpkg -x $f $TARGET_ROOT/build; done
RUN apt-get install -y libglib2.0-dev libsystemd0 libglib2.0-dev:$UBUNTU_ARCH libsystemd0:$UBUNTU_ARCH
RUN cp -r /usr/lib/x86_64-linux-gnu/glib-2.0 /usr/lib/


# Setup build directory
COPY --from=build-openblas $TARGET_ROOT $TARGET_ROOT/build
COPY --from=build-python $TARGET_ROOT $TARGET_ROOT/build
COPY --from=build-python-numpy $TARGET_ROOT $TARGET_ROOT/build

# Download OpenCV
WORKDIR $BUILD_ROOT
RUN curl -fsSL https://github.com/opencv/opencv/archive/${OPENCV_VERSION}.tar.gz | tar -xz
WORKDIR $BUILD_ROOT/opencv-${OPENCV_VERSION}

# A fix for cmake not finding our blas/lapack headers when crosscompiling
RUN sed -i 's/_find_header_file_in_dirs(OPENCV_CBLAS.*/set(OPENCV_CBLAS_H_PATH_OpenBLAS "${LAPACK_INCLUDE_DIR}\/cblas.h")/g' cmake/OpenCVFindLAPACK.cmake
RUN sed -i 's/_find_header_file_in_dirs(OPENCV_LAPACKE.*/set(OPENCV_LAPACKE_H_PATH_OpenBLAS "${LAPACK_INCLUDE_DIR}\/lapacke.h")/g' cmake/OpenCVFindLAPACK.cmake

WORKDIR $BUILD_ROOT/opencv-${OPENCV_VERSION}/build
RUN cmake -D CMAKE_TOOLCHAIN_FILE="../platforms/linux/${CMAKE_TOOLCHAIN_FOLDER}.toolchain.cmake" \
    -D CMAKE_BUILD_TYPE=RELEASE \
    # This path will contain all opencv header files
    -D CMAKE_INSTALL_PREFIX=$TARGET_ROOT/usr \
    -D INSTALL_C_EXAMPLES=OFF \
    -D PYTHON3_EXECUTABLE=/usr/bin/python3 \
    -D PYTHON3_INCLUDE_PATH=$TARGET_ROOT/build/usr/include/$(cat /tmp/python_version) \
    -D PYTHON3_LIBRARIES=$TARGET_ROOT/build/usr/lib/$TARGET_TOOLCHAIN/lib$(cat /tmp/python_version).so \
    -D PYTHON3_NUMPY_INCLUDE_DIRS=$TARGET_ROOT/build/usr/lib/$(cat /tmp/python_version)/site-packages/numpy/core/include \
    -D OPENCV_PYTHON3_INSTALL_PATH=$TARGET_ROOT/usr/lib/$(cat /tmp/python_version)/site-packages \
    -D CMAKE_C_FLAGS="$ARCH_CFLAGS --sysroot=$TARGET_ROOT/build" \
    -D CMAKE_CXX_FLAGS="$ARCH_CFLAGS --sysroot=$TARGET_ROOT/build" \
    -D OpenBLAS_LIB=$TARGET_ROOT/build/usr/lib/libopenblas.so \
    -D OpenBLAS_INCLUDE_DIR=$TARGET_ROOT/build/usr/include \
    -D BLAS_LIBRARIES=$TARGET_ROOT/build/usr/lib/libopenblas.so \
    # ON:
    -D BUILD_opencv_python3=ON \
    -D WITH_TBB=ON \
    -D WITH_OPENGL=ON \
    -D BUILD_JPEG=ON \
    -D ENABLE_NEON=ON \
    -D CPU_BASELINE=NEON,VFPV3 \
    -D CMAKE_SKIP_RPATH=ON \
    -D OPENCV_SKIP_PYTHON_LOADER=ON \
    -D OPENCV_GENERATE_PKGCONFIG=ON \
    # ON end.
    -D WITH_OPENEXR=OFF \
    -D WITH_IPP=OFF \
    -D WITH_WEBP=OFF \
    -D ENABLE_PRECOMPILED_HEADERS=OFF \
    -D WITH_1394=OFF \
    -D WITH_LIBV4L=OFF \
    -D WITH_V4L=OFF \
    -D WITH_QT=OFF \
    -D WITH_GTK=OFF \
    -D WITH_FFMPEG=OFF \
    -D WITH_GSTREAMER=OFF \
    -D WITH_GSTREAMER_0_10=OFF \
    -D BUILD_LIST=$OPENCV_MODULES \
    -D BUILD_EXAMPLES=OFF \
    -D BUILD_OPENCV_DNN=OFF \
    -D BUILD_OPENCV_APPS=OFF \
    -D BUILD_DOCS=OFF \
    -D BUILD_opencv_python=OFF \
    -D BUILD_PNG=OFF \
    -D BUILD_IPP_IWD=OFF \
    -D BUILD_QUIRC=OFF \
    -D BUILD_OPENEXR=OFF \
    -D WITH_JASPER=OFF \
    -D BUILD_TIFF=OFF \
    -D BUILD_PERF_TESTS=OFF \
    -D HAVE_IPP_ICV=OFF \
    -D BUILD_IPP=OFF \
    -D BUILD_ZLIB=OFF \
    -D BUILD_TESTS=OFF \
    -D BUILD_IPP_ICV=OFF \
    -D BUILD_PROTOBUF=OFF \
    -D WITH_CUDA=OFF \
    -D HAVE_WEBP=OFF \
    ..

# Build openCV libraries and other tools
RUN make -j ${OPENCV_BUILD_CORES} install

# Remove the build directory
RUN rm -rf $TARGET_ROOT/build

# Make the header files available by creating a symlink to
# the path specified in CMAKE params
WORKDIR $TARGET_ROOT/usr/include
RUN ln -sf opencv4/opencv2 opencv2

RUN <<EOF
cd $TARGET_ROOT/usr/lib/$(cat /tmp/python_version)/site-packages
mv cv2.*.so cv2.so
cp -r $TARGET_ROOT/lib/* $TARGET_ROOT/usr/lib/
rm -rf $TARGET_ROOT/lib
EOF

# Package all compiled packages to their SDK directories
FROM ubuntu:${UBUNTU_VERSION} AS packages
ARG SDK_ROOT_DIR
ARG TARGET_ROOT
RUN mkdir -p $SDK_ROOT_DIR
COPY --from=build-openblas $TARGET_ROOT $SDK_ROOT_DIR/openblas
COPY --from=build-opencv $TARGET_ROOT $SDK_ROOT_DIR/opencv
COPY --from=build-python $TARGET_ROOT $SDK_ROOT_DIR/python
COPY --from=build-python-numpy $TARGET_ROOT $SDK_ROOT_DIR/python-numpy
COPY --from=build-python-pytesseract $TARGET_ROOT $SDK_ROOT_DIR/python-pytesseract
COPY --from=build-python-tfserving $TARGET_ROOT $SDK_ROOT_DIR/python-tfserving
COPY --from=build-python-vdoproto $TARGET_ROOT $SDK_ROOT_DIR/python-vdoproto
COPY --from=build-python-scipy $TARGET_ROOT $SDK_ROOT_DIR/python-scipy
COPY --from=build-tesseract $TARGET_ROOT $SDK_ROOT_DIR/tesseract

# Get OpenCL-related libs from the Native SDK
FROM build-base AS build-opencl-devel
ARG AXIS_ARCH
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/include/CL $TARGET_ROOT/usr/include/CL
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/pkgconfig/opencl.pc $TARGET_ROOT/usr/lib/pkgconfig/opencl.pc
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/libEGL* $TARGET_ROOT/usr/lib/
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/libOpenCL* $TARGET_ROOT/usr/lib/
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/libGAL* $TARGET_ROOT/usr/lib/
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/libVSC* $TARGET_ROOT/usr/lib/
COPY --from=acap-native-sdk /opt/axis/acapsdk/sysroots/$AXIS_ARCH/usr/lib/libGLES* $TARGET_ROOT/usr/lib/

# Development-related tensorflow proto files
FROM build-base AS build-tensorflow-proto-devel
ARG TENSORFLOW_BUILD_CORES
WORKDIR $BUILD_ROOT/tmp
# Download tensorflow
RUN curl -fsSL https://github.com/tensorflow/tensorflow/archive/v2.9.0.tar.gz | tar -xz --one-top-level=tf --strip-components 1

# Download tensorflow serving
RUN curl -fsSL https://github.com/tensorflow/serving/archive/2.9.0.tar.gz | tar -xz --one-top-level=tf-serving --strip-components 1

RUN mkdir -p $BUILD_ROOT/tfproto
RUN cp -r $BUILD_ROOT/tmp/tf/tensorflow $BUILD_ROOT/tfproto/tensorflow
RUN cp -r $BUILD_ROOT/tmp/tf-serving/tensorflow_serving $BUILD_ROOT/tfproto/tensorflow_serving

# Install packages needed for building
RUN apt-get install -y \
    binutils-multiarch \
    protobuf-compiler \
    protobuf-compiler-grpc \
    libprotobuf-dev \
    libgrpc++-dev \
    make

WORKDIR $BUILD_ROOT/tfproto/build
# Compile proto files from tensorflow
COPY tfproto/Makefile .

RUN CXX=$TARGET_TOOLCHAIN-g++ OUT_PATH=$TARGET_ROOT API_PATH=$BUILD_ROOT/tfproto make -j ${TENSORFLOW_BUILD_CORES}

# Package the "devel"-tagged image and prune some unneeded files
FROM build-base AS sdk-devel-prune
ARG SDK_ROOT_DIR
COPY --from=packages $SDK_ROOT_DIR $SDK_ROOT_DIR
COPY --from=build-opencl-devel $TARGET_ROOT $SDK_ROOT_DIR/opencl
COPY --from=build-tensorflow-proto-devel $TARGET_ROOT $SDK_ROOT_DIR/tfproto
COPY --from=build-python-vdoproto $TARGET_ROOT $SDK_ROOT_DIR/tfproto

# General pruning
WORKDIR $SDK_ROOT_DIR
RUN find * -type d -name 'x86_64-linux-gnu' -prune -exec rm -rf {} \;
RUN find * -type d -name 'share' -prune -exec rm -rf {} \;

# Package the "runtime"-tagged image and prune some unneeded files
FROM ubuntu:${UBUNTU_VERSION} AS sdk-runtime-prune
ARG SDK_ROOT_DIR
COPY --from=packages $SDK_ROOT_DIR $SDK_ROOT_DIR
WORKDIR $SDK_ROOT_DIR

# Prune runtime unrelated files
RUN find */usr/* -maxdepth 0 -type d -not -name 'bin' -and -not -name 'lib' -and -not -name 'sbin' -exec rm -rf {} \;
RUN find * -type f -name "*.a" -exec rm -f {} \;

# Minimal container for the devel-tagged SDK
FROM build-base AS sdk-devel
ARG ARCH_CFLAGS
ARG AXIS_ARCH
ARG BUILD_ROOT
ARG DOCKERHUB_ARCH
ARG PYTHON_VERSION
ARG SDK_ROOT_DIR
ARG TARGET_TOOLCHAIN
ARG TARGET_ROOT
ARG UBUNTU_ARCH
ARG UBUNTU_CODENAME
ARG http_proxy
ARG https_proxy

# To support DOCKER_BUILDKIT=0, base ARGs are converted to ENVs to allow propagation
ENV ARCH_CFLAGS=$ARCH_CFLAGS
ENV AXIS_ARCH=$AXIS_ARCH
ENV BUILD_ROOT=$BUILD_ROOT
ENV DOCKERHUB_ARCH=$DOCKERHUB_ARCH
ENV TARGET_TOOLCHAIN=$TARGET_TOOLCHAIN
ENV TARGET_ROOT=$TARGET_ROOT
ENV UBUNTU_ARCH=$UBUNTU_ARCH
ENV UBUNTU_CODENAME=$UBUNTU_CODENAME
COPY --from=sdk-devel-prune $SDK_ROOT_DIR $SDK_ROOT_DIR

# Minimal container for the runtime-tagged SDK
FROM ubuntu:${UBUNTU_VERSION} AS sdk-runtime
ARG SDK_ROOT_DIR
COPY --from=sdk-runtime-prune $SDK_ROOT_DIR $SDK_ROOT_DIR