特征提取与匹配案例代码
特征提取与匹配案例代码、环境：Android studio + opencv for AndroidMainActivity.javapackage com.packtpub.masteringopencvandroid.chapter3;import android.app.Activity;import android.content.Intent;import android.graphics.Bitmap;import android.graphics.BitmapFactory;import .Uri;import android.os.AsyncTask;import android.os.Bundle;import android.os.Environment;import android.util.Log;import android.view.Menu;import android.view.MenuItem;import android.widget.ImageView;import android.widget.TextView;import android.widget.Toast;import org.opencv.android.BaseLoaderCallback;import org.opencv.android.LoaderCallbackInterface;import org.opencv.android.OpenCVLoader;import org.opencv.android.Utils;import org.opencv.core.Core;import org.opencv.core.CvType;import org.opencv.core.Mat;import org.opencv.core.MatOfDMatch;import org.opencv.core.MatOfKeyPoint;import org.opencv.core.Point;import org.opencv.core.Scalar;import org.opencv.features2d.DMatch;import org.opencv.features2d.DescriptorExtractor;import org.opencv.features2d.DescriptorMatcher;import org.opencv.features2d.FeatureDetector;import org.opencv.features2d.Features2d;import org.opencv.highgui.Highgui;import org.opencv.imgproc.Imgproc;import java.io.FileNotFoundException;import java.io.InputStream;import java.util.Collections;import parator;import java.util.Date;import java.util.List;public class MainActivity extends Activity {private final int SELECT_PHOTO_1 = 1;private final int SELECT_PHOTO_2 = 2;private final int MAX_MATCHES = 50;private ImageView ivImage1;private TextView tvKeyPointsObject1, tvKeyPointsObject2, tvKeyPointsMatches, tvTime;private int keypointsObject1, keypointsObject2, keypointMatches;Mat src1, src2;static int ACTION_MODE = 0;private boolean src1Selected = false, src2Selected = false;private BaseLoaderCallback mOpenCVCallBack = new BaseLoaderCallback(this) { @Overridepublic void onManagerConnected(int status) {switch (status) {case LoaderCallbackInterface.SUCCESS://DO YOUR WORK/STUFF HERESystem.loadLibrary("nonfree");break;default:super.onManagerConnected(status);break;}}};@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);getActionBar().setDisplayHomeAsUpEnabled(true);ivImage1 = (ImageView)findViewById(R.id.ivImage1);tvKeyPointsObject1 = (TextView) findViewById(KeyPointsObject1);tvKeyPointsObject2 = (TextView) findViewById(KeyPointsObject2);tvKeyPointsMatches = (TextView) findViewById(KeyPointsMatches);keypointsObject1 = keypointsObject2 = keypointMatches = -1;tvTime = (TextView) findViewById(Time);Intent intent = getIntent();if(intent.hasExtra("ACTION_MODE")){ACTION_MODE = intent.getIntExtra("ACTION_MODE", 0);}}@Overridepublic boolean onCreateOptionsMenu(Menu menu) {getMenuInflater().inflate(R.menu.menu_main, menu);return true;}@Overridepublic boolean onOptionsItemSelected(MenuItem item) {int id = item.getItemId();if (id == R.id.action_load_first_image) {Intent photoPickerIntent = new Intent(Intent.ACTION_PICK);photoPickerIntent.setType("image/*");startActivityForResult(photoPickerIntent, SELECT_PHOTO_1);return true;} else if (id == R.id.action_load_second_image) {Intent photoPickerIntent = new Intent(Intent.ACTION_PICK);photoPickerIntent.setType("image/*");startActivityForResult(photoPickerIntent, SELECT_PHOTO_2);return true;}return super.onOptionsItemSelected(item);}@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent imageReturnedIntent) {super.onActivityResult(requestCode, resultCode, imageReturnedIntent);switch(requestCode) {case SELECT_PHOTO_1:if(resultCode == RESULT_OK){try {final Uri imageUri = imageReturnedIntent.getData();final InputStream imageStream =getContentResolver().openInputStream(imageUri);final Bitmap selectedImage = BitmapFactory.decodeStream(imageStream);src1 = new Mat(selectedImage.getHeight(), selectedImage.getWidth(), CvType.CV_8UC4);// ivImage1.setImageBitmap(selectedImage);Utils.bitmapToMat(selectedImage, src1);src1Selected = true;} catch (FileNotFoundException e) {e.printStackTrace();}}break;case SELECT_PHOTO_2:if(resultCode == RESULT_OK){try {final Uri imageUri = imageReturnedIntent.getData();final InputStream imageStream = getContentResolver().openInputStream(imageUri);final Bitmap selectedImage = BitmapFactory.decodeStream(imageStream);src2 = new Mat(selectedImage.getHeight(), selectedImage.getWidth(), CvType.CV_8UC4);Utils.bitmapToMat(selectedImage, src2);src2Selected = true;} catch (FileNotFoundException e) {e.printStackTrace();}}break;}Toast.makeText(MainActivity.this, src1Selected + " " + src2Selected, Toast.LENGTH_SHORT).show();if(src1Selected && src2Selected){Log.d("com.packtpub.chapter3", "Before Execute");new AsyncTask<Void, Void, Bitmap>() {private long startTime, endTime;@Overrideprotected void onPreExecute() {super.onPreExecute();startTime = System.currentTimeMillis();}@Overrideprotected Bitmap doInBackground(Void... params) {return executeTask();}@Overrideprotected void onPostExecute(Bitmap bitmap) {super.onPostExecute(bitmap);endTime = System.currentTimeMillis();ivImage1.setImageBitmap(bitmap);tvKeyPointsObject1.setText("Object 1 : "+keypointsObject1);tvKeyPointsObject2.setText("Object 2 : "+keypointsObject2);tvKeyPointsMatches.setText("Keypoint Matches : "+keypointMatches);tvTime.setText("Time taken : "+(endTime-startTime)+" ms");}}.execute();}}private Bitmap executeTask(){Log.d("com.packtpub.chapter3", "Execute");FeatureDetector detector;MatOfKeyPoint keypoints1, keypoints2;DescriptorExtractor descriptorExtractor;Mat descriptors1, descriptors2;DescriptorMatcher descriptorMatcher;MatOfDMatch matches = new MatOfDMatch();keypoints1 = new MatOfKeyPoint();keypoints2 = new MatOfKeyPoint();descriptors1 = new Mat();descriptors2 = new Mat();Log.d("com.packtpub.chapter3", "before switch");switch (ACTION_MODE){case HomeActivity.MODE_SIFT:detector = FeatureDetector.create(FeatureDetector.SIFT);descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.SIFT);descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_SL2);// descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);break;case HomeActivity.MODE_SURF:detector = FeatureDetector.create(FeatureDetector.SURF);descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.SURF);descriptorMatcher =DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_SL2);break;case HomeActivity.MODE_ORB:detector = FeatureDetector.create(FeatureDetector.ORB);descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.ORB);descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);break;case HomeActivity.MODE_BRISK:detector = FeatureDetector.create(FeatureDetector.BRISK);descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.BRISK);descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);break;case HomeActivity.MODE_FREAK:detector = FeatureDetector.create(FeatureDetector.FAST);descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.FREAK);descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);break;default:detector = FeatureDetector.create(FeatureDetector.FAST);descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);break;}Log.d("com.packtpub.chapter3", "After switch");detector.detect(src2, keypoints2);detector.detect(src1, keypoints1);Log.d("com.packtpub.chapter3", CvType.typeToString(src1.type())+" "+CvType.typeToString(src2.type()));Log.d("com.packtpub.chapter3", keypoints1.toArray().length+" keypoints");Log.d("com.packtpub.chapter3", keypoints2.toArray().length+" keypoints");Log.d("com.packtpub.chapter3", "Detect");keypointsObject1 = keypoints1.toArray().length;keypointsObject2 = keypoints2.toArray().length;pute(src1, keypoints1, descriptors1);pute(src2, keypoints2, descriptors2);descriptorMatcher.match(descriptors1, descriptors2, matches);Log.d("com.packtpub.chapter3", matches.toArray().length+" matches");keypointMatches = matches.toArray().length;Collections.sort(matches.toList(), new Comparator<DMatch>() {@Overridepublic int compare(DMatch o1, DMatch o2) {if(o1.distance<o2.distance)return -1;if(o1.distance>o2.distance)return 1;return 0;}});List<DMatch> listOfDMatch = matches.toList();if(listOfDMatch.size()>MAX_MATCHES){matches.fromList(listOfDMatch.subList(0,MAX_MATCHES));}// Mat src3 = src1.clone();// Features2d.drawMatches(src1, keypoints1, src2, keypoints2, matches, src3);Mat src3 = drawMatches(src1, keypoints1, src2, keypoints2, matches, false);Log.d("com.packtpub.chapter3", CvType.typeToString(src3.type()));Bitmap image1 = Bitmap.createBitmap(src3.cols(), src3.rows(), Bitmap.Config.ARGB_8888);Utils.matToBitmap(src3, image1);Imgproc.cvtColor(src3, src3, Imgproc.COLOR_BGR2RGB);boolean bool = Highgui.imwrite(Environment.getExternalStorageDirectory()+"/Download/PacktBook/Chapter3/" +ACTION_MODE+".png", src3);Log.d("com.packtpub.chapter3", bool+" "+Environment.getExternalStorageDirectory()+"/Download/PacktBook/Chapter3/"+ACTION_MO DE+".png");return image1;}@Overrideprotected void onResume() {super.onResume();OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_10, this,mOpenCVCallBack);}static Mat drawMatches(Mat img1, MatOfKeyPoint key1, Mat img2, MatOfKeyPoint key2, MatOfDMatch matches, boolean imageOnly){//https:///mustafaakin/image-matcher/tree/master/src/in/mustafaak/imagematcher Mat out = new Mat();Mat im1 = new Mat();Mat im2 = new Mat();Imgproc.cvtColor(img1, im1, Imgproc.COLOR_BGR2RGB);Imgproc.cvtColor(img2, im2, Imgproc.COLOR_BGR2RGB);if ( imageOnly){MatOfDMatch emptyMatch = new MatOfDMatch();MatOfKeyPoint emptyKey1 = new MatOfKeyPoint();MatOfKeyPoint emptyKey2 = new MatOfKeyPoint();Features2d.drawMatches(im1, emptyKey1, im2, emptyKey2, emptyMatch, out);} else {Features2d.drawMatches(im1, key1, im2, key2, matches, out);}Bitmap bmp = Bitmap.createBitmap(out.cols(), out.rows(), Bitmap.Config.ARGB_8888);Imgproc.cvtColor(out, out, Imgproc.COLOR_BGR2RGB);Core.putText(out, "FRAME", new Point(img1.width() / 2,30), Core.FONT_HERSHEY_PLAIN, 2, new Scalar(0,255,255),3);Core.putText(out, "MATCHED", new Point(img1.width() + img2.width() / 2,30), Core.FONT_HERSHEY_PLAIN, 2, new Scalar(255,0,0),3);return out;}}HomeActivity.javapackage com.packtpub.masteringopencvandroid.chapter3;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.widget.Button;public class HomeActivity extends Activity {public static final int MODE_SIFT = 1;public static final int MODE_SURF = 2;public static final int MODE_ORB = 3;public static final int MODE_BRISK = 4;public static final int MODE_FREAK = 5;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_home);Button bSIFT, bSURF, bORB, bBRISK, bFREAK;bSIFT = (Button) findViewById(R.id.bSIFT);bSURF = (Button) findViewById(R.id.bSURF);bORB = (Button) findViewById(R.id.bORB);bBRISK = (Button) findViewById(R.id.bBRISK);bFREAK = (Button) findViewById(R.id.bFREAK);bSIFT.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent i = new Intent(getApplicationContext(), MainActivity.class);i.putExtra("ACTION_MODE", MODE_SIFT);startActivity(i);}});bSURF.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent i = new Intent(getApplicationContext(), MainActivity.class);i.putExtra("ACTION_MODE", MODE_SURF);startActivity(i);}});bORB.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent i = new Intent(getApplicationContext(), MainActivity.class);i.putExtra("ACTION_MODE", MODE_ORB);startActivity(i);}});bBRISK.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent i = new Intent(getApplicationContext(), MainActivity.class);i.putExtra("ACTION_MODE", MODE_BRISK);startActivity(i);}});bFREAK.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent i = new Intent(getApplicationContext(), MainActivity.class);i.putExtra("ACTION_MODE", MODE_FREAK);startActivity(i);}});}}。
pycharm sift特征提取代码
PyCharm是一种流行的集成开发环境（IDE），用于编写Python代码。
SIFT（尺度不变特征转换）是一种计算机视觉算法，用于检测和描述图像中的局部特征。
在本文中，我们将介绍如何使用PyCharm编写SIFT特征提取的代码。
SIFT特征提取是一种在计算机视觉领域广泛应用的技术，它可以检测图像中的角点和边缘，并生成具有旋转和尺度不变性的特征描述子。
这使得SIFT特征在图像匹配、目标识别和三维重构等领域具有很高的实用价值。
在PyCharm中编写SIFT特征提取的代码需要以下步骤：1. 安装OpenCV库：OpenCV是一个开源的计算机视觉库，它包含了许多用于图像处理和计算机视觉领域的函数和工具。
在PyCharm中，我们可以使用pip命令来安装OpenCV库。
2. 导入OpenCV库：在PyCharm中，我们使用import语句来导入OpenCV库，以便在代码中调用OpenCV中的函数和类。
3. 加载图像：使用OpenCV库中的imread函数来加载要进行特征提取的图像，将其存储在一个变量中以备后续使用。
4. 创建SIFT对象：通过调用OpenCV库中的SIFT_create函数来创建一个SIFT对象，以便对图像进行特征提取操作。
5. 提取特征点和描述子：使用SIFT对象的detectAndCompute函数来提取图像中的关键点和对应的描述子，这些描述子将用于后续的特征匹配和识别操作。
6. 显示特征点：通过调用OpenCV库中的drawKeypoints函数来在图像上绘制出提取出的特征点，以便可视化和检查特征提取的效果。
7. 保存结果图像：使用OpenCV库中的imwrite函数将包含特征点的图像保存到指定的文件路径。
通过上述步骤，我们可以在PyCharm中编写出SIFT特征提取的代码，并在图像上成功提取出关键点和描述子。
这样的代码可以被应用到图像匹配、目标识别和其他计算机视觉任务中，为实际应用提供了便利。
Python进行特征提取的示例代码
Python进⾏特征提取的⽰例代码#过滤式特征选择#根据⽅差进⾏选择，⽅差越⼩，代表该属性识别能⼒很差，可以剔除from sklearn.feature_selection import VarianceThresholdx=[[100,1,2,3],[100,4,5,6],[100,7,8,9],[101,11,12,13]]selector=VarianceThreshold(1) #⽅差阈值值，selector.fit(x)selector.variances_ #展现属性的⽅差selector.transform(x)#进⾏特征选择selector.get_support(True) #选择结果后，特征之前的索引selector.inverse_transform(selector.transform(x)) #将特征选择后的结果还原成原始数据#被剔除掉的数据，显⽰为0#单变量特征选择from sklearn.feature_selection import SelectKBest,f_classifx=[[1,2,3,4,5],[5,4,3,2,1],[3,3,3,3,3],[1,1,1,1,1]]y=[0,1,0,1]selector=SelectKBest(score_func=f_classif,k=3)#选择3个特征，指标使⽤的是⽅差分析F值selector.fit(x,y)selector.scores_ #每⼀个特征的得分selector.pvalues_selector.get_support(True) #如果为true，则返回被选出的特征下标，如果选择False，则#返回的是⼀个布尔值组成的数组，该数组只是那些特征被选择selector.transform(x)#包裹时特征选择from sklearn.feature_selection import RFEfrom sklearn.svm import LinearSVC #选择svm作为评定算法from sklearn.datasets import load_iris #加载数据集iris=load_iris()x=iris.datay=iris.targetestimator=LinearSVC()selector=RFE(estimator=estimator,n_features_to_select=2) #选择2个特征selector.fit(x,y)selector.n_features_ #给出被选出的特征的数量selector.support_ #给出了被选择特征的maskselector.ranking_ #特征排名，被选出特征的排名为1#注意：特征提取对于预测性能的提升没有必然的联系，接下来进⾏⽐较；from sklearn.feature_selection import RFEfrom sklearn.svm import LinearSVCfrom sklearn import cross_validationfrom sklearn.datasets import load_iris#加载数据iris=load_iris()X=iris.datay=iris.target#特征提取estimator=LinearSVC()selector=RFE(estimator=estimator,n_features_to_select=2)X_t=selector.fit_transform(X,y)#切分测试集与验证集x_train,x_test,y_train,y_test=cross_validation.train_test_split(X,y,test_size=0.25,random_state=0,stratify=y)x_train_t,x_test_t,y_train_t,y_test_t=cross_validation.train_test_split(X_t,y,test_size=0.25,random_state=0,stratify=y)clf=LinearSVC()clf_t=LinearSVC()clf.fit(x_train,y_train)clf_t.fit(x_train_t,y_train_t)print('origin dataset test score:',clf.score(x_test,y_test))#origin dataset test score: 0.973684210526print('selected Dataset:test score:',clf_t.score(x_test_t,y_test_t))#selected Dataset:test score: 0.947368421053import numpy as npfrom sklearn.feature_selection import RFECVfrom sklearn.svm import LinearSVCfrom sklearn.datasets import load_irisiris=load_iris()x=iris.datay=iris.targetestimator=LinearSVC()selector=RFECV(estimator=estimator,cv=3)selector.fit(x,y)selector.n_features_selector.support_selector.ranking_selector.grid_scores_#嵌⼊式特征选择import numpy as npfrom sklearn.feature_selection import SelectFromModelfrom sklearn.svm import LinearSVCfrom sklearn.datasets import load_digitsdigits=load_digits()x=digits.datay=digits.targetestimator=LinearSVC(penalty='l1',dual=False)selector=SelectFromModel(estimator=estimator,threshold='mean')selector.fit(x,y)selector.transform(x)selector.threshold_selector.get_support(indices=True)#scikitlearn提供了Pipeline来讲多个学习器组成流⽔线，通常流⽔线的形式为：将数据标准化，#--》特征提取的学习器————》执⾏预测的学习器，除了最后⼀个学习器之后，#前⾯的所有学习器必须提供transform⽅法，该⽅法⽤于数据转化（如归⼀化、正则化、#以及特征提取#学习器流⽔线（pipeline）from sklearn.svm import LinearSVCfrom sklearn.datasets import load_digitsfrom sklearn import cross_validationfrom sklearn.linear_model import LogisticRegressionfrom sklearn.pipeline import Pipelinedef test_Pipeline(data):x_train,x_test,y_train,y_test=datasteps=[('linear_svm',LinearSVC(C=1,penalty='l1',dual=False)),('logisticregression',LogisticRegression(C=1))]pipeline=Pipeline(steps)pipeline.fit(x_train,y_train)print('named steps',d_steps)print('pipeline score',pipeline.score(x_test,y_test))if __name__=='__main__':data=load_digits()x=data.datay=data.targettest_Pipeline(cross_validation.train_test_split(x,y,test_size=0.25,random_state=0,stratify=y))以上就是Python进⾏特征提取的⽰例代码的详细内容，更多关于Python 特征提取的资料请关注其它相关⽂章！。
Python技术实现图像特征提取与匹配的方法
Python技术实现图像特征提取与匹配的方法随着科技的不断进步，图像处理技术在各个领域得到了广泛应用。
图像特征提取与匹配是图像处理中的重要环节之一，它能够通过识别图像中的关键特征点，进行图像的检索、识别和对比。
Python作为一门功能强大的编程语言，提供了各种库和工具，可以方便地实现图像特征提取与匹配的方法。
一、图像特征提取图像特征是指在图像中具有独特而稳定的可视化特性，例如边缘、角点、颜色分布等。
图像特征提取的目的就是从图像中找到这些独特的特征点，以便后续的处理和分析。
1. 边缘检测边缘是图像中不同区域之间的分界线，是图像中的显著特征。
Python的OpenCV库提供了Sobel算子、Canny算子等用于边缘检测的函数，可以方便地实现边缘检测的过程。
2. 角点检测角点是图像中具有明显曲率或者弯曲的地方，是图像中的显著特征。
OpenCV 中的Harris角点检测算法和Shi-Tomasi角点检测算法提供了在Python中实现角点检测的函数。
3. SIFT和SURF特征提取SIFT（尺度不变特征变换）和SURF（加速稳健特征）是两种经典的特征提取算法，它们可以提取图像中的局部特征，并具有旋转、尺度不变性。
Python中的OpenCV库提供了SIFT和SURF算法的实现，可以方便地提取图像的特征。
二、图像特征匹配图像特征匹配是将两幅或多幅图像中的特征点进行对齐和匹配。
通过图像特征匹配，可以实现图像的检索、识别和对比，是图像处理中的重要环节。
1. 特征点描述在进行图像特征匹配之前，需要对特征点进行描述。
描述子是一种对特征点进行数学表示的方法，可以用于特征点的匹配和对比。
OpenCV中的SIFT和SURF 算法可以提取特征点的描述子。
2. 特征点匹配特征点匹配是将两个图像中的对应特征点连接起来，实现图像的对齐和匹配。
OpenCV中提供了FLANN（最近邻搜索）库，可以高效地实现特征点的匹配。
同时，还可以使用RANSAC算法进行特征点匹配的筛选和优化。
superglue代码解析
SuperGlue代码解析概述在计算机视觉领域，S u pe rG lu e是一种用于姿态估计和形状匹配的算法。
它采用深度学习方法，通过对输入图像进行特征提取和匹配，实现了精确的姿态估计和有效的形状匹配。
本文将对Su pe rG lu e代码进行解析，介绍其核心原理和实现细节。
目录1.引言2.特征提取3.特征匹配4.姿态估计5.形状匹配6.实验结果7.总结与展望1.引言S u pe rG lu e通过结合深度学习和几何优化方法，实现了精确的姿态估计和形状匹配。
下面将逐步介绍其中的关键技术。
2.特征提取在S up er Gl ue中，使用了神经网络提取图像的特征。
该网络通常是一个预训练好的卷积神经网络（CN N），如R e sN et等。
通过将图像输入网络，可以得到表示图像特征的高维向量。
这些向量可以用于后续的匹配和姿态估计。
3.特征匹配S u pe rG lu e使用了相似性度量来计算两个特征向量之间的相似程度。
常用的相似性度量方法包括余弦相似度、欧氏距离等。
通过比较不同特征向量之间的相似性，S u pe rG lu e能够找到最佳的匹配对。
4.姿态估计姿态估计是S up er Gl u e的核心任务之一。
在特征匹配的基础上，S u pe rG lu e使用了优化算法（如RA NS AC）来估计物体的姿态。
通过最小化重投影误差，S upe r Gl ue能够准确地估计物体的旋转和平移参数。
5.形状匹配除了姿态估计，S upe r Gl ue还能进行形状匹配。
通过在特征空间中寻找相似的特征点，Su p er Gl ue可以对形状进行匹配和对齐。
这对于物体识别和目标跟踪等任务非常有用。
6.实验结果S u pe rG lu e在多个数据集上进行了实验，取得了令人瞩目的结果。
在姿态估计任务中，Su p er Gl ue能够实现高精度的旋转和平移估计。
在形状匹配任务中，S upe r G l ue能够准确地匹配不同形状的物体。
特征提取总结及代码
特征提取代码总结颜色提取颜色直方图提取：C ode:#include<cv.h>#include<highgui.h>#include<iostream>usingnamespace std;int main( int argc, char** argv ){IplImage * src= cvLoadImage("E:\\Download\\test1.jpg",1);IplImage* hsv = cvCreateImage(cvGetSize(src), 8, 3 );IplImage* h_plane = cvCreateImage(cvGetSize(src), 8, 1 );IplImage* s_plane = cvCreateImage(cvGetSize(src), 8, 1 );IplImage* v_plane = cvCreateImage(cvGetSize(src), 8, 1 );IplImage* planes[] = { h_plane, s_plane };/** H 分量划分为16个等级，S分量划分为8个等级*/int h_bins = 16, s_bins = 8;int hist_size[] = {h_bins, s_bins};/** H 分量的变化范围*/float h_ranges[] = { 0, 180 };/** S 分量的变化范围*/float s_ranges[] = { 0, 255 };float* ranges[] = { h_ranges, s_ranges };/** 输入图像转换到HSV颜色空间*/cvCvtColor(src, hsv, CV_BGR2HSV );cvCvtPixToPlane(hsv, h_plane, s_plane, v_plane, 0 );/** 创建直方图，二维, 每个维度上均分*/CvHistogram * hist = cvCreateHist( 2, hist_size, CV_HIST_ARRAY, ranges, 1 ); /** 根据H,S两个平面数据统计直方图*/cvCalcHist( planes, hist, 0, 0 );/** 获取直方图统计的最大值，用于动态显示直方图*/float max_value;cvGetMinMaxHistValue(hist, 0, &max_value, 0, 0 );/** 设置直方图显示图像*/int height = 240;int width = (h_bins*s_bins*6);IplImage* hist_img = cvCreateImage(cvSize(width,height), 8, 3 );cvZero(hist_img );/** 用来进行HSV到RGB颜色转换的临时单位图像*/IplImage * hsv_color = cvCreateImage(cvSize(1,1),8,3);IplImage * rgb_color = cvCreateImage(cvSize(1,1),8,3);int bin_w = width / (h_bins * s_bins);for(int h = 0; h <h_bins; h++){for(int s = 0; s <s_bins; s++){int i = h*s_bins + s;/** 获得直方图中的统计次数，计算显示在图像中的高度*/float bin_val = cvQueryHistValue_2D( hist, h, s );int intensity = cvRound(bin_val*height/max_value);/** 获得当前直方图代表的颜色，转换成RGB用于绘制*/cvSet2D(hsv_color,0,0,cvScalar(h*180.f / h_bins,s*255.f/s_bins,255,0)); cvCvtColor(hsv_color,rgb_color,CV_HSV2BGR);CvScalar color = cvGet2D(rgb_color,0,0);cvRectangle(hist_img, cvPoint(i*bin_w,height),cvPoint((i+1)*bin_w,height - intensity),color, -1, 8, 0 );}}cvNamedWindow("Source", 1 );cvShowImage("Source", src );cvNamedWindow("H-S Histogram", 1 );cvShowImage("H-S Histogram", hist_img );cvWaitKey(0);}运行效果截图：形状提取C andy算子对边缘提取：Code：#include"cv.h"#include"cxcore.h"#include"highgui.h"int main( int argc, char** argv ){//声明IplImage指针IplImage* pImg = NULL;IplImage* pCannyImg = NULL;//载入图像，强制转化为GraypImg = cvLoadImage( "E:\\Download\\test.jpg", 0);//为canny边缘图像申请空间pCannyImg = cvCreateImage(cvGetSize(pImg), IPL_DEPTH_8U, 1); //canny边缘检测cvCanny(pImg, pCannyImg, 50, 150, 3);//创建窗口cvNamedWindow("src", 1);cvNamedWindow("canny",1);//显示图像cvShowImage("src", pImg );cvShowImage("canny", pCannyImg );//等待按键cvWaitKey(0);//销毁窗口cvDestroyWindow("src" );cvDestroyWindow("canny" );//释放图像cvReleaseImage(&pImg );cvReleaseImage(&pCannyImg );return 0;}运行效果截图：角点提取：Code：#include<stdio.h>#include"cv.h"#include"highgui.h"#define MAX_CORNERS 100int main(void){int cornersCount=MAX_CORNERS;//得到的角点数目CvPoint2D32f corners[MAX_CORNERS];//输出角点集合IplImage *srcImage = 0,*grayImage = 0,*corners1 = 0,*corners2 = 0;int i;CvScalar color = CV_RGB(255,0,0);cvNamedWindow("image",1);//Load the image to be processedsrcImage = cvLoadImage("E:\\Download\\1.jpg",1);grayImage = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_8U,1);//copy the source image to copy image after converting the format//复制并转为灰度图像cvCvtColor(srcImage,grayImage,CV_BGR2GRAY);//create empty images os same size as the copied images//两幅临时位浮点图像，cvGoodFeaturesToTrack会用到corners1 = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_32F,1);corners2 = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_32F,1);cvGoodFeaturesToTrack(grayImage,corners1,corners2,corners,&cornersCount,0.05, 30,//角点的最小距离是0,//整个图像3,0,0.4);printf("num corners found: %d\n",cornersCount);//开始画出每个点if (cornersCount>0){for (i=0;i<cornersCount;i++){cvCircle(srcImage,cvPoint((int)(corners[i].x),(int)(corners[i].y)),2,color,2,CV_AA,0);}}cvShowImage("image",srcImage);cvSaveImage("imagedst.png",srcImage);cvReleaseImage(&srcImage);cvReleaseImage(&grayImage);cvReleaseImage(&corners1);cvReleaseImage(&corners2);cvWaitKey(0);return 0;}运行效果截图：H ough直线提取：Code：#include<cv.h>#include<highgui.h>#include<math.h>int main(int argc, char** argv){IplImage* src = cvLoadImage("E:\\Download\\2.jpg" , 0 );IplImage* dst;IplImage* color_dst;CvMemStorage* storage = cvCreateMemStorage(0);CvSeq* lines = 0;int i;if( !src )return -1;dst = cvCreateImage( cvGetSize(src), 8, 1 );color_dst = cvCreateImage(cvGetSize(src), 8, 3 );cvCanny(src, dst, 50, 200, 3 );cvCvtColor(dst, color_dst, CV_GRAY2BGR );#if 0lines = cvHoughLines2( dst, storage, CV_HOUGH_STANDARD, 1, CV_PI/180, 100, 0, 0 );for(i = 0; i< MIN(lines->total,100); i++ ){float* line = (float*)cvGetSeqElem(lines,i);float rho = line[0];float theta = line[1];CvPoint pt1, pt2;double a = cos(theta), b = sin(theta);double x0 = a*rho, y0 = b*rho;pt1.x = cvRound(x0 + 1000*(-b));pt1.y = cvRound(y0 + 1000*(a));pt2.x = cvRound(x0 - 1000*(-b));pt2.y = cvRound(y0 - 1000*(a));cvLine(color_dst, pt1, pt2, CV_RGB(255,0,0), 3, CV_AA, 0 );}#elselines = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 1, CV_PI/180, 50, 50, 10 ); for(i = 0; i< lines->total; i++ ){CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i);cvLine(color_dst, line[0], line[1], CV_RGB(255,0,0), 3, CV_AA, 0 );}#endifcvNamedWindow("Source", 1 );cvShowImage("Source", src );cvNamedWindow("Hough", 1 );cvShowImage("Hough", color_dst );cvWaitKey(0);return 0;}运行效果截图：Hough圆提取：C ode：#include<cv.h>#include<highgui.h>#include<math.h>#include<iostream>usingnamespace std;int main(int argc, char** argv){IplImage* img;img=cvLoadImage("E:\\Download\\3.jpg", 1);IplImage* gray = cvCreateImage(cvGetSize(img), 8, 1 );CvMemStorage* storage = cvCreateMemStorage(0);cvCvtColor(img, gray, CV_BGR2GRAY );cvSmooth( gray, gray, CV_GAUSSIAN, 5, 15 );// smooth it, otherwise a lot of false circles may be detectedCvSeq* circles = cvHoughCircles( gray, storage, CV_HOUGH_GRADIENT, 2, gray->height/4, 200, 1 00 );int i;for(i = 0; i< circles->total; i++ ){float* p = (float*)cvGetSeqElem( circles, i );cvCircle( img, cvPoint(cvRound(p[0]),cvRound(p[1])), 3, CV_RGB(0,255,0), -1, 8, 0 ); cvCircle( img, cvPoint(cvRound(p[0]),cvRound(p[1])), cvRound(p[2]), CV_RGB(255,0,0), 3, 8, 0 );cout<<"圆心坐标x= "<<cvRound(p[0])<<endl<<"圆心坐标y= "<<cvRound(p[1])<<endl;cout<<"半径="<<cvRound(p[2])<<endl;}cout<<"圆数量="<<circles->total<<endl;cvNamedWindow("circles", 1 );cvShowImage("circles", img );cvWaitKey(0);return 0;}运行效果截图：Hough矩形提取：C ode：#include"cv.h"#include"highgui.h"#include<stdio.h>#include<math.h>#include<string.h>int thresh = 50;IplImage* img = 0;IplImage* img0 = 0;CvMemStorage* storage = 0;CvPointpt[4];constchar* wndname = "Square Detection Demo";double angle( CvPoint* pt1, CvPoint* pt2, CvPoint* pt0 ){double dx1 = pt1->x - pt0->x;double dy1 = pt1->y - pt0->y;double dx2 = pt2->x - pt0->x;double dy2 = pt2->y - pt0->y;return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10); }CvSeq* findSquares4(IplImage* img, CvMemStorage* storage ){CvSeq* contours;int i, c, l, N = 11;CvSizesz = cvSize(img->width & -2, img->height & -2 );IplImage* timg = cvCloneImage(img );IplImage* gray = cvCreateImage(sz, 8, 1 );IplImage* pyr = cvCreateImage(cvSize(sz.width/2, sz.height/2), 8, 3 );IplImage* tgray;CvSeq* result;double s, t;CvSeq* squares = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvPoint), storage ); cvSetImageROI(timg, cvRect( 0, 0, sz.width, sz.height ));// down-scale and upscale the image to filter out the noisecvPyrDown(timg, pyr, 7 );cvPyrUp(pyr, timg, 7 );tgray = cvCreateImage( sz, 8, 1 );// find squares in every color plane of the imagefor( c = 0; c < 3; c++ ){cvSetImageCOI(timg, c+1 );cvCopy(timg, tgray, 0 );for( l = 0; l < N; l++ ){if( l == 0 ){cvCanny(tgray, gray, 0, thresh, 5 );cvDilate( gray, gray, 0, 1 );}else{cvThreshold(tgray, gray, (l+1)*255/N, 255, CV_THRESH_BINARY );}cvFindContours( gray, storage, &contours, sizeof(CvContour),CV_RETR_LIST, CV_CHAIN_APPROX_SI MPLE, cvPoint(0,0) );while( contours ){result = cvApproxPoly( contours, sizeof(CvContour), storage,CV_POLY_APPROX_DP, cvContourPerim eter(contours)*0.02, 0 );if( result->total == 4 &&fabs(cvContourArea(result,CV_WHOLE_SEQ)) > 1000 &&cvCheckContour Convexity(result) ){s = 0;for(i = 0; i< 5; i++ ){if(i>= 2 ){t = fabs(angle( (CvPoint*)cvGetSeqElem( result, i ),(CvPoint*)cvGetSeqElem( result, i-2 ),(C vPoint*)cvGetSeqElem( result, i-1 )));s = s >t ?s : t;}}if( s < 0.3 )for(i = 0; i< 4; i++ )cvSeqPush( squares,(CvPoint*)cvGetSeqElem( result, i ));}contours = contours->h_next;}}}cvReleaseImage(&gray );cvReleaseImage(&pyr );cvReleaseImage(&tgray );cvReleaseImage(&timg );return squares;}// the function draws all the squares in the imagevoid drawSquares( IplImage* img, CvSeq* squares ){CvSeqReader reader;IplImage* cpy = cvCloneImage(img );int i;cvStartReadSeq( squares, &reader, 0 );for(i = 0; i< squares->total; i += 4 ){CvPoint* rect = pt;int count = 4;memcpy(pt, reader.ptr, squares->elem_size );CV_NEXT_SEQ_ELEM( squares->elem_size, reader );memcpy(pt + 1, reader.ptr, squares->elem_size );CV_NEXT_SEQ_ELEM( squares->elem_size, reader );memcpy(pt + 2, reader.ptr, squares->elem_size );CV_NEXT_SEQ_ELEM( squares->elem_size, reader );memcpy(pt + 3, reader.ptr, squares->elem_size );CV_NEXT_SEQ_ELEM( squares->elem_size, reader );cvPolyLine(cpy, &rect, &count, 1, 1, CV_RGB(0,255,0), 3, CV_AA, 0 );}cvShowImage(wndname, cpy );cvReleaseImage(&cpy );}void on_trackbar( int a ){if(img )drawSquares(img, findSquares4( img, storage ) );}char* names[] = { "1.jpg", 0 };int main(int argc, char** argv){int i, c;storage = cvCreateMemStorage(0);for(i = 0; names[i] != 0; i++ ){img0 = cvLoadImage( names[i], 1 );if( !img0 ){printf("Couldn't load %s\n", names[i] );continue;}img = cvCloneImage( img0 );cvNamedWindow(wndname, 1 );cvCreateTrackbar("canny thresh", wndname, &thresh, 1000, on_trackbar ); on_trackbar(0);c = cvWaitKey(0);cvReleaseImage(&img );cvReleaseImage(&img0 );cvClearMemStorage( storage );if( c == 27 )break;}cvDestroyWindow(wndname );return 0;}运行效果截图：边缘直方图提取：Code：#include"cv.h"#include"highgui.h"#include<stdio.h>#include<ctype.h>#define PI 3.14int main(){IplImage *src = 0; // source imagreIplImage *histimg = 0; // histogram imageCvHistogram *hist = 0; // define multi_demention histogram IplImage* canny;CvMat* canny_m;IplImage* dx; // the sobel x differenceIplImage* dy; // the sobel y differenceCvMat* gradient; // value of gradientCvMat* gradient_dir; // direction of gradientCvMat* dx_m; // format transform to matrixCvMat* dy_m;CvMat* mask;CvSize size;IplImage* gradient_im;int i,j;float theta;int hdims = 8; // 划分HIST的个数，越高越精确float hranges_arr[] = {-PI/2,PI/2}; // 直方图的上界和下界float* hranges = hranges_arr;float max_val; //int bin_w;src=cvLoadImage("E:\\Download\\test.jpg", 0); // force to gray imageif(src==0) return -1;cvNamedWindow("Histogram", 0 );//cvNamedWindow( "src", 0);size=cvGetSize(src);canny=cvCreateImage(cvGetSize(src),8,1);//边缘图像dx=cvCreateImage(cvGetSize(src),32,1);//x方向上的差分//此处的数据类型为U 不怕溢出吗？dy=cvCreateImage(cvGetSize(src),32,1);gradient_im=cvCreateImage(cvGetSize(src),32,1);//梯度图像canny_m=cvCreateMat(size.height,size.width,CV_32FC1);//边缘矩阵dx_m=cvCreateMat(size.height,size.width,CV_32FC1);dy_m=cvCreateMat(size.height,size.width,CV_32FC1);gradient=cvCreateMat(size.height,size.width,CV_32FC1);//梯度矩阵gradient_dir=cvCreateMat(size.height,size.width,CV_32FC1);//梯度方向矩阵mask=cvCreateMat(size.height,size.width,CV_32FC1);//掩码cvCanny(src,canny,60,180,3);//边缘检测cvConvert(canny,canny_m);//把图像转换为矩阵cvSobel(src,dx,1,0,3);// 一阶X方向的图像差分:dxcvSobel(src,dy,0,1,3);// 一阶Y方向的图像差分:dycvConvert(dx,dx_m);cvConvert(dy,dy_m);cvAdd(dx_m,dy_m,gradient); // value of gradient//梯度不是等于根号下x的导数的平方加上y导数的平方吗？cvDiv(dx_m,dy_m,gradient_dir); // directionfor(i=0;i<size.height;i++)for(j=0;j<size.width;j++){if(cvmGet(canny_m,i,j)!=0 &&cvmGet(dx_m,i,j)!=0)//此行是什么意思？只看边缘上的方向？{theta=cvmGet(gradient_dir,i,j);theta=atan(theta);cvmSet(gradient_dir,i,j,theta);}else{cvmSet(gradient_dir,i,j,0);}}hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 );// 创建一个指定尺寸的直方图，并返回创建的直方图指针histimg = cvCreateImage( cvSize(320,200), 8, 3 ); // 创建一个图像，通道cvZero( histimg ); // 清；cvConvert(gradient_dir,gradient_im);//把梯度方向矩阵转化为图像cvCalcHist( &gradient_im, hist, 0, canny ); // 计算直方图cvGetMinMaxHistValue( hist, 0, &max_val, 0, 0 ); // 只找最大值cvConvertScale(hist->bins, hist->bins, max_val ? 255. / max_val : 0., 0 );// 缩放bin 到区间[0,255] ，比例系数cvZero(histimg );bin_w = histimg->width /16; // hdims: 条的个数，则bin_w 为条的宽度// 画直方图for(i = 0; i<hdims; i++ ){double val = ( cvGetReal1D(hist->bins,i)*histimg->height/255 );// 返回单通道数组的指定元素，返回直方图第i条的大小，val为histimg中的i条的高度CvScalar color = CV_RGB(255,255,0); //(hsv2rgb(i*180.f/hdims);//直方图颜色cvRectangle( histimg, cvPoint(100+i*bin_w,histimg->height),cvPoint(100+(i+1)*bin_w,(int)(his timg->height - val)), color, 1, 8, 0 ); // 画直方图——画矩形，左下角，右上角坐标}cvShowImage("src", src);cvShowImage("Histogram", histimg );cvWaitKey(0);cvDestroyWindow("src");cvDestroyWindow("Histogram");cvReleaseImage(&src );cvReleaseImage(&histimg );cvReleaseHist ( &hist );return 0;}运行效果截图：视频流中边缘检测：Code：#include"highgui.h"#include"cv.h"#include"stdio.h"#include<ctype.h>int main(int argc,char ** argv){IplImage * laplace = 0;IplImage * colorlaplace = 0;IplImage * planes[3] = {0,0,0};CvCapture *capture = 0;//从摄像头读取/*if(argc == 1 ||( argc==2 &&strlen(argv[1])==1 &&isdigit(argv[1][0]) ))capture = cvCaptureFromCAM(argc == 2 ? argv[1][0] -'0':0);*///从文件中读取/* else if(argc == 2)*/capture = cvCaptureFromAVI("1.avi");if(!capture){fprintf(stderr,"Could not initialize capturing...\n");return -1;}cvNamedWindow("Laplacian",1);cvNamedWindow("video",1);//循环捕捉，直到用户按键跳出循环体for(;;){IplImage * frame =0; //抓起一祯frame = cvQueryFrame(capture);if(!frame)break;if(!laplace){//创建图像for(int i=0;i<3;i++)planes[i] = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);laplace = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_16S,1);colorlaplace=cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,3);}cvCvtPixToPlane(frame,planes[0],planes[1],planes[2],0);for(int i=0;i<3;i++){//交换，如通道变换cvLaplace(planes[i],laplace,3);//使用线性变换转换输入函数元素成为无符号整形cvConvertScaleAbs(laplace,planes[i],1,0);}cvCvtPlaneToPix(planes[0],planes[1],planes[2],0,colorlaplace); //结构相同（- 顶—左结构,1 - 底—左结构）colorlaplace->origin = frame->origin;//高斯滤波，平滑图像// cvSmooth(colorlaplace, colorlaplace, CV_GAUSSIAN, 1, 0, 0); //形态学滤波,闭运算cvDilate(colorlaplace, colorlaplace, 0, 1);//膨胀cvErode(colorlaplace, colorlaplace, 0, 1);//腐蚀cvShowImage("video", frame);cvShowImage("Laplacian",colorlaplace);if(cvWaitKey(10)>0)break;}cvReleaseCapture(&capture);cvDestroyWindow("Laplacian");cvDestroyWindow("video");return 0;}运行效果截图：纹理提取：Code：#include<iostream>#include<math.h>#include"cv.h"#include"highgui.h"int main(int argc, char* argv[])int tmp[8]={0};int sum=0;int k=0;IplImage* img,*dst;img=cvLoadImage("E:\\Download\\2.jpg",0);CvScalar s;cvNamedWindow("img",NULL);cvNamedWindow("dst",NULL);cvShowImage("img",img);uchar* data=(uchar*)img->imageData;int step=img->widthStep;dst=cvCreateImage(cvSize(img->width,img->height),img->depth,1);dst->widthStep=img->widthStep;for(int i=1;i<img->height-1;i++)for(int j=1;j<img->width-1;j++){if(data[(i-1)*step+j-1]>data[i*step+j]) tmp[0]=1;else tmp[0]=0;if(data[i*step+(j-1)]>data[i*step+j]) tmp[1]=1;else tmp[1]=0;if(data[(i+1)*step+(j-1)]>data[i*step+j]) tmp[2]=1;else tmp[2]=0;if (data[(i+1)*step+j]>data[i*step+j]) tmp[3]=1;else tmp[3]=0;if (data[(i+1)*step+(j+1)]>data[i*step+j]) tmp[4]=1;else tmp[4]=0;if(data[i*step+(j+1)]>data[i*step+j]) tmp[5]=1;else tmp[5]=0;if(data[(i-1)*step+(j+1)]>data[i*step+j]) tmp[6]=1;else tmp[6]=0;if(data[(i-1)*step+j]>data[i*step+j]) tmp[7]=1;else tmp[7]=0;for(k=0;k<=7;k++)sum+=abs(tmp[k]-tmp[k+1]);sum=sum+abs(tmp[7]-tmp[0]);if (sum<=2)s.val[0]=(tmp[0]*128+tmp[1]*64+tmp[2]*32+tmp[3]*16+tmp[4]*8+tmp[5]*4+tmp[6]*2+tmp[7]);else s.val[0]=59;cvSet2D(dst,i,j,s);}cvShowImage("dst",dst);cvWaitKey(-1);return 0;运行效果截图：。
matlab特征提取代码（Matlabfeatureextractioncode）
matlab特征提取代码（Matlab feature extraction code）我= 1:26F = strcat（想：\ bishe \”，num2str（我））；图像= strcat（F，“.jpg”）；PS = imread（图像）；PS = imresize（PS，[ 300300 ]，'bilinear’）；%归一化大小PS = rgb2gray（PS）；[ M ]，N =大小（PS）；%测量图像尺寸参数GP =零（1256）；%预创建存放灰度出现概率的向量K = 0:255GP（K + 1）=长度（找到（PS = = k））/（m×n）；%计算每级灰度出现的概率，将其存入GP中相应位置结束%直方图均衡化S1 =零（1256）；我为1:256J = 1：我S1（我）= GP（J）+ S1（我）；%计算SK结束结束S2 =圆（（S1×256）+ 0.5）；%将SK归到相近级的灰度%图像均衡化F＝PS；我= 0:255F（找到（PS = =我））= S2（i + 1）；%将各个像素归一化后的灰度值赋给这个像素结束图，imshow（f）；%边缘检测F =边缘（F，'canny '，0.25）；imshow（f）；%二值法锐化图像F =双（F）；【X，Y ] =梯度（F）；G = SQRT（X * X + Y Y）；我发现（G＞＝0.5）；G（我）= 256；J =找到（g＜0.5）；G（j）= 0；imshow（G）；标题（“二值法锐化图像”）；%中值滤波G = medfilt2（G）；G =抖动（G）；imshow（G）；%提取面积，矩形度，圆形度，拉伸度特征% G = im2bw（G）；【X，Y ] =大小（G）；BW = bwperim（G，8）；%检测边缘跟踪，用于计算周长检测垂直方向连读的周长像素点% %P1 = 0；P2 = 0；纽约= 0；%记录垂直方向连续周长像素点的个数我= 1 xJ = 1：Y如果（BW（i，j）> 0）P2 = J；如果（（p2-p1）= = 1）%判断是否为垂直方向连续的周长像素点纽约纽约+ 1；结束P1 = P2；结束结束结束%检测水平方向连读的周长像素点P1 = 0；P2 = 0；NX = 0；%记录水平方向连续周长像素点的个数J = 1：Y我= 1 x如果（BW（i，j）> 0）P2 =我；如果（（p2-p1）= = 1）%判断是否为水平方向连续的周长像素点NX = NX + 1；结束P1 = P2；结束结束结束Sn =金额（金额（BW））；%计算周长像素点的总数ND = Sn NX纽约；%计算奇数码的链码数目H=max (sum (g));% calculated the target heightW=max (sum (G')); g% by image matrix transpose, calculating widthL=sqrt (2) *Nd+Nx+Ny%; calculate the perimeter%==== form eigenvalue calculation ===%A=bwarea (g);% calculated the target areaR=A/ (H*W);% rectangular degreeE=min (H, W) /max (H, W);% calculated lengthTemp1=[A, R, E];% extraction of invariant feature[M, N]=size (g);[x, y]=meshgrid (1:N, 1:M);X=x (:);Y=y (:);G=g (:);M.m00=sum (g);If (m.m00==0)M.m00=eps;EndM.m10=sum (x.*g);M.m01=sum (y.*g);M.m11=sum (x.*y.*g); M.m20=sum (x.^2.*g); M.m02=sum (y.^2.*g); M.m30=sum (x.^3.*g); M.m03=sum (y.^3.*g); M.m12=sum (x.*y.^2.*g); M.m21=sum (x.^2.*y.*g); Xbar=m.m10/m.m00;Ybar=m.m01/m.m00;E.eta11= (m.m11-ybar*m.m10) /m.m00^2;E.eta20= (m.m20-xbar*m.m10) /m.m00^2;E.eta02= (m.m02-ybar*m.m01) /m.m00^2;E.eta30= (m.m30-3*xbar*m.m20+2*xbar^2*m.m10) /m.m00^2.5;E.eta03= (m.m03-3*ybar*m.m02+2*ybar^2*m.m01) /m.m00^2.5;E.eta21= (m.m21-2*xbar*m.m11-ybar*m.m20+2*xbar^2*m.m01) /m.m00^2.5;E.eta12= (m.m12-2*ybar*m.m11-xbar*m.m02+2*ybar^2*m.m10) /m.m00^2.5;Phi (1) =e.eta20+e.eta02;Phi (2) = (e.eta20-e.eta02) ^2+4*e.eta11^2;Phi (3) = (e.eta30-3*e.eta12) ^2+ (3*e.eta21-e.eta03) ^2;Phi (4) = (e.eta30+e.eta12) ^2+ (e.eta21+e.eta03) ^2;Phi (5) = (e.eta30-3*e.eta12) * (e.eta30+e.eta12) * ((e.eta30+e.eta12) ^2-3* (e.eta21+e.eta03) ^2+(3*e.eta21-e.eta03) * (e.eta21+e.eta03) * (3*(e.eta30+e.eta12) ^2- (e.eta21+e.eta03) ^2));Phi (6) = (e.eta20-e.eta02) * ((e.eta30+e.eta12) ^2-(e.eta21+e.eta03) ^2) +4*e.eta11* (e.eta30+e.eta12) *(e.eta21+e.eta03);Phi (7) = (3*e.eta21-e.eta03) * (e.eta30+e.eta12) *((e.eta30+e.eta12) ^2-3* (e.eta21+e.eta03) ^2) +(3*e.eta12-e.eta30) * (e.eta21+e.eta03) * (3*(e.eta30+e.eta12) ^2- (e.eta21+e.eta03) ^2);Temp2 = ABS (log (PHI));% contains seven characteristic values Temp=[temp1, temp2]End。
OPENCV特征提取代码总结
OPENCV特征提取代码总结OpenCV是一个计算机视觉库，提供了许多用于图像处理和计算机视觉任务的函数和算法。
其中特征提取是OpenCV中一个非常重要的功能，它可以从图像中提取出能够表达图像特征的向量。
下面是几个常见的特征提取方法的代码总结。
1. Harris角点检测算法代码Harris角点检测算法是一种常用的角点检测算法，可以检测图像中的角点。
它的代码如下：```import cv2import numpy as npdef harris_corner_detector(image):gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)#计算图像的梯度dx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)dy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)# 计算Harris角点响应函数dx2 = cv2.multiply(dx, dx)dy2 = cv2.multiply(dy, dy)dxy = cv2.multiply(dx, dy)k=0.04det = cv2.subtract(cv2.multiply(dx2, dy2), cv2.multiply(dxy, dxy))trace = cv2.add(dx2, dy2)response = cv2.divide(det, trace + k)#寻找响应值大于阈值的角点corners = []threshold = 0.01for i in range(response.shape[0]):for j in range(response.shape[1]):if response[i, j] > threshold:corners.append(cv2.KeyPoint(j, i, 1, -1, response[i, j]))return corners# 调用Harris角点检测算法image = cv2.imread('image.jpg')corners = harris_corner_detector(image)#在图片上绘制出检测到的角点cv2.drawKeypoints(image, corners, image)cv2.imshow('image', image)cv2.waitKey(0)cv2.destroyAllWindows```2.SIFT特征提取算法代码SIFT(Scale-Invariant Feature Transform)是一种尺度不变的特征提取算法，可以提取出图像的关键点和对应的描述子。
特征提取模型代码
特征提取模型代码特征提取是机器学习中非常重要的一个环节，通常特征提取模型代码是实现特征提取的核心代码。
在本文中，我们将分步骤地讨论特征提取模型代码，以便更好地理解这个过程。
1. 导入必要的库在开始编写特征提取代码之前，我们需要导入一些必要的库。
根据不同的任务和需要，导入的库可能有所不同。
但是，通常情况下，我们需要导入numpy、pandas、scikit-learn等库。
```pythonimport numpy as npimport pandas as pdfrom sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer```2. 加载数据特征提取的第一步是加载数据。
在加载数据时，我们需要指定文件路径或URL或者其他可以获取数据的方式。
然后，将数据转换为特定格式的数据框或张量，以便在后续步骤中使用。
```pythondata = pd.read_csv("data.csv")X = data["text"].valuesy = data["label"].values```3. 特征提取特征提取是特征工程的核心步骤之一。
它的主要目的是从原始数据中提取有意义的特征。
这些特征可以是文本中的单词或短语、图像中的纹理或颜色、声音中的频率模式等。
下面是在文本数据上使用CountVectorizer和TfidfVectorizer进行特征提取的示例代码。
```python# CountVectorizercv = CountVectorizer()X_cv = cv.fit_transform(X)# TfidfVectorizertfidf = TfidfVectorizer()X_tfidf = tfidf.fit_transform(X)```4. 特征选择在进行特征提取之后，我们需要对提取出的特征进行选择。
Python中的数据清洗和特征提取实战案例
Python中的数据清洗和特征提取实战案例数据清洗和特征提取是数据分析和机器学习中不可或缺的步骤。
Python提供了丰富的库和工具，使得数据清洗和特征提取变得更加高效和方便。
在本文中，我们将介绍一些实战案例，展示如何使用Python进行数据清洗和特征提取的操作。
一、数据清洗数据清洗是指对原始数据进行处理，以去除重复值、处理缺失值、处理异常值等操作，以保证数据的质量和准确性。
1.去除重复值在数据集中，重复值可能对分析结果产生误导。
我们可以使用Pandas库提供的drop_duplicates()函数来去除重复值。
下面是一个简单的示例：```pythonimport pandas as pddata = pd.read_csv('data.csv')data = data.drop_duplicates()```2.处理缺失值缺失值是数据分析中常见的问题，我们需要处理这些缺失值以保证分析的准确性。
Pandas库提供了fillna()函数来填充缺失值。
下面是一个示例：```pythonimport pandas as pddata = pd.read_csv('data.csv')data = data.fillna(0) # 用0填充缺失值```3.处理异常值异常值可能会对我们的分析结果产生不良影响。
我们可以使用一些统计方法，如Z-score、箱线图等来检测和处理异常值。
下面是一个使用Z-score方法处理异常值的示例：```pythonimport pandas as pdfrom scipy import statsdata = pd.read_csv('data.csv')data['z_score'] = stats.zscore(data['column_name'])data = data[(data['z_score'] < 3) & (data['z_score'] > -3)] # 去除3倍标准差之外的值```二、特征提取特征提取是从原始数据中提取有用信息的过程。
matlab sift特征提取代码
一、介绍SIFT特征提取算法SIFT（Scale-Invariant Feature Transform）是一种用于图像处理和计算机视觉领域的特征提取算法，由David Lowe在1999年提出。
SIFT算法能够在不同尺度、旋转和光照条件下检测和描述图像中的关键特征点。
二、SIFT特征提取的原理1. 尺度空间极值检测SIFT算法首先通过高斯滤波器构建图像的尺度空间金字塔，在不同尺度上检测图像中的极值点，用于定位关键特征点。
2. 关键点定位在尺度空间金字塔上定位极值点，并通过尺度空间的拟合插值定位关键点的位置和尺度。
3. 方向确定对关键点周围的梯度方向进行统计，选择主要梯度方向作为关键点的方向。
4. 关键点描述基于关键点周围的梯度幅值和方向构建特征向量，用于描述关键点的外观特征。
三、MATLAB实现SIFT特征提取代码MATLAB提供了丰富的图像处理工具包，其中也包括对SIFT算法的支持。
下面给出MATLAB实现SIFT特征提取的简单示例代码：```matlab读入图像I = imread('image.jpg');I = single(rgb2gray(I));提取SIFT特征点[f, d] = vl_sift(I);显示特征点imshow(I);h1 = vl_plotframe(f);h2 = vl_plotsiftdescriptor(d, f);set(h1,'color','k','linewidth',3);set(h2,'color','g')；```上述代码中，首先使用`imread`读入一张图像，并将其转化为灰度图像。
然后使用`vl_sift`函数提取图像中的SIFT特征点，其中`f`为特征点的位置和尺度，`d`为特征点的描述子。
最后使用`vl_plotframe`和`vl_plotsiftdescriptor`函数将特征点和特征描述子可视化出来。