cv pose1

其他 2018-07-12 21:59:14 阅读次数: 0 
#include <jni.h>
#include <string>
#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <android/log.h>
#define  LOGSHOW(X)  __android_log_print(ANDROID_LOG_INFO,X,"PRINTRESULT:::");
// TODO
#define POSE_COCO_COLORS_RENDER_GPU \
   255.f, 0.f, 85.f, \
   255.f, 0.f, 0.f, \
   255.f, 85.f, 0.f, \
   255.f, 170.f, 0.f, \
   255.f, 255.f, 0.f, \
   170.f, 255.f, 0.f, \
   85.f, 255.f, 0.f, \
   0.f, 255.f, 0.f, \
   0.f, 255.f, 85.f, \
   0.f, 255.f, 170.f, \
   0.f, 255.f, 255.f, \
   0.f, 170.f, 255.f, \
   0.f, 85.f, 255.f, \
   0.f, 0.f, 255.f, \
   255.f, 0.f, 170.f, \
   170.f, 0.f, 255.f, \
   255.f, 0.f, 255.f, \
   85.f, 0.f, 255.f
using namespace cv;
using namespace std;

extern "C" {
void denoising(Mat& mat, Mat& result) {
    Mat matc = mat.clone();
    result.setTo(Scalar(0, 0, 0, 0));
    Mat temp;
    temp.create(mat.rows + 2, mat.cols + 2, mat.type());
    int flags = 8 | FLOODFILL_MASK_ONLY | FLOODFILL_FIXED_RANGE;
    for (int h = 0; h < mat.rows; h++) {
        for (int w = 0; w < mat.cols; w++) {
            if (matc.at<uchar>(h, w) == 255) {
                temp.setTo(Scalar(0, 0, 0, 0));
                floodFill(matc, temp, cv::Point(w, h), Scalar(255, 255, 255, 255), 0, Scalar(0, 0, 0, 0), Scalar(0, 0, 0, 0), flags);
                if (countNonZero(temp) > 6000){
                    result.setTo(Scalar(255, 255, 255, 255), temp(Rect(1, 1, mat.cols, mat.rows)));
                }
                matc.setTo(Scalar(0, 0, 0, 0), temp(Rect(1, 1, mat.cols, mat.rows)));
            }
        }
    }
}
JNIEXPORT jint JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_getDifPoint(JNIEnv *env, jclass type, jlong v1, jlong v2) {
Mat *mat1=(Mat*)v1;
    Mat *mat2=(Mat*)v2;
    int  rows=(*mat1).rows;
    int  cols=(*mat1).cols;
    int  dt=(*mat1).type();
    Mat mat3(Size(rows, cols), dt);
    absdiff(*mat1,*mat2,mat3);
    threshold(mat3, mat3, 100, 255, 0);
    
 /*   Mat result;
    result.create(rows, cols, dt);
    denoising(mat3,result);*/
  jint  count=countNonZero(mat3);
    return  count;
}



JNIEXPORT jlong JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_convolution(JNIEnv *env, jclass type, jlong v1,
                                                  jintArray v_) {
    jint *b = env->GetIntArrayElements(v_, NULL);
    Mat  *mat=(Mat*)v1;
    int  rows=(*mat).rows;
    int  cols=(*mat).cols;
    int  ntype=(*mat).type();
    static  Mat  mat2(Size(cols, rows), ntype);
   for (int i = 2; i < rows - 2; i++)
    {
        for (int j = 2; j < cols - 2; j++)
        {
            int a = (*mat).at<uchar>(i - 1, j - 1);
            int a1 = (*mat).at<uchar>(i, j - 1);
            int a2 = (*mat).at<uchar>(i + 1, j - 1);
            int ba = (*mat).at<uchar>(i - 1, j);
            int ba1 = (*mat).at<uchar>(i, j);
            int ba2 = (*mat).at<uchar>(i + 1, j);
            int ca = (*mat).at<uchar>(i - 1, j + 1);
            int ca1 = (*mat).at<uchar>(i, j - 1);
            int ca2 = (*mat).at<uchar>(i + 1, j + 1);
            int  result = a*b[0] + a1*b[1] + a2*b[2] + ba*b[3] + ba1*b[4] + ba2*b[5] + ca*b[6] + ca1*b[7] + ca2*b[8];
            if (result >= 0) {
                result = 255;
            }
            if (result < 0) {
                result = 0;
            }
            mat2.at<uchar>(i, j) = result;
        }
    }

    return (jlong)&mat2;
  }
JNIEXPORT jdouble JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_compareSimilar(JNIEnv *env, jclass type, jlong v1, jlong v2) {
    // TODO
    Mat *mat1 = (Mat *) v1;
    Mat *mat2 = (Mat *) v2;
    int  r=(*mat1).rows;
    int  c=(*mat1).cols;
    double  a = 0;
    double  sum = r*c;
    for (size_t i = 0; i < r; i++)
    {
        for (size_t j = 0; j < c; j++)
        {
            uchar a1 = (*mat1).at<uchar>(i, j);
            uchar a2 = (*mat2).at<uchar>(i, j);
            if (a1 == a2) a++;

        }
    }
    return a/sum;
}

extern "C"
JNIEXPORT jint JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_nCompareHist(JNIEnv *env, jclass type, jlong v1, jlong v2) {
Mat*  mat1=(Mat*)v1;
Mat*  mat2=(Mat*)v2;
    Mat  out1,out2,com1,com2;
    float h_ranges[] = { 0,256 };
    float s_ranges[] = { 0,256 };
    const float*ranges[] = { h_ranges,s_ranges };
    int h_bins = 50;
    int s_bins = 60;
    int histSize[] = { h_bins,s_bins };
    int channels[] = { 0,1 };
    cvtColor(*mat1, out1, COLOR_BGR2HSV);
    cvtColor(*mat2, out2, COLOR_BGR2HSV);
    calcHist(&out1, 1, channels, Mat(), com1, 2, histSize, ranges, true, false);
    normalize(com1, com1, 0, 1, NORM_MINMAX, -1, Mat());
    calcHist(&out2 ,1, channels, Mat(), com2, 2, histSize, ranges, true, false);
    normalize(com2, com2, 0, 1, NORM_MINMAX, -1, Mat());
    double  v= compareHist(com1,com2,0);
    int  va=v*100;
    return va;
}
extern "C"
JNIEXPORT jlong JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_equalizeHist(JNIEnv *env, jclass type, jlong v1) {
  Mat* mat=(Mat*)v1;
    Mat imageRGB[3];

    split(*mat, imageRGB);
    for (int i = 0; i < 3; i++)
    {
        equalizeHist(imageRGB[i], imageRGB[i]);
    }
    merge(imageRGB, 3, *mat);
    return (jlong)&mat;
}
}

float gett(Mat m1,Mat ma2) {
    float  a = 0;
    for (size_t i = 0; i < m1.rows; i++)
    {
        for (size_t j = 0; j < m1.cols; j++)
        {
            uchar  u = m1.at<uchar>(i, j);
            uchar  u2 = ma2.at<uchar>(i, j);
            if (u == u2) {
                a++;
            }
        }
    }
    float  s = m1.rows*ma2.cols;
    return a / s;
}
extern "C"

JNIEXPORT jfloat JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_charCompare(JNIEnv *env, jclass type, jlong v1, jlong v2) {

    // TODO
    Mat*  mat1=(Mat*)v1;
    Mat*  mat2=(Mat*)v2;
    Mat sobelx1, sobelx2;
    Sobel(*mat1, sobelx1, CV_32F, 1, 0);
    Sobel(*mat2, sobelx2, CV_32F, 1, 0);
    jfloat  a = 0;
    int rows=(*mat1).rows;
    int cols=(*mat1).cols;
    for (size_t i = 0; i < rows; i++)
    {
        for (size_t j = 0; j < cols; j++)
        {
            uchar  u = (*mat1).at<uchar>(i, j);
            uchar  u2 = (*mat2).at<uchar>(i, j);
            if (u == u2) {
                a++;
            }
        }
    }
    jfloat  s = rows*cols;
    return a / s;

}
 extern "C"
JNIEXPORT jlong JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_lplsChange(JNIEnv *env, jclass type, jlong v1) {
    Mat kernelY =Mat::zeros(Size(3,3),CV_8UC1);
    Mat* vsd=(Mat*)v1;
    kernelY.at<float>(0,0)=0;

    kernelY.at<float>(0,1)=-1;

    kernelY.at<float>(0,2)=0;

    kernelY.at<float>(1,0)=0;

    kernelY.at<float>(1,1)=7;

    kernelY.at<float>(1,2)=0;

    kernelY.at<float>(2,0)=-1;

    kernelY.at<float>(2,1)=-2;

    kernelY.at<float>(2,2)=-1;

}
extern "C"
#define  THREVALUE 100
JNIEXPORT jdouble JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_convoSimilar(JNIEnv *env, jclass type, jlong v1, jlong v2) {
    Mat *mat1 = (Mat *) v1;
    Mat *mat2 = (Mat *) v2;
    int  r=(*mat1).rows;
    int  c=(*mat1).cols;
    double  a = 0;
    double  sum = r*c;
    for (size_t i = 0; i < r; i++)
    {
        for (size_t j = 0; j < c; j++)
        {
            uchar a1 = (*mat1).at<uchar>(i, j);
            uchar a2 = (*mat2).at<uchar>(i, j);
            int  rst=a1-a2;
            int  rst2=rst>0?rst:-rst;
            if (rst2>THREVALUE){
                a++;
            }


        }
    }
    return a;
}
extern "C"
JNIEXPORT jlong JNICALL
Java_opencv_zhongke_ktcv_ndk_JniEnter_getDifPoint2(JNIEnv *env, jclass type, jlong v1, jlong v2 ) {
     Mat *mat1=(Mat*)v1;
    Mat *mat2=(Mat*)v2;
    int  rows=(*mat1).rows;
    int  cols=(*mat1).cols;
    int  dt=(*mat1).type();
    static Mat mat3=Mat::zeros(Size(rows,cols),dt);
    absdiff(*mat1,*mat2,mat3);
  //  threshold(mat3, mat3, va, 255, 0);
     return (jlong)&mat3;
}

template<typename T>
inline T fastMax(const T a, const T b)
{
    return (a > b ? a : b);
}
template<typename T>
inline int intRound(const T a)
{
    return int(a+0.5f);
}

int va[34]={1, 2, 1, 5, 2, 3, 3, 4, 5, 6, 6, 7, 1, 8, 8, 9, 9, 10, 1, 11, 11, 12, 12, 13, 1, 0, 0, 14, 14, 16, 0, 15, 15, 17};
const std::vector<unsigned int> POSE_COCO_PAIRS_RENDER(va,va+34);
float va2[54]={    255.f, 0.f, 85.f,
   255.f, 0.f, 0.f,
   255.f, 85.f, 0.f,
   255.f, 170.f, 0.f,
   255.f, 255.f, 0.f,
   170.f, 255.f, 0.f,
   85.f, 255.f, 0.f,
   0.f, 255.f, 0.f,
   0.f, 255.f, 85.f,
   0.f, 255.f, 170.f,
   0.f, 255.f, 255.f,
   0.f, 170.f, 255.f,
   0.f, 85.f, 255.f,
   0.f, 0.f, 255.f,
   255.f, 0.f, 170.f,
   170.f, 0.f, 255.f,
   255.f, 0.f, 255.f,
   85.f, 0.f, 255.f};
const std::vector<float> POSE_COCO_COLORS_RENDER(va2, va2+54);

void renderKeypointsCpu(Mat& frame, const vector<float>& keypoints, vector<int> keyshape, const std::vector<unsigned int>& pairs,
                        const std::vector<float> colors, const float thicknessCircleRatio, const float thicknessLineRatioWRTCircle,
                        const float threshold, float scale)
{
    // Get frame channels { }

    const auto width = frame.cols;
    const auto height = frame.rows;
    const auto area = width * height;

    // Parameters
    const auto lineType = 8;
    const auto shift = 0;
    const auto numberColors = colors.size();
    const auto thresholdRectangle = 0.1f;
    const auto numberKeypoints = keyshape[1];

    // Keypoints
    for (auto person = 0; person < keyshape[0]; person++)
    {
        {
            const auto ratioAreas = 1;
            // Size-dependent variables
            const auto thicknessRatio = fastMax(intRound(std::sqrt(area)*thicknessCircleRatio * ratioAreas), 1);
            // Negative thickness in cv::circle means that a filled circle is to be drawn.
            const auto thicknessCircle = (ratioAreas > 0.05 ? thicknessRatio : -1);
            const auto thicknessLine = 2;// intRound(thicknessRatio * thicknessLineRatioWRTCircle);
            const auto radius = thicknessRatio / 2;
            LOGSHOW("11111---------4444444------------")
            // Draw lines
            for (auto pair = 0u; pair < pairs.size(); pair += 2)
            {
                //pairs=34;
               // int va[34]={1, 2, 1, 5, 2, 3, 3, 4, 5, 6, 6, 7, 1, 8, 8, 9, 9, 10, 1, 11, 11, 12, 12, 13, 1, 0, 0, 14, 14, 16, 0, 15, 15, 17};
                const auto index1 = (person * numberKeypoints + pairs[pair]) * keyshape[2];

                const auto index2 = (person * numberKeypoints + pairs[pair + 1]) * keyshape[2];

                if (keypoints[index1 + 2] > threshold && keypoints[index2 + 2] > threshold)
                {

                    const auto colorIndex = pairs[pair + 1] * 3; // Before: colorIndex = pair/2*3;

                    const cv::Scalar color(colors[(colorIndex+2) % numberColors],
                                            colors[(colorIndex + 1) % numberColors],
                                            colors[(colorIndex + 0) % numberColors] );

                    const cv::Point keypoint1(intRound(keypoints[index1] * scale), intRound(keypoints[index1 + 1] * scale) ) ;
                    const cv::Point keypoint2(intRound(keypoints[index2] * scale), intRound(keypoints[index2 + 1] * scale))  ;

                    cv::line(frame, keypoint1, keypoint2, color, thicknessLine, lineType, shift);

                }
            }

      /*      // Draw circles
            for (auto part = 0; part < numberKeypoints; part++)
            {
                const auto faceIndex = (person * numberKeypoints + part) * keyshape[2];
                if (keypoints[faceIndex + 2] > threshold)
                {
                    const auto colorIndex = part * 3;
                    const cv::Scalar color( colors[(colorIndex+2) % numberColors],
                                            colors[(colorIndex + 1) % numberColors],
                                            colors[(colorIndex + 0) % numberColors] );

                    const cv::Point center(intRound(keypoints[faceIndex] * scale), intRound(keypoints[faceIndex + 1] * scale));
                    cv::circle(frame, center, radius, color, thicknessCircle, lineType, shift);
                }
            }
*/
        }
    }
}
void renderPoseKeypointsCpu(Mat& frame, const vector<float>& poseKeypoints, vector<int> keyshape,
                            const float renderThreshold, float scale, const bool blendOriginalFrame = true)
{

    // Background
    if (!blendOriginalFrame)
        frame.setTo(0.f); // [0-255]

    // Parameters
    const auto thicknessCircleRatio = 1.f / 75.f;
    const auto thicknessLineRatioWRTCircle = 0.75f;
    const auto& pairs = POSE_COCO_PAIRS_RENDER;

    // Render keypoints
    renderKeypointsCpu(frame, poseKeypoints, keyshape, pairs, POSE_COCO_COLORS_RENDER, thicknessCircleRatio,
                       thicknessLineRatioWRTCircle, renderThreshold, scale);
}


extern "C"
JNIEXPORT jlong JNICALL
Java_opencv_zhongke_ktcv_pedetion_Jniuti_hold(JNIEnv *env, jclass type, jlong mat, jfloatArray v_,
                                              jintArray v1_, jfloat scale,jint offlen) {

    jfloat *v = env->GetFloatArrayElements(v_, NULL);
    jint *v1 = env->GetIntArrayElements(v1_, NULL);
    Mat* mat1=(Mat*)mat;
    vector<float> poseKeypointsx(v,v+offlen);
    vector<int> keyshape(v1,v1+3);
    float   scaler=scale;
    renderPoseKeypointsCpu(*mat1,poseKeypointsx,keyshape,0.05,scaler);
    env->ReleaseFloatArrayElements(v_, v, 0);
    env->ReleaseIntArrayElements(v1_, v1, 0);
   return (jlong) mat1;
}

猜你喜欢

转载自blog.csdn.net/www5256246/article/details/80094657
CV
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022