Java 我想删除输入图像和匹配线，添加一条线来显示边框的中心

我在android studio 2.3.1中工作

我想删除输入图像和匹配线，添加一条线来显示边框的中心

基于OpenCV的目标跟踪

我有核心java

public类MainActivity扩展活动实现CameraBridgeViewBase.CvCameraViewListener2{
私有静态最终字符串TAG=“OCVSample:：Activity”；
私人int w，h；
私人摄像机BridgeViewBase mOpenCvCameraView；
标量红色=新标量（255,0,0）；
标量绿色=新标量（0，255，0）；
特征检测器；
描述子描述子；
描述符匹配器；
Mat描述符2，描述符1；
Mat-img1；
MatOfKeyPoint关键点1、关键点2；
静止的{
如果（！OpenCVLoader.initDebug（））
Log.d（“错误”，“无法加载OpenCV”）；
其他的
Log.d（“成功”，“加载OpenCV”）；
}
专用BaseLoaderCallback mlLoaderCallback=新BaseLoaderCallback（此）{
@凌驾
已连接管理器上的公共无效（int状态）{
开关（状态）{
案例加载程序CallbackInterface.SUCCESS：{
Log.i（标记“OpenCV已成功加载”）；
mOpenCvCameraView.enableView（）；
试一试{
initializeOpenCVDependencies（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
打破
默认值：{
超级管理器已连接（状态）；
}
打破
}
}
};
private void initializeOpenCVDependencies（）引发IOException{
mOpenCvCameraView.enableView（）；
检测器=FeatureDetector.create（FeatureDetector.FAST）；
descriptor=DescriptorExtractor.create（DescriptorExtractor.ORB）；
matcher=DescriptorMatcher.create（DescriptorMatcher.BRUTEFORCE_HAMMING）；
img1=新垫（）；
AssetManager AssetManager=getAssets（）；
InputStream istr=assetManager.open（“test.png”）；
位图位图=位图工厂.decodeStream（istr）；
位图编辑器（位图，img1）；
Imgproc.cvt颜色（img1、img1、Imgproc.COLOR_rgb2灰色）；
convertTo（img1，0）；//将图像转换为与相机图像类型匹配
描述符1=新材料（）；
keypoints1=新的MatOfKeyPoint（）；
检测器。检测（img1，关键点1）；
compute（img1，keypoints1，描述符1）；
}
公共活动（）{
Log.i（标记“实例化新”+this.getClass（））；
}
@凌驾
创建时的公共void（Bundle savedInstanceState）{
Log.i（标记“calledoncreate”）；
super.onCreate（savedInstanceState）；
getWindow（）.addFlags（WindowManager.LayoutParams.FLAG\u保持屏幕打开）；
setContentView（R.layout.activity_main）；
mOpenCvCameraView=（CameraBridgeViewBase）findViewById（R.id.tutorial1\u活动\u java\u曲面\u视图）；
mOpenCvCameraView.setVisibility（SurfaceView.VISIBLE）；
mOpenCvCameraView.setCvCameraViewListener（本）；
}
@凌驾
公共无效暂停（）{
super.onPause（）；
if（mOpenCvCameraView！=null）
mOpenCvCameraView.disableView（）；
}
@凌驾
恢复时公开作废（）{
super.onResume（）；
如果（！OpenCVLoader.initDebug（））{
d（标记“找不到内部OpenCV库。使用OpenCV管理器进行初始化”）；
initAsync（OpenCVLoader.OPENCV_VERSION_3_1_0，this，mLoaderCallback）；
}否则{
d（标记“在包中找到OpenCV库。正在使用它！”）；
mLoaderCallback.onManagerConnected（LoaderCallbackInterface.SUCCESS）；
}
}
公共空间{
super.ondestory（）；
if（mOpenCvCameraView！=null）
mOpenCvCameraView.disableView（）；
}
开始时的公共空隙（整数宽度、整数高度）{
w=宽度；
h=高度；
}
CAMERAVIEWSTOPPED（）上的公共空白{
}
公共Mat识别（Mat aInputFrame）{
Imgproc.cvt颜色（aInputFrame、aInputFrame、Imgproc.COLOR\u rgb2灰色）；
描述符2=新材料（）；
keypoints2=新的MatOfKeyPoint（）；
检测器。检测（输入帧，关键点2）；
descriptor.compute（aInputFrame，keypoints2，descriptors2）；
//匹配
MatOfDMatch matches=新的MatOfDMatch（）；
if（img1.type（）==aInputFrame.type（））{
匹配（描述符1，描述符2，匹配）；
}否则{
返回帧；
}
List matchesList=matches.toList（）；
双最大距离=0.0；
双最小距离=100.0；
对于（int i=0；i最大距离）
最大距离=距离；
}
LinkedList good_matches=新建LinkedList（）；
对于（int i=0；iif（matchesList.get）（i）.distance欢迎使用StackOverflow。您需要提供更多信息，了解您所说的
我想要框定所需对象的意思。
。您转储了一些代码并提供了指向图像的链接这一事实无助于定义您的问题。请编辑您的问题并改进对您试图实现的目标的描述。Helppppme plsss
public class MainActivity extends Activity implements CameraBridgeViewBase.CvCameraViewListener2 {

private static final String TAG = "OCVSample::Activity";
private int w, h;
private CameraBridgeViewBase mOpenCvCameraView;
Scalar RED = new Scalar(255, 0, 0);
Scalar GREEN = new Scalar(0, 255, 0);
FeatureDetector detector;
DescriptorExtractor descriptor;
DescriptorMatcher matcher;
Mat descriptors2,descriptors1;
Mat img1;
MatOfKeyPoint keypoints1,keypoints2;

static {
    if (!OpenCVLoader.initDebug())
        Log.d("ERROR", "Unable to load OpenCV");
    else
        Log.d("SUCCESS", "OpenCV loaded");
}

private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
    @Override
    public void onManagerConnected(int status) {
        switch (status) {
            case LoaderCallbackInterface.SUCCESS: {
                Log.i(TAG, "OpenCV loaded successfully");
                mOpenCvCameraView.enableView();
                try {
                    initializeOpenCVDependencies();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            break;
            default: {
                super.onManagerConnected(status);
            }
            break;
        }
    }
};

private void initializeOpenCVDependencies() throws IOException {
    mOpenCvCameraView.enableView();
    detector = FeatureDetector.create(FeatureDetector.FAST);
    descriptor = DescriptorExtractor.create(DescriptorExtractor.ORB);
    matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
    img1 = new Mat();
    AssetManager assetManager = getAssets();
    InputStream istr = assetManager.open("test.png");
    Bitmap bitmap = BitmapFactory.decodeStream(istr);
    Utils.bitmapToMat(bitmap, img1);
    Imgproc.cvtColor(img1, img1, Imgproc.COLOR_RGB2GRAY);
    img1.convertTo(img1, 0); //converting the image to match with the type of the cameras image
    descriptors1 = new Mat();
    keypoints1 = new MatOfKeyPoint();
    detector.detect(img1, keypoints1);
    descriptor.compute(img1, keypoints1, descriptors1);

}


public MainActivity() {

    Log.i(TAG, "Instantiated new " + this.getClass());
}

@Override
public void onCreate(Bundle savedInstanceState) {

    Log.i(TAG, "called onCreate");
    super.onCreate(savedInstanceState);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    setContentView(R.layout.activity_main);
    mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.tutorial1_activity_java_surface_view);
    mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
    mOpenCvCameraView.setCvCameraViewListener(this);

}

@Override
public void onPause() {
    super.onPause();
    if (mOpenCvCameraView != null)
        mOpenCvCameraView.disableView();
}

@Override
public void onResume() {
    super.onResume();
    if (!OpenCVLoader.initDebug()) {
        Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_1_0, this, mLoaderCallback);
    } else {
        Log.d(TAG, "OpenCV library found inside package. Using it!");
        mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
    }
}

public void onDestroy() {
    super.onDestroy();
    if (mOpenCvCameraView != null)
        mOpenCvCameraView.disableView();
}

public void onCameraViewStarted(int width, int height) {
    w = width;
    h = height;
}

public void onCameraViewStopped() {
}

public Mat recognize(Mat aInputFrame) {

    Imgproc.cvtColor(aInputFrame, aInputFrame, Imgproc.COLOR_RGB2GRAY);
    descriptors2 = new Mat();
    keypoints2 = new MatOfKeyPoint();
    detector.detect(aInputFrame, keypoints2);
    descriptor.compute(aInputFrame, keypoints2, descriptors2);

    // Matching
    MatOfDMatch matches = new MatOfDMatch();
    if (img1.type() == aInputFrame.type()) {
        matcher.match(descriptors1, descriptors2, matches);
    } else {
        return aInputFrame;
    }
    List<DMatch> matchesList = matches.toList();

    Double max_dist = 0.0;
    Double min_dist = 100.0;

    for (int i = 0; i < matchesList.size(); i++) {
        Double dist = (double) matchesList.get(i).distance;
        if (dist < min_dist)
            min_dist = dist;
        if (dist > max_dist)
            max_dist = dist;
    }

    LinkedList<DMatch> good_matches = new LinkedList<DMatch>();
    for (int i = 0; i < matchesList.size(); i++) {
        if (matchesList.get(i).distance <= (1.5 * min_dist))
            good_matches.addLast(matchesList.get(i));
    }

    MatOfDMatch goodMatches = new MatOfDMatch();
    goodMatches.fromList(good_matches);
    Mat outputImg = new Mat();
    MatOfByte drawnMatches = new MatOfByte();
    if (aInputFrame.empty() || aInputFrame.cols() < 1 || aInputFrame.rows() < 1) {
        return aInputFrame;
    }
    Features2d.drawMatches(img1, keypoints1, aInputFrame, keypoints2, goodMatches, outputImg, GREEN, RED, drawnMatches,Features2d.NOT_DRAW_SINGLE_POINTS);
    Imgproc.resize(outputImg, outputImg, aInputFrame.size());

    return outputImg;
}

public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
    return recognize(inputFrame.rgba());

    }
}