void Labeler::convert2Example(const Instance* pInstance, Example& exam) {
  exam.clear();
  const vector<string> &label1s = pInstance->label1s;
  const vector<string> &label2s = pInstance->label2s;
  int curInstSize = label1s.size();
  for (int i = 0; i < curInstSize; ++i) {
    string orcale1 = label1s[i];
    string orcale2 = label2s[i];
    if (orcale2.length() > 2)
      orcale2 = orcale2.substr(2);

    int numLabel2s = m_label2Alphabet.size();
    vector<int> curlabel2s;
    for (int j = 0; j < numLabel2s; ++j) {
      string str = m_label2Alphabet.from_id(j);
      if (str.compare(orcale2) == 0)
        curlabel2s.push_back(1);
      else
        curlabel2s.push_back(0);
    }

    exam.m_label2s.push_back(curlabel2s);

    Feature feat;
    extractFeature(feat, pInstance, i);
    exam.m_features.push_back(feat);
  }

}
void Labeler::convert2Example(const Instance* pInstance, Example& exam) {
  exam.clear();
  const string &label = pInstance->label;
  const vector<vector<string> > &words = pInstance->words;
  const vector<vector<vector<string> > > &chars = pInstance->chars;

  int numLabels = m_labelAlphabet.size();
  for (int j = 0; j < numLabels; ++j) {
    string str = m_labelAlphabet.from_id(j);
    if (str.compare(label) == 0)
      exam.m_labels.push_back(1);
    else
      exam.m_labels.push_back(0);
  }

  int curInstSize = words.size();
  for (int i = 0; i < curInstSize; ++i) {
    Feature feat;
    extractFeature(feat, pInstance, i);
    exam.m_features.push_back(feat);
  }
  if (m_linearfeat > 0) {
    vector<string> linear_features;
    extractLinearFeatures(linear_features, pInstance);
    for (int i = 0; i < linear_features.size(); i++) {
      int curFeatId = m_featAlphabet.from_string(linear_features[i]);
      if (curFeatId >= 0)
        exam.m_linears.push_back(curFeatId);
    }
  }
}
Exemple #3
0
  int PlateJudge::plateJudge(const Mat &inMat, int &result) {
    Mat features;
    extractFeature(inMat, features);

    float response = svm_->predict(features);
    result = (int)response;

    return 0;
  }
int HaarFeature::extractOneTypeFeatures45(int is_extract_feature, HaarFeatureInfoT &info, float *pt_feature)
{
	int type = info.type;
	int L_r = feature_sizes[type].x;
	int R_r = feature_sizes[type].y;
	double inv_r = feature_inv_ratio[type] * 2;

	CB_PointT image_size = {template_w, template_h};

	info.pos1.y = FEATURE_MARGIN;
	while (info.pos1.y < template_h - 1)
	{
		info.pos1.x = FEATURE_MARGIN;
		while (info.pos1.x < template_w - 1)
		{
			info.size.y = 2;
			while (info.pos1.x + R_r * info.size.y < template_w)
			{
				info.size.x = 2; 
				while (info.pos1.x - L_r * info.size.x > 0)
				{
					CB_SlantT slant = {info.pos1.x, info.pos1.y, L_r * info.size.x, R_r * info.size.y};
					CB_RectangleT rect;
					int result = slantToRect(slant, rect, image_size);
					if (result == 0)
					{
						info.size.x += HAAR_SCALE_STEP_X;
						continue;
					}
					if (is_extract_feature == 0)
					{
						info.inv_area = INV_AREA_R / (info.size.x * info.size.y * inv_r);
						pt_feature_infos[feature_count] = info;
					}
					else if (is_extract_feature > 0)
					{
						*(pt_feature + feature_count) = extractFeature(pt_feature_infos[feature_count]);
					}
					feature_count++;
					info.size.x += HAAR_SCALE_STEP_X;
				}
				info.size.y += HAAR_SCALE_STEP_Y;
			}
			info.pos1.x += HAAR_SHIFT_STEP_X;
		}
		info.pos1.y += HAAR_SHIFT_STEP_Y;
	}
	return feature_count;
}
Exemple #5
0
  //! 设置车牌图像的置信度
  //! 返回值,0代表是车牌,其他值代表不是
  int PlateJudge::plateSetScore(CPlate& plate) {
    Mat features;
    extractFeature(plate.getPlateMat(), features);

    float score = svm_->predict(features, noArray(), cv::ml::StatModel::Flags::RAW_OUTPUT);

    // score值代表离margin的距离,小于0代表是车牌,大于0代表不是车牌
    // 当小于0时,值越小代表是车牌的概率越大
    plate.setPlateScore(score);

    if (score < 0)
      return 0;
    else
      return -1;
  }
void classifierSVM(Mat& trainData, Mat& labelsTrain, vector<string> trainImgName, vector<string> testImgName, string kernelFunction, Mat& resultTrain, Mat& resultTest)
{
    Mat trainFeatureData(0,1764, CV_32FC1);
    Mat testFeatureData(0,1764, CV_32FC1);
    string predictTrainFeatureVector="./result/PredictTrain-Features-LBP.txt";
    string predictTestFeatureVector="./result/PredictTest-Features-LBP.txt";
    stringstream predictTrainDataTxt;
    stringstream predictTestDataTxt;
    
    SVM::Params params;
    params.svmType = SVM::C_SVC;//C_SVC用于n类分类问题
    if( kernelFunction == "LINEAR" )
    params.kernelType = SVM::LINEAR;
    if( kernelFunction == "RBF" )
    params.kernelType = SVM::RBF;
    Ptr<SVM> svm = SVM::create(params);
    svm->train( trainData , ROW_SAMPLE , labelsTrain );

    /*----------------Predict traindata------------------*/
//    Mat resultTrain;   // 输出分类结果
    trainFeatureData=extractFeature(trainImgName);
    WriteData(predictTrainFeatureVector, trainFeatureData);

    predictTrainDataTxt<<"./result/PredictTrain-LBP-SVM-"<<kernelFunction<<".txt";
    svm->predict(trainFeatureData, resultTrain);
    WriteData(predictTrainDataTxt.str(), resultTrain);
    
    /*----------------Predict testdata-------------------*/
//    Mat resultTest;   // 输出分类结果
    testFeatureData=extractFeature(testImgName);
    WriteData(predictTestFeatureVector, testFeatureData);

    predictTestDataTxt<<"./result/PredictTest-LBP-SVM-"<<kernelFunction<<".txt";
    svm->predict(testFeatureData, resultTest);
    WriteData(predictTestDataTxt.str(), resultTest);
}
Exemple #7
0
void GeoJson::extractLayer(const rapidjson::Value& _in, Layer& _out, const MapTile& _tile) {
    
    const auto& featureIter = _in.FindMember("features");
    
    if (featureIter == _in.MemberEnd()) {
        logMsg("ERROR: GeoJSON missing 'features' member\n");
        return;
    }
    
    const auto& features = featureIter->value;
    for (auto featureJson = features.Begin(); featureJson != features.End(); ++featureJson) {
        _out.features.emplace_back();
        extractFeature(*featureJson, _out.features.back(), _tile);
    }
    
}
Exemple #8
0
void ImageProcess::run()
{
	switch(processStep)
	{
	case 1:
		//提取特征
		extractFeature();
		break;
	case 2:
		//匹配特征
		matchFeature();
		break;
	case 3:
		//对齐影像
		alignImage();
		break;
	}
}
ControlWidget::ControlWidget(MainWindow* mainWin) : QDockWidget("Control Widget", (QWidget*)mainWin) {
	this->mainWin = mainWin;

	// set up the UI
	ui.setupUi(this);
	ui.checkBoxRoadTypeHighway->setChecked(true);
	ui.checkBoxRoadTypeBoulevard->setChecked(true);
	ui.checkBoxRoadTypeAvenue->setChecked(true);
	ui.checkBoxRoadTypeLocalStreet->setChecked(true);

	// register the event handlers
	connect(ui.checkBoxRoadTypeHighway, SIGNAL(stateChanged(int)), this, SLOT(showRoad(int)));
	connect(ui.checkBoxRoadTypeBoulevard, SIGNAL(stateChanged(int)), this, SLOT(showRoad(int)));
	connect(ui.checkBoxRoadTypeAvenue, SIGNAL(stateChanged(int)), this, SLOT(showRoad(int)));
	connect(ui.checkBoxRoadTypeLocalStreet, SIGNAL(stateChanged(int)), this, SLOT(showRoad(int)));
	connect(ui.pushButtonExtractFeature, SIGNAL(clicked()), this, SLOT(extractFeature()));

	hide();
}
Exemple #10
0
void QueryExecutor::execute(HitCollectorPtr& pCollector,
                            ScorerPtr& pScorer,
                            const QueryTracerPtr& pTracer)
{
    //TODO: allocate from mempool
    MatchedDocSet machedDocs(m_pPool, DEFAULT_MATCHED_DOC_BUFFER_SIZE, size());
    machedDocs.setTracer(pTracer);

    QueryFeature queryFeature;
    queryFeature.reserve(size());
    extractFeature(queryFeature);

    pScorer->beginQuery(m_pFeatureProvider, queryFeature);
    while (advance(machedDocs) > 0)
    {
        FX_TRACE("Matched doc count: [%u]", (uint32_t)machedDocs.size());
        pScorer->score(machedDocs);
        pCollector->collect(machedDocs);
        machedDocs.reset();
    }
    pScorer->endQuery();
}
int HaarFeature::extractOneTypeFeatures(int is_extract_feature, HaarFeatureInfoT &info, float *pt_feature)
{
	int type = info.type;
	int x_r = feature_sizes[type].x;
	int y_r = feature_sizes[type].y;
	double inv_r = feature_inv_ratio[type];

	info.pos1.y = FEATURE_MARGIN;
	while (info.pos1.y < template_h - 1)
	{
		info.pos1.x = FEATURE_MARGIN;
		while (info.pos1.x < template_w - 1)
		{
			info.size.y = 2;
			while (info.pos1.y + y_r * info.size.y - 1 < template_h - FEATURE_MARGIN)
			{
				info.size.x = 2; 
				while (info.pos1.x + x_r * info.size.x - 1 < template_w - FEATURE_MARGIN)
				{
					if (is_extract_feature == 0)
					{
						info.inv_area = INV_AREA_R / (info.size.x * info.size.y * inv_r);
						pt_feature_infos[feature_count] = info;
					}
					else if (is_extract_feature > 0)
					{
						*(pt_feature + feature_count) = extractFeature(pt_feature_infos[feature_count]);
					}
					feature_count++;
					info.size.x += HAAR_SCALE_STEP_X;
				}
				info.size.y += HAAR_SCALE_STEP_Y;
			}
			info.pos1.x += HAAR_SHIFT_STEP_X;
		}
		info.pos1.y += HAAR_SHIFT_STEP_Y;
	}
	return feature_count;
}