Undefined reference to cv::

Пытаюсь заставить работать OpenCV и Stasm вместе на Ubuntu 16.04 lts. Постоянно вылетает ошибка

Undefined reference to cv::...

cmake_minimum_required(VERSION 3.7)
project(tryCV)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_PREFIX_PATH  "/usr/local/share/cmake")
if(OpenCV_FOUND)
    include_directories(${OpenCV_INCLUDE_DIRS})
endif()
find_package(STASM REQUIRED)
if(STASM_FOUND)
    include_directories(${STASM_INCLUDE_DIRS})
endif()
LINK_DIRECTORIES( ${OpenCV_LIB_DIR} ${STASM_LINK_DIRS} )
SET(LIBS ${STASM_LIBRARIES} ${OpenCV_LIBS} )
set(SOURCE_FILES main.cpp HandlerImp.cpp)
add_executable(tryCV ${SOURCE_FILES})
target_link_libraries(tryCV ${OpenCV_LIBS})

#include <iostream>
#include <experimental/filesystem>
#include <chrono>
#include <opencv2/opencv.hpp>
#include "Handler.h"
using namespace std::experimental::filesystem::v1;
bool isJPG(std::string path);
// input
/*
    * Input images dir
    * Output images dir
    * HaarCascade dir
    * Output size
    * Output ratio
    * Equalize type: no_equalize, global_equalize, local_equalize
    * Retina settings: no_retina, retina_1, retina_2
*/
int main(int argc, char* argv[])
{
    if (argc != 8)
    {
        std::cout << "Bad arguments";
        return -1;
    }
    int output_size = 0;
    double output_ratio = 0;
    handler::EQUALIZE_USE equalize;
    int retina = 0;
    output_size = atoi(argv[4]);
    output_ratio = atof(argv[5]);
    if ((output_size < 50) || (output_size > 150)) output_size = 0;
    if ((output_ratio < 0.35) || (output_ratio > 0.55)) output_ratio = 0;
    if (!output_size || !output_ratio)
    {
        std::cout << "Bad output size || output ratio arguments";
        return -2;
    }
    if (!strcmp(argv[6], "no_equalize")) equalize = handler::EQUALIZE_USE::NOT_USE;
    else if (!strcmp(argv[6], "local_equalize")) equalize = handler::EQUALIZE_USE::USE_CUSTOM_EQUALIZE;
    else if (!strcmp(argv[6], "global_equalize")) equalize = handler::EQUALIZE_USE::USE_CV_EQUALIZE;
    else
    {
        std::cout << "Bad equalize type";
        return -3;
    }
    if (!strcmp(argv[7], "no_retina")) retina = 0;
    else if (!strcmp(argv[7], "retina_1")) retina = 1;
    else if (!strcmp(argv[7], "retina_2")) retina = 2;
    else
    {
        std::cout << "Bad retina type";
        return -4;
    }
    path src_path = u8path(argv[1]);
    path dst_path = u8path(argv[2]);
//    if (!exists(src_path) || !exists(dst_path))
//    {
//        std::cout << "Bad src_path || dst_path arguments";
//        return -5;
//    }
    handler::Handler * _handler = handler::createHandlerInstance();
    handler::HandlerData h_data;
    _handler->set_out_size(output_size);
    _handler->set_out_ratio(output_ratio);
    _handler->set_use_equalize(equalize);
    _handler->set_use_retinex(retina);
    _handler->set_haar_classifier_dir(argv[3]);
    int counter = 0;
    cv::Mat image;
    double common_time = 0;
    std::chrono::high_resolution_clock::time_point t1;
    std::chrono::high_resolution_clock::time_point t2;

    for (directory_iterator i = directory_iterator(src_path); i != directory_iterator(); i++)
    {
        if (isJPG(i->path().string()))
        {
            image = cv::imread(i->path().u8string());
            if (image.empty())
            {
                std::cout << "Cannot load to cv: " << i->path() << std::endl;
            }
            else
            {
                t1 = std::chrono::high_resolution_clock::now();
                h_data = _handler->handle(image.data, image.cols, image.rows);
                t2 = std::chrono::high_resolution_clock::now();
                if (h_data.haveError)
                {
                    std::cout << "Error processing " << i->path() << ": " << _handler->last_error() << std::endl;
                }
                else
                {
                    std::string filename = std::string(argv[2]) + std::string("/") + std::to_string(counter) + std::string(".jpg");
                    if (!cv::imwrite(filename, h_data.image))
                    {
                        std::cout << "Cannot save to filesystem: " << i->path() << " as "  << filename << std::endl;
                    }
                    else
                    {
                        double time = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count() / 1.0e6;
                        std::cout << "Success: " << i->path().string() << " || time (ms): " << time << std::endl;
                        common_time += time;
                        counter++;
                    }
                }
            }
        }
    }
    std::cout << "Done. Common time: " << common_time;
    return 0;
}

bool isJPG(std::string &path)
{
    std::transform(path.begin(), path.end(), path.begin(), ::tolower);
    static std::string jpg(".jpg");
    static std::string jpeg(".jpeg");
    return (path.find(jpg) == std::string::npos) && (path.find(jpeg) == std::string::npos);
}