Java C++；（OpenCV）

我在OpenCV文档中找到了以下使用k-NN的示例。现在，我的任务是将以下代码转换为Java，并对其进行一些更改，因为我的数据不是图像。 我很难理解示例中发生了什么

首先看一下代码：

#include "ml.h"
#include "highgui.h"

int main( int argc, char** argv )
{
    const int K = 10;
    int i, j, k, accuracy;
    float response;
    int train_sample_count = 100;
    CvRNG rng_state = cvRNG(-1);
    CvMat* trainData = cvCreateMat( train_sample_count, 2, CV_32FC1 );
    CvMat* trainClasses = cvCreateMat( train_sample_count, 1, CV_32FC1 );
    IplImage* img = cvCreateImage( cvSize( 500, 500 ), 8, 3 );
    float _sample[2];
    CvMat sample = cvMat( 1, 2, CV_32FC1, _sample );
    cvZero( img );

    CvMat trainData1, trainData2, trainClasses1, trainClasses2;

    // form the training samples
    cvGetRows( trainData, &trainData1, 0, train_sample_count/2 );
    cvRandArr( &rng_state, &trainData1, CV_RAND_NORMAL, cvScalar(200,200), cvScalar(50,50) );

    cvGetRows( trainData, &trainData2, train_sample_count/2, train_sample_count );
    cvRandArr( &rng_state, &trainData2, CV_RAND_NORMAL, cvScalar(300,300), cvScalar(50,50) );

    cvGetRows( trainClasses, &trainClasses1, 0, train_sample_count/2 );
    cvSet( &trainClasses1, cvScalar(1) );

    cvGetRows( trainClasses, &trainClasses2, train_sample_count/2, train_sample_count );
    cvSet( &trainClasses2, cvScalar(2) );

    // learn classifier
    CvKNearest knn( trainData, trainClasses, 0, false, K );
    CvMat* nearests = cvCreateMat( 1, K, CV_32FC1);

    for( i = 0; i < img->height; i++ )
    {
        for( j = 0; j < img->width; j++ )
        {
            sample.data.fl[0] = (float)j;
            sample.data.fl[1] = (float)i;

            // estimate the response and get the neighbors' labels
            response = knn.find_nearest(&sample,K,0,0,nearests,0);

            // compute the number of neighbors representing the majority
            for( k = 0, accuracy = 0; k < K; k++ )
            {
                if( nearests->data.fl[k] == response)
                    accuracy++;
            }
            // highlight the pixel depending on the accuracy (or confidence)
            cvSet2D( img, i, j, response == 1 ?
                (accuracy > 5 ? CV_RGB(180,0,0) : CV_RGB(180,120,0)) :
                (accuracy > 5 ? CV_RGB(0,180,0) : CV_RGB(120,120,0)) );
        }
    }

    // display the original training samples
    for( i = 0; i < train_sample_count/2; i++ )
    {
        CvPoint pt;
        pt.x = cvRound(trainData1.data.fl[i*2]);
        pt.y = cvRound(trainData1.data.fl[i*2+1]);
        cvCircle( img, pt, 2, CV_RGB(255,0,0), CV_FILLED );
        pt.x = cvRound(trainData2.data.fl[i*2]);
        pt.y = cvRound(trainData2.data.fl[i*2+1]);
        cvCircle( img, pt, 2, CV_RGB(0,255,0), CV_FILLED );
    }

    cvNamedWindow( "classifier result", 1 );
    cvShowImage( "classifier result", img );
    cvWaitKey(0);

    cvReleaseMat( &trainClasses );
    cvReleaseMat( &trainData );
    return 0;
}

#包括“ml.h”
#包括“highgui.h”
int main（int argc，字符**argv）
{
常数int K=10；
int i，j，k，精度；
浮动响应；
int系列样品计数=100；
CvRNG rng_状态=CvRNG（-1）；
CvMat*列车数据=cvCreateMat（列车样本计数，2，CV\U 32FC1）；
CvMat*列车等级=cvCreateMat（列车样本计数，1，CV\U 32FC1）；
IplImage*img=cvCreateImage（cvSize（500500），8，3）；
浮子样本[2]；
CvMat样本=CvMat（1,2，CV_32FC1，_样本）；
cvZero（img）；
CvMat trainData1、trainData2、trainClasses1、trainClasses2；
//形成训练样本
cvGetRows（列车数据和列车数据1、0、列车样本计数/2）；
cvRandArr（&rng_state，&trainData1，CV_RAND_NORMAL，cvScalar（200200），cvScalar（50,50））；
cvGetRows（列车数据和列车数据2、列车样本计数/2、列车样本计数）；
cvRandArr（&rng_state，&trainData2，CVRANDU NORMAL，cvScalar（300300），cvScalar（50,50））；
cvGetRows（列车类别和列车类别1、0、列车样本计数/2）；
cvSet（&trainClasses1，cvScalar（1））；
cvGetRows（列车类别和列车类别2、列车样本计数/2、列车样本计数）；
cvSet（&trainClasses2，cvScalar（2））；
//学习分类器
CvKNearest knn（列车数据，列车等级，0，false，K）；
CvMat*nearests=cvCreateMat（1，K，CV_32FC1）；
对于（i=0；iheight；i++）
{
对于（j=0；jwidth；j++）
{
sample.data.fl[0]=（float）j；
sample.data.fl[1]=（float）i；
//估计响应并获取邻居的标签
响应=knn.查找最近的（样本，K，0,0，最近的，0）；
//计算代表多数的邻居数
对于（k=0，精度=0；kdata.fl[k]==响应）
准确度++；
}
//根据精度（或置信度）高亮显示像素
cvSet2D（img，i，j，response==1？
（精度>5？CV_RGB（180,0,0）：CV_RGB（180120,0））：
（精度>5？CV_RGB（0180,0）：CV_RGB（120120,0））；
}
}
//显示原始训练样本
对于（i=0；i

现在是问题。
一,。什么是

cvRNG

的类型。在OpenCV的Java版本中找不到它
二,<代码>CvMat样本=CvMat（1,2，CV_32FC1，_样本）-需要一个java中不可用的四字段构造函数。
三,。为什么我需要形成培训样本？我该怎么做？ 提到“只支持CV_行_样本数据布局”是什么意思

---

除了答案之外，欢迎使用各种其他工作示例。=）

示例首先生成随机训练数据。它构建训练样本的

Nx2

矩阵（

N=100

2D点），以及相应的类标签（

Nx1

matrix）。因此，样本具有“行布局”，每行为一个样本

生成的数据一分为二；在前半部分

（N/2）中，x2

样本由均值=200、方差=50（X和Y坐标）的正态分布生成，属于第一类

类=1

。类似地，后半部分由

X~N（300,50）

生成，并标记为具有

class=2

所以你可以想象数据看起来像二维空间中截然相反的两个点

接下来，我们创建K-最近邻分类器（示例中为

K=10

），并为其提供训练集

然后，代码在500x500范围内的点网格上循环（即，我们在二维点上循环

[0,0]，[0,1]，…，[1,0]，[1,1]，…[499499]

）。对于每个点，我们使用分类器查找K-最近邻（基于欧几里德距离）及其相应的类别标签，并预测网格点的标签（基于最近邻的多数投票）。它计算一个“置信度”度量（通过计算有多少

K=10

最近的邻居与预测的邻居具有相同的类别）

我们将预测存储在与网格（500x500）大小相同的图像中，颜色编码表示类别（

1

或

2

），颜色强度表示预测置信度

最后，它将原始数据样本绘制在图像的顶部，点用其真实类标签着色，并显示结果图像

现在我没有运行完全相同的代码，但我想它会给出如下结果：

这是我用英文写的。以下是我的代码，以防您感兴趣（我使用的是一个用于OpenCV的MATLAB包装工具箱）：

%由两个正态分布生成的随机训练集
N=100；%训练样本数
列车数据=[randn（N/2,2）*50+200；randn（N/2,2）*50+300]；
列车等级=int32（[一个（N/2,1）*1；一个（N/2,1）*2]）；
%kNN分类器
K=10；
knn=cv.KNearest（）；
knn.列车（列车数据、列车等级）；
%建造