Java DescriptorExtractor.create方法代码示例

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
public KMeansMatcher()
{
	model = null;
	featureDetector = FeatureDetector.create(FeatureDetector.PYRAMID_ORB);
	descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
	matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_SL2);
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
public ExtractPath() {
    super();

    mKeyPointsPrev = new MatOfKeyPoint();
    // set up feature detection
    try {
        mFeatureDectector = FeatureDetector.create(FeatureDetector.FAST);
    } catch (UnsatisfiedLinkError err) {
        Log.e(TAG, "Feature detector failed with");
        err.printStackTrace();
    }
    // set up description detection
    mDescExtractor = DescriptorExtractor.create(DescriptorExtractor.BRISK);
    mDescMatcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);

    mPrevFrame = new Mat();
    prevKeyPoints = new MatOfKeyPoint();
    RGBFrame = new Mat();
    mForeGroundMask = new Mat();
    mContours = new ArrayList<MatOfPoint>();
    //creates a new BackgroundSubtractorMOG class with the arguments
    mBackgroundSub = Video.createBackgroundSubtractorMOG2(50, 0, true);
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
/**
 * Calculates descriptors as defined by detectorType and 
 * descriptorType provided at construction for the provided image
 * @param input
 * @return
 * @throws IOException
 */
private Mat calculateDescriptors(byte[] buffer) throws IOException{
	MatOfByte mob = new MatOfByte(buffer);
	Mat image = Highgui.imdecode(mob, Highgui.CV_LOAD_IMAGE_ANYCOLOR);
	
	FeatureDetector siftDetector = FeatureDetector.create(detectorType);
	MatOfKeyPoint mokp = new MatOfKeyPoint();
	siftDetector.detect(image, mokp);
	
	Mat descriptors = new Mat();
	DescriptorExtractor extractor = DescriptorExtractor.create(descriptorType);
	extractor.compute(image, mokp, descriptors);
	return descriptors;
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
@Override
public void onManagerConnected(int status) {
    switch (status) {
        case LoaderCallbackInterface.SUCCESS:
            try {
                target = Utils.loadResource(MyActivity.this, R.raw.f1, Highgui.CV_LOAD_IMAGE_COLOR);
                detector = FeatureDetector.create(FeatureDetector.ORB);
                extractor = DescriptorExtractor.create(DescriptorExtractor.ORB);

                MatOfKeyPoint keyPoint = new MatOfKeyPoint();
                Mat descriptors = new Mat();

                long time = System.currentTimeMillis();
                detector.detect(target, keyPoint);
                extractor.compute(target, keyPoint, descriptors);
                Log.d("opencv", "计算关键点耗时（毫秒）: " + (System.currentTimeMillis() - time) +
                        ", 关键点总数: " + keyPoint.toArray().length);

                for (KeyPoint k : keyPoint.toArray()) {
                    Core.circle(target, k.pt, 5, new Scalar(255, 0, 0));
                }

                Mat tmp = new Mat(target.cols(), target.rows(), CvType.CV_8U, new Scalar(4));
                Bitmap image = Bitmap.createBitmap(target.cols(), target.rows(), Bitmap.Config.ARGB_8888);
                Imgproc.cvtColor(target, tmp, Imgproc.COLOR_RGB2BGRA, 4);
                Utils.matToBitmap(tmp, image);
                myImageView.setImageBitmap(image);

            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            break;
        default:
            super.onManagerConnected(status);
    }
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
private Mat detectMinutiae(Mat skeleton, int border) {
    HashSet<Minutiae> minutiaeSet = new HashSet<>();
    System.out.println("Detecting minutiae");
    for(int c = border; c<skeleton.cols()-border; c++){
        for(int r = border; r<skeleton.rows()-border; r++) {
            double point = skeleton.get(r, c)[0];
            if (point != 0) {  // Not black
                int cn = neighbourCount(skeleton, r, c);

                if(cn == 1)
                    minutiaeSet.add(new Minutiae(c, r, Minutiae.Type.RIDGEENDING));
                else if(cn == 3)
                    minutiaeSet.add(new Minutiae(c, r, Minutiae.Type.BIFURCATION));
            }
        }
    }

    System.out.println("filtering minutiae");
    HashSet<Minutiae> filteredMinutiae = filterMinutiae(minutiaeSet, skeleton);
    System.out.println("number of minutiae: " + filteredMinutiae.size());
    Mat result = new Mat();
    System.out.println("Drawing minutiae");
    Imgproc.cvtColor(skeleton, result, Imgproc.COLOR_GRAY2RGB);
    double[] red = {255, 0, 0};
    double[] green = {0, 255, 0};
    for (Minutiae m : filteredMinutiae) {
        double [] color;
        if (m.type == Minutiae.Type.BIFURCATION) color = green;
        else color = red;
        result.put(m.y, m.x  , color);
        result.put(m.y, m.x-1, color);
        result.put(m.y, m.x+1, color);
        result.put(m.y-1, m.x  , color);
        result.put(m.y+1, m.x  , color);
    }
    MatOfKeyPoint keypoints = new MatOfKeyPoint();
    keypoints.fromArray(minutiaeToKeyPoints(skeleton, filteredMinutiae));
    keypointsField = keypoints;
    DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.ORB);
    Mat descriptors = new Mat();
    extractor.compute(skeleton, keypoints, descriptors);
    descriptorsField = descriptors;
    return result;
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
@NonNull
private Mat detectFeatures(Mat skeleton, Mat edges) {
    FeatureDetector star = FeatureDetector.create(FeatureDetector.ORB);
    DescriptorExtractor brief = DescriptorExtractor.create(DescriptorExtractor.ORB);

    MatOfKeyPoint keypoints = new MatOfKeyPoint();
    star.detect(skeleton, keypoints);
    keypointsField = keypoints;

    KeyPoint[] keypointArray = keypoints.toArray();
    ArrayList<KeyPoint> filteredKeypointArray = new ArrayList<>(keypointArray.length);

    int filterCount = 0;
    for (KeyPoint k : keypointArray) {
        if (edges.get((int)k.pt.y, (int)k.pt.x)[0] <= 0.0) {
            k.size /= 8;
            filteredKeypointArray.add(k);
        } else {
            filterCount++;
        }
    }
    Log.d(TAG, String.format("Filtered %s Keypoints", filterCount));

    keypoints.fromList(filteredKeypointArray);

    Mat descriptors = new Mat();
    brief.compute(skeleton, keypoints, descriptors);
    descriptorsField = descriptors;

    Mat results = new Mat();
    Scalar color = new Scalar(255, 0, 0); // RGB
    Features2d.drawKeypoints(skeleton, keypoints, results, color, Features2d.DRAW_RICH_KEYPOINTS);
    return results;
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
/**
 * Instantiate an object detector based on the FAST, BRIEF, and BRUTEFORCE_HAMMING algorithms
 */
public ObjectDetection() {
    detector = FeatureDetector.create(FeatureDetectorType.FAST.val());
    extractor = DescriptorExtractor.create(DescriptorExtractorType.BRIEF.val());
    matcher = DescriptorMatcher.create(DescriptorMatcherType.BRUTEFORCE_HAMMING.val());
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
private void initializeOpenCVDependencies() throws IOException {
    mOpenCvCameraView.enableView();
    detector = FeatureDetector.create(FeatureDetector.ORB);
    descriptor = DescriptorExtractor.create(DescriptorExtractor.ORB);
    matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
    img1 = new Mat();
    AssetManager assetManager = getAssets();
    InputStream istr = assetManager.open("a.jpeg");
    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);

}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
@Override
public void surfaceCreated(SurfaceHolder holder) {
    matches = new MatOfDMatch();
    orbDetector = FeatureDetector.create(FeatureDetector.ORB);
    orbDescriptor = DescriptorExtractor.create(DescriptorExtractor.ORB);
    kp2 = new MatOfKeyPoint();
    desc2 = new Mat();
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
public ImageDetector(int detector_type, int extractor_type, int matcher_type)
{
	fDetector = FeatureDetector.create
			(detector_type);
	dExtractor = DescriptorExtractor.create
			(extractor_type);
	dMatcher= DescriptorMatcher.create
			(matcher_type);
	training_library= new ArrayList<TrainingImage>();
	
	// Specific values selected after experimenting with different data sets
	max_side = 300;
	filter_ratio = 5;
	distance_bound = 50;
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
private void testMatSerialization(){
	File storage = Environment.getExternalStorageDirectory();
	String path = storage.getAbsolutePath()+"/opencv/file.bin";
	
	FeatureDetector detector = FeatureDetector.create(FeatureDetector.GRID_ORB);
	DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.ORB);
	
	MatOfKeyPoint kpts = new MatOfKeyPoint();
	detector.detect(mRgba, kpts);
	
	Mat descriptors = new Mat();
	extractor.compute(mGray, kpts, descriptors);
	
	Log.d(TAG, "test - descriptors "+descriptors);			
			
	UtilsOpenCV.matToJson(descriptors);
	
	//UtilsOpenCV.matStore(path, descriptors);
	
	// UtilsOpenCV.matRetrieve(path, rows, cols, type);
	
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
@Override
public List<CVParticle> execute(CVParticle particle) throws Exception {
	List<CVParticle> result = new ArrayList<CVParticle>();
	if(!(particle instanceof Frame)) return result;
	
	Frame frame = (Frame)particle;
	if(frame.getImageType().equals(Frame.NO_IMAGE)) return result;
	try{
		MatOfByte mob = new MatOfByte(frame.getImageBytes());
		Mat image = Highgui.imdecode(mob, Highgui.CV_LOAD_IMAGE_ANYCOLOR);
		
		FeatureDetector siftDetector = FeatureDetector.create(detectorType);
		MatOfKeyPoint mokp = new MatOfKeyPoint();
		siftDetector.detect(image, mokp);
		List<KeyPoint> keypoints = mokp.toList();
		
		Mat descriptors = new Mat();
		DescriptorExtractor extractor = DescriptorExtractor.create(descriptorType);
		extractor.compute(image, mokp, descriptors);
		List<Descriptor> descrList = new ArrayList<Descriptor>();
		float[] tmp = new float[1];
		for(int r=0; r<descriptors.rows(); r++){
			float[] values = new float[descriptors.cols()];
			for(int c=0; c<descriptors.cols(); c++){
				descriptors.get(r, c, tmp);
				values[c] = tmp[0];
			}
			descrList.add(new Descriptor(frame.getStreamId(), frame.getSequenceNr(), new Rectangle((int)keypoints.get(r).pt.x, (int)keypoints.get(r).pt.y, 0, 0), 0, values));
		}
		
		Feature feature = new Feature(frame.getStreamId(), frame.getSequenceNr(), featureName, 0, descrList, null);
		if(outputFrame){
			frame.getFeatures().add(feature);
			result.add(frame);
		}else{
			result.add(feature);
		}		
	}catch(Exception e){
		// catching exception at this point will prevent the sent of a fail! 
		logger.warn("Unable to extract features for frame!", e);
	}
	return result;
}
 

import org.opencv.features2d.DescriptorExtractor; //导入方法依赖的package包/类
public static FeatureData detectFeatures(Mat mat) {
	FeatureDetector detector = FeatureDetector.create(FeatureDetector.ORB);
	DescriptorExtractor extractor = DescriptorExtractor
			.create(DescriptorExtractor.ORB);
	MatOfKeyPoint keypoints = new MatOfKeyPoint();
	Mat descriptors = new Mat();
	detector.detect(mat, keypoints);
	extractor.compute(mat, keypoints, descriptors);
	return new FeatureData(keypoints, descriptors);
}