Undefined references error when trying to insert mask detection code in Face Recogntion

[rsingh2083]

Hi there,

So I was trying to insert mask detection code in main.cpp of face_recognition but have been getting lots of undefined references errors. Right now Ive just inserted the relevant header files and some variables from the mask_detection code to debug the issues one by one gradually as they come. The code that Ive inserted starts with comments //Mask headers, //MASK namespace //MASK variables Heres the main.cpp

#include <iostream>
#include <opencv2/opencv.hpp>
#include "TMtCNN.h"
#include "TArcface.h"
#include "TRetina.h"
#include "TWarp.h"
#include "TLive.h"
#include "TBlur.h"

// Mask headers
#include <string>
#include "/usr/local/include/paddle-lite/paddle_api.h"             // NOLINT
#include "/usr/local/include/paddle-lite/paddle_use_kernels.h"     // NOLINT
#include "/usr/local/include/paddle-lite/paddle_use_ops.h"         // NOLINT
#include "UltraFace.hpp"
//ENDMask headers

//----------------------------------------------------------------------------------------
//
// Created by markson zhang
//
// Edited by Xinghao Chen 2020/7/27
//
// Modified by Q-engineering 2020/12/28
//
//----------------------------------------------------------------------------------------
// Build defines
// comment them to turn a function off
//----------------------------------------------------------------------------------------
#define RETINA                  //comment if you want to use MtCNN landmark detection instead
#define RECOGNIZE_FACE
#define TEST_LIVING
#define AUTO_FILL_DATABASE
#define BLUR_FILTER_STRANGER
// some diagnostics
#define SHOW_LEGEND
#define SHOW_LANDMARKS
//----------------------------------------------------------------------------------------
// Adjustable Parameters
//----------------------------------------------------------------------------------------
const int   MaxItemsDatabase = 2000;
const int   MinHeightFace    = 90;
const float MinFaceThreshold = 0.50;
const float FaceLiving       = 0.93;
const double MaxBlur         = -25.0;   //more positive = sharper image
const double MaxAngle        = 10.0;
//----------------------------------------------------------------------------------------
// Some globals
//----------------------------------------------------------------------------------------
const int   RetinaWidth      = 320;
const int   RetinaHeight     = 240;
float ScaleX, ScaleY;
vector<cv::String> NameFaces;
//----------------------------------------------------------------------------------------
using namespace std;
using namespace cv;
//----------------------------------------------------------------------------------------
//  Computing the cosine distance between input feature and ground truth feature
//----------------------------------------------------------------------------------------
inline float CosineDistance(const cv::Mat &v1, const cv::Mat &v2)
{
    double dot = v1.dot(v2);
    double denom_v1 = norm(v1);
    double denom_v2 = norm(v2);
    return dot / (denom_v1 * denom_v2);
}
//----------------------------------------------------------------------------------------
// painting
//----------------------------------------------------------------------------------------
void DrawObjects(cv::Mat &frame, vector<FaceObject> &Faces)
{
    for(size_t i=0; i < Faces.size(); i++){
        FaceObject& obj = Faces[i];

//----- rectangle around the face -------
        obj.rect.x *= ScaleX;
        obj.rect.y *= ScaleY;
        obj.rect.width *= ScaleX;
        obj.rect.height*= ScaleY;
        cv::rectangle(frame, obj.rect, cv::Scalar(0, 255, 0));
//---------------------------------------

//----- diagnostic ----------------------
#ifdef SHOW_LANDMARKS
        for(int u=0;u<5;u++){
            obj.landmark[u].x*=ScaleX;
            obj.landmark[u].y*=ScaleY;
        }

        cv::circle(frame, obj.landmark[0], 2, cv::Scalar(0, 255, 255), -1);
        cv::circle(frame, obj.landmark[1], 2, cv::Scalar(0, 255, 255), -1);
        cv::circle(frame, obj.landmark[2], 2, cv::Scalar(0, 255, 255), -1);
        cv::circle(frame, obj.landmark[3], 2, cv::Scalar(0, 255, 255), -1);
        cv::circle(frame, obj.landmark[4], 2, cv::Scalar(0, 255, 255), -1);
#endif // SHOW_LANDMARKS
//---------------------------------------
#ifdef SHOW_LEGEND
        cv::putText(frame, cv::format("Angle : %0.1f", obj.Angle),cv::Point(10,40),cv::FONT_HERSHEY_SIMPLEX,0.6, cv::Scalar(180, 180, 0));
        cv::putText(frame, cv::format("Face prob : %0.4f", obj.FaceProb),cv::Point(10,60),cv::FONT_HERSHEY_SIMPLEX,0.6, cv::Scalar(180, 180, 0));
        cv::putText(frame, cv::format("Name prob : %0.4f", obj.NameProb),cv::Point(10,80),cv::FONT_HERSHEY_SIMPLEX,0.6, cv::Scalar(180, 180, 0));
        cv::putText(frame, cv::format("Live prob : %0.4f", obj.LiveProb),cv::Point(10,100),cv::FONT_HERSHEY_SIMPLEX,0.6, cv::Scalar(180, 180, 0));
#endif // SHOW_LEGEND
//----- labels ----------------------------
#ifdef RECOGNIZE_FACE
        cv::String Str;
        cv::Scalar color;
        int  baseLine = 0;

        switch(obj.Color){
            case 0 : color = cv::Scalar(255, 255, 255); break;  //default white -> face ok
            case 1 : color = cv::Scalar( 80, 255, 255); break;  //yellow ->stranger
            case 2 : color = cv::Scalar(255, 237, 178); break;  //blue -> too tiny
            case 3 : color = cv::Scalar(127, 127, 255); break;  //red -> fake
            default: color = cv::Scalar(255, 255, 255);
        }

        switch(obj.NameIndex){
            case -1: Str="Stranger"; break;
            case -2: Str="too tiny"; break;
            case -3: Str="Fake !";   break;
            default: Str=NameFaces[obj.NameIndex];
        }

        cv::Size label_size = cv::getTextSize(Str, cv::FONT_HERSHEY_SIMPLEX, 0.6, 1, &baseLine);
        int x = obj.rect.x;
        int y = obj.rect.y - label_size.height - baseLine;
        if(y<0) y = 0;
        if(x+label_size.width > frame.cols) x=frame.cols-label_size.width;

        cv::rectangle(frame, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)),color, -1);
        cv::putText(frame, Str, cv::Point(x, y+label_size.height+2),cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(0, 0, 0));
#endif // RECOGNIZE_FACE
    }
}
//----------------------------------------------------------------------------------------
// main
//----------------------------------------------------------------------------------------

//MASK namespace
using namespace paddle::lite_api;
using namespace std;
//END MASK namespace

int main(int argc, char **argv)
{
    float f;
    float FPS[16];
    int   n,Fcnt=0;
    size_t i;
    cv::Mat frame;
    cv::Mat result_cnn;
    cv::Mat faces;
    std::vector<FaceObject> Faces;
    vector<cv::Mat> fc1;
    string pattern_jpg = "./img/*.jpg";
    cv::String NewItemName;
    size_t FaceCnt;

    //MASK variables
    int classify_w = 128;
    int classify_h = 128;
    float scale_factor = 1.f / 256;
    int FaceImgSz  = classify_w * classify_h;
    // Mask detection (second phase, when the faces are located)
    MobileConfig Mconfig;
    std::shared_ptr<PaddlePredictor> Mpredictor;
    //END MASK VARIABLES

    //the networks
    TLive Live;
    TWarp Warp;
    TMtCNN MtCNN;
    TArcFace ArcFace;
    TRetina Rtn(RetinaWidth, RetinaHeight, false);     //no Vulkan support on a RPi
    TBlur Blur;
    //some timing
    chrono::steady_clock::time_point Tbegin, Tend;

    Live.LoadModel();

    for(i=0;i<16;i++) FPS[i]=0.0;

    //OpenCV Version
    cout << "OpenCV Version: " << CV_MAJOR_VERSION << "." << CV_MINOR_VERSION << "."
    << CV_SUBMINOR_VERSION << endl;
    cout << " " << endl;

#ifdef RECOGNIZE_FACE
    cout << "Trying to recognize faces" << endl;
    cout << " " << endl;
#ifdef RETINA
    cout << "Using Retina" << endl;
    cout << " " << endl;
#else
    cout << "Using MtCNN" << endl;
    cout << " " << endl;
#endif // RETINA

#ifdef TEST_LIVING
    cout << "Test living or fake fave" << endl;
    cout << " " << endl;
#endif // TEST_LIVING

#ifdef AUTO_FILL_DATABASE
    cout << "Automatic adding strangers to database" << endl;
    cout << " " << endl;
#ifdef BLUR_FILTER_STRANGER
    cout << "Blur filter - only sharp images to database" << endl;
    cout << " " << endl;
#endif // BLUR_FILTER_STRANGER
#endif // AUTO_FILL_DATABASE
#endif // RECOGNIZE_FACE

    //if you like to load a picture of a face into the database
    //give the name of the .jpg image as argument on the command line
    //without arguments the app will run the .mp4 video or use the camera
    if(argc>1){
        const char* imagepath = argv[1];

        cv::Mat frame = cv::imread(imagepath, 1);
        if(frame.empty()){
            fprintf(stderr, "cv::imread %s failed\n", imagepath);
            return -1;
        }
        //extract
        ScaleX = ((float) frame.cols) / RetinaWidth;
        ScaleY = ((float) frame.rows) / RetinaHeight;
        // copy/resize image to result_cnn as input tensor
        cv::resize(frame, result_cnn, Size(RetinaWidth,RetinaHeight),INTER_LINEAR);
        //get the face
        Rtn.detect_retinaface(result_cnn,Faces);
        //only one face per picture
        if(Faces.size()==1){
            if(Faces[0].FaceProb>MinFaceThreshold){
                //get centre aligned image
                cv::Mat aligned = Warp.Process(result_cnn,Faces[0]);

                cv::String Str = imagepath;
                n   = Str.rfind('/');
                Str = Str.erase(0,n+1);
                Str = Str.erase(Str.length()-4, Str.length()-1);  //remove .jpg

                imwrite("./img/"+Str+".jpg", aligned);
                cout << "Stored to database : " << Str << endl;
            }
        }
        return 0;
    }

    //loading the faces
    cv::glob(pattern_jpg, NameFaces);
    FaceCnt=NameFaces.size();
    if(FaceCnt==0) {
        cout << "No image files[jpg] in database" << endl;
    }
    else{
        cout << "Found "<< FaceCnt << " pictures in database." << endl;
        for(i=0; i<FaceCnt; i++){
            //convert to landmark vector and store into fc
            faces = cv::imread(NameFaces[i]);
            fc1.push_back(ArcFace.GetFeature(faces));
            //get a proper name
            cv::String &Str = NameFaces[i];
            n   = Str.rfind('/');
            Str = Str.erase(0,n+1);
            n   = Str.find('#');
            if(n>0) Str = Str.erase(n,Str.length()-1);                //remove # some numbers.jpg
            else    Str = Str.erase(Str.length()-4, Str.length()-1);  //remove .jpg
            if(FaceCnt>1) printf("\rloading: %.2lf%% ",(i*100.0)/(FaceCnt-1));
        }
        cout << "" << endl;
        cout << "Loaded "<<FaceCnt<<" faces in total"<<endl;
    }

    // RaspiCam or Norton_2.mp4 ?
    // cv::VideoCapture cap(0);             //RaspiCam
    cv::VideoCapture cap(0);   //Movie
    if (!cap.isOpened()) {
        cerr << "ERROR: Unable to open the camera" << endl;
        return 0;
    }
    cout << "Start grabbing, press ESC on TLive window to terminate" << endl;

    while(1){
        cap >> frame;
        if (frame.empty()) {
            cerr << "End of movie" << endl;
            break;
        }
        ScaleX = ((float) frame.cols) / RetinaWidth;
        ScaleY = ((float) frame.rows) / RetinaHeight;

        // copy/resize image to result_cnn as input tensor
        cv::resize(frame, result_cnn, Size(RetinaWidth,RetinaHeight),INTER_LINEAR);

        Tbegin = chrono::steady_clock::now();

#ifdef RETINA
        Rtn.detect_retinaface(result_cnn,Faces);
#else
        MtCNN.detect(result_cnn,Faces);
#endif // RETINA

#ifdef RECOGNIZE_FACE
        //reset indicators
        for(i=0;i<Faces.size();i++){
            Faces[i].NameIndex = -2;    //-2 -> too tiny (may be negative to signal the drawing)
            Faces[i].Color     =  2;
            Faces[i].NameProb  = 0.0;
            Faces[i].LiveProb  = 0.0;
        }
        //run through the faces only when you got one face.
        //more faces (if large enough) are not a problem
        //in this app with an input image of 324x240, they become too tiny
        if(Faces.size()==1){
            //looks stupid, running through a loop of size 1
            //however, for your convenience using [i]
            for(i=0;i<Faces.size();i++){
                if(Faces[i].FaceProb>MinFaceThreshold){
                    //get centre aligned image
                    cv::Mat aligned = Warp.Process(result_cnn,Faces[i]);
                    Faces[i].Angle  = Warp.Angle;
                    //features of camera image
                    cv::Mat fc2 = ArcFace.GetFeature(aligned);
                    //reset indicators
                    Faces[i].NameIndex = -1;    //a stranger
                    Faces[i].Color     =  1;
                    //the similarity score
                    if(FaceCnt>0){
                        vector<double> score_;
                        for(size_t c=0;c<FaceCnt;c++) score_.push_back(CosineDistance(fc1[c], fc2));
                        int Pmax = max_element(score_.begin(),score_.end()) - score_.begin();
                        Faces[i].NameIndex = Pmax;
                        Faces[i].NameProb  = score_[Pmax];
                        score_.clear();
                        if(Faces[i].NameProb >= MinFaceThreshold){
                            //recognize a face
                            if(Faces[i].rect.height < MinHeightFace){
                                Faces[i].Color = 2; //found face in database, but too tiny
                            }
                            else{
                                Faces[i].Color = 0; //found face in database and of good size
#ifdef TEST_LIVING
                                //test fake face
                                float x1 = Faces[i].rect.x;
                                float y1 = Faces[i].rect.y;
                                float x2 = Faces[i].rect.width+x1;
                                float y2 = Faces[i].rect.height+y1;
                                struct LiveFaceBox LiveBox={x1,y1,x2,y2};

                                Faces[i].LiveProb=Live.Detect(result_cnn,LiveBox);
                                if(Faces[i].LiveProb<=FaceLiving){
                                    Faces[i].Color     =  3; //fake
                                    Faces[i].NameIndex = -3;
                                }
#endif // TEST_LIVING
                            }
                        }
                        else{
                            Faces[i].NameIndex = -1;    //a stranger
                            Faces[i].Color     =  1;
                        }
                    }

                    //test if the face is recognized, or should it be added to database
                    if(Faces[i].NameIndex == -1){
                        if(Faces[i].rect.height < MinHeightFace){
                            //a stranger with a small face
                            Faces[i].Color = 2; //too tiny
                        }
#ifdef AUTO_FILL_DATABASE
                        else{
                            //a stranger with a large face, who can be added to the database
                            if(FaceCnt>=MaxItemsDatabase){
                                cout << "Database full !" << endl;
                            }
                            else{
                                double blur=0.0;
#ifdef BLUR_FILTER_STRANGER
                                blur=Blur.Execute(aligned);
#endif // BLUR_FILTER_STRANGER
                                if(Warp.Angle<=MaxAngle && blur>=MaxBlur){
//                                cout <<"Probability : " << Faces[i].FaceProb << "   Angle : " << Warp.Angle << "   Blur : " << blur << endl;
//                                cv::imshow("Add",aligned);
                                    FaceCnt++;
                                    NewItemName = format("person %i",(int)FaceCnt);
                                    fc1.push_back(fc2);
                                    NameFaces.push_back(NewItemName);
                                    imwrite("./img/"+NewItemName+".jpg", aligned);
                                    cout << "Stored to database : " << NewItemName << endl;
                                }
                            }
                        }
#endif // AUTO_FILL_DATABASE
                    }
                }
            }
        }
#endif // RECOGNIZE_FACE

        Tend = chrono::steady_clock::now();

        DrawObjects(frame, Faces);

        //calculate frame rate
        f = chrono::duration_cast <chrono::milliseconds> (Tend - Tbegin).count();
        if(f>0.0) FPS[((Fcnt++)&0x0F)]=1000.0/f;
        for(f=0.0, i=0;i<16;i++){ f+=FPS[i]; }
        cv::putText(frame, cv::format("FPS %0.2f", f/16),cv::Point(10,20),cv::FONT_HERSHEY_SIMPLEX,0.6, cv::Scalar(180, 180, 0));

        //show output
        cv::imshow("RPi 64 OS - 1,95 GHz - 2 Mb RAM", frame);
        char esc = cv::waitKey(5);
        if(esc == 27) break;
    }

    cv::destroyAllWindows();

    return 0;
}

Heres the BUILD LOG :-

-------------- Build: Release in FaceRecognition (compiler: GNU GCC Compiler)---------------

g++ -L/usr/local/lib/ -L/usr/lib/ -o bin/Release/FaceRecognition obj/Release/src/main.o obj/Release/src/TArcface.o obj/Release/src/TBlur.o obj/Release/src/TLive.o obj/Release/src/TMtCNN.o obj/Release/src/TRetina.o obj/Release/src/TWarp.o  -fopenmp -I/usr/include/opencv4/opencv -I/usr/include/opencv4 -lopencv_gapi -lopencv_stitching -lopencv_aruco -lopencv_bgsegm -lopencv_bioinspired -lopencv_ccalib -lopencv_cudabgsegm -lopencv_cudafeatures2d -lopencv_cudaobjdetect -lopencv_cudastereo -lopencv_dnn_objdetect -lopencv_dnn_superres -lopencv_dpm -lopencv_highgui -lopencv_face -lopencv_freetype -lopencv_fuzzy -lopencv_hdf -lopencv_hfs -lopencv_img_hash -lopencv_line_descriptor -lopencv_quality -lopencv_reg -lopencv_rgbd -lopencv_saliency -lopencv_sfm -lopencv_stereo -lopencv_structured_light -lopencv_phase_unwrapping -lopencv_superres -lopencv_cudacodec -lopencv_surface_matching -lopencv_tracking -lopencv_datasets -lopencv_text -lopencv_dnn -lopencv_plot -lopencv_videostab -lopencv_cudaoptflow -lopencv_optflow -lopencv_cudalegacy -lopencv_video -lopencv_videoio -lopencv_cudawarping -lopencv_xfeatures2d -lopencv_shape -lopencv_ml -lopencv_ximgproc -lopencv_xobjdetect -lopencv_objdetect -lopencv_calib3d -lopencv_imgcodecs -lopencv_features2d -lopencv_flann -lopencv_xphoto -lopencv_photo -lopencv_cudaimgproc -lopencv_cudafilters -lopencv_imgproc -lopencv_cudaarithm -lopencv_core -lopencv_cudev -ldl -lpthread -s  /usr/local/lib/ncnn/libncnn.a /usr/lib/aarch64-linux-gnu/libvulkan.so /usr/local/lib/ncnn/libglslang.a /usr/local/lib/ncnn/libOGLCompiler.a /usr/local/lib/ncnn/libOSDependent.a /usr/local/lib/ncnn/libSPIRV.a
obj/Release/src/main.o: In function `_GLOBAL__sub_I_shuffle_channelkARMkFloatkNCHWdef__use_lite_kernel':
main.cpp:(.text.startup+0x40): undefined reference to `touch_shuffle_channelkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x48): undefined reference to `touch_castkARMkAnykNCHWdef()'
main.cpp:(.text.startup+0x50): undefined reference to `touch_pool2dkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x58): undefined reference to `touch_reshapekHostkAnykAnydef()'
main.cpp:(.text.startup+0x60): undefined reference to `touch_reshape2kHostkAnykAnydef()'
main.cpp:(.text.startup+0x68): undefined reference to `touch_flattenkHostkAnykAnydef()'
main.cpp:(.text.startup+0x70): undefined reference to `touch_flatten2kHostkAnykAnydef()'
main.cpp:(.text.startup+0x78): undefined reference to `touch_splitkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x80): undefined reference to `touch_splitkARMkInt64kNCHWdef()'
main.cpp:(.text.startup+0x88): undefined reference to `touch_pad2dkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x90): undefined reference to `touch_top_kkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x98): undefined reference to `touch_roi_alignkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xa0): undefined reference to `touch_matmulkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xa8): undefined reference to `touch_reduce_prodkARMkInt32kNCHWdef()'
main.cpp:(.text.startup+0xb0): undefined reference to `touch_reduce_prodkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xb8): undefined reference to `touch_expand_askHostkFloatkAnydef()'
main.cpp:(.text.startup+0xc0): undefined reference to `touch_pixel_shufflekHostkFloatkNCHWdef()'
main.cpp:(.text.startup+0xc8): undefined reference to `touch_grid_samplerkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xd0): undefined reference to `touch_affine_gridkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xd8): undefined reference to `touch_reduce_meankARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xe0): undefined reference to `touch_deformable_convkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xe8): undefined reference to `touch_box_coderkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xf0): undefined reference to `touch_rangekARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0xf8): undefined reference to `touch_rangekARMkInt32kNCHWdef()'
main.cpp:(.text.startup+0x100): undefined reference to `touch_gatherkHostkFloatkNCHWint32int32()'
main.cpp:(.text.startup+0x108): undefined reference to `touch_gatherkHostkFloatkNCHWint64int64()'
main.cpp:(.text.startup+0x110): undefined reference to `touch_gatherkHostkFloatkNCHWint64int32()'
main.cpp:(.text.startup+0x118): undefined reference to `touch_gatherkHostkFloatkNCHWint32int64()'
main.cpp:(.text.startup+0x120): undefined reference to `touch_split_lod_tensorkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x128): undefined reference to `touch_instance_normkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x130): undefined reference to `touch_arg_maxkARMkAnykNCHWfp32()'
main.cpp:(.text.startup+0x138): undefined reference to `touch_arg_maxkARMkAnykNCHWint64()'
main.cpp:(.text.startup+0x140): undefined reference to `touch_arg_maxkARMkAnykNCHWint32()'
main.cpp:(.text.startup+0x148): undefined reference to `touch_arg_maxkARMkAnykNCHWint16()'
main.cpp:(.text.startup+0x150): undefined reference to `touch_arg_maxkARMkAnykNCHWuint8()'
main.cpp:(.text.startup+0x158): undefined reference to `touch_scalekARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x160): undefined reference to `touch_scalekARMkInt32kNCHWdef()'
main.cpp:(.text.startup+0x168): undefined reference to `touch_logical_xorkHostkAnykAnydef()'
main.cpp:(.text.startup+0x170): undefined reference to `touch_logical_andkHostkAnykAnydef()'
main.cpp:(.text.startup+0x178): undefined reference to `touch_logical_orkHostkAnykAnydef()'
main.cpp:(.text.startup+0x180): undefined reference to `touch_logical_notkHostkAnykAnydef()'
main.cpp:(.text.startup+0x188): undefined reference to `touch_lookup_table_dequantkARMkAnykNCHWdef()'
main.cpp:(.text.startup+0x190): undefined reference to `touch_normkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x198): undefined reference to `touch_fill_constant_batch_size_likekHostkAnykNCHWdef()'
main.cpp:(.text.startup+0x1a0): undefined reference to `touch_group_normkARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x1a8): undefined reference to `touch_unsqueezekHostkAnykAnydef()'
main.cpp:(.text.startup+0x1b0): undefined reference to `touch_unsqueeze2kHostkAnykAnydef()'
main.cpp:(.text.startup+0x1b8): undefined reference to `touch_decode_bboxeskARMkFloatkNCHWdef()'
main.cpp:(.text.startup+0x1c0): undefined reference to `touch_crf_decodingkHostkFloatkNCHWdef()'
main.cpp:(.text.startup+0x1c8): undefined reference to `touch_ctc_alignkHostkInt64kNCHWdef()'
Process terminated with status 1 (0 minute(s), 2 second(s))
50 error(s), 0 warning(s) (0 minute(s), 2 second(s))

Any idea as to what could be the issue.

[rsingh2083]

Included paddle libraries in the .cbp file and errors were gone.