diff --git a/.gitignore b/.gitignore index 3ba54c9ff83..58a089181f9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,28 +1,81 @@ -# built application files +# Built application files *.apk +*.aar *.ap_ +*.aab -# Java class files -*.class +# Files for the ART/Dalvik VM +*.dex -# generated files +# Generated files bin/ gen/ +out/ +# Uncomment the following line in case you need and you don't have the release build type files in your app +# release/ + +# Gradle files +.gradle/ # Local configuration file (sdk path, etc) local.properties -# Windows thumbnail db -Thumbs.db +# Proguard folder generated by Eclipse +proguard/ + +# Log Files +*.log -# OSX files -.DS_Store +# Android Studio Navigation editor temp files +.navigation/ -# Android Studio +# Android Studio captures folder +captures/ + +# IntelliJ *.iml -.idea -.gradle -build/ +.idea/workspace.xml +.idea/tasks.xml +.idea/gradle.xml +.idea/assetWizardSettings.xml +.idea/dictionaries +.idea/libraries +# Android Studio 3 in .gitignore file. +.idea/caches +.idea/modules.xml +# Comment next line if keeping position of elements in Navigation Editor is relevant for you +.idea/navEditor.xml + +# Keystore files +# Uncomment the following lines if you do not want to check your keystore files in. +#*.jks +#*.keystore + +# External native build folder generated in Android Studio 2.2 and later +.externalNativeBuild +.cxx/ + +# Google Services (e.g. APIs or Firebase) +# google-services.json + +# Freeline +freeline.py +freeline/ +freeline_project_description.json + +# fastlane +fastlane/report.xml +fastlane/Preview.html +fastlane/screenshots +fastlane/test_output +fastlane/readme.md -*ASUS_PC_01* +# Version control +vcs.xml +# lint +lint/intermediates/ +lint/generated/ +lint/outputs/ +lint/tmp/ +# lint/reports/ diff --git a/DogeCV/.gitignore b/DogeCV/.gitignore new file mode 100644 index 00000000000..796b96d1c40 --- /dev/null +++ b/DogeCV/.gitignore @@ -0,0 +1 @@ +/build diff --git a/DogeCV/build.gradle b/DogeCV/build.gradle new file mode 100644 index 00000000000..7972915f698 --- /dev/null +++ b/DogeCV/build.gradle @@ -0,0 +1,26 @@ +apply plugin: 'com.android.library' + +android { + compileSdkVersion 23 + buildToolsVersion '26.0.2' + + defaultConfig { + minSdkVersion 19 + targetSdkVersion 19 + versionCode 1 + versionName "1.0" + + + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } +} + +dependencies { + compile fileTree(dir: 'libs', include: ['*.jar']) + compile project(path: ':openCVLibrary330') +} diff --git a/DogeCV/proguard-rules.pro b/DogeCV/proguard-rules.pro new file mode 100644 index 00000000000..523e77cd022 --- /dev/null +++ b/DogeCV/proguard-rules.pro @@ -0,0 +1,25 @@ +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in /home/guinea/Android/Sdk/tools/proguard/proguard-android.txt +# You can edit the include path and order by changing the proguardFiles +# directive in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# Add any project specific keep options here: + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile diff --git a/DogeCV/src/main/AndroidManifest.xml b/DogeCV/src/main/AndroidManifest.xml new file mode 100644 index 00000000000..7c8a4f3454d --- /dev/null +++ b/DogeCV/src/main/AndroidManifest.xml @@ -0,0 +1,10 @@ + + + + + + + diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/ActivityViewDisplay.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/ActivityViewDisplay.java new file mode 100644 index 00000000000..c0a32f0d2b9 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/ActivityViewDisplay.java @@ -0,0 +1,46 @@ +package com.disnodeteam.dogecv; + +import android.app.Activity; +import android.content.Context; +import android.view.View; + +/** + * Created by guinea on 6/23/17. + * This ViewDisplay displays a View over the entire screen. + * As a singleton, you'll want to pass ActivityViewDisplay.getInstance() instead of directly instantiating it. + */ + +public class ActivityViewDisplay implements ViewDisplay { + private static ActivityViewDisplay instance; + private static View main = null; + + private ActivityViewDisplay() { + } + + public static ActivityViewDisplay getInstance() { + if (instance == null) instance = new ActivityViewDisplay(); + return instance; + } + + public void setCurrentView(final Context context, final View view) { + final Activity activity = (Activity) context; + activity.runOnUiThread(new Runnable() { + @Override + public void run() { + if (main == null) + main = activity.getCurrentFocus(); + activity.setContentView(view); + } + }); + } + + public void removeCurrentView(final Context context) { + final Activity activity = (Activity) context; + activity.runOnUiThread(new Runnable() { + @Override + public void run() { + activity.setContentView(main.getRootView()); + } + }); + } +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/CameraViewDisplay.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/CameraViewDisplay.java new file mode 100644 index 00000000000..680574bd9a5 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/CameraViewDisplay.java @@ -0,0 +1,62 @@ +package com.disnodeteam.dogecv; + +import android.app.Activity; +import android.content.Context; +import android.view.View; +import android.view.ViewGroup; + + +/** + * Created by guinea on 6/23/17. + * Nicely adds/removes a View from the main body of the robot controller app screen. + * As a singleton, you'll want to pass CameraViewDisplay.getInstance() instead of directly instantiating it. + */ + +public class CameraViewDisplay implements ViewDisplay { + private static CameraViewDisplay instance; + + View view; + private CameraViewDisplay() { + } + + public static CameraViewDisplay getInstance() { + if (instance == null) instance = new CameraViewDisplay(); + + return instance; + } + + public void setCurrentView(Context context, View newView) { + // finding the resID dynamically allows this class to exist outside of the TeamCode module + final int resID = context.getResources().getIdentifier("RelativeLayout", "id", context.getPackageName()); + final Activity activity = (Activity) context; + final View queuedView = newView; + activity.runOnUiThread(new Runnable() { + @Override + public void run() { + ViewGroup l = (ViewGroup) activity.findViewById(resID); //R.id.RelativeLayout); + if (view != null) { + l.removeView(view); + } + l.addView(queuedView); + view = queuedView; + + } + }); + } + + public void removeCurrentView(Context context) { + final int resID = context.getResources().getIdentifier("RelativeLayout", "id", context.getPackageName()); + final Activity activity = (Activity) context; + activity.runOnUiThread(new Runnable() { + @Override + public void run() { + //cameraMonitorViewId + ViewGroup l = (ViewGroup) activity.findViewById(resID); // .id.RelativeLayout); + if (view != null) { + l.removeView(view); + } + view = null; + } + }); + } +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/DogeCV.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/DogeCV.java new file mode 100644 index 00000000000..c6597e2e7b8 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/DogeCV.java @@ -0,0 +1,15 @@ +package com.disnodeteam.dogecv; + +import android.util.Log; + +import org.opencv.core.Core; +import org.opencv.core.Mat; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.util.ArrayList; +import java.util.List; + +public class DogeCV { +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/OpenCVPipeline.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/OpenCVPipeline.java new file mode 100644 index 00000000000..26e20be3d35 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/OpenCVPipeline.java @@ -0,0 +1,155 @@ +package com.disnodeteam.dogecv; + +import android.app.Activity; +import android.content.Context; +import android.view.View; + +import org.opencv.android.CameraBridgeViewBase; +import org.opencv.android.JavaCameraView; +import org.opencv.core.Mat; + +import java.util.List; + +/** + * Created by guinea on 6/19/17. + * This is a base class for an OpenCV pipeline loop. + * TODO: consider more functionality in here, relating to camera parameter manipulation? For most cases it's not needed. + */ + +public abstract class OpenCVPipeline implements CameraBridgeViewBase.CvCameraViewListener2 { + static { + System.loadLibrary("opencv_java3"); + } + private JavaCameraView cameraView; + private ViewDisplay viewDisplay; + public Context context; + private boolean initStarted = false; + private boolean inited = false; + + private int viewIndex = 0; + + /** + * Initializes the OpenCVPipeline, but implicitly uses the rear camera. + * @param context the application context, usually hardwareMap.appContext + * @param viewDisplay the ViewDisplay that will display the underlying JavaCameraView to the screen; + * in most cases, using CameraViewDisplay.getInstance() as the argument is just fine. + */ + public void init(Context context, ViewDisplay viewDisplay) { + init(context, viewDisplay, 0); + } + + /** + * Initializes the OpenCVPipeline. + * @param context the application context, usually hardwareMap.appContext + * @param viewDisplay the ViewDisplay that will display the underlying JavaCameraView to the screen; + * in most cases, using CameraViewDisplay.getInstance() as the argument is just fine. + * @param cameraIndex The index of the camera to use. On every FTC-legal phone (afaik) 0 is the back camera, and 1 is the front camera. + */ + public void init(Context context, final ViewDisplay viewDisplay, final int cameraIndex) { + this.initStarted = true; + this.viewDisplay = viewDisplay; + this.context = context; + final Activity activity = (Activity) context; + final Context finalContext = context; + final CameraBridgeViewBase.CvCameraViewListener2 self = this; + activity.runOnUiThread(new Runnable() { + @Override + public void run() { + // JCVs must be instantiated on a UI thread + cameraView = new JavaCameraView(finalContext, cameraIndex); + + cameraView.enableFpsMeter(); + + cameraView.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + viewIndex++; + } + }); + + cameraView.setCameraIndex(cameraIndex); + cameraView.setCvCameraViewListener(self); + inited = true; + } + }); + } + //TODO: allow other JavaCameraViews to be used, with the stipulation that they must already be instantiated from a UI thread + + /** + * Attaches the underlying JavaCameraView to the screen and the camera using the set {@link ViewDisplay} to do so, essentially starting OpenCV processing. + * This function must be called after init(). + * @throws IllegalStateException if enable() is called before init() + */ + public void enable() { + if (!initStarted) throw new IllegalStateException("init() needs to be called before an OpenCVPipeline can be enabled!"); + // this is an absolute hack + try { + while (!inited) Thread.sleep(10); + } catch (InterruptedException e) { return; } + + cameraView.enableView(); + + viewDisplay.setCurrentView(context, getCameraView()); + + } + + /** + * Detaches the JavaCameraView from the camera and the screen, stopping OpenCV processing. + * Be careful not to: + * - disable twice + * - disable before enabling + * because dean kamen help you if something bad happens from that + */ + public void disable() { + cameraView.disableView(); + viewDisplay.removeCurrentView(context); + } + + /** + * Exposes the underlying JavaCameraView used. Before init() is called, this is null. + * @return the JavaCameraView. + */ + public JavaCameraView getCameraView() { + return cameraView; + } + + /** + * This function is called when the camera is started; overriding this may be useful to set the + * maximum width and height parameters of an image processing pipeline. + * @param width - the width of the frames that will be delivered + * @param height - the height of the frames that will be delivered + */ + @Override + public void onCameraViewStarted(int width, int height) { + // override this if you wish + } + + /** + * Override this function if there should be logic on camera close. + */ + @Override + public void onCameraViewStopped() { + + } + + /** + * The method that calls {@link #processFrame(Mat, Mat)}; there's little reason to override this, if ever. + * @param inputFrame the input frame given by the internal JavaCameraView + * @return the result of {@link #processFrame(Mat, Mat)} + */ + @Override + public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) { + + + return processFrame(inputFrame.rgba(), inputFrame.gray()); + } + + /** + * Override this with the main image processing logic. This is run every time the camera recieves a frame. + * @param rgba a {@link Mat} that is in RGBA format + * @param gray a {@link Mat} that is already grayscale + * @return the Mat that should be displayed to the screen; in most cases one would probably just want to return rgba + */ + public abstract Mat processFrame(Mat rgba, Mat gray); + +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/ViewDisplay.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/ViewDisplay.java new file mode 100644 index 00000000000..bebd89ad631 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/ViewDisplay.java @@ -0,0 +1,14 @@ +package com.disnodeteam.dogecv; + +import android.content.Context; +import android.view.View; + +/** + * Created by guinea on 6/26/17. + * Provides methods to display and remove a View from the screen. + */ + +public interface ViewDisplay { + void setCurrentView(Context context, View view); + void removeCurrentView(Context context); +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/BlankDetector.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/BlankDetector.java new file mode 100644 index 00000000000..099d613db5e --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/BlankDetector.java @@ -0,0 +1,18 @@ +package com.disnodeteam.dogecv.detectors; + +import com.disnodeteam.dogecv.OpenCVPipeline; +import com.disnodeteam.dogecv.filters.DogeCVColorFilter; +import com.disnodeteam.dogecv.filters.LeviColorFilter; + +import org.opencv.core.Mat; + +/** + * Created by Victo on 12/17/2017. + */ + +public class BlankDetector extends OpenCVPipeline { + @Override + public Mat processFrame(Mat rgba, Mat gray) { + return rgba; + } +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/CryptoboxDetector.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/CryptoboxDetector.java new file mode 100644 index 00000000000..617ac2576a1 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/CryptoboxDetector.java @@ -0,0 +1,373 @@ +package com.disnodeteam.dogecv.detectors; + +import android.util.Log; + + +import com.disnodeteam.dogecv.OpenCVPipeline; +import com.disnodeteam.dogecv.filters.DogeCVColorFilter; +import com.disnodeteam.dogecv.filters.LeviColorFilter; +import com.disnodeteam.dogecv.math.Line; +import com.disnodeteam.dogecv.math.Lines; +import com.disnodeteam.dogecv.math.MathFTC; +import com.disnodeteam.dogecv.math.Points; +import org.opencv.core.Core; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.MatOfPoint; +import org.opencv.core.Point; +import org.opencv.core.Rect; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + + +public class CryptoboxDetector extends OpenCVPipeline { + + public enum CryptoboxDetectionMode { + RED, BLUE + } + + public enum CryptoboxSpeed { + VERY_FAST, FAST, BALANCED, SLOW, VERY_SLOW + } + + public CryptoboxDetectionMode detectionMode = CryptoboxDetectionMode.RED; + public double downScaleFactor = 0.5; + public boolean rotateMat = false; + public CryptoboxSpeed speed = CryptoboxSpeed.BALANCED; + public int centerOffset = 0; + public boolean debugShowMask = true; + public int trackableMemory = 5; + public DogeCVColorFilter colorFilterRed = new LeviColorFilter(LeviColorFilter.ColorPreset.RED); + public DogeCVColorFilter colorFilterBlue = new LeviColorFilter(LeviColorFilter.ColorPreset.BLUE); + + + private boolean CryptoBoxDetected = false; + private boolean ColumnDetected = false; + private int[] CryptoBoxPositions = new int[3]; + + private Mat workingMat = new Mat(); + private Mat mask = new Mat(); + private Size newSize = new Size(); + + + private List> trackables = new ArrayList<>(3); + List avgPoints = new ArrayList<>(); + Point fullAvgPoint = new Point(); + + @Override + public Mat processFrame(Mat rgba, Mat gray) { + downScaleFactor = 0.5; + Size initSize= rgba.size(); + newSize = new Size(initSize.width * downScaleFactor, initSize.height * downScaleFactor); + rgba.copyTo(workingMat); + + avgPoints = new ArrayList<>(); + + Imgproc.resize(workingMat, workingMat,newSize); + if(rotateMat) { + Mat tempBefore = workingMat.t(); + Core.flip(tempBefore, workingMat, 1); //mRgba.t() is the transpose + tempBefore.release(); + } + + switch(detectionMode){ + case RED: + Mat redMask = workingMat.clone(); + colorFilterRed.process(redMask, mask); + redMask.release(); + break; + case BLUE: + Mat blueMask = workingMat.clone(); + colorFilterBlue.process(blueMask, mask); + blueMask.release(); + break; + } + + //display = new Mat(mask.height(), mask.width(), CvType.CV_8UC1); + ArrayList lines = (ArrayList) Lines.getOpenCvLines(mask, 1, 55); + lines = (ArrayList) Lines.linearExtend(lines, 4, newSize); + //lines = Lines.mergeLines(lines, 13, 300, 6); + //lines = Lines.mergeLines(lines, 6, 2000, 4); + List linesVertical = new ArrayList(); + for (Line line : lines) { + if(Lines.getAngularDistance(line, new Line(new Point(0,0), new Point(100,0))) > 45) { + linesVertical.add(line); + } + } + + Collections.sort(linesVertical, new Comparator() { + @Override + public int compare(Line line1, Line line2) { + if(line1.center().x > line2.center().x){ + return 1; + }else if(line1.center().x < line2.center().x){ + return -1; + }else{ + return 0; + } + } + }); + + if(linesVertical.size() == 0){ + + CryptoBoxDetected = false; + ColumnDetected = false; + + return rgba; + } + + Line left = linesVertical.get(0); + Line right = linesVertical.get(linesVertical.size()-1); + + double perpDistance = Lines.getPerpindicularDistance(left, right); + double collumnLength =Lines.getPerpindicularDistance(left, right)/6; + + List> groupings = new ArrayList>(); + int j = 0; + while (j < linesVertical.size()) { + List group = new ArrayList(); + group.add(linesVertical.get(j)); + int i = j+1; + while ( i < linesVertical.size() && Lines.getPerpindicularDistance(linesVertical.get(j), linesVertical.get(i)) < collumnLength) { + group.add(linesVertical.get(i)); + i++; + } + groupings.add(group); + j = i; + } + + for (int i = 0; i < groupings.size()-1; i++) { + Point center = new Line(Lines.getMeanPoint(groupings.get(i)), Lines.getMeanPoint(groupings.get(i+1))).center(); + int y = (int) MathFTC.clip(0.6*center.y, 0, mask.height()); + double max = 1.4*center.y; + if (center.y < 125) { + y = 1; + max = 250; + } + int count = 0; + while (y < mask.height() && y < max && count < 10) { + if(mask.get(y, (int) center.x)[0] > 0) { + count++; + //Imgproc.circle(original, new Point(2*center.x, 2*y), 10, new Scalar(255,255,255), 6); + } else { + //Imgproc.circle(original, new Point(2*center.x, 2*y), 10, new Scalar(30,30,200), 6); + } + y += 10; + } + if(count >= 10) { + List appendee = groupings.get(i); + appendee.addAll(groupings.get(i+1)); + groupings.set(i, appendee); + groupings.remove(i+1); + i -= 1; + } + } + + for (int i = 0; i < groupings.size(); i++) { + Point center = Lines.getMeanPoint(groupings.get(i)); + int y = (int) MathFTC.clip(0.2*center.y, 0, mask.height()); + double max = 1.8*center.y; + if (center.y < 50) { + y = 1; + max = (int) 0.8*mask.height(); + } + int minX = (int) MathFTC.clip(center.x-5, 0, mask.width()); + int maxX = (int) MathFTC.clip(center.x+5, 0, mask.width()); + int count = 0; + while (y < mask.height() && y < max && count < 10) { + if(mask.get(y, (int) center.x)[0] > 0 || mask.get(y, minX)[0] > 0 || mask.get(y, maxX)[0] > 0) { + count++; + // Imgproc.circle(rgba, new Point(2*center.x, 2*y), 10, new Scalar(255,255,255), 6); + } else { + //Imgproc.circle(rgba, new Point(2*center.x, 2*y), 10, new Scalar(30,30,200), 6); + } + y += 4; + } + if(count <= 9) { + groupings.remove(i); + i -= 1; + } + } + + if(groupings.size() > 4) { + Collections.sort(groupings, new Comparator>() { + @Override + public int compare(List g1, List g2) { + if(Lines.stdDevX(g1) > Lines.stdDevX(g2)){ + return 1; + }else if(Lines.stdDevX(g1) < Lines.stdDevX(g2)){ + return -1; + }else{ + return 0; + } + } + }); + groupings = groupings.subList(0, 4); + } + List columns = new ArrayList(); + for (int i = 0; i < groupings.size(); i++) { + Point center = Lines.getMeanPoint(groupings.get(i)); + double angle = Lines.getMeanAngle(groupings.get(i)); + columns.add(Lines.constructLine(Lines.getMeanPoint(groupings.get(i)), Lines.getMeanAngle(groupings.get(i)), 400)); + } + + for(int i = 0; i < groupings.size(); i++) { + groupings.set(i, Lines.resize(groupings.get(i), 1/downScaleFactor)); + } + + for(int i = 0; i < groupings.size(); i++) { + //Imgproc.circle(original, Lines.getMeanPoint(groupings.get(i)), 50, new Scalar(40,200,70), 4); + for (Line line : groupings.get(i)) { + //Imgproc.line(rgba, line.point1, line.point2, new Scalar(50,200,55), 4); + //Imgproc.circle(rgba, line.center(), 20, new Scalar(80,60,190),4); + //Imgproc.putText(rgba, Integer.toString(i), line.center(), Core.FONT_HERSHEY_PLAIN, 7, new Scalar(10,240,230),3); + } + } + + for (Line line : columns) { + line.resize(1/downScaleFactor); + Imgproc.line(rgba, line.point1, line.point2, new Scalar(20,165,240), 20); + } + if(columns.size() < 3){ + trackables = new ArrayList<>(); + CryptoBoxDetected = false; + ColumnDetected = false; + + return rgba; + } + + + + for(int i=0;i()); + } + } + if(trackables.size() <= i ){ + trackables.add(new ArrayList()); + } + + if(trackables.get(i).size() < trackableMemory){ + trackables.get(i).add(centerPoint); + }else{ + Collections.rotate(trackables.get(i), -1); + trackables.get(i).set(trackableMemory -1 ,centerPoint); + } + + for(int k =0;k< trackables.get(i).size();k++){ + //Imgproc.circle(rgba, trackables.get(i).get(k),4,new Scalar(255,255,255),3); + } + } + + Point avgPoint = Points.getMeanPoint(trackables.get(i)); + Imgproc.putText(rgba,"Col #" + i, new Point(avgPoint.x, avgPoint.y - 15), 0, 1.5, new Scalar(0,255,255), 2); + //DogeLogger.LogVar("Col-"+i, avgPoint.toString()); + Imgproc.circle(rgba,avgPoint, 15,new Scalar(0,255,0),6); + avgPoints.add(avgPoint); + + CryptoBoxPositions[i] = (int)avgPoint.x; + + } + if(avgPoints.size() == 3){ + CryptoBoxDetected = true; + } + + ColumnDetected = true; + Point newFull = Points.getMeanPoint(avgPoints); + Line newFullLine = new Line(newFull, fullAvgPoint); + if(newFullLine.length() > 75){ + trackables = new ArrayList<>(); + Log.d("DogeCV", "RESETTING TRACKABLE!"); + } + fullAvgPoint = newFull; + // Imgproc.cvtColor(white, white, Imgproc.COLOR_RGB2HSV); + + + Imgproc.putText(rgba,"DogeCV 1.1 Crypto: " + newSize.toString() + " - " + speed.toString() + " - " + detectionMode.toString() ,new Point(5,30),0,1.2,new Scalar(0,255,255),2); + + + + return rgba; + + + + } + + + + public Point drawSlot(int slot, List boxes){ + Rect leftColumn = boxes.get(slot); //Get the pillar to the left + Rect rightColumn = boxes.get(slot + 1); //Get the pillar to the right + + int leftX = leftColumn.x; //Get the X Coord + int rightX = rightColumn.x; //Get the X Coord + + int drawX = ((rightX - leftX) / 2) + leftX; //Calculate the point between the two + int drawY = leftColumn.height + leftColumn.y; //Calculate Y Coord. We wont use this in our bot's opetation, buts its nice for drawing + + return new Point(drawX, drawY); + } + + + public static double[] getPosition(Line left, Line right, Size size, double f, double x0, double y0) { + Line connector = Lines.getPerpindicularConnector(left, right, size); + double u1 = connector.x1-x0; + double u2 = connector.x2-x0; + double v1 = y0-connector.y1; + double v2 = y0-connector.y2; + + double y1 = 7.63*f*Math.sqrt(1/( (Math.pow(u1, 2)+1) - (2*v1*(u1*u2+1)/v2) + (Math.pow(v1/v2, 2)*(Math.pow(u2, 2)+1)) )); + double y2 = 7.63*f*Math.sqrt(1/( (Math.pow(u2, 2)+1) - (2*v2*(u1*u2+1)/v1) + (Math.pow(v2/v1, 2)*(Math.pow(u1, 2)+1)) )); + + double x1 = y1*u1/f; + double x2 = y2*u2/f; + + return new double[] {x1,y1,x2,y2}; + } + + public int[] getCryptoBoxPositions() { + return CryptoBoxPositions; + } + + public int getCryptoBoxLeftPosition() { + return CryptoBoxPositions[0]; + } + + public int getCryptoBoxCenterPosition() { + return CryptoBoxPositions[1]; + } + + public int getCryptoBoxRightPosition() { + return CryptoBoxPositions[2]; + } + + public boolean isCryptoBoxDetected() { + return CryptoBoxDetected; + } + + public boolean isColumnDetected() { + return ColumnDetected; + } + + + public Size getFrameSize() { + return newSize; + } + + +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/GenericDetector.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/GenericDetector.java new file mode 100644 index 00000000000..037edec1e67 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/GenericDetector.java @@ -0,0 +1,202 @@ +package com.disnodeteam.dogecv.detectors; + + +import com.disnodeteam.dogecv.DogeCV; +import com.disnodeteam.dogecv.OpenCVPipeline; +import com.disnodeteam.dogecv.filters.DogeCVColorFilter; +import com.disnodeteam.dogecv.filters.HSVColorFilter; +import com.disnodeteam.dogecv.filters.LeviColorFilter; + +import org.opencv.core.Core; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.MatOfPoint; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.Point; +import org.opencv.core.Rect; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by Victo on 11/5/2017. + */ + +public class GenericDetector extends OpenCVPipeline { + + public enum GenericDetectionMode { + PERFECT_AREA, MAX_AREA + } + + public enum GenericDetectionSpeed { + VERY_FAST, FAST, BALANCED, SLOW, VERY_SLOW + } + + + public GenericDetectionMode detectionMode = GenericDetectionMode.MAX_AREA; + public double downScaleFactor = 0.4; + public double perfectRatio = 1; + public boolean rotateMat = false; + public GenericDetectionSpeed speed = GenericDetectionSpeed.BALANCED; + + public DogeCVColorFilter colorFilter = new HSVColorFilter(new Scalar(50,50,50), new Scalar(50,50,50)); + + public double perfectArea = 6500; + public double areaWeight = 0.05; // Since we're dealing with 100's of pixels + public double minArea = 700; + public double ratioWeight = 15; // Since most of the time the area diffrence is a decimal place + public double maxDiffrence = 10; // Since most of the time the area diffrence is a decimal place + public boolean debugContours = false; + public boolean stretch = false; + public Size stretchKernal = new Size(10,10); + + private Point resultLocation = null; + private Rect resultRect = null; + private boolean resultFound = false; + private Mat workingMat = new Mat(); + private Mat blurredMat = new Mat(); + private Mat mask = new Mat(); + private Mat hiarchy = new Mat(); + private Mat structure = new Mat(); + + private Size newSize = new Size(); + + @Override + public Mat processFrame(Mat rgba, Mat gray) { + + Size initSize = rgba.size(); + newSize = new Size(initSize.width * downScaleFactor, initSize.height * downScaleFactor); + rgba.copyTo(workingMat); + + Imgproc.resize(workingMat, workingMat, newSize); + + if (rotateMat) { + Mat tempBefore = workingMat.t(); + + Core.flip(tempBefore, workingMat, -1); //mRgba.t() is the transpose + + tempBefore.release(); + } + + Mat preConvert = workingMat.clone(); + colorFilter.process(preConvert,mask); + + if(stretch){ + structure = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_RECT,stretchKernal); + Imgproc.morphologyEx(mask,mask,Imgproc.MORPH_CLOSE,structure); + } + List contours = new ArrayList<>(); + + Imgproc.findContours(mask, contours, hiarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE); + Imgproc.drawContours(workingMat, contours, -1, new Scalar(230, 70, 70), 2); + Rect chosenRect = null; + double chosenScore = Integer.MAX_VALUE; + + MatOfPoint2f approxCurve = new MatOfPoint2f(); + + for (MatOfPoint c : contours) { + MatOfPoint2f contour2f = new MatOfPoint2f(c.toArray()); + + //Processing on mMOP2f1 which is in type MatOfPoint2f + double approxDistance = Imgproc.arcLength(contour2f, true) * 0.02; + Imgproc.approxPolyDP(contour2f, approxCurve, approxDistance, true); + + //Convert back to MatOfPoint + MatOfPoint points = new MatOfPoint(approxCurve.toArray()); + + // Get bounding rect of contour + Rect rect = Imgproc.boundingRect(points); + + // You can find this by printing the area of each found rect, then looking and finding what u deem to be perfect. + // Run this with the bot, on a balance board, with jewels in their desired location. Since jewels should mostly be + // in the same position, this hack could work nicely. + + + double area = Imgproc.contourArea(c); + double areaDiffrence = 0; + + switch (detectionMode) { + case MAX_AREA: + areaDiffrence = -area * areaWeight; + break; + case PERFECT_AREA: + areaDiffrence = Math.abs(perfectArea - area); + break; + } + + // Just declaring vars to make my life eassy + double x = rect.x; + double y = rect.y; + double w = rect.width; + double h = rect.height; + Point centerPoint = new Point(x + (w / 2), y + (h / 2)); + + + double cubeRatio = Math.max(Math.abs(h / w), Math.abs(w / h)); // Get the ratio. We use max in case h and w get swapped??? it happens when u account for rotation + double ratioDiffrence = Math.abs(cubeRatio - perfectRatio); + + + double finalDiffrence = (ratioDiffrence * ratioWeight) + (areaDiffrence * areaWeight); + + + // Optional to ALWAYS return a result. + + // Update the chosen rect if the diffrence is lower then the curreny chosen + // Also can add a condition for min diffrence to filter out VERY wrong answers + // Think of diffrence as score. 0 = perfect + if (finalDiffrence < chosenScore && finalDiffrence < maxDiffrence && area > minArea) { + chosenScore = finalDiffrence; + chosenRect = rect; + } + + if (debugContours && area > 100) { + Imgproc.circle(workingMat, centerPoint, 3, new Scalar(0, 255, 255), 3); + Imgproc.putText(workingMat, "Area: " + String.format("%.1f", area), centerPoint, 0, 0.5, new Scalar(0, 255, 255)); + } + + } + + if (chosenRect != null) { + Imgproc.rectangle(workingMat, + new Point(chosenRect.x, chosenRect.y), + new Point(chosenRect.x + chosenRect.width, chosenRect.y + chosenRect.height), + new Scalar(0, 255, 0), 3); + + Imgproc.putText(workingMat, + "Result: " + String.format("%.2f", chosenScore), + new Point(chosenRect.x - 5, chosenRect.y - 10), + Core.FONT_HERSHEY_PLAIN, + 1.3, + new Scalar(0, 255, 0), + 2); + Point centerPoint = new Point(chosenRect.x + (chosenRect.width / 2), chosenRect.y + (chosenRect.height / 2)); + resultRect = chosenRect; + resultLocation = centerPoint; + resultFound = true; + }else{ + resultFound = false; + resultRect = null; + resultLocation = null; + } + Imgproc.resize(workingMat, workingMat, initSize); + + preConvert.release(); + Imgproc.putText(workingMat, "DogeCV v1.1 Generic: " + newSize.toString() + " - " + speed.toString() + " - " + detectionMode.toString(), new Point(5, 30), 0, 1.2, new Scalar(0, 255, 255), 2); + + return workingMat; + } + + public Rect getRect() { + return resultRect; + } + + public Point getLocation(){ + return resultLocation; + } + public boolean getFound(){ + return resultFound; + } +} \ No newline at end of file diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/GlyphDetector.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/GlyphDetector.java new file mode 100644 index 00000000000..7fba282911e --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/detectors/GlyphDetector.java @@ -0,0 +1,295 @@ +package com.disnodeteam.dogecv.detectors; + +import com.disnodeteam.dogecv.OpenCVPipeline; + +import org.opencv.android.Utils; +import org.opencv.core.Core; +import org.opencv.core.Mat; +import org.opencv.core.MatOfPoint; +import org.opencv.core.Point; +import org.opencv.core.Rect; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +/** + * Created by Victo on 11/25/2017. + */ + +public class GlyphDetector extends OpenCVPipeline { + + + public enum GlyphDetectionMode { + EDGE + } + + public enum GlyphDetectionSpeed { + VERY_FAST, FAST, BALANCED, SLOW, VERY_SLOW + } + + //Settings + + public GlyphDetectionMode detectionMode = GlyphDetectionMode.EDGE; + public double downScaleFactor = 0.6; + public boolean rotateMat = false; + public double minScore = 0.5; + public double scoreRatioWeight = 0.5; + public double scoreDistanceXWeight = 0.8; + public double scoreDistanceYWeight = 1.1; + public double scoreAreaWeight = 0.5; + public GlyphDetectionSpeed speed = GlyphDetectionSpeed.BALANCED; + public boolean debugDrawStats = false; + public boolean debugDrawRects = true; + + + //results + private Point chosenGlyphPosition = null; + private double chosenGlyphOffset = 0; + private boolean foundRect = false; + + private Mat workingMat = new Mat(); + private Mat edges = new Mat(); + private Mat processed = new Mat(); + private Mat structure = new Mat(); + private Size newSize = new Size(); + @Override + public Mat processFrame(Mat rgba, Mat gray) { + + Size initSize = rgba.size(); + newSize = new Size(initSize.width * downScaleFactor, initSize.height * downScaleFactor); + + rgba.copyTo(workingMat); + Imgproc.resize(workingMat,workingMat, newSize); + + if(rotateMat){ + Mat tempBefore = workingMat.t(); + Core.flip(tempBefore, workingMat, 1); //mRgba.t() is the transpose + tempBefore.release(); + } + + + Imgproc.putText(workingMat,newSize.toString() + " - " + speed.toString(),new Point(5,15),0,0.5,new Scalar(0,255,0),1); + + Imgproc.cvtColor(workingMat,processed,Imgproc.COLOR_RGB2GRAY); + + switch (speed){ + case VERY_FAST: + + Imgproc.blur(processed,processed,new Size(2,2)); + + Imgproc.bilateralFilter(processed.clone(),processed,11,17,17); + + Imgproc.Canny(processed,edges,15,45.0); + + structure = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_RECT, new Size(3,3)); + Imgproc.morphologyEx(edges,edges,Imgproc.MORPH_CLOSE,structure); + break; + case FAST: + Imgproc.blur(processed,processed,new Size(3,3)); + + Imgproc.bilateralFilter(processed.clone(),processed,11,17,17); + + Imgproc.Canny(processed,edges,15,45.0); + + structure = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_RECT, new Size(6,6)); + Imgproc.morphologyEx(edges,edges,Imgproc.MORPH_CLOSE,structure); + break; + + case BALANCED: + Imgproc.blur(processed,processed,new Size(4,4)); + + Imgproc.bilateralFilter(processed.clone(),processed,11,17,17); + + Imgproc.Canny(processed,edges,15,45.0); + + structure = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_RECT, new Size(7,7)); + Imgproc.morphologyEx(edges,edges,Imgproc.MORPH_CLOSE,structure); + break; + + + case SLOW: + + Imgproc.blur(processed,processed,new Size(6,6)); + + Imgproc.bilateralFilter(processed.clone(),processed,11,17,17); + + Imgproc.Canny(processed,edges,15,45.0); + + + structure = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_RECT, new Size(10,10)); + Imgproc.morphologyEx(edges,edges,Imgproc.MORPH_CLOSE,structure); + break; + + case VERY_SLOW: + + Imgproc.blur(processed,processed,new Size(7,7)); + + Imgproc.bilateralFilter(processed.clone(),processed,11,17,17); + + Imgproc.Canny(processed,edges,15,45.0); + + structure = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_RECT, new Size(15,15)); + Imgproc.morphologyEx(edges,edges,Imgproc.MORPH_CLOSE,structure); + break; + } + + List contours = new ArrayList<>(); + Mat hierarchy = new Mat(); + + Imgproc.findContours(edges, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE); + hierarchy.release(); + + double chosenScore = 0; + Rect chosenRect = null; + + Collections.sort(contours, new Comparator() { + @Override + public int compare(MatOfPoint matOfPoint, MatOfPoint t1) { + if(Imgproc.contourArea(matOfPoint) > Imgproc.contourArea(t1)){ + return -1; + }else if(Imgproc.contourArea(matOfPoint) < Imgproc.contourArea(t1)){ + return 1; + } else{ + return 0; + } + } + }); + + contours.remove(0); // Remove First Index which is usually a large square filling the entire screen, + + for(MatOfPoint c : contours) { + + if(Imgproc.contourArea(c) > 1000){ + Rect rect = Imgproc.boundingRect(c); + + double x = rect.x; + double y = rect.y; + double w = rect.width; + double h = rect.height; + + Point centerPoint = new Point(x + ( w/2), y + (h/2)); + double cubeRatio = Math.max(Math.abs(h/w), Math.abs(w/h)); + + double score = 100; + + double diffrenceFromPerfect = Math.abs(1 - cubeRatio); + double scoreRatioPunishment = 1 - diffrenceFromPerfect; + double scoreRatio = scoreRatioPunishment * scoreRatioWeight; + score *= scoreRatio; + + double distanceFromCenterX = (newSize.width / 2) - centerPoint.x; + double distanceFromCenterY = newSize.height - centerPoint.y; + distanceFromCenterX = Math.abs(distanceFromCenterX / newSize.width); + distanceFromCenterY = Math.abs(distanceFromCenterY / newSize.height); + + double scoreDistanceFromCenterXPunishment = 1 - distanceFromCenterX; + double scoreDistanceFromCenterYPunishment = 1 - distanceFromCenterY; + + double scoreDistanceFromCenterX = scoreDistanceFromCenterXPunishment * scoreDistanceXWeight; + double scoreDistanceFromCenterY = scoreDistanceFromCenterYPunishment * scoreDistanceYWeight; + + score *= scoreDistanceFromCenterX; + score *= scoreDistanceFromCenterY; + + double minArea = GetMinArea(contours); + double maxArea = GetMaxArea(contours); + double area = Imgproc.contourArea(c); + double normalizedArea = (area - minArea) / (maxArea - minArea); + double scoreAreaPunishment = normalizedArea; + double scoreArea =scoreAreaPunishment * scoreAreaWeight; + score *= scoreArea; + + if(chosenRect == null){ + chosenRect = rect; + chosenScore = score; + } + + if(score > chosenScore){ + chosenRect = rect; + chosenScore = score; + } + + if(debugDrawRects){ + Imgproc.rectangle(workingMat,new Point(x,y), new Point((x+w),(y+h)),new Scalar(0,255,255),1); + } + + if(debugDrawRects){ + String toPrint = String.format("Score: %.2f",score); + Imgproc.putText(workingMat,toPrint , new Point(x+5,y+5),0,0.5, new Scalar(0,255,255)); + } + } + + + + + } + if(chosenRect != null && chosenScore > minScore){ + double x = chosenRect.x; + double y = chosenRect.y; + double w = chosenRect.width; + double h = chosenRect.height; + Imgproc.rectangle(workingMat,new Point(x,y), new Point((x+w),(y+h)),new Scalar(0,255,0),3); + + + chosenGlyphPosition = new Point((x+(w/2)), (y+(h/2))); + chosenGlyphOffset = newSize.width - (x+(w/2)) ; + + foundRect = false; + }else{ + foundRect = true; + } + + Imgproc.resize(workingMat,workingMat,initSize); + + return workingMat; + } + + + private double GetMaxArea(List allConturs){ + double currentMax = 0; + + for (MatOfPoint c: allConturs){ + double area= Imgproc.contourArea(c); + if(area>currentMax){ + currentMax = area; + } + } + + return currentMax; + } + + private double GetMinArea(List allConturs){ + double currentMax = Double.MAX_VALUE; + + for (MatOfPoint c: allConturs){ + double area= Imgproc.contourArea(c); + if(area contoursRed = new ArrayList<>(); + + Imgproc.findContours(maskRed, contoursRed, hiarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE); + Imgproc.drawContours(workingMat,contoursRed,-1,new Scalar(230,70,70),2); + Rect chosenRedRect = null; + double chosenRedScore = Integer.MAX_VALUE; + + MatOfPoint2f approxCurve = new MatOfPoint2f(); + + for(MatOfPoint c : contoursRed) { + MatOfPoint2f contour2f = new MatOfPoint2f(c.toArray()); + + //Processing on mMOP2f1 which is in type MatOfPoint2f + double approxDistance = Imgproc.arcLength(contour2f, true) * 0.02; + Imgproc.approxPolyDP(contour2f, approxCurve, approxDistance, true); + + //Convert back to MatOfPoint + MatOfPoint points = new MatOfPoint(approxCurve.toArray()); + + // Get bounding rect of contour + Rect rect = Imgproc.boundingRect(points); + + // You can find this by printing the area of each found rect, then looking and finding what u deem to be perfect. + // Run this with the bot, on a balance board, with jewels in their desired location. Since jewels should mostly be + // in the same position, this hack could work nicely. + + + double area = Imgproc.contourArea(c); + double areaDiffrence = 0; + + switch(detectionMode){ + case MAX_AREA: + areaDiffrence = -area * areaWeight; + break; + case PERFECT_AREA: + areaDiffrence = Math.abs(perfectArea - area); + break; + } + + // Just declaring vars to make my life eassy + double x = rect.x; + double y = rect.y; + double w = rect.width; + double h = rect.height; + Point centerPoint = new Point(x + ( w/2), y + (h/2)); + + + + double cubeRatio = Math.max(Math.abs(h/w), Math.abs(w/h)); // Get the ratio. We use max in case h and w get swapped??? it happens when u account for rotation + double ratioDiffrence = Math.abs(cubeRatio - perfectRatio); + + + double finalDiffrence = (ratioDiffrence * ratioWeight) + (areaDiffrence * areaWeight); + + + // Optional to ALWAYS return a result. + + // Update the chosen rect if the diffrence is lower then the curreny chosen + // Also can add a condition for min diffrence to filter out VERY wrong answers + // Think of diffrence as score. 0 = perfect + if(finalDiffrence < chosenRedScore && finalDiffrence < maxDiffrence && area > minArea){ + chosenRedScore = finalDiffrence; + chosenRedRect = rect; + } + + if(debugContours && area > 100){ + Imgproc.circle(workingMat,centerPoint,3,new Scalar(0,255,255),3); + Imgproc.putText(workingMat,"Area: " + area,centerPoint,0,0.5,new Scalar(0,255,255)); + } + + } + + List contoursBlue = new ArrayList<>(); + + Imgproc.findContours(maskBlue, contoursBlue,hiarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE); + Imgproc.drawContours(workingMat,contoursBlue,-1,new Scalar(70,130,230),2); + Rect chosenBlueRect = null; + double chosenBlueScore = Integer.MAX_VALUE; + + for(MatOfPoint c : contoursBlue) { + MatOfPoint2f contour2f = new MatOfPoint2f(c.toArray()); + + //Processing on mMOP2f1 which is in type MatOfPoint2f + double approxDistance = Imgproc.arcLength(contour2f, true) * 0.02; + Imgproc.approxPolyDP(contour2f, approxCurve, approxDistance, true); + + //Convert back to MatOfPoint + MatOfPoint points = new MatOfPoint(approxCurve.toArray()); + + // Get bounding rect of contour + Rect rect = Imgproc.boundingRect(points); + + // You can find this by printing the area of each found rect, then looking and finding what u deem to be perfect. + // Run this with the bot, on a balance board, with jewels in their desired location. Since jewels should mostly be + // in the same position, this hack could work nicely. + + + double area = Imgproc.contourArea(c); + double areaDiffrence = 0; + + switch(detectionMode){ + case MAX_AREA: + areaDiffrence = -area * areaWeight; + break; + case PERFECT_AREA: + areaDiffrence = Math.abs(perfectArea - area); + break; + } + + + // Just declaring vars to make my life eassy + double x = rect.x; + double y = rect.y; + double w = rect.width; + double h = rect.height; + Point centerPoint = new Point(x + ( w/2), y + (h/2)); + + double cubeRatio = Math.max(Math.abs(h/w), Math.abs(w/h)); // Get the ratio. We use max in case h and w get swapped??? it happens when u account for rotation + double ratioDiffrence = Math.abs(cubeRatio - 1); + + double finalDiffrence = (ratioDiffrence * ratioWeight) + (areaDiffrence * areaWeight); + + + + // Update the chosen rect if the diffrence is lower then the curreny chosen + // Also can add a condition for min diffrence to filter out VERY wrong answers + // Think of diffrence as score. 0 = perfect + if(finalDiffrence < chosenBlueScore && finalDiffrence < maxDiffrence && area > minArea){ + chosenBlueScore = finalDiffrence; + chosenBlueRect = rect; + } + + if(debugContours && area > 100){ + Imgproc.circle(workingMat,centerPoint,3,new Scalar(0,255,255),3); + Imgproc.putText(workingMat,"Area: " + area,centerPoint,0,0.5,new Scalar(0,255,255)); + } + + } + + if(chosenRedRect != null){ + Imgproc.rectangle(workingMat, + new Point(chosenRedRect.x, chosenRedRect.y), + new Point(chosenRedRect.x + chosenRedRect.width, chosenRedRect.y + chosenRedRect.height), + new Scalar(255, 0, 0), 2); + + Imgproc.putText(workingMat, + "Red: " + String.format("%.2f", chosenRedScore), + new Point(chosenRedRect.x - 5, chosenRedRect.y - 10), + Core.FONT_HERSHEY_PLAIN, + 1.3, + new Scalar(255, 0, 0), + 2); + } + + if(chosenBlueRect != null){ + Imgproc.rectangle(workingMat, + new Point(chosenBlueRect.x, chosenBlueRect.y), + new Point(chosenBlueRect.x + chosenBlueRect.width, chosenBlueRect.y + chosenBlueRect.height), + new Scalar(0, 0, 255), 2); + + Imgproc.putText(workingMat, + "Blue: " + String.format("%.2f", chosenBlueScore), + new Point(chosenBlueRect.x - 5, chosenBlueRect.y - 10), + Core.FONT_HERSHEY_PLAIN, + 1.3, + new Scalar(0, 0, 255), + 2); + } + + if(chosenBlueRect != null && chosenRedRect != null){ + if(chosenBlueRect.x < chosenRedRect.x){ + currentOrder = JewelOrder.BLUE_RED; + lastOrder = currentOrder; + }else{ + currentOrder = JewelOrder.RED_BLUE; + lastOrder = currentOrder; + } + }else{ + currentOrder = JewelOrder.UNKNOWN; + } + + Imgproc.putText(workingMat,"Result: " + lastOrder.toString(),new Point(10,newSize.height - 30),0,1, new Scalar(255,255,0),1); + Imgproc.putText(workingMat,"Current Track: " + currentOrder.toString(),new Point(10,newSize.height - 10),0,0.5, new Scalar(255,255,255),1); + + Imgproc.resize(workingMat,workingMat,initSize); + + redConvert.release(); + blueConvert.release(); + Imgproc.putText(workingMat,"DogeCV 1.1 Jewel: " + newSize.toString() + " - " + speed.toString() + " - " + detectionMode.toString() ,new Point(5,30),0,1.2,new Scalar(0,255,255),2); + + return workingMat; + } + + + public JewelOrder getCurrentOrder() { + return currentOrder; + } + + public JewelOrder getLastOrder() { + return lastOrder; + } +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/DogeCVColorFilter.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/DogeCVColorFilter.java new file mode 100644 index 00000000000..328b91116a7 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/DogeCVColorFilter.java @@ -0,0 +1,11 @@ +package com.disnodeteam.dogecv.filters; + +import org.opencv.core.Mat; + +/** + * Created by Victo on 1/1/2018. + */ + +public abstract class DogeCVColorFilter { + public abstract void process(Mat input, Mat mask); +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/HSVColorFilter.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/HSVColorFilter.java new file mode 100644 index 00000000000..989b227cd16 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/HSVColorFilter.java @@ -0,0 +1,33 @@ +package com.disnodeteam.dogecv.filters; + +import org.opencv.core.Core; +import org.opencv.core.Mat; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +/** + * Created by Victo on 1/1/2018. + */ + +public class HSVColorFilter extends DogeCVColorFilter{ + + private Scalar perfect = new Scalar(255,255,255); + private Scalar range = new Scalar(0,0,0); + + public HSVColorFilter(Scalar color, Scalar threshold){ + perfect = color; + range = threshold; + } + + @Override + public void process(Mat input, Mat mask) { + Imgproc.cvtColor(input,input,Imgproc.COLOR_RGB2HSV_FULL); + Imgproc.GaussianBlur(input,input,new Size(3,3),0); + + Scalar lower = new Scalar(perfect.val[0] - range.val[0], perfect.val[1] - range.val[1],perfect.val[2] - range.val[2]); + Scalar upper = new Scalar(perfect.val[0] + range.val[0], perfect.val[1] + range.val[1],perfect.val[2] + range.val[2]); + Core.inRange(input,lower,upper,mask); + input.release(); + } +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/LeviColorFilter.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/LeviColorFilter.java new file mode 100644 index 00000000000..18a87b86c59 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/filters/LeviColorFilter.java @@ -0,0 +1,132 @@ +package com.disnodeteam.dogecv.filters; + +import android.graphics.Color; + +import org.opencv.core.Core; +import org.opencv.core.Mat; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by Victo on 1/1/2018. + */ + +public class LeviColorFilter extends DogeCVColorFilter { + public enum ColorPreset{ + RED, + BLUE, + YELLOW + } + private ColorPreset color = ColorPreset.RED; + private double threshold = -1; // if -1 the color mode will use its own defaults + private List channels = new ArrayList<>(); + + public LeviColorFilter(ColorPreset filterColor){ + color = filterColor; + } + + public LeviColorFilter(ColorPreset filterColor, double filterThreshold){ + color = filterColor; + filterThreshold = filterThreshold; + } + + + + @Override + public void process(Mat input, Mat mask) { + channels = new ArrayList<>(); + + switch(color){ + case RED: + if(threshold == -1){ + threshold = 164; + } + + Imgproc.cvtColor(input, input, Imgproc.COLOR_RGB2Lab); + Imgproc.GaussianBlur(input,input,new Size(3,3),0); + Core.split(input, channels); + Imgproc.threshold(channels.get(1), mask, threshold, 255, Imgproc.THRESH_BINARY); + break; + case BLUE: + if(threshold == -1){ + threshold = 145; + } + + Imgproc.cvtColor(input, input, Imgproc.COLOR_RGB2YUV); + Imgproc.GaussianBlur(input,input,new Size(3,3),0); + Core.split(input, channels); + Imgproc.threshold(channels.get(1), mask, threshold, 255, Imgproc.THRESH_BINARY); + break; + case YELLOW: + if(threshold == -1){ + threshold = 95; + } + + Imgproc.cvtColor(input, input, Imgproc.COLOR_RGB2YUV); + Imgproc.GaussianBlur(input,input,new Size(3,3),0); + Core.split(input, channels); + Imgproc.threshold(channels.get(1), mask, threshold, 255, Imgproc.THRESH_BINARY_INV); + break; + } + + for(int i=0;i channels = new ArrayList<>(); + + Imgproc.cvtColor(input, input, Imgproc.COLOR_RGB2Lab); + Imgproc.GaussianBlur(input,input,new Size(3,3),0); + Core.split(input, channels); + Imgproc.threshold(channels.get(1), mask, 145, 255, Imgproc.THRESH_BINARY); + + for(int i=0;i channels = new ArrayList<>(); + + Imgproc.cvtColor(input, input, Imgproc.COLOR_RGB2YUV); + Imgproc.GaussianBlur(input,input,new Size(3,3),0); + Core.split(input, channels); + Imgproc.threshold(channels.get(1), mask, threshold, 255, Imgproc.THRESH_BINARY); + + for(int i=0;i { + + public Point point1; + public Point point2; + + public double x1,y1,x2,y2; + + public Line(Point point1, Point point2) { + this.point1 = point1; + this.point2 = point2; + x1 = point1.x; + x2 = point2.x; + y1 = point1.y; + y2 = point2.y; + } + + public double length() { + return Math.sqrt(Math.pow(x1-x2, 2) + Math.pow(y1-y2, 2)); + } + + public Point center() { + return new Point((int) (0.5*(x1 + x2)),(int) (0.5*(y1 + y2))); + } + + public double angle() { + return Math.atan2(y2-y1,x2-x1); + } + + public void resize(double scale) { + this.x1 = scale*x1; + this.y1 = scale*y1; + this.x2 = scale*x2; + this.y2 = scale*y2; + this.point1 = new Point(x1,y1); + this.point2 = new Point(x2,y2); + } + + @Override + public int compareTo(Line other) { + return Double.compare(this.length(), other.length()); + } + + @Override + public String toString() { + return "{" + Double.toString(x1) + "," + Double.toString(y1) + "} to {" + Double.toString(x2) + "," + Double.toString(y2) + "}"; + } + +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/math/Lines.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/math/Lines.java new file mode 100644 index 00000000000..d8ed2c74fab --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/math/Lines.java @@ -0,0 +1,339 @@ +package com.disnodeteam.dogecv.math; + +import com.disnodeteam.dogecv.math.Line; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.opencv.core.Core; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.Point; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.CLAHE; +import org.opencv.imgproc.Imgproc; +import org.opencv.imgproc.LineSegmentDetector; + + +public class Lines { + + //Individual Lines + /** + * Returns the angular distance, in degrees, between lines 1 and 2. + * @param line1 + * @param line2 + * @return + */ + public static double getAngularDistance(Line line1, Line line2) { + double ang1 = line1.angle(); + double ang2 = line2.angle(); + double ang_diff = 57.296*(ang1 - ang2); + ArrayList list = new ArrayList(); + list.add(Math.abs(ang_diff)); + list.add(Math.abs(180-Math.abs(ang_diff))); + list.add(Math.abs(360-Math.abs(ang_diff))); + return Collections.min(list); + } + /** + * Returns whether three points are clockwise or counter-clockwise + * @param A + * @param B + * @param C + * @return + */ + private static boolean ccw(Point A, Point B, Point C) { + return (C.y-A.y)*(B.x-A.x) > (B.y-A.y)*(C.x-A.x); + } + /** + * Returns a boolean corresponding to whether the two lines intersect + * @param line1 + * @param line2 + * @return + */ + public static boolean intersect(Line line1, Line line2) { + return ccw(line1.point1,line2.point1,line2.point2) != ccw(line1.point2,line2.point1,line2.point2) && ccw(line1.point1,line1.point2,line2.point1) != ccw(line1.point1,line1.point2,line2.point2); + } + /** + * Returns the signed cross product of a line and a point, such that the relative position of a point to a line can be determined. + * @param line The line forming the first vector, taken from Point 1 to Point 2 + * @param point The point to form the second vector, taken from line1.point1 to this point. + * @return 1 if the point is on one side, -1 if on the other, 0 if exactly on the line. + */ + public static double crossSign(Line line, Point point) { + double ABx = line.x2 - line.x1; + double ACx = point.x - line.x1; + double ABy = line.y2 - line.y1; + double ACy = point.y - line.y1; + return Math.signum((ABx*ACy - ABy*ACx)); + } + /** + * Extends a line as a vector, increasing the Euclidean distance of point 2 from point 1 by moving only point 2. + * @param line The line to be modified. + * @param lengthFinal The final desired Euclidean length of the line + * @param size The size of the working image + * @return A new Line object of the appropriate length + */ + public static Line vectorExtend(Line line, double lengthFinal, Size size) { + double scalar = lengthFinal/line.length(); + line.x2 = (int) (MathFTC.clip(scalar*(line.x2 - line.x1) + line.x1, 0, size.width - 1)); + line.y2 = (int) (MathFTC.clip(scalar*(line.y2 - line.y1) + line.y1, 0, size.height - 1)); + line.point2 = new Point(line.x2,line.y2); + return line; + } + + public static List vectorExtend(List lines, double lengthFinal, Size size) { + List newLines = new ArrayList(); + for (Line line : lines) { + newLines.add(vectorExtend(line, lengthFinal, size)); + } + return newLines; + } + + public static Line linearExtend(Line line, double scale, Size size) { + scale *= 2; + double xN1 = line.x1 + (line.x1 - line.x2)/scale; + double yN1 = line.y1 + (line.y1 - line.y2)/scale; + double xN2 = line.x2 + (line.x2 - line.x1)/scale; + double yN2 = line.y2 + (line.y2 - line.y1)/scale; + Point p1 = new Point(MathFTC.clip((int)xN1, 0, size.width -1),MathFTC.clip((int)yN1, 0, size.height-1)); + Point p2 = new Point(MathFTC.clip((int)xN2, 0, size.width -1),MathFTC.clip((int)yN2, 0, size.height-1)); + return new Line(p1, p2); + } + + public static List linearExtend(List lines, double scale, Size size) { + List newLines = new ArrayList(); + for (Line line : lines) { + newLines.add(linearExtend(line, scale, size)); + } + return newLines; + } + + public static Line constructLine(Point point, double angle, double length) { + double dx = Math.cos(angle*Math.PI/180); + double dy = Math.sin(angle*Math.PI/180); + Point p1 = new Point(point.x + 0.5*length*dx, point.y + 0.5*length*dy); + Point p2 = new Point(point.x - 0.5*length*dx, point.y - 0.5*length*dy); + return new Line(p1,p2); + } + + //Multiple Lines + static LineSegmentDetector detector = Imgproc.createLineSegmentDetector(Imgproc.LSD_REFINE_STD, 0.8, 0.6,2.0, 22.5, 0, 0.7, 32); + public static List getOpenCvLines(Mat original, int scale, double minLength) { + Mat raw = new Mat(); + Imgproc.resize(original.clone(), raw, new Size((int) (original.size().width/scale), (int) (original.size().height/scale))); + if(raw.channels() > 1) { + Imgproc.cvtColor(raw, raw, Imgproc.COLOR_RGB2GRAY); + } + Imgproc.equalizeHist(raw, raw); + Imgproc.blur(raw, raw, new Size(3,3)); + //Line Segment Detection 2 + Mat linesM1 = new Mat(); + //LineSegmentDetector detector = Imgproc.createLineSegmentDetector(Imgproc.LSD_REFINE_ADV, 0.6, 0.3, 2.6, 22.5, 0, 0.3,256); + //LineSegmentDetector detector = Imgproc.createLineSegmentDetector(Imgproc.LSD_REFINE_STD, 0.5, 0.4,2.0, 19.5, 0, 0.6, 32); + //Reference for final glyph detection + + detector.detect(raw, linesM1); + ArrayList lines = new ArrayList(); + for (int x = 0; x < linesM1.rows(); x++) { + double[] vec = linesM1.get(x, 0); + Point start = new Point(vec[0],vec[1]); + Point end = new Point(vec[2], vec[3]); + Line line = new Line(start, end); + line = new Line(new Point((int)line.x1*scale, (int) line.y1*scale), new Point((int)line.x2*scale, (int)line.y2*scale)); + if(line.length() > minLength) lines.add(line); + } + + raw.release(); + linesM1.release(); + + return lines; + } + + public static List resize(List lines, double scale) { + List linesN = new ArrayList(); + for (Line line : lines) { + line.resize(scale); + linesN.add(line); + } + return linesN; + } + + public static Line findRightMost(List lines, Size size) { + double maxX = 0; + int maxXi = -1; + for (int i = 0; i < lines.size(); i++) { + if(lines.get(i).center().x > maxX && Points.inBounds(lines.get(i).point1, size) && Points.inBounds(lines.get(i).point2, size)) { + maxX = lines.get(i).center().x; + maxXi = i; + } + } + return lines.get(maxXi); + } + + public static Line findLeftMost(List lines, Size size) { + double minX = 1000000; + int minXi = -1; + for (int i = 0; i < lines.size(); i++) { + if(lines.get(i).center().x < minX) { + minX = lines.get(i).center().x; + minXi = i; + } + } + return lines.get(minXi); + } + + public static Line getPerpindicular(Line line, double sign) { + double angle = Lines.getAngularDistance(line, new Line(new Point(0,0), new Point(100,0))); + angle += 90; + double x = line.center().x + 50*Math.cos(angle*Math.PI/180); + double y = line.center().y + 50*Math.sin(angle*Math.PI/180); + if(Lines.crossSign(line, new Point(x,y)) != sign) { + x = line.center().x - 50*Math.cos(angle*Math.PI/180); + y = line.center().y - 50*Math.sin(angle*Math.PI/180); + } + Line perp = new Line(line.center(), new Point(x,y)); + return perp; + } + + public static double getPerpindicularDistance(Line line1, Line line2) { + Line perp = Lines.getPerpindicular(line1, Lines.crossSign(line1, line2.center())); + Line joint = new Line(line1.center(), line2.center()); + return Math.cos(Lines.getAngularDistance(perp, joint)*Math.PI/180)*joint.length(); + } + + public static double getPerpindicularDistance(Line line1, Point point) { + Line perp = Lines.getPerpindicular(line1, Lines.crossSign(line1, point)); + Line joint = new Line(line1.center(), point); + return Math.cos(Lines.getAngularDistance(perp, joint)*Math.PI/180)*joint.length(); + } + + public static Line getPerpindicularConnector(Line left, Line right, Size size) { + double angle = Lines.getAngularDistance(left, new Line(new Point(0,0), new Point(100,0))); + angle += 90; + double dx = 3*Math.cos(angle*Math.PI/180); + double dy = 3*Math.sin(angle*Math.PI/180); + double x = left.center().x + dx; + double y = left.center().y + dy; + if(Lines.crossSign(left, new Point(x,y)) != Lines.crossSign(left, right.center())) { + dx = -dx; + dy = -dy; + x -= 2*dx; + y -= 2*dy; + } + while(Points.inBounds(new Point(x,y), size) && !Lines.intersect(new Line(left.center(),new Point(x,y)), right)) { + x += dx; + y += dy; + } + return new Line(left.center(), new Point(x,y)); + } + + public static List> groupLines(ArrayList lines, double seperation) { + //Merge close and parallel lines + //Find parallel lines and create list of joints to be merged + ArrayList joints = new ArrayList(); + for (List b : MathFTC.combinations(lines, 2)) { + Line jointLine = new Line(b.get(0).center(), b.get(1).center()); + if (Lines.getPerpindicularDistance(b.get(0),b.get(1)) < seperation) { + joints.add(new Joint(b.get(0),b.get(1),jointLine.center())); + } + } + //Create a dictionary of mergers close together (i.e. same edge) + ArrayList mergeCollections = new ArrayList(); + for (Joint joint : joints) { + int close = -1; + for (int i = 0; i < mergeCollections.size(); i++) { + if(Lines.getPerpindicularDistance(joint.line1, mergeCollections.get(i).center) < seperation) { + close = i; + break; + } + } + if (close >= 0) { + MergeFocus focus = mergeCollections.get(close); + if(!focus.lines.contains(joint.line1)) { + focus.lines.add(joint.line1); + } + if(!focus.lines.contains(joint.line2)) { + focus.lines.add(joint.line2); + } + } else { + ArrayList jointLines = new ArrayList(); + jointLines.add(joint.line1); + jointLines.add(joint.line2); + mergeCollections.add(new MergeFocus(joint.center,jointLines)); + } + } + List> mergeCollectionsList= new ArrayList>(); + for (MergeFocus focus : mergeCollections) { + List list = new ArrayList(); + for (Line line : focus.lines) { + lines.remove(line); + list.add(line); + } + mergeCollectionsList.add(list); + } + return mergeCollectionsList; + } + + private static class Joint { + + Line line1, line2; + Point center; + + Joint(Line line1, Line line2, Point center) { + this.center = center; + this.line1 = line1; + this.line2 = line2; + } + } + + private static class MergeFocus { + + List lines; + Point center; + + MergeFocus(Point center, List lines) { + this.center = center; + this.lines = lines; + } + } + + public static Point getMeanPoint(List lines) { + if (lines.size() == 0) return null; + double x = 0; + double y = 0; + for(Line line : lines) { + x += line.center().x; + y += line.center().y; + } + return new Point(x/lines.size(), y/lines.size()); + } + + public static double getMeanAngle(List lines) { + if(lines.size() == 0) return Double.NaN; + double angle = 0; + for (Line line : lines) { + angle += MathFTC.normalizeAngle(line.angle()*180/Math.PI); + } + return angle/lines.size(); + } + + public static double stdDevX(List lines) { + if (lines.size() == 0) return Double.NaN; + List data = new ArrayList(); + for(Line line : lines) { + data.add(line.center().x); + } + return MathFTC.getStdDev(data); + } + + public static double stdDevY(List lines) { + List data = new ArrayList(); + for(Line line : lines) { + data.add(line.center().y); + } + return MathFTC.getStdDev(data); + } + +} \ No newline at end of file diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/math/MathFTC.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/math/MathFTC.java new file mode 100644 index 00000000000..4c061c239d9 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/math/MathFTC.java @@ -0,0 +1,65 @@ +package com.disnodeteam.dogecv.math; + +import java.util.ArrayList; +import java.util.List; + +public class MathFTC { + + /** + * A simple clamp function, which assumes a valid range. + * @param value The double being clamped + * @param min The minimum value of the range (inclusive) + * @param max The maximum value of the range (inclusive) + * @return + */ + public static double clip(double value, double min, double max) { + if (value > max) return max; + else if (value < min) return min; + else return value; + } + + /** + * A recursive function which return a list of lists, where each list is a combination of length k. + * @param list The input list to be chosen from + * @param k The sample size + * @return + */ + public static List> combinations(List list, int k) { + int n = list.size(); + List> combos = new ArrayList>(); + if (k == 0 ) { + combos.add(new ArrayList()); + return combos; + } + if ( n < k || n == 0) { + return combos; + } + T last = list.get(n-1); + combos.addAll(combinations(list.subList(0, n-1),k)); + for (List subCombo : combinations(list.subList(0, n-1), k-1)) { + subCombo.add(last); + combos.add(subCombo); + } + return combos; + } + + public static double getStdDev(List samples) { + if(samples.size() == 0) return 0; + double mean = 0; + for (Double point : samples) { + mean += point; + } + mean = mean/samples.size(); + double sigma = 0; + for (Double point : samples) { + sigma += Math.pow(point-mean, 2); + } + return Math.sqrt(sigma/(samples.size() - 1)); + } + + public static double normalizeAngle(double angle) { + angle = angle % 180; + if (angle > 0) return angle; + else return angle+180; + } +} diff --git a/DogeCV/src/main/java/com/disnodeteam/dogecv/math/Points.java b/DogeCV/src/main/java/com/disnodeteam/dogecv/math/Points.java new file mode 100644 index 00000000000..12c3e148497 --- /dev/null +++ b/DogeCV/src/main/java/com/disnodeteam/dogecv/math/Points.java @@ -0,0 +1,29 @@ +package com.disnodeteam.dogecv.math; + +import org.opencv.core.Mat; +import org.opencv.core.Point; +import org.opencv.core.Size; + +import java.util.List; + +public class Points { + public static boolean inBounds(Point point, Size size) { + if(point.x < size.width - 1 && point.x >= 0 && point.y < size.height-1 && point.y >= 0) { + return true; + } + else { + return false; + } + } + + public static Point getMeanPoint(List points) { + if (points.size() == 0) return null; + double x = 0; + double y = 0; + for(Point point : points) { + x += Math.pow(point.x, 2); + y += Math.pow(point.y, 2); + } + return new Point(Math.sqrt(x/points.size()), Math.sqrt(y/points.size())); + } +} \ No newline at end of file diff --git a/DogeCV/src/main/jniLibs/armeabi-v7a/libopencv_java3.so b/DogeCV/src/main/jniLibs/armeabi-v7a/libopencv_java3.so new file mode 100644 index 00000000000..b57592c0f00 Binary files /dev/null and b/DogeCV/src/main/jniLibs/armeabi-v7a/libopencv_java3.so differ diff --git a/DogeCV/src/main/res/values/strings.xml b/DogeCV/src/main/res/values/strings.xml new file mode 100644 index 00000000000..72fdbe9e185 --- /dev/null +++ b/DogeCV/src/main/res/values/strings.xml @@ -0,0 +1,3 @@ + + CVFTC + diff --git a/FtcRobotController/build.gradle b/FtcRobotController/build.gradle index b73fbe4f1a9..186c31d94b9 100644 --- a/FtcRobotController/build.gradle +++ b/FtcRobotController/build.gradle @@ -2,7 +2,6 @@ // build.gradle in FtcRobotController // apply plugin: 'com.android.library' - android { defaultConfig { @@ -18,11 +17,13 @@ android { targetCompatibility JavaVersion.VERSION_1_7 } } - repositories { flatDir { dirs '../libs' } } - apply from: 'build.release.gradle' + +dependencies { + compile project(':openCVLibrary330') +} \ No newline at end of file diff --git a/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/external/samples/ConceptVuMarkIdentification.java b/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/external/samples/ConceptVuMarkIdentification.java index 041e2a20a85..fc7a53b4359 100644 --- a/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/external/samples/ConceptVuMarkIdentification.java +++ b/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/external/samples/ConceptVuMarkIdentification.java @@ -31,6 +31,7 @@ import com.qualcomm.robotcore.eventloop.opmode.Autonomous; import com.qualcomm.robotcore.eventloop.opmode.Disabled; import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode; +import com.vuforia.Image; import org.firstinspires.ftc.robotcore.external.ClassFactory; import org.firstinspires.ftc.robotcore.external.matrices.OpenGLMatrix; @@ -46,6 +47,8 @@ import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackableDefaultListener; import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackables; +import java.util.concurrent.BlockingQueue; + /** * This OpMode illustrates the basics of using the Vuforia engine to determine * the identity of Vuforia VuMarks encountered on the field. The code is structured as @@ -71,6 +74,8 @@ public class ConceptVuMarkIdentification extends LinearOpMode { public static final String TAG = "Vuforia VuMark Sample"; + private BlockingQueue ray; + OpenGLMatrix lastLocation = null; /** @@ -103,7 +108,7 @@ public class ConceptVuMarkIdentification extends LinearOpMode { * Once you've obtained a license key, copy the string from the Vuforia web site * and paste it in to your code onthe next line, between the double quotes. */ - parameters.vuforiaLicenseKey = "ATsODcD/////AAAAAVw2lR...d45oGpdljdOh5LuFB9nDNfckoxb8COxKSFX"; + parameters.vuforiaLicenseKey = "AZPbGaP/////AAAAGcIykH/KO0QNvZGSYxc0fDlVytYrk0HHv6OLmjHsswRvi/1l9RZCkepChaAZup3DIJlrjK2BV57DEz/noNO0oqT9iu2moP/svGmJ+pBG7FlfF4RHxu6UhvVLaKUZCsTJ1zTkd7XnMuRw8aSuIxowOiLJQYcgjmddi11LG26lAr6aRmoWJzr2pv6Yui2Gom0wt9J4+1g3kXqjngnH3h6NPA/6aUfpVngFaFPp5knyDJWZT88THttPsqcKW41QC/qgNh3CHIdADu15Rm51JNRlvG+2+sYstiHeHFQqCDwUkTgWor0v/Bk+xXoj3oUCb4REwT9w94E/VEI4qEAFPpmeo6YgxQ4LLFknu6tgNy8xdD6S"; /* * We also indicate which camera on the RC that we wish to use. @@ -129,6 +134,10 @@ public class ConceptVuMarkIdentification extends LinearOpMode { relicTrackables.activate(); + this.vuforia.setFrameQueueCapacity(1); + this.ray = this.vuforia.getFrameQueue(); + + while (opModeIsActive()) { /** @@ -172,6 +181,19 @@ public class ConceptVuMarkIdentification extends LinearOpMode { telemetry.addData("VuMark", "not visible"); } + try { + VuforiaLocalizer.CloseableFrame frame = ray.take(); + telemetry.addData("frame", frame.getNumImages() + " images"); + for (int i = 0; i < frame.getNumImages(); i++) { + Image temp = frame.getImage(i); + telemetry.addData("image #" + i, "type: %d width: %d", temp.getFormat(), temp.getBufferWidth()); + } + frame.close(); + } + catch (InterruptedException e) { + //oops + } + telemetry.update(); } } @@ -179,4 +201,24 @@ public class ConceptVuMarkIdentification extends LinearOpMode { String format(OpenGLMatrix transformationMatrix) { return (transformationMatrix != null) ? transformationMatrix.formatAsTransform() : "null"; } + + private class GetImg extends Thread { + @Override + public void run() { + try { + while(true) { + VuforiaLocalizer.CloseableFrame frame = ray.take(); + telemetry.addData("frame", frame.getNumImages() + " images"); + for (int i = 0; i < frame.getNumImages(); i++) { + Image temp = frame.getImage(i); + telemetry.addData("image #" + i, "type: ", temp.getFormat() + ", width:" + temp.getBufferHeight()); + } + } + } + catch (InterruptedException e) { + //oops + } + } + + } } diff --git a/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/internal/FtcRobotControllerActivity.java b/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/internal/FtcRobotControllerActivity.java index 4ec32fa4315..b22d656650d 100644 --- a/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/internal/FtcRobotControllerActivity.java +++ b/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/internal/FtcRobotControllerActivity.java @@ -622,4 +622,4 @@ protected class SharedPreferencesListener implements SharedPreferences.OnSharedP } } } -} +} \ No newline at end of file diff --git a/FtcRobotController/src/main/res/layout/activity_ftc_controller.xml b/FtcRobotController/src/main/res/layout/activity_ftc_controller.xml index b47f9c24782..335e37a7a73 100644 --- a/FtcRobotController/src/main/res/layout/activity_ftc_controller.xml +++ b/FtcRobotController/src/main/res/layout/activity_ftc_controller.xml @@ -125,13 +125,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. android:layout_below="@+id/textOpMode" android:layout_above="@+id/textGamepad1"> - - front of vehicle + // | | | + // | X | + // |__________________________| + + // we will use the convention PITCH = +X, ROLL = +Y, YAW(Heading) = +Z + // which corresponds to mounting the REV hub laying flat on the vehicle as shown above. + + // other orientations need these settings: + private byte[] config = { 0x24, 0x24, 0x21, 0x21, 0x6, 0x6, 0x9, 0x9, 0x21 }; + private byte[] sign = { 0x0, 0x6, 0x4, 0x2, 0x1, 0x4, 0x5, 0x3, 0x7 }; + // 0: flat with top of REV label on right side of vehicle (default): + // byte AXIS_MAP_CONFIG_BYTE = 0x24; // Z=Z Y=Y X=X + // byte AXIS_MAP_SIGN_BYTE = 0x0; // X Y Z + // 1: flat with top of REV label on left side of vehicle: + // byte AXIS_MAP_CONFIG_BYTE = 0x24; // Z=Z Y=-Y X=-X + // byte AXIS_MAP_SIGN_BYTE = 0x6; // -X -Y Z + // 2: flat with top of REV label along front side of vehicle: + // byte AXIS_MAP_CONFIG_BYTE = 0x21; // Z=Z Y=-X X=Y + // byte AXIS_MAP_SIGN_BYTE = 0x4; // -X Y Z + // 3: flat with top of REV label along back side of vehicle: + // byte AXIS_MAP_CONFIG_BYTE = 0x21; // Z=Z Y=X X=-Y + // byte AXIS_MAP_SIGN_BYTE = 0x2; // X -Y Z + // 4: upright longitudinally with R nearest the front of vehicle: + // byte AXIS_MAP_CONFIG_BYTE = 0x6; // Z=-X Y=-Y X=-Z + // byte AXIS_MAP_SIGN_BYTE = 0x1; // X Y -Z ?? if 0x7 -X -Y -Z, X and Y are LH rotations + // 5: upright longitudinally with V nearest the front of vehicle: + // byte AXIS_MAP_CONFIG_BYTE = 0x6; // Z=X Y=-Y X=Z + // byte AXIS_MAP_SIGN_BYTE = 0x4; // -X Y Z, X is RH, but around +=180 ?? + // 6: upright crosswise with REV facing backward: + // byte AXIS_MAP_CONFIG_BYTE = 0x9; // Z=-X Y=-Z X=Y + // byte AXIS_MAP_SIGN_BYTE = 0x5; // -X Y -Z + // 7: upright crosswise with REV facing forward: + // byte AXIS_MAP_CONFIG_BYTE = 0x9; // Z=-X Y=Z X=-Y + // byte AXIS_MAP_SIGN_BYTE = 0x3; // X -Y -Z ?? if 0x5 -X Y -Z, X and Y are LH rotations + // 8: flat face DOWN with top of REV label nearest the back of vehicle: + // byte AXIS_MAP_CONFIG_BYTE = 0x21; // Z=-Z Y=-X X=-Y + // byte AXIS_MAP_SIGN_BYTE = 0x7; // -X -Y -Z + + private void setRevOrientation(BNO055IMU imu, int orientation) { + + //Need to be in CONFIG mode to write to registers + imu.write8(BNO055IMU.Register.OPR_MODE, BNO055IMU.SensorMode.CONFIG.bVal); + sleep(19); //Changing to CONFIG mode require a delay of 19ms before doing anything else + + //Write to the AXIS_MAP_CONFIG register + imu.write8(BNO055IMU.Register.AXIS_MAP_CONFIG, config[orientation]); + + //Write to the AXIS_MAP_SIGN register + imu.write8(BNO055IMU.Register.AXIS_MAP_SIGN, sign[orientation]); + + //Need to change back into the IMU mode to use the gyro + imu.write8(BNO055IMU.Register.OPR_MODE, BNO055IMU.SensorMode.IMU.bVal); + sleep(7); //Changing back to any operating mode requires a delay of 7ms + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/DisplacementSensor.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/DisplacementSensor.java new file mode 100644 index 00000000000..690e420eec9 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/DisplacementSensor.java @@ -0,0 +1,13 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +/** + * Created by Robotics on 12/2/2016. + */ + +public interface DisplacementSensor { + + // return current heading reported by sensor, in degrees. + // convention is positive angles CCW, wrapping from 359-0 + public float getDisp(); + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/FinishSensor.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/FinishSensor.java new file mode 100644 index 00000000000..dea0924c4a9 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/FinishSensor.java @@ -0,0 +1,10 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +/** + * Created by Robotics on 12/2/2016. + */ + +public interface FinishSensor { + + public boolean checkStop(); +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/FunctionCall.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/FunctionCall.java new file mode 100644 index 00000000000..0d6b2b8f6f1 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/FunctionCall.java @@ -0,0 +1,11 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +/** + * Created by Noah on 3/17/2017. + */ + +public interface FunctionCall { + //simple interface to run step based on function pointer + + public void run(); +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/HeadingSensor.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/HeadingSensor.java new file mode 100644 index 00000000000..e5a5d922693 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/HeadingSensor.java @@ -0,0 +1,12 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +/** + * Created by phanau on 10/31/16. + */ +public interface HeadingSensor { + + // return current heading reported by sensor, in degrees. + // convention is positive angles CCW, wrapping from 359-0 + public float getHeading(); + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/LocationSensor.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/LocationSensor.java new file mode 100644 index 00000000000..cec612d20ba --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/LocationSensor.java @@ -0,0 +1,13 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +import org.firstinspires.ftc.robotcore.external.matrices.VectorF; + +/** + * Created by phanau on 11/1/16. + */ +public interface LocationSensor { + + // return current location on field reported by sensor, in mm from center post. + public VectorF getLocation(); + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/PointHandler.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/PointHandler.java new file mode 100644 index 00000000000..5a3b347bcb6 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/PointHandler.java @@ -0,0 +1,9 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +/** + * Created by Noah on 4/9/2017. + */ + +public interface PointHandler { + public float[] getPoints(); +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/SetPower.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/SetPower.java new file mode 100644 index 00000000000..de3c51ccca5 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libraries/interfaces/SetPower.java @@ -0,0 +1,9 @@ +package org.firstinspires.ftc.teamcode.libraries.interfaces; + +/** + * Created by Noah on 3/17/2017. + */ +// interface for setting the current power of either kind of MotorStep +public interface SetPower { + public void setPower(double power); +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/2020-21/SimpleDriveTeleOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/2020-21/SimpleDriveTeleOp.java new file mode 100644 index 00000000000..6aff06438b6 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/2020-21/SimpleDriveTeleOp.java @@ -0,0 +1,106 @@ +package org.firstinspires.ftc.teamcode.opmodes; + +import android.os.SystemClock; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotorEx; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.ToggleButton; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import com.qualcomm.robotcore.hardware.Gamepad; +import java.sql.Time; + +/* + * Made by Scoot, 10/4/2020 + **/ +@TeleOp(name="Simple Drive TeleOp") +public class SimpleDriveTeleOp extends OpMode { + private static final float slowPow = 0.33f; + private static final float fastPow = 1.0f; + private boolean robotSlow = false; //init value + private boolean lastA = false; + + protected BotHardware bot = new BotHardware(this); + + @Override + public void init(){ + bot.init(); + telemetry.addData("TeleOp Init", ""); + } + + @Override + public void start(){ + gamepad1.setJoystickDeadzone(0.05f); + gamepad2.setJoystickDeadzone(0.05f); + bot.start(); + telemetry.addData("TeleOp Start", ""); + } + + @Override + public void loop(){ + float tx = 2*gamepad1.right_stick_x*gamepad1.right_stick_x*gamepad1.right_stick_x; // WTF?? + float ty = -1*gamepad1.left_stick_y*gamepad1.left_stick_y*gamepad1.left_stick_y; + float left = (ty +tx /2 ); + float right = (ty -tx/2); + + float x = gamepad1.left_stick_x; //strafe + float y = -gamepad1.right_stick_y;//forward & back + x=x*x*x; + y=y*y*y; + + double theta = Math.atan2(-x, y); + double heading = theta * 180.0/Math.PI; + + AutoLib.MotorPowers mp = AutoLib.GetSquirrelyWheelMotorPowers(heading); + double front = mp.Front(); + double back = mp.Back(); + double power = Math.sqrt(x*x + y*y); + front *= power; + back *= power; + + if(robotSlow && gamepad1.a){ + robotSlow = false; + SystemClock.sleep(500); + + } + else if(!robotSlow && gamepad1.a){ + robotSlow = true; + SystemClock.sleep(500); + } + + double fr = 0f; + double br = 0f; + double fl = 0f; + double bl = 0f; + + if(robotSlow) { + fr = (back + right) * slowPow; //switched right sides font and back + br = (front + right) * slowPow; // WTF?? + fl = (front + left) * slowPow; + bl = (back + left) * slowPow; + } + else if(!robotSlow){ + fr = (back + right) * fastPow; //switched right sides font and back + br = (front + right) * fastPow; // WTF?? + fl = (front + left) * fastPow; + bl = (back + left) * fastPow; + } + + fr = Range.clip(fr, -1, 1); + br = Range.clip(br, -1, 1); + fl = Range.clip(fl, -1, 1); + bl = Range.clip(bl, -1, 1); + bot.setAllDrive(fr, br, fl, bl); + + telemetry.addData("Moto Pow", fr + ", " + br + ", " + fl +", " + bl); + telemetry.addData("slow mode", robotSlow); + } + + @Override + public void stop(){ + bot.stopAll(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/HardwareColorDistanceSensor.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/HardwareColorDistanceSensor.java new file mode 100644 index 00000000000..b9ae37a4b9d --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/HardwareColorDistanceSensor.java @@ -0,0 +1,75 @@ +package org.firstinspires.ftc.teamcode.opmodes; + +import android.graphics.Color; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.DistanceSensor; + +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; + +import java.util.Locale; + +/** + * Created by bremm on 10/20/2017. + */ + +@Autonomous(name = "Sensor: ColorDistance", group = "Sensor") +@Disabled + +public class HardwareColorDistanceSensor extends LinearOpMode { + + ColorSensor sensorColor; + DistanceSensor sensorDistance; + + @Override + public void runOpMode() { + + + sensorColor = hardwareMap.get(ColorSensor.class, "sensor_color_distance"); + sensorDistance = hardwareMap.get(DistanceSensor.class, "sensor_color_distance"); + + + float hsvValues[] = {0F, 0F, 0F}; + final float values[] = hsvValues; + + + final double SCALE_FACTOR = 255; + + /* int relativeLayoutId = hardwareMap.appContext.getResources().getIdentifier("RelativeLayout", "id", hardwareMap.appContext.getPackageName()); + final View relativeLayout = ((Activity) hardwareMap.appContext).findViewById(relativeLayoutId); */ + + waitForStart(); + + while (opModeIsActive()) { + + Color.RGBToHSV((int) (sensorColor.red() * SCALE_FACTOR), + (int) (sensorColor.green() * SCALE_FACTOR), + (int) (sensorColor.blue() * SCALE_FACTOR), + hsvValues); + + telemetry.addData("Distance (cm)", + String.format(Locale.US, "%.02f", sensorDistance.getDistance(DistanceUnit.CM))); + telemetry.addData("Alpha", sensorColor.alpha()); + telemetry.addData("Red ", sensorColor.red()); + telemetry.addData("Green", sensorColor.green()); + telemetry.addData("Blue ", sensorColor.blue()); + telemetry.addData("Hue", hsvValues[0]); + + /* relativeLayout.post(new Runnable() { + public void run() { + relativeLayout.setBackgroundColor(Color.HSVToColor(0xff, values)); + } + }); */ + + telemetry.update(); + } + /* relativeLayout.post(new Runnable() { + public void run() { + relativeLayout.setBackgroundColor(Color.WHITE); */ + } + }; + //} +//} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/RoverRuckusCode/RoverRuckusAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/RoverRuckusCode/RoverRuckusAuto.java new file mode 100644 index 00000000000..c6d847d5533 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/RoverRuckusCode/RoverRuckusAuto.java @@ -0,0 +1,30 @@ +package org.firstinspires.ftc.teamcode.opmodes.RoverRuckusCode; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.RoverRuckusRatbotHardware; + +@Autonomous(name = "RR2 Main Auto (Straight)") +public class RoverRuckusAuto extends OpMode{ + RoverRuckusRatbotHardware robot = new RoverRuckusRatbotHardware(); + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + public void init() { + robot.init(hardwareMap); + mSeq.add(new AutoLib.MoveByEncoderStep(robot.fl, robot.fr, 1.0f, 6000, true)); + //mSeq.add(new AutoLib.TurnByEncoderStep(robot.fr, robot.fl, 1.0f, -1.0f, 2000, -2000, true)); + } + + @Override + public void start() { + + } + + @Override + public void loop() { + if(mSeq.loop()) requestOpModeStop(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/RoverRuckusCode/RoverRuckusRatbotTeleOP.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/RoverRuckusCode/RoverRuckusRatbotTeleOP.java new file mode 100644 index 00000000000..63f34253afe --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/RoverRuckusCode/RoverRuckusRatbotTeleOP.java @@ -0,0 +1,62 @@ +package org.firstinspires.ftc.teamcode.opmodes.RoverRuckusCode; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; + +import org.firstinspires.ftc.teamcode.libraries.hardware.RoverRuckusRatbotHardware; + +import java.text.DecimalFormat; + +/** + * Created by bremm on 10/26/18. + */ + +@TeleOp(name="Rover Ruckus TeleOp") + + + +public class RoverRuckusRatbotTeleOP extends OpMode{ + RoverRuckusRatbotHardware robot = new RoverRuckusRatbotHardware(); + + double left, right; + double speedFactor = 0.5; + double liftSpeed = 1; + DecimalFormat printFormat = new DecimalFormat ("#.###"); + + @Override + public void init() { + robot.init(hardwareMap); + } + + @Override + public void loop() { + if(gamepad1.left_bumper && !gamepad1.right_bumper){ + speedFactor = 1; } //Fast Speed (Left Bumper, Gamepad 1) + else if(gamepad1.right_bumper && !gamepad1.left_bumper){ + speedFactor = 0.25; } //Slow Speed (Right Bumper, Gamepad 1) + else if(!gamepad1.right_bumper && !gamepad1.left_bumper){ + speedFactor = 0.5; } //Medium Speed (Default Mode (No Bumpers), Gamepad 1) + + if(gamepad2.left_bumper && !gamepad2.right_bumper){ + robot.lift.setPower(liftSpeed); } //Raise LIft (Left Bumper, Gamepad 2) + else if(gamepad2.right_bumper && !gamepad2.left_bumper){ + robot.lift.setPower(-1 * liftSpeed); } //Lower Lift (Right Bumper, Gamepad 2) + else if(!gamepad2.right_bumper && !gamepad2.left_bumper){ + robot.lift.setPower(0); } + + + left = (-1) * Math.pow(gamepad1.left_stick_y, 3) * speedFactor; + right = (-1) * Math.pow(gamepad1.right_stick_y, 3) * speedFactor; + + robot.fl.setPower(left); + robot.bl.setPower(left); + robot.fr.setPower(right); + robot.br.setPower(right); + + telemetry.addData("Drive Speed: ", printFormat.format(speedFactor)); + telemetry.addData("Left: ", printFormat.format(left)); + telemetry.addData("Right: ", printFormat.format(right)); + telemetry.addData("Lift Motor: ", printFormat.format(robot.lift.getPower())); + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/APDSDistance.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/APDSDistance.java new file mode 100644 index 00000000000..ef04d791916 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/APDSDistance.java @@ -0,0 +1,118 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; + +import org.firstinspires.ftc.robotcore.external.Func; +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9930; +import org.firstinspires.ftc.teamcode.libraries.CrappyGraphLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9960; + +import java.util.Arrays; +import java.util.LinkedList; + +/** + * Created by Noah on 12/21/2017. + */ + +@Autonomous(name = "APDS Linearization", group = "test") +@Disabled +public class APDSDistance extends CrappyGraphLib { + APDS9960 dist; + APDS9960.Config distConfig = new APDS9960.Config(); + APDS9960 redDist; + APDS9960.Config redDistConfig = new APDS9960.Config(); + + private int regDist; + private double linearDist; + private int redRegDist; + private double redLinearDist; + + private LinkedList data = new LinkedList<>(); + + public void init() { + initGraph(data, true); + + dist = new APDS9960(distConfig, hardwareMap.get(I2cDeviceSynch.class, "bluedist"), true, APDS9960.Config.DistGain.GAIN_8X); + redDist = new APDS9960(redDistConfig, hardwareMap.get(I2cDeviceSynch.class, "reddist"), true, APDS9960.Config.DistGain.GAIN_8X); + dist.initDevice(); + redDist.initDevice(); + dist.startDevice(); + redDist.startDevice(); + + telemetry.addAction(new Runnable() { + @Override + public void run() { + APDS9960.Config.DistGain mahGain = dist.getSensorGain(); + regDist = dist.getDist(); + linearDist = dist.getLinearizedDistance(regDist, mahGain, false); + mahGain = redDist.getSensorGain(); + redRegDist = redDist.getDist(); + redLinearDist = redDist.getLinearizedDistance(redRegDist, mahGain, false); + } + }); + + telemetry.addLine().addData("Unfixed Distance", new Func() { + @Override + public Integer value() { + return regDist; + } + }); + telemetry.addLine().addData("Linear Distance", new Func() { + @Override + public Double value() { + return linearDist; + } + }); + + telemetry.addLine().addData("Red Unfixed Distance", new Func() { + @Override + public Integer value() { + return redRegDist; + } + }); + telemetry.addLine().addData("Red Linear Distance", new Func() { + @Override + public Double value() { + return redLinearDist; + } + }); + } + + public void start() { + telemetry.clearAll(); + } + + public void loop() { + APDS9960.Config.DistGain gain = dist.getSensorGain(); + int heh = dist.getDist(); + linearDist = dist.getLinearizedDistance(heh, gain, false); + + APDS9960.Config.DistGain gain2 = redDist.getSensorGain(); + int heh2 = redDist.getDist(); + double linearDist2 = redDist.getLinearizedDistance(heh2, gain2, false); + + //add graph stuff + this.data.add(linearDist); + if(this.data.size() > 100) this.data.remove(); + + drawGraph(); + telemetry.addData("BLUE", ""); + telemetry.addData("Gain", dist.getSensorGain().toString()); + telemetry.addData("Regular", heh); + telemetry.addData("Linear", linearDist); + telemetry.addData("Color", Arrays.toString(dist.getColor())); + telemetry.addData("RED", ""); + telemetry.addData("Red Gain", redDist.getSensorGain().toString()); + telemetry.addData("Red Regular", heh2); + telemetry.addData("Red Linear", linearDist2); + telemetry.addData("Red Color", Arrays.toString(redDist.getColor())); + } + + public void stop() { + dist.stopDevice(); + redDist.stopDevice(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/APDSGrapher.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/APDSGrapher.java new file mode 100644 index 00000000000..cf481884b1e --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/APDSGrapher.java @@ -0,0 +1,100 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; +/*( +import android.app.Activity; +import android.graphics.Color; +import android.view.ViewGroup; +import android.widget.RelativeLayout; +import com.github.mikephil.charting.charts.LineChart; +import com.github.mikephil.charting.data.Entry; +import com.github.mikephil.charting.data.LineData; +import com.github.mikephil.charting.data.LineDataSet; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; + +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9960; + +import java.util.LinkedList; +import java.util.concurrent.locks.ReentrantReadWriteLock; +*/ + +/** + * Created by Noah on 10/16/2017. + * Opmode demonstrating the APDS distance sensor with a graph + */ +/* + +@Autonomous(name = "APDS", group = "Line Follow") +@Disabled +public class APDSGrapher extends OpMode{ + APDS9960 dist; + + private RelativeLayout layout; + private LineChart chart; + + final LinkedList data = new LinkedList<>(); + final ReentrantReadWriteLock dataLock = new ReentrantReadWriteLock(); + + byte thing; + + @Override + public void init() { + final APDS9960.Config config = new APDS9960.Config(); + config.setPulse(APDS9960.Config.PulseLength.PULSE_16US, (byte)8, APDS9960.Config.LEDStrength.STREN_100MA, APDS9960.Config.LEDBoost.BOOST_1X, APDS9960.Config.DistGain.GAIN_4X); + dist = new APDS9960(config, hardwareMap.get(I2cDeviceSynch.class, "bluedist")); + thing = dist.initDevice(); + + //graph stuff + layout = (RelativeLayout)((Activity)hardwareMap.appContext).findViewById(com.qualcomm.ftcrobotcontroller.R.id.CheapCamera); + + Runnable doGraphSetup = new Runnable() { + @Override + public void run() { + chart = new LineChart(hardwareMap.appContext); + + RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT); + layout.addView(chart, params); + } + }; + + layout.getHandler().post(doGraphSetup); + } + + @Override + public void start() { + dist.startDevice(); + } + + @Override + public void loop() { + telemetry.addData("dist", dist.getDist()); + telemetry.addData("ID", thing & 0xFF); + + final double run = getRuntime(); + //dataLock.readLock().lock(); + final LineDataSet lineData = new LineDataSet(data, "Dist (mm)"); + final LineData realLineData = new LineData(lineData); + //dataLock.readLock().unlock(); + + lineData.setColor(Color.GREEN); + //add data + dataLock.writeLock().lock(); + if(data.size() >= 50) data.removeFirst(); + data.add(new Entry((float)run, (float)dist.getDist())); + dataLock.writeLock().unlock(); + + Runnable postData = new Runnable() { + @Override + public void run() { + dataLock.readLock().lock(); + chart.setData(realLineData); + chart.invalidate(); + dataLock.readLock().unlock(); + } + }; + + layout.getHandler().post(postData); + } +} +*/ \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/BlinkTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/BlinkTest.java new file mode 100644 index 00000000000..c3ae98f44b3 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/BlinkTest.java @@ -0,0 +1,44 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.hardware.adafruit.AdafruitI2cColorSensor; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.DcMotor; +import org.firstinspires.ftc.teamcode.libraries.hardware.StupidColor; + +/** + * Created by Noah on 3/6/2018. + */ + +@TeleOp(name="Lights On") +@Disabled +public class BlinkTest extends OpMode { + private DcMotor glow; + private ColorSensor frontColor; + private ColorSensor backColor; + + + public void init() { + glow = hardwareMap.get(DcMotor.class, "g"); + frontColor = new StupidColor(hardwareMap.get(AdafruitI2cColorSensor.class, "fc")); + backColor = new StupidColor(hardwareMap.get(AdafruitI2cColorSensor.class, "bc")); + + frontColor.enableLed(false); + backColor.enableLed(false); + glow.setPower(1); + } + + public void start() { + + } + + public void loop() { + + } + + public void stop() { + glow.setPower(0); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/CVBallDemo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/CVBallDemo.java new file mode 100644 index 00000000000..cb323044dbc --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/CVBallDemo.java @@ -0,0 +1,68 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.graphics.Bitmap; +import android.hardware.camera2.CameraDevice; +import android.os.Environment; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.libraries.VuforiaBallLib; + +import java.io.FileOutputStream; +import java.io.IOException; + +/** + * Created by Noah on 2/27/2018. + */ + +@Autonomous(name = "CV Ball Demo") +@Disabled +public class CVBallDemo extends VuforiaBallLib { + @Override + public void init() { + initVuforia(true); + super.startTracking(); + } + + public void init_loop() { + getCVBallColor(); + } + + @Override + public void start() { + FileOutputStream out = null; + try{ + out = new FileOutputStream(Environment.getExternalStorageDirectory().getAbsolutePath() + "/balls.png"); + bm.compress(Bitmap.CompressFormat.PNG, 100, out); + + } + catch(Exception e) { + //oops + e.printStackTrace(); + } + finally { + try { + if (out != null) { + out.close(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + com.vuforia.CameraDevice.getInstance().setFlashTorchMode(true); + } + + @Override + public void loop() { + telemetry.addData("Path", Environment.getExternalStorageDirectory().getAbsolutePath() + "/balls.png"); + telemetry.addData("Tracking", isTracking().toString()); + telemetry.addData("Ball Color", getCVBallColor()); + } + + @Override + public void stop() { + super.stopVuforia(); + com.vuforia.CameraDevice.getInstance().setFlashTorchMode(true); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/Color.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/Color.java new file mode 100644 index 00000000000..7a5d5eab376 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/Color.java @@ -0,0 +1,70 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.hardware.adafruit.AdafruitI2cColorSensor; +import com.qualcomm.hardware.ams.AMSColorSensor; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; + +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9960; +import org.firstinspires.ftc.teamcode.libraries.hardware.StupidColor; + +import java.util.Arrays; + +/** + * Created by Noah on 2/21/2018. + */ + +@Autonomous(name = "Color", group = "test") +@Disabled +public class Color extends OpMode { + APDS9960 frontDist; + APDS9960.Config distConfig = new APDS9960.Config(); + APDS9960.Config backDistConfig = new APDS9960.Config(); + APDS9960 backDist; + StupidColor frontColor; + ColorSensor backColor; + + public void init() { + /* + frontDist = new APDS9960(distConfig, hardwareMap.get(I2cDeviceSynch.class, "reddist"), true, APDS9960.Config.DistGain.GAIN_8X); + backDist = new APDS9960(distConfig, hardwareMap.get(I2cDeviceSynch.class, "bluedist"), true, APDS9960.Config.DistGain.GAIN_8X); + frontDist.initDevice(); + backDist.initDevice(); + */ + + frontColor = new StupidColor(hardwareMap.get(AdafruitI2cColorSensor.class, "fc")); + frontColor.setGain(AMSColorSensor.Gain.GAIN_64); + + //backColor = new StupidColor(hardwareMap.get(AdafruitI2cColorSensor.class, "bc")); + + //frontColor.enableLed(true); + //backColor.enableLed(true); + } + + public void start() { + //frontDist.startDevice(); + //backDist.startDevice(); + } + + public void loop() { + //telemetry.addData("Distance", dist.getLinearizedDistance(false)); + telemetry.addData("Front Red", frontColor.red()); + telemetry.addData("Front Green", frontColor.green()); + telemetry.addData("Front Blue", frontColor.blue()); + /* + telemetry.addData("Back Red", backColor.red()); + telemetry.addData("Back Green", backColor.green()); + telemetry.addData("Back Blue", backColor.blue()); + telemetry.addData("APDS Front", Arrays.toString(frontDist.getColor())); + telemetry.addData("APDS Back", Arrays.toString(backDist.getColor())); + */ + } + + public void stop() { + //frontColor.enableLed(false); + //backColor.enableLed(false); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderHoneTweak.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderHoneTweak.java new file mode 100644 index 00000000000..b8487865aed --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderHoneTweak.java @@ -0,0 +1,77 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.EncoderHoneStep; +import org.firstinspires.ftc.teamcode.libraries.GyroCorrectStep; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.UDPid; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 3/27/2018. + * Tweaking encoder pid values using the internet! + */ + + +@TeleOp(name="Wifi Encoder PID Tweak") +@Disabled +public class EncoderHoneTweak extends OpMode { + private final BotHardware bot = new BotHardware(this); + private final UDPid udPid = new UDPid(); + private final SensorLib.PID gyroTurnPID = new SensorLib.PID(-16.0f, 0, 0, 0); + private static final float POWER = 100; + private static final float POWER_MIN = 55; + private static final float POWER_MAX = 720; + private static final int COUNTS = 500; + + private AutoLib.Sequence step; + + private boolean drivingBackward = false; + + public void init() { + udPid.beginListening(); + bot.init(); + bot.start(); + } + + public void init_loop() { + telemetry.addData("P", udPid.getP()); + telemetry.addData("I", udPid.getI()); + telemetry.addData("D", udPid.getD()); + } + + public void start() { + step = makeEncoderStep(drivingBackward); + } + + public void loop() { + if(step.loop()) step = makeEncoderStep(drivingBackward = !drivingBackward); + telemetry.addData("P", udPid.getP() * 100); + telemetry.addData("I", udPid.getI() * 1000); + telemetry.addData("D", udPid.getD() * 100); + } + + public void stop() { + bot.stopAll(); + udPid.shutdown(); + } + + private GyroCorrectStep makeGyroDriveStep(float heading, SensorLib.PID pid, float power, float powerMin, float powerMax) { + return new GyroCorrectStep(this, heading, bot.getHeadingSensor(), pid, bot.getMotorVelocityShimArray(), power, powerMin, powerMax, 0.5f); + } + + private AutoLib.Sequence makeEncoderStep(boolean reversed) { + AutoLib.LinearSequence mSeq = new AutoLib.LinearSequence(); + mSeq.add(new EncoderHoneStep(this, reversed ? -COUNTS : COUNTS, 5, 25, + new SensorLib.PID((float)udPid.getP() * 100, (float)udPid.getI() * 1000, (float)udPid.getD() * 100, 50), + makeGyroDriveStep(0, gyroTurnPID, POWER, POWER_MIN, POWER_MAX), + new DcMotor[] {BotHardware.Motor.frontLeft.motor, BotHardware.Motor.frontRight.motor})); + mSeq.add(new AutoLib.LogTimeStep(this, "WAIT", 1.0)); + return mSeq; + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderIntegration.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderIntegration.java new file mode 100644 index 00000000000..c717423ad7b --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderIntegration.java @@ -0,0 +1,82 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; + +/** + * Created by Noah on 3/19/2018. + */ + +@TeleOp(name="Encoder Integration") +@Disabled +public class EncoderIntegration extends OpMode { + double xpos = 0; + double ypos = 0; + int leftEncoderLast = 0; + int rightEncoderLast = 0; + float lastHeading = 0; + double lastNetForward = 0; + + HeadingSensor sensor; + static final float slowFactor = 0.4f; + + protected BotHardware bot = new BotHardware(this); + + @Override + public void init() { + bot.init(); + DcMotor[] ray = bot.getMotorRay(); + for(DcMotor motor : ray) + motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER); + bot.start(); + sensor = bot.getHeadingSensor(); + } + + @Override + public void start() { + leftEncoderLast = BotHardware.Motor.frontLeft.motor.getCurrentPosition(); + rightEncoderLast = BotHardware.Motor.frontRight.motor.getCurrentPosition(); + lastHeading = sensor.getHeading(); + + telemetry.addAction(new Runnable() { + @Override + public void run() { + telemetry.addData("XPos", xpos); + telemetry.addData("YPos", ypos); + telemetry.addData("Heading", lastHeading); + telemetry.addData("Net Forward", lastNetForward); + } + }); + } + + @Override + public void loop() { + //Integrate! + int nowEncoderLeft = BotHardware.Motor.frontLeft.motor.getCurrentPosition(); + int nowEncoderRight = BotHardware.Motor.frontRight.motor.getCurrentPosition(); + lastHeading = sensor.getHeading(); + + //get net forward movement from averaging encoder counts + double netForward = ((nowEncoderLeft - leftEncoderLast) + (nowEncoderRight - rightEncoderLast)) / 2.0; + //use vector with heading and gyro and determine x and y movement + xpos += Math.cos(Math.toRadians(lastHeading)) * netForward; + ypos += Math.sin(Math.toRadians(lastHeading)) * netForward; + + leftEncoderLast = nowEncoderLeft; + rightEncoderLast = nowEncoderRight; + lastNetForward = netForward; + + bot.setLeftDrive(gamepad1.left_stick_y * slowFactor); + bot.setRightDrive(gamepad1.right_stick_y * slowFactor); + } + + @Override + public void stop() { + super.stop(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderRotationData.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderRotationData.java new file mode 100644 index 00000000000..161504129d8 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/EncoderRotationData.java @@ -0,0 +1,139 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.graphics.Bitmap; +import android.os.Environment; +import android.util.JsonWriter; +import android.widget.Toast; + +import com.disnodeteam.dogecv.math.Line; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.IOException; +import java.io.Writer; +import java.util.LinkedList; +import java.util.concurrent.TimeUnit; + +/** + * Created by Noah on 3/25/2018. + */ + +@Autonomous(name="Ultra Encoder Stuff") +@Disabled +public class EncoderRotationData extends OpMode { + private final int COUNTS = 750; + private final float POWER = 0.4f; + //parameters for gyro turning + private float Kp5 = 10.0f; // degree heading proportional term correction per degree of deviation + private float Ki5 = 0.0f; // ... integrator term + private float Kd5 = 0; // ... derivative term + private float Ki5Cutoff = 0.0f; // maximum angle error for which we update integrator + + private final SensorLib.PID motorPID = new SensorLib.PID(Kp5, Ki5, Kd5, Ki5Cutoff); + + private AutoLib.LinearSequence mSeq; + private final BotHardware bot = new BotHardware(this); + private MatbotixUltra sensor; + + private int startUltra; + private int startCount; + + private JSONArray dataRay = new JSONArray(); + + public void init() { + bot.init(); + bot.start(); + + sensor = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraback"), 100); + sensor.initDevice(); + sensor.startDevice(); + sensor.getReading(); + + buildSeq(); + } + + public void start() { + startUltra = sensor.getReading(); + startCount = BotHardware.Motor.frontRight.motor.getCurrentPosition(); + } + + public void loop() { + if(mSeq.loop()) buildSeq(); + } + + public void stop() { + bot.stopAll(); + + Writer output = null; + try { + File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/data.json"); + output = new BufferedWriter(new FileWriter(file)); + output.write(dataRay.toString()); + Toast.makeText(hardwareMap.appContext, "F ME IT WORKED", Toast.LENGTH_LONG).show(); + } + catch(Exception e) { + //oops + e.printStackTrace(); + } + finally { + try { + if (output != null) { + output.close(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + private void buildSeq() { + int counts = COUNTS + (int)Math.round(Math.random() * 1000 - 500); + + mSeq = new AutoLib.LinearSequence(); + mSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorRay(), -POWER, counts, true)); + mSeq.add(new AutoLib.LogTimeStep(this, "WAIT", 1.0)); + mSeq.add(new RecordUltra()); + mSeq.add(new AutoLib.GyroTurnStep(this, 0, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 90.0f, 360.0f, motorPID, 0.25f, 10, true)); + mSeq.add(new AutoLib.LogTimeStep(this, "WAIT", 1.0)); + mSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorRay(), POWER, counts, true)); + mSeq.add(new AutoLib.LogTimeStep(this, "WAIT", 1.0)); + mSeq.add(new RecordUltra()); + mSeq.add(new AutoLib.GyroTurnStep(this, 0, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 90.0f, 360.0f, motorPID, 0.25f, 10, true)); + mSeq.add(new AutoLib.LogTimeStep(this, "WAIT", 1.0)); + } + + private class RecordUltra extends AutoLib.Step { + public boolean loop() { + int reading = sensor.getReading(); + int pos = BotHardware.Motor.frontRight.motor.getCurrentPosition(); + JSONObject data = new JSONObject(); + try { + data.put("ultra", Math.abs(reading - startUltra)); + data.put("encode", Math.abs(pos - startCount)); + } + catch (JSONException e) { + throw new IllegalStateException(e.getMessage()); + } + dataRay.put(data); + startUltra = reading; + startCount = pos; + return true; + } + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GlyphHunting.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GlyphHunting.java new file mode 100644 index 00000000000..49db184b260 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GlyphHunting.java @@ -0,0 +1,211 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.DcMotorEx; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.CrappyGraphLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +import java.util.Date; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.TimeUnit; + +/** + * Created by Noah on 3/19/2018. + */ + +@TeleOp(name="Glyph Motor Speed") +@Disabled +public class GlyphHunting extends CrappyGraphLib { + BotHardware bot = new BotHardware(this); + //private int lastLeft = 0; + private LinkedList data = new LinkedList<>(); + double lastLeft; + double lastRight; + boolean motorStopped = false; + boolean leftStopped = false; + boolean motorRamping = false; + int motorRampCount = 0; + + private static final int MIN_VELOCITY = 550; + private static final int FOUND_VELOCITY = 790; + + public void init() { + bot.init(); + BotHardware.Motor.suckRight.motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER); + BotHardware.Motor.suckLeft.motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER); + BotHardware.Motor.suckLeft.motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + //bot.start(); + } + + public void start() { + initGraph(data, true); + + telemetry.addAction(new Runnable() { + @Override + public void run() { + telemetry.addData("Left Velocity", lastLeft); + telemetry.addData("Right Velocity", lastRight); + } + }); + + bot.setSuckRight(1); + bot.setSuckLeft(1); + motorRamping = true; + } + + public void loop() { + lastRight = BotHardware.Motor.suckRight.motor.getVelocity(AngleUnit.DEGREES); + lastLeft = BotHardware.Motor.suckLeft.motor.getVelocity(AngleUnit.DEGREES); + + if(motorRamping) { + if(lastRight > MIN_VELOCITY && lastLeft > MIN_VELOCITY) motorRampCount++; + else motorRampCount = 0; + if(motorRampCount >= 10) { + motorRamping = false; + motorRampCount = 0; + } + } + else if(!motorStopped){ + if(lastRight < MIN_VELOCITY || lastLeft < MIN_VELOCITY) { + if(lastLeft < lastRight) { + BotHardware.Motor.suckRight.motor.setPower(0); + leftStopped = false; + } + else { + BotHardware.Motor.suckLeft.motor.setPower(0); + leftStopped = true; + } + motorStopped = true; + } + else if(lastLeft < FOUND_VELOCITY) { + bot.setLeftDrive(-0.4f); + bot.setRightDrive(0); + } + else if(lastRight < FOUND_VELOCITY) { + bot.setLeftDrive(0); + bot.setRightDrive(-0.4f); + } + else { + bot.setLeftDrive(0); + bot.setRightDrive(0); + } + } + else if((leftStopped && lastRight > MIN_VELOCITY) || (!leftStopped && lastLeft > MIN_VELOCITY)) { + BotHardware.Motor.suckLeft.motor.setPower(1); + BotHardware.Motor.suckRight.motor.setPower(1); + bot.setRightDrive(0); + bot.setLeftDrive(0); + motorStopped = false; + motorRamping = true; + } + + data.add(lastRight); + if(data.size() > 200) data.remove(); + drawGraph(); + } + + public void stop() { + bot.stopAll(); + } + + public static class GlyphHunt extends AutoLib.Step { + private enum HUNT_STATE { + SEARCHING_LEFT, + SEARCHING_RIGHT, + HUNTING_LEFT, + HUNTING_RIGHT, + } + + private final DcMotorEx[] drive; + private final DcMotorEx[] sucks; + private final int searchTime; + private final float huntSpeed; + private final int huntTime; + private final float power; + private HUNT_STATE state = null; + private long startMillis; + private boolean motorsRamped = false; + //sucks are right then left + //drive is fr br fl bl + GlyphHunt(DcMotorEx[] motors, DcMotorEx[] sucks, int searchMillis, float huntVelocity, int huntMillis, float drivePower) { + this.drive = motors; + this.sucks = sucks; + this.searchTime = searchMillis; + this.huntSpeed = huntVelocity; + this.huntTime = huntMillis; + this.power = drivePower; + int D = 3; + if(8==D) motors.clone(); //wait + } + public boolean loop() { + super.loop(); + if(firstLoopCall()) { + setSuck(power); + setRightDrive(0); + setLeftDrive(power); + state = HUNT_STATE.SEARCHING_LEFT; + startMillis = System.currentTimeMillis(); + } + if(!motorsRamped) { + if(sucks[0].getVelocity(AngleUnit.DEGREES) > huntSpeed && sucks[1].getVelocity(AngleUnit.DEGREES) > huntSpeed) motorsRamped = true; + if(!motorsRamped) return false; + } + //check if we should start hunting + if(state == HUNT_STATE.SEARCHING_LEFT || state == HUNT_STATE.SEARCHING_RIGHT) { + //right + if(sucks[0].getVelocity(AngleUnit.DEGREES) < huntSpeed) { + setRightDrive(power); + setLeftDrive(0); + state = HUNT_STATE.HUNTING_LEFT; + startMillis = System.currentTimeMillis(); + } + //left + else if(sucks[1].getVelocity(AngleUnit.DEGREES) < huntSpeed) { + setRightDrive(0); + setLeftDrive(power); + state = HUNT_STATE.HUNTING_RIGHT; + startMillis = System.currentTimeMillis(); + } + } + //run state machine + long deltaTime = System.currentTimeMillis() - startMillis; + if( ((state == HUNT_STATE.SEARCHING_RIGHT || state == HUNT_STATE.SEARCHING_LEFT) && deltaTime >= searchTime) + || ((state == HUNT_STATE.HUNTING_RIGHT || state == HUNT_STATE.HUNTING_RIGHT) && deltaTime >= huntTime)) { + //switch state and searching direction + if(state == HUNT_STATE.SEARCHING_LEFT || state == HUNT_STATE.HUNTING_LEFT) { + setRightDrive(power); + setLeftDrive(0); + state = HUNT_STATE.SEARCHING_RIGHT; + } + else if(state == HUNT_STATE.SEARCHING_RIGHT || state == HUNT_STATE.HUNTING_RIGHT) { + setRightDrive(0); + setLeftDrive(power); + state = HUNT_STATE.SEARCHING_LEFT; + } + startMillis = System.currentTimeMillis(); + } + return false; + } + + private void setRightDrive(float power) { + drive[0].setPower(power); + drive[1].setPower(power); + } + + private void setLeftDrive(float power) { + drive[1].setPower(power); + drive[2].setPower(power); + } + + private void setSuck(float power) { + for(DcMotor i : sucks) i.setPower(power); + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GlyphStupid.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GlyphStupid.java new file mode 100644 index 00000000000..54e239c1fae --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GlyphStupid.java @@ -0,0 +1,66 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +import java.util.concurrent.TimeUnit; + +/** + * Created by Noah on 3/23/2018. + */ + +@Autonomous(name="Glyph Hunt") +@Disabled +public class GlyphStupid extends OpMode{ + BotHardware bot = new BotHardware(this); + private static final int FOUND_VELOCITY = 790; + + public void init() { + bot.init(); + BotHardware.Motor.suckRight.motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER); + BotHardware.Motor.suckLeft.motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER); + BotHardware.Motor.suckLeft.motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + BotHardware.Motor.suckRight.motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + } + + public void start() { + bot.setSuckRight(1); + bot.setSuckLeft(1); + + try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) {} + } + + public void loop() { + double lastRight = BotHardware.Motor.suckRight.motor.getVelocity(AngleUnit.DEGREES); + double lastLeft = BotHardware.Motor.suckLeft.motor.getVelocity(AngleUnit.DEGREES); + + if(lastLeft < 100 || lastLeft < 100) { + bot.setRightDrive(0); + bot.setLeftDrive(0); + bot.setSuckLeft(0); + bot.setSuckRight(0); + requestOpModeStop(); + } + else if(lastLeft < FOUND_VELOCITY) { + bot.setLeftDrive(-0.2f); + bot.setRightDrive(0.1f); + } + else if(lastRight < FOUND_VELOCITY) { + bot.setLeftDrive(0.1f); + bot.setRightDrive(-0.2f); + } + else { + bot.setLeftDrive(0); + bot.setRightDrive(0); + } + } + + public void stop() { + bot.stopAll(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GraphDemo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GraphDemo.java new file mode 100644 index 00000000000..7f0c40b1b89 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GraphDemo.java @@ -0,0 +1,114 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; +/* +import android.app.Activity; +import android.graphics.Color; +import android.os.Handler; +import android.util.AttributeSet; +import android.view.ViewGroup; +import android.widget.RelativeLayout; + +import com.github.mikephil.charting.charts.LineChart; +import com.github.mikephil.charting.data.DataSet; +import com.github.mikephil.charting.data.Entry; +import com.github.mikephil.charting.data.LineData; +import com.github.mikephil.charting.data.LineDataSet; +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.robotcontroller.internal.FtcRobotControllerActivity; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by Noah on 4/2/2017. + + +@Autonomous(name="Graph Fun", group="Test") +@Disabled +public class GraphDemo extends OpMode{ + int stupid = 0; + + private RelativeLayout layout; + private LineChart chart; + + @Override + public void init(){ + telemetry.addData("Graph test!", "Go!"); + telemetry.update(); + + layout = (RelativeLayout)((Activity)hardwareMap.appContext).findViewById(com.qualcomm.ftcrobotcontroller.R.id.CheapCamera); + + Runnable doGraphSetup = new Runnable() { + @Override + public void run() { + chart = new LineChart(hardwareMap.appContext); + + RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT); + layout.addView(chart, params); + } + }; + + layout.getHandler().post(doGraphSetup); + + + + List data = new ArrayList(); + + for(int i = 0; i < 50; i++){ + data.add(new Entry(i, i % 5)); + } + + LineDataSet datas = new LineDataSet(data, "Rando"); + datas.setColor(Color.GREEN); + + final LineData maDatum = new LineData(datas); + + Runnable postData = new Runnable() { + @Override + public void run() { + chart.setData(maDatum); + //chart.setAutoScaleMinMaxEnabled(true); + chart.fitScreen(); + chart.setTouchEnabled(true); + //chart.enableScroll(); + //chart.setDoubleTapToZoomEnabled(true); + chart.invalidate(); + //chart.setAutoScaleMinMaxEnabled(true); + chart.fitScreen(); + chart.setAlpha(1.0f); + } + }; + + layout.getHandler().post(postData); + } + + @Override + public void init_loop(){ + + } + + @Override + public void start(){ + + } + + @Override + public void loop(){ + + } + + @Override + public void stop(){ + Runnable hideChart = new Runnable() { + @Override + public void run() { + chart.setAlpha(0.0f); + layout.removeView(chart); + } + }; + + layout.getHandler().post(hideChart); + } + +} +*/ \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GyroTurnTweak.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GyroTurnTweak.java new file mode 100644 index 00000000000..c59008f05ad --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GyroTurnTweak.java @@ -0,0 +1,59 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.UDPid; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 4/4/2018. + */ + +@Autonomous(name="Gyro PID Tweak") +@Disabled +public class GyroTurnTweak extends OpMode { + private final BotHardware bot = new BotHardware(this); + private final UDPid udPid = new UDPid(); + + private AutoLib.Sequence step; + private boolean reversed = false; + + public void init() { + udPid.beginListening(); + bot.init(); + bot.start(); + } + + public void init_loop() { + telemetry.addData("P", udPid.getP()); + telemetry.addData("I", udPid.getI()); + telemetry.addData("D", udPid.getD()); + } + + public void start() { + step = makeTurnStep(reversed); + } + + public void loop() { + if(step.loop()) step = makeTurnStep(reversed = !reversed); + telemetry.addData("P", udPid.getP()); + telemetry.addData("I", udPid.getI()); + telemetry.addData("D", udPid.getD()); + } + + public void stop() { + bot.stopAll(); + udPid.shutdown(); + } + + private AutoLib.Sequence makeTurnStep(boolean reversed) { + AutoLib.LinearSequence mSeq = new AutoLib.LinearSequence(); + mSeq.add(new AutoLib.GyroTurnStep(this, reversed ? 0 : 180, bot.getHeadingSensor(), bot.getMotorRay(), 0.045f, 0.7f, new SensorLib.PID((float)udPid.getP(), (float)udPid.getI(), (float)udPid.getD(), 7.0f), 2f, 5, true)); + mSeq.add(new AutoLib.LogTimeStep(this, "WAIT", 1.0)); + return mSeq; + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GyroUltraCorrect.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GyroUltraCorrect.java new file mode 100644 index 00000000000..e6aed7e8b98 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/GyroUltraCorrect.java @@ -0,0 +1,45 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder; +import org.firstinspires.ftc.robotcore.external.navigation.AxesReference; +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; + +/** + * Created by Noah on 4/4/2018. + */ + +@Autonomous(name = "Gyro Angle Corrections") +@Disabled +public class GyroUltraCorrect extends OpMode { + MatbotixUltra ultra; + BotHardware bot = new BotHardware(this); + private static final double HEIGHT_CM = DistanceUnit.INCH.toCm(10.3); + + public void init() { + bot.init(); + ultra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraright")); + ultra.initDevice(); + ultra.startDevice(); + bot.start(); + } + + public void start() { + + } + + public void loop() { + double angle = bot.getImu().getAngularOrientation(AxesReference.INTRINSIC, AxesOrder.ZYX, AngleUnit.DEGREES).secondAngle; + int reading = ultra.getReading(); + telemetry.addData("Ultra", reading); + telemetry.addData("Angle", angle); + telemetry.addData("Corrected Ultra", reading - Math.sin(Math.toRadians(angle)) * HEIGHT_CM); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/JewelOpMode.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/JewelOpMode.java new file mode 100644 index 00000000000..4d49e167c3e --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/JewelOpMode.java @@ -0,0 +1,78 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; + +import com.disnodeteam.dogecv.CameraViewDisplay; +import com.disnodeteam.dogecv.detectors.*; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.util.ElapsedTime; +import java.io.IOException; + + +@Autonomous(name="DogeCV Jewel Detector", group="DogeCV") +@Disabled +public class JewelOpMode extends OpMode +{ + // Declare OpMode members. + private ElapsedTime runtime = new ElapsedTime(); + + + private JewelDetector jewelDetector = null; + /* + * Code to run ONCE when the driver hits INIT + */ + @Override + public void init() { + telemetry.addData("Status", "Initialized"); + + jewelDetector = new JewelDetector(); + jewelDetector.init(hardwareMap.appContext, CameraViewDisplay.getInstance()); + + //Jewel Detector Settings + jewelDetector.areaWeight = 0.02; + jewelDetector.detectionMode = JewelDetector.JewelDetectionMode.MAX_AREA; // PERFECT_AREA + //jewelDetector.perfectArea = 6500; <- Needed for PERFECT_AREA + jewelDetector.debugContours = true; + jewelDetector.maxDiffrence = 15; + jewelDetector.ratioWeight = 15; + jewelDetector.minArea = 700; + + jewelDetector.speed = JewelDetector.JewelDetectionSpeed.VERY_SLOW; + + jewelDetector.enable(); + + + } + + @Override + public void init_loop() { + telemetry.addData("Status", "Initialized."); + } + + @Override + public void start() { + runtime.reset(); + } + + @Override + public void loop() { + + + + telemetry.addData("Status", "Run Time: " + runtime.toString()); + + telemetry.addData("Current Order", "Jewel Order: " + jewelDetector.getCurrentOrder().toString()); // Current Result + telemetry.addData("Last Order", "Jewel Order: " + jewelDetector.getLastOrder().toString()); // Last Known Result + + } + + @Override + public void stop() { + jewelDetector.disable(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/LineStopTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/LineStopTest.java new file mode 100644 index 00000000000..b152ea2bb33 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/LineStopTest.java @@ -0,0 +1,72 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.hardware.adafruit.AdafruitI2cColorSensor; +import com.qualcomm.hardware.ams.AMSColorSensor; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.EncoderHoneStep; +import org.firstinspires.ftc.teamcode.libraries.GyroCorrectStep; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.StupidColor; + +/** + * Created by Noah on 4/6/2018. + */ + +@Autonomous(name = "Line Color Stop") +@Disabled +public class LineStopTest extends OpMode { + private static final float RED_RATIO_MIN = 3f; + private final SensorLib.PID encoderHonePID = new SensorLib.PID(3.88f, 9.00f, 0, 50); + private final SensorLib.PID gyroDrivePID = new SensorLib.PID(-64.0f, 0, 0, 0); + + private final BotHardware bot = new BotHardware(this); + private StupidColor color; + private boolean lineFound = false; + + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + public void init() { + bot.init(); + bot.start(); + + color = new StupidColor(hardwareMap.get(AdafruitI2cColorSensor.class, "fc")); + color.setGain(AMSColorSensor.Gain.GAIN_64); + } + + public void start() { + bot.setRightDrive(0.5f); + bot.setLeftDrive(0.5f); + } + + public void loop() { + if(!lineFound && (double)color.red() / ((double)(color.blue() + color.green()) / 2.0) >= RED_RATIO_MIN) { + //read position + final int counts = BotHardware.Motor.frontLeft.motor.getCurrentPosition(); + //stop motors + bot.setLeftDrive(0); + bot.setRightDrive(0); + //wait until velocity is zero + while (BotHardware.Motor.frontLeft.motor.getVelocity(AngleUnit.DEGREES) > 0); + //create encoder hone step + final GyroCorrectStep step = makeGyroDriveStep(0, gyroDrivePID, 600, 720, 55); + mSeq.add(new EncoderHoneStep(this, counts - BotHardware.Motor.frontLeft.motor.getCurrentPosition(), 5, 5, encoderHonePID, step, new DcMotor[]{BotHardware.Motor.frontLeft.motor})); + lineFound = true; + } + else if(lineFound) mSeq.loop(); + } + + public void stop() { + bot.stopAll(); + } + + private GyroCorrectStep makeGyroDriveStep(float heading, SensorLib.PID pid, float power, float powerMin, float powerMax) { + return new GyroCorrectStep(this, heading, bot.getHeadingSensor(), pid, bot.getMotorVelocityShimArray(), power, powerMin, powerMax); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/MotorHoldTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/MotorHoldTest.java new file mode 100644 index 00000000000..6eead5fa3a2 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/MotorHoldTest.java @@ -0,0 +1,34 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 12/30/2017. + */ + +@TeleOp(name="Motor Hold Test") +@Disabled +public class MotorHoldTest extends OpMode { + BotHardware bot = new BotHardware(this); + private static final int MAX_COUNT = 100; + + public void init() { + bot.init(); + } + + public void start() { + + } + + public void loop() { + bot.setLiftMotors((int)(gamepad1.left_trigger * MAX_COUNT)); + } + + public void stop() { + bot.stopAll(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVGraphFun.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVGraphFun.java new file mode 100644 index 00000000000..4eea612868b --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVGraphFun.java @@ -0,0 +1,151 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; +/* +import android.app.Activity; +import android.graphics.Color; +import android.view.ViewGroup; +import android.widget.RelativeLayout; + +import com.github.mikephil.charting.charts.LineChart; +import com.github.mikephil.charting.components.AxisBase; +import com.github.mikephil.charting.components.YAxis; +import com.github.mikephil.charting.data.Entry; +import com.github.mikephil.charting.data.LineData; +import com.github.mikephil.charting.data.LineDataSet; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.libraries.LineFollowLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.opencv.core.Mat; + +import java.util.ArrayList; +import java.util.LinkedList; + + +/** + * Created by Robotics on 10/28/2016. + * + +@Autonomous(name = "Line Follow Algorithm + Graph Demo", group = "Test") +@Disabled +public class OpenCVGraphFun extends OpenCVLib { + + private int[] yValStore = new int[3]; + + private RelativeLayout layout; + private LineChart chart; + + private LinkedList dataAngle = new LinkedList(); + private LinkedList dataDisp = new LinkedList(); + + @Override + public void init(){ + layout = (RelativeLayout)((Activity)hardwareMap.appContext).findViewById(com.qualcomm.ftcrobotcontroller.R.id.CheapCamera); + + Runnable doGraphSetup = new Runnable() { + @Override + public void run() { + chart = new LineChart(hardwareMap.appContext); + + RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT); + layout.addView(chart, params); + + chart.setAutoScaleMinMaxEnabled(false); + AxisBase leftAxis = chart.getAxisLeft(); + leftAxis.setAxisMinimum(-180); + leftAxis.setAxisMaximum(180); + AxisBase rightAxis = chart.getAxisRight(); + rightAxis.setAxisMinimum(-1); + rightAxis.setAxisMaximum(1); + chart.setTouchEnabled(true); + } + }; + + layout.getHandler().post(doGraphSetup); + + initOpenCV(); + startCamera(); + + //catch a frame as soon as one becomes availible + Mat frame = getCameraFrame(); + + //init scanline Y values + yValStore[0] = frame.rows() / 4; + yValStore[1] = frame.rows() / 2; + yValStore[2] = (frame.rows() * 3) / 4; + + //log all the data + telemetry.addData("Top Y Value", yValStore[0]); + telemetry.addData("Middle Y Value", yValStore[1]); + telemetry.addData("Bottom Y Value", yValStore[2]); + + telemetry.addData("Frame Width", frame.width()); + telemetry.addData("Frame Height", frame.height()); + } + + @Override + public void start(){ + //wait ten seconds + } + + @Override + public void loop(){ + //get frame + //catch a frame + Mat frame = getCameraFrame(); + + final double angle = LineFollowLib.getAngle(frame, yValStore[0], yValStore[2]); + final double displace = LineFollowLib.getDisplacment(frame, yValStore[1]); + + //log data + telemetry.addData("Angle", angle); + telemetry.addData("Displacement", displace); + + //graph that shizzle + dataAngle.add(new Entry((float)getRuntime(), (float)angle)); + dataDisp.add(new Entry((float)getRuntime(), (float)displace)); + + //cutoff lists so no overflow + if(dataAngle.size() > 100) dataAngle.removeFirst(); + if(dataDisp.size() > 100) dataDisp.removeFirst(); + + //create data sets + LineDataSet angleFormat = new LineDataSet(new ArrayList<>(dataAngle), "Angle"); + LineDataSet dispFormat = new LineDataSet(new ArrayList<>(dataDisp), "Dispalcement"); + + angleFormat.setColor(Color.RED); + angleFormat.setCircleColor(Color.RED); + angleFormat.setAxisDependency(YAxis.AxisDependency.LEFT); + dispFormat.setColor(Color.BLACK); + dispFormat.setCircleColor(Color.BLACK); + dispFormat.setAxisDependency(YAxis.AxisDependency.RIGHT); + + //put them in a super data set + final LineData allData = new LineData(angleFormat, dispFormat); + + Runnable postData = new Runnable() { + @Override + public void run() { + chart.setData(allData); + chart.invalidate(); + } + }; + + layout.getHandler().post(postData); + } + + @Override + public void stop(){ + stopCamera(); + + Runnable hideChart = new Runnable() { + @Override + public void run() { + layout.removeView(chart); + } + }; + + layout.getHandler().post(hideChart); + } +} +*/ \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVPeakFinding.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVPeakFinding.java new file mode 100644 index 00000000000..32fc23d537a --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVPeakFinding.java @@ -0,0 +1,74 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.sun.tools.javac.util.List; + +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.opencv.android.CameraBridgeViewBase; +import org.opencv.core.Core; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.util.ArrayList; + +/** + * Created by Noah on 11/10/2017. + * OpenCV Peak Finding Using a Dilation Algorithm + */ + +@Autonomous(name="OpenCV Peaks") +@Disabled +public class OpenCVPeakFinding extends OpenCVLib{ + private Mat kernel; + + @Override + public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame frame) { + Mat in = frame.rgba(); + ArrayList out = new ArrayList<> (in.channels()); + + //extract only red data + Core.split(in, out); + Mat red = out.get(0); + //emptey memory + out.clear(); + //dilate red data + Mat dilated = new Mat(red.size(), CvType.CV_8UC1); + Imgproc.dilate(red, dilated, kernel); + //filter out any that increased + Core.compare(red, dilated, red, Core.CMP_GE); + dilated.release(); + //mask to remove the non-peak pixels + Mat ret = new Mat(); + in.copyTo(ret, red); + //memory + in.release(); + red.release(); + return ret; + } + + @Override + public void init() { + initOpenCV(); + + //create kernel + kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(15, 15)); + } + + @Override + public void start() { + startCamera(); + } + + @Override + public void loop() { + + } + + @Override + public void stop() { + stopCamera(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVSimpleTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVSimpleTest.java new file mode 100644 index 00000000000..886b9e263e1 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVSimpleTest.java @@ -0,0 +1,66 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.LineFollowLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; +import org.opencv.core.Mat; + + +/** + * Created by Robotics on 10/28/2016. + */ + +@Autonomous(name = "Line Follow Algorithm 2", group = "Line Follow") +@Disabled +public class OpenCVSimpleTest extends OpenCVLib { + + private int[] yValStore = new int[3]; + + private BotHardwareOld robot = new BotHardwareOld(); + + @Override + public void init(){ + robot.init(this, true); + + initOpenCV(); + startCamera(); + + //catch a frame + Mat frame = getCameraFrame(); + + //init scanline Y values + yValStore[0] = frame.rows() / 4; + yValStore[1] = frame.rows() / 2; + yValStore[2] = (frame.rows() * 3) / 4; + + //log all the data + telemetry.addData("Top Y Value", yValStore[0]); + telemetry.addData("Middle Y Value", yValStore[1]); + telemetry.addData("Bottom Y Value", yValStore[2]); + + telemetry.addData("Frame Width", frame.width()); + telemetry.addData("Frame Height", frame.height()); + } + + @Override + public void start(){ + //wait ten seconds + } + + @Override + public void loop(){ + //get frame + Mat frame = getCameraFrame(); + + //log data + telemetry.addData("Angle", LineFollowLib.getAngle(frame, yValStore[0], yValStore[2])); + telemetry.addData("Displacement", LineFollowLib.getDisplacment(frame, yValStore[1])); + } + + @Override + public void stop(){ + stopCamera(); + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVSimplerTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVSimplerTest.java new file mode 100644 index 00000000000..2d329c480c0 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVSimplerTest.java @@ -0,0 +1,62 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.LineFollowLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; +import org.opencv.core.Mat; + +/** + * Created by Robotics on 10/28/2016. + */ + +@Autonomous(name = "Line Follow Algorithm 3", group = "Line Follow") +@Disabled +public class OpenCVSimplerTest extends OpenCVLib { + + private int yVal; + + private BotHardwareOld robot = new BotHardwareOld(); + + @Override + public void init(){ + robot.init(this, true); + + initOpenCV(); + startCamera(); + + //catch a frame + Mat frame = getCameraFrame(); + + //init scanline Y values + yVal = frame.rows() / 8; + + //log all the data + telemetry.addData("Y Value", yVal); + + telemetry.addData("Frame Width", frame.width()); + telemetry.addData("Frame Height", frame.height()); + } + + @Override + public void start(){ + //wait ten seconds + } + + @Override + public void loop(){ + //get frame + Mat frame = getCameraFrame(); + + double linePos = LineFollowLib.getDisplacment(frame, yVal); + + if(linePos == LineFollowLib.ERROR_TOO_NOISY) telemetry.addData("Line Position", "ERROR"); + else telemetry.addData("Line Position", linePos); + } + + @Override + public void stop(){ + stopCamera(); + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVTest.java new file mode 100644 index 00000000000..931d75a4c6c --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpenCVTest.java @@ -0,0 +1,264 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.opencv.android.CameraBridgeViewBase; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.Point; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +import java.util.LinkedList; +import java.util.List; + +import static org.opencv.core.CvType.*; + +/** + * Created by Robotics on 10/28/2016. + */ + +@Autonomous(name = "Line Follow Algorithm 1", group = "Line Follow") +@Disabled +public class OpenCVTest extends OpenCVLib { + //edge kernel (stolen from http://roboreal.com) + private static final float[][] kernel = {{-1, -1, -1, -1, -1}, + {-1, 0, 0, 0, -1}, + {-1, 0, 16, 0, -1}, + {-1, 0, 0, 0, -1}, + {-1, -1, -1, -1, -1}}; + + @Override + public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame frame){ + //here we gooooooooo! + //my not very simple edge detection algorithm! + Mat src = frame.gray(); + + src.convertTo(src, CV_32F); + + //Mat rotation = Imgproc.getRotationMatrix2D(new Point(src.cols()/2, src.rows()/2), 90, 1); + + //Imgproc.warpAffine(src, src, rotation, new Size(src.cols(), src.rows())); + + Imgproc.GaussianBlur(src, src, new Size(7,7), 0); + + Mat edgeKernel = new Mat(5, 5, CV_32F); + for (int i=0; i thresh){ + ray[i][o] = 1; + } + else{ + ray[i][o] = 0; + } + } + } + + ThinningService thinThing = new ThinningService(); + + thinThing.doZhangSuenThinning(ray, true); + + float totalRow = 0; + float totalCol = 0; + long totalPix = 0; + + for(int i = 0; i < imgRow; i++) { + for (int o = 0; o < imgCol; o++) { + if(ray[i][o] == 0 || (o < 50 || o > imgCol - 50)) buff[i * imgCol + o] = 0; + else{ + buff[i * imgCol + o] = 165.0f; + totalRow += i; + totalCol += o; + totalPix++; + } + } + } + + if(totalPix != 0){ + totalCol /= totalPix; + totalRow /= totalPix; + } + else{ + totalCol = imgCol/2.0f; + totalRow = imgRow/2.0f; + } + + src.put(0, 0, buff); + + src.convertTo(src, CvType.CV_8U); + + Imgproc.circle(src, new Point((int)totalCol, (int)totalRow), 4, new Scalar(255,0,0)); + + Imgproc.circle(src, new Point(imgCol/2, imgRow/2), 10, new Scalar(255,0,0)); + + return src; + } + + @Override + public void init(){ + initOpenCV(); + } + + @Override + public void start(){ + startCamera(); + } + + @Override + public void loop(){ + + } + + @Override + public void stop(){ + stopCamera(); + } + +} + +class ThinningService { + /** + * @param givenImage + * @param changeGivenImage decides whether the givenArray should be modified or a clone should be used + * @return a 2D array of binary image after thinning using zhang-suen thinning algo. + */ + public int[][] doZhangSuenThinning(final int[][] givenImage, boolean changeGivenImage) { + int[][] binaryImage; + if (changeGivenImage) { + binaryImage = givenImage; + } else { + binaryImage = givenImage.clone(); + } + int a, b; + List pointsToChange = new LinkedList(); + boolean hasChange; + do { + hasChange = false; + for (int y = 1; y + 1 < binaryImage.length; y++) { + for (int x = 1; x + 1 < binaryImage[y].length; x++) { + a = getA(binaryImage, y, x); + b = getB(binaryImage, y, x); + if (binaryImage[y][x] == 1 && 2 <= b && b <= 6 && a == 1 + && (binaryImage[y - 1][x] * binaryImage[y][x + 1] * binaryImage[y + 1][x] == 0) + && (binaryImage[y][x + 1] * binaryImage[y + 1][x] * binaryImage[y][x - 1] == 0)) { + pointsToChange.add(new mPoint(x, y)); +//binaryImage[y][x] = 0; + hasChange = true; + } + } + } + for (mPoint point : pointsToChange) { + binaryImage[point.getY()][point.getX()] = 0; + } + pointsToChange.clear(); + for (int y = 1; y + 1 < binaryImage.length; y++) { + for (int x = 1; x + 1 < binaryImage[y].length; x++) { + a = getA(binaryImage, y, x); + b = getB(binaryImage, y, x); + if (binaryImage[y][x] == 1 && 2 <= b && b <= 6 && a == 1 + && (binaryImage[y - 1][x] * binaryImage[y][x + 1] * binaryImage[y][x - 1] == 0) + && (binaryImage[y - 1][x] * binaryImage[y + 1][x] * binaryImage[y][x - 1] == 0)) { + pointsToChange.add(new mPoint(x, y)); + hasChange = true; + } + } + } + for (mPoint point : pointsToChange) { + binaryImage[point.getY()][point.getX()] = 0; + } + pointsToChange.clear(); + } while (hasChange); + return binaryImage; + } + + private int getA(int[][] binaryImage, int y, int x) { + int count = 0; +//p2 p3 + if (y - 1 >= 0 && x + 1 < binaryImage[y].length && binaryImage[y - 1][x] == 0 && binaryImage[y - 1][x + 1] == 1) { + count++; + } +//p3 p4 + if (y - 1 >= 0 && x + 1 < binaryImage[y].length && binaryImage[y - 1][x + 1] == 0 && binaryImage[y][x + 1] == 1) { + count++; + } +//p4 p5 + if (y + 1 < binaryImage.length && x + 1 < binaryImage[y].length && binaryImage[y][x + 1] == 0 && binaryImage[y + 1][x + 1] == 1) { + count++; + } +//p5 p6 + if (y + 1 < binaryImage.length && x + 1 < binaryImage[y].length && binaryImage[y + 1][x + 1] == 0 && binaryImage[y + 1][x] == 1) { + count++; + } +//p6 p7 + if (y + 1 < binaryImage.length && x - 1 >= 0 && binaryImage[y + 1][x] == 0 && binaryImage[y + 1][x - 1] == 1) { + count++; + } +//p7 p8 + if (y + 1 < binaryImage.length && x - 1 >= 0 && binaryImage[y + 1][x - 1] == 0 && binaryImage[y][x - 1] == 1) { + count++; + } +//p8 p9 + if (y - 1 >= 0 && x - 1 >= 0 && binaryImage[y][x - 1] == 0 && binaryImage[y - 1][x - 1] == 1) { + count++; + } +//p9 p2 + if (y - 1 >= 0 && x - 1 >= 0 && binaryImage[y - 1][x - 1] == 0 && binaryImage[y - 1][x] == 1) { + count++; + } + return count; + } + + private int getB(int[][] binaryImage, int y, int x) { + return binaryImage[y - 1][x] + binaryImage[y - 1][x + 1] + binaryImage[y][x + 1] + + binaryImage[y + 1][x + 1] + binaryImage[y + 1][x] + binaryImage[y + 1][x - 1] + + binaryImage[y][x - 1] + binaryImage[y - 1][x - 1]; + } +} + +/** + * Created by nayef on 1/27/15. + */ +class mPoint { + private int x; + private int y; + + public mPoint(int x, int y) { + this.x = x; + this.y = y; + } + + public int getX() { + return x; + } + + public void setX(int x) { + this.x = x; + } + + public int getY() { + return y; + } + + public void setY(int y) { + this.y = y; + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpmodeVuforiaNavigationTest0.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpmodeVuforiaNavigationTest0.java new file mode 100644 index 00000000000..876828b28d3 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpmodeVuforiaNavigationTest0.java @@ -0,0 +1,382 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.ftcrobotcontroller.R; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode; +import com.qualcomm.robotcore.util.RobotLog; + +import org.firstinspires.ftc.robotcore.external.ClassFactory; +import org.firstinspires.ftc.robotcore.external.matrices.MatrixF; +import org.firstinspires.ftc.robotcore.external.matrices.OpenGLMatrix; +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder; +import org.firstinspires.ftc.robotcore.external.navigation.AxesReference; +import org.firstinspires.ftc.robotcore.external.navigation.Orientation; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaLocalizer; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackable; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackableDefaultListener; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackables; + +import java.util.ArrayList; +import java.util.List; + +/** + * This OpMode illustrates the basics of using the Vuforia localizer to determine + * positioning and orientation of robot on the FTC field. + * The code is structured as a LinearOpMode + * + * Vuforia uses the phone's camera to inspect it's surroundings, and attempt to locate target images. + * + * When images are located, Vuforia is able to determine the position and orientation of the + * image relative to the camera. This sample code than combines that information with a + * knowledge of where the target images are on the field, to determine the location of the camera. + * + * This example assumes a "diamond" field configuration where the red and blue alliance stations + * are adjacent on the corner of the field furthest from the audience. + * From the Audience perspective, the Red driver station is on the right. + * The two vision target are located on the two walls closest to the audience, facing in. + * The Stones are on the RED side of the field, and the Chips are on the Blue side. + * + * A final calculation then uses the location of the camera on the robot to determine the + * robot's location and orientation on the field. + * + * @see VuforiaLocalizer + * @see VuforiaTrackableDefaultListener + * see ftc_app/doc/tutorial/FTC_FieldCoordinateSystemDefinition.pdf + * + * Use Android Studio to Copy this Class, and Paste it into your team's code folder with a new name. + * Remove or comment out the @Disabled line to add this opmode to the Driver Station OpMode list. + * + * IMPORTANT: In order to use this OpMode, you need to obtain your own Vuforia license key as + * is explained below. + */ + +@Autonomous(name="Concept: Vuforia Navigation 0", group ="Concept") +@Disabled +public class OpmodeVuforiaNavigationTest0 extends LinearOpMode { + + public static final String TAG = "Vuforia Test0"; + + OpenGLMatrix lastLocation = null; + + /** + * {@link #vuforia} is the variable we will use to store our instance of the Vuforia + * localization engine. + */ + VuforiaLocalizer vuforia; + + @Override public void runOpMode() throws InterruptedException { + /** + * Start up Vuforia, telling it the id of the view that we wish to use as the parent for + * the camera monitor feedback; if no camera monitor feedback is desired, use the parameterless + * constructor instead. We also indicate which camera on the RC that we wish to use. For illustration + * purposes here, we choose the back camera; for a competition robot, the front camera might + * prove to be more convenient. + * + * Note that in addition to indicating which camera is in use, we also need to tell the system + * the location of the phone on the robot; see phoneLocationOnRobot below. + * + * IMPORTANT: You need to obtain your own license key to use Vuforia. The string below with which + * 'parameters.vuforiaLicenseKey' is initialized is for illustration only, and will not function. + * Vuforia will not load without a valid license being provided. Vuforia 'Development' license + * keys, which is what is needed here, can be obtained free of charge from the Vuforia developer + * web site at https://developer.vuforia.com/license-manager. + * + * Valid Vuforia license keys are always 380 characters long, and look as if they contain mostly + * random data. As an example, here is a example of a fragment of a valid key: + * ... yIgIzTqZ4mWjk9wd3cZO9T1axEqzuhxoGlfOOI2dRzKS4T0hQ8kT ... + * Once you've obtained a license key, copy the string form of the key from the Vuforia web site + * and paste it in to your code as the value of the 'vuforiaLicenseKey' field of the + * {@link Parameters} instance with which you initialize Vuforia. + */ + VuforiaLocalizer.Parameters parameters = new VuforiaLocalizer.Parameters(R.id.cameraMonitorViewId); + parameters.vuforiaLicenseKey = "ARf809H/////AAAAGRswBQwUCUJ5nqfgZxGbDEQ8oO7YP5GdnbReYr8ZHinqQ74OsP7UdOxNZJDmhaF2OeGD20jpSexpr2CcXGSGuHXNB2p9Z6zUNLDTfEggL+yg4ujefoqdkSpCqZf1medpwh3KXcK76FcfSJuqEudik2PC6kQW/cqJXnnHofVrrDTzJmWMnK3hlqTMjig81DEPMAHbRnA5wn7Eu0irnmqqboWyOlQ0xTF+P4LVuxaOUFlQC8zPqkr1Gvzvix45paWtyuLCnS9YDWMvI1jIM4giMrTRCT0lG8F+vkuKMiK647KJp9QIsFdWQ0ecQhau3ODNQ03pcTzprVN72b9VObpv6FNBpjGKRAcA59xlZiM2l6fc"; + parameters.cameraDirection = VuforiaLocalizer.CameraDirection.BACK; + this.vuforia = ClassFactory.createVuforiaLocalizer(parameters); + + /** + * Load the data sets that for the trackable objects we wish to track. These particular data + * sets are stored in the 'assets' part of our application (you'll see them in the Android + * Studio 'Project' view over there on the left of the screen). You can make your own datasets + * with the Vuforia Target Manager: https://developer.vuforia.com/target-manager. PDFs for the + * example "StonesAndChips", datasets can be found in in this project in the + * documentation directory. + */ + + /* + VuforiaTrackables stonesAndChips = this.vuforia.loadTrackablesFromAsset("StonesAndChips"); + VuforiaTrackable redTarget = stonesAndChips.get(0); + redTarget.setName("RedTarget"); // Stones + VuforiaTrackable blueTarget = stonesAndChips.get(1); + blueTarget.setName("BlueTarget"); // Chips + */ + + VuforiaTrackables FTC_2016_17 = this.vuforia.loadTrackablesFromAsset("FTC_2016-17"); + VuforiaTrackable wheelsTarget = FTC_2016_17.get(0); + wheelsTarget.setName("Wheels"); + VuforiaTrackable toolsTarget = FTC_2016_17.get(1); + toolsTarget.setName("Tools"); + VuforiaTrackable legosTarget = FTC_2016_17.get(2); + legosTarget.setName("Legos"); + VuforiaTrackable gearsTarget = FTC_2016_17.get(3); + gearsTarget.setName("Gears"); + + + /** For convenience, gather together all the trackable objects in one easily-iterable collection */ + List allTrackables = new ArrayList(); + allTrackables.addAll(FTC_2016_17); + + /** + * We use units of mm here because that's the recommended units of measurement for the + * size values specified in the XML for the ImageTarget trackables in data sets. E.g.: + * + * You don't *have to* use mm here, but the units here and the units used in the XML + * target configuration files *must* correspond for the math to work out correctly. + */ + float mmPerInch = 25.4f; + float mmBotWidth = 18 * mmPerInch; // ... or whatever is right for your robot + float mmFTCFieldWidth = (12*12 - 2) * mmPerInch; // the FTC field is ~11'10" center-to-center of the glass panels + + /** + * In order for localization to work, we need to tell the system where each target we + * wish to use for navigation resides on the field, and we need to specify where on the robot + * the phone resides. These specifications are in the form of transformation matrices. + * Transformation matrices are a central, important concept in the math here involved in localization. + * See Transformation Matrix + * for detailed information. Commonly, you'll encounter transformation matrices as instances + * of the {@link OpenGLMatrix} class. + * + * For the most part, you don't need to understand the details of the math of how transformation + * matrices work inside (as fascinating as that is, truly). Just remember these key points: + *
    + * + *
  1. You can put two transformations together to produce a third that combines the effect of + * both of them. If, for example, you have a rotation transform R and a translation transform T, + * then the combined transformation matrix RT which does the rotation first and then the translation + * is given by {@code RT = T.multiplied(R)}. That is, the transforms are multiplied in the + * reverse of the chronological order in which they applied.
    2. + * + *
  2. A common way to create useful transforms is to use methods in the {@link OpenGLMatrix} + * class and the Orientation class. See, for example, {@link OpenGLMatrix#translation(float, + * float, float)}, {@link OpenGLMatrix#rotation(AngleUnit, float, float, float, float)}, and + * {@link Orientation#getRotationMatrix(AxesReference, AxesOrder, AngleUnit, float, float, float)}. + * Related methods in {@link OpenGLMatrix}, such as {@link OpenGLMatrix#rotated(AngleUnit, + * float, float, float, float)}, are syntactic shorthands for creating a new transform and + * then immediately multiplying the receiver by it, which can be convenient at times.
    3. + * + *
  3. If you want to break open the black box of a transformation matrix to understand + * what it's doing inside, use {@link MatrixF#getTranslation()} to fetch how much the + * transform will move you in x, y, and z, and use {@link Orientation#getOrientation(MatrixF, + * AxesReference, AxesOrder, AngleUnit)} to determine the rotational motion that the transform + * will impart. See {@link #format(OpenGLMatrix)} below for an example.
    4. + * + *
+ * + * This example places the "stones" image on the perimeter wall to the Left + * of the Red Driver station wall. Similar to the Red Beacon Location on the Res-Q + * + * This example places the "chips" image on the perimeter wall to the Right + * of the Blue Driver station. Similar to the Blue Beacon Location on the Res-Q + * + * See the doc folder of this project for a description of the field Axis conventions. + * + * Initially the target is conceptually lying at the origin of the field's coordinate system + * (the center of the field), facing up. + * + * In this configuration, the target's coordinate system aligns with that of the field. + * + * In a real situation we'd also account for the vertical (Z) offset of the target, + * but for simplicity, we ignore that here; for a real robot, you'll want to fix that. + * + * To place the Wheels Target on the 1st Audience wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it 90 around the field's Z access to face it away from the audience. + * - Finally, we translate it back along the X axis towards the red audience wall. + */ + OpenGLMatrix wheelsTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the RED WALL. Our translation here + is a negative translation in X.*/ + .translation(-mmFTCFieldWidth/2, 0, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X, then 90 in Z */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 90, 0)); + wheelsTarget.setLocation(wheelsTargetLocationOnField); + RobotLog.ii(TAG, "Wheels Target=%s", format(wheelsTargetLocationOnField)); + + /* + * To place the Tools Target on the 2nd Audience wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Finally, we translate it along the Y axis towards the blue audience wall. + */ + OpenGLMatrix toolsTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the Blue Audience wall. + Our translation here is a positive translation in Y.*/ + .translation(0, mmFTCFieldWidth/2, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 0, 0)); + toolsTarget.setLocation(toolsTargetLocationOnField); + RobotLog.ii(TAG, "Tools Target=%s", format(toolsTargetLocationOnField)); + + /* + * To place the Legos Target on the 3rd Audience wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it -90 around the field's Z access to face it away from the audience. + * - Finally, we translate it along the X axis towards the blue audience wall. + */ + OpenGLMatrix legosTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the Blue Audience wall. + Our translation here is a positive translation in Y.*/ + .translation(mmFTCFieldWidth/2, 0, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, -90, 0)); + legosTarget.setLocation(legosTargetLocationOnField); + RobotLog.ii(TAG, "Legos Target=%s", format(legosTargetLocationOnField)); + + /* + * To place the Gears Target on the 4th wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it 180 around the field's Z access to face it away from the audience. + * - Finally, we translate it along the -Y axis towards the blue audience wall. + */ + OpenGLMatrix gearsTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the Blue Audience wall. + Our translation here is a positive translation in Y.*/ + .translation(0, -mmFTCFieldWidth/2, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 180, 0)); + gearsTarget.setLocation(gearsTargetLocationOnField); + RobotLog.ii(TAG, "Gears Target=%s", format(gearsTargetLocationOnField)); + + /** + * Create a transformation matrix describing where the phone is on the robot. Here, we + * put the phone on the right hand side of the robot with the screen facing in (see our + * choice of BACK camera above) and in landscape mode. Starting from alignment between the + * robot's and phone's axes, this is a rotation of -90deg along the Y axis. + * + * When determining whether a rotation is positive or negative, consider yourself as looking + * down the (positive) axis of rotation from the positive towards the origin. Positive rotations + * are then CCW, and negative rotations CW. An example: consider looking down the positive Z + * axis towards the origin. A positive rotation about Z (ie: a rotation parallel to the the X-Y + * plane) is then CCW, as one would normally expect from the usual classic 2D geometry. + */ + OpenGLMatrix phoneLocationOnRobot = OpenGLMatrix + .translation(mmBotWidth/2,0,0) + .multiplied(Orientation.getRotationMatrix( + AxesReference.EXTRINSIC, AxesOrder.YZY, + AngleUnit.DEGREES, -90, 0, 0)); + RobotLog.ii(TAG, "phone=%s", format(phoneLocationOnRobot)); + + /** + * Let the trackable listeners we care about know where the phone is. We know that each + * listener is a {@link VuforiaTrackableDefaultListener} and can so safely cast because + * we have not ourselves installed a listener of a different type. + */ + ((VuforiaTrackableDefaultListener)wheelsTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + ((VuforiaTrackableDefaultListener)toolsTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + ((VuforiaTrackableDefaultListener)legosTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + ((VuforiaTrackableDefaultListener)gearsTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + + /** + * A brief tutorial: here's how all the math is going to work: + * + * C = phoneLocationOnRobot maps phone coords -> robot coords + * P = tracker.getPose() maps image target coords -> phone coords + * L = redTargetLocationOnField maps image target coords -> field coords + * + * So + * + * C.inverted() maps robot coords -> phone coords + * P.inverted() maps phone coords -> imageTarget coords + * + * Putting that all together, + * + * L x P.inverted() x C.inverted() maps robot coords to field coords. + * + * @see VuforiaTrackableDefaultListener#getRobotLocation() + */ + + /** Wait for the game to begin */ + telemetry.addData(">", "Press Play to start tracking"); + telemetry.update(); + waitForStart(); + + /** Start tracking the data sets we care about. */ + FTC_2016_17.activate(); + + while (opModeIsActive()) { + + for (VuforiaTrackable trackable : allTrackables) { + /** + * getUpdatedRobotLocation() will return null if no new information is available since + * the last time that call was made, or if the trackable is not currently visible. + * getRobotLocation() will return null if the trackable is not currently visible. + */ + telemetry.addData(trackable.getName(), ((VuforiaTrackableDefaultListener)trackable.getListener()).isVisible() ? "Visible" : "Not Visible"); // + + OpenGLMatrix robotLocationTransform = ((VuforiaTrackableDefaultListener)trackable.getListener()).getUpdatedRobotLocation(); + if (robotLocationTransform != null) { + lastLocation = robotLocationTransform; + } + } + /** + * Provide feedback as to where the robot was last located (if we know). + */ + if (lastLocation != null) { + // RobotLog.vv(TAG, "robot=%s", format(lastLocation)); + telemetry.addData("Pos", format(lastLocation)); + } else { + telemetry.addData("Pos", "Unknown"); + } + telemetry.update(); + idle(); + } + } + + /** + * A simple utility that extracts positioning information from a transformation matrix + * and formats it in a form palatable to a human being. + */ + String format(OpenGLMatrix transformationMatrix) { + return transformationMatrix.formatAsTransform(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpmodeVuforiaNavigationTest1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpmodeVuforiaNavigationTest1.java new file mode 100644 index 00000000000..29ace26e5b1 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpmodeVuforiaNavigationTest1.java @@ -0,0 +1,402 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.ftcrobotcontroller.R; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.RobotLog; + +import org.firstinspires.ftc.robotcore.external.ClassFactory; +import org.firstinspires.ftc.robotcore.external.matrices.MatrixF; +import org.firstinspires.ftc.robotcore.external.matrices.OpenGLMatrix; +import org.firstinspires.ftc.robotcore.external.matrices.VectorF; +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder; +import org.firstinspires.ftc.robotcore.external.navigation.AxesReference; +import org.firstinspires.ftc.robotcore.external.navigation.Orientation; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaLocalizer; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackable; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackableDefaultListener; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackables; + +import java.util.ArrayList; +import java.util.List; + +/** + * This OpMode illustrates the basics of using the Vuforia localizer to determine + * positioning and orientation of robot on the FTC field. + * The code is structured as a normal OpMode + * + * Vuforia uses the phone's camera to inspect its surroundings, and attempt to locate target images. + * + * When images are located, Vuforia is able to determine the position and orientation of the + * image relative to the camera. This sample code than combines that information with a + * knowledge of where the target images are on the field, to determine the location of the camera. + * + * This example assumes a "diamond" field configuration where the red and blue alliance stations + * are adjacent on the corner of the field furthest from the audience. + * From the Audience perspective, the Red driver station is on the right. + * The two vision target are located on the two walls closest to the audience, facing in. + * The Stones are on the RED side of the field, and the Chips are on the Blue side. + * + * A final calculation then uses the location of the camera on the robot to determine the + * robot's location and orientation on the field. + * + * @see VuforiaLocalizer + * @see VuforiaTrackableDefaultListener + * see ftc_app/doc/tutorial/FTC_FieldCoordinateSystemDefinition.pdf + * + * Use Android Studio to Copy this Class, and Paste it into your team's code folder with a new name. + * Remove or comment out the @Disabled line to add this opmode to the Driver Station OpMode list. + * + * IMPORTANT: In order to use this OpMode, you need to obtain your own Vuforia license key as + * is explained below. + */ + +@Autonomous(name="Concept: Vuforia Navigation 1", group ="Concept") +@Disabled +public class OpmodeVuforiaNavigationTest1 extends OpMode { + + public static final String TAG = "Vuforia Test1"; + + OpenGLMatrix lastLocation = null; + + /** + * {@link #vuforia} is the variable we will use to store our instance of the Vuforia + * localization engine. + */ + VuforiaLocalizer vuforia; + VuforiaTrackables FTC_2016_17 = null; + + List allTrackables; + + @Override public void init() { + /** + * Start up Vuforia, telling it the id of the view that we wish to use as the parent for + * the camera monitor feedback; if no camera monitor feedback is desired, use the parameterless + * constructor instead. We also indicate which camera on the RC that we wish to use. For illustration + * purposes here, we choose the back camera; for a competition robot, the front camera might + * prove to be more convenient. + * + * Note that in addition to indicating which camera is in use, we also need to tell the system + * the location of the phone on the robot; see phoneLocationOnRobot below. + * + * IMPORTANT: You need to obtain your own license key to use Vuforia. The string below with which + * 'parameters.vuforiaLicenseKey' is initialized is for illustration only, and will not function. + * Vuforia will not load without a valid license being provided. Vuforia 'Development' license + * keys, which is what is needed here, can be obtained free of charge from the Vuforia developer + * web site at https://developer.vuforia.com/license-manager. + * + * Valid Vuforia license keys are always 380 characters long, and look as if they contain mostly + * random data. As an example, here is a example of a fragment of a valid key: + * ... yIgIzTqZ4mWjk9wd3cZO9T1axEqzuhxoGlfOOI2dRzKS4T0hQ8kT ... + * Once you've obtained a license key, copy the string form of the key from the Vuforia web site + * and paste it in to your code as the value of the 'vuforiaLicenseKey' field of the + * {@link Parameters} instance with which you initialize Vuforia. + */ + VuforiaLocalizer.Parameters parameters = new VuforiaLocalizer.Parameters(R.id.cameraMonitorViewId); + parameters.vuforiaLicenseKey = "ARf809H/////AAAAGRswBQwUCUJ5nqfgZxGbDEQ8oO7YP5GdnbReYr8ZHinqQ74OsP7UdOxNZJDmhaF2OeGD20jpSexpr2CcXGSGuHXNB2p9Z6zUNLDTfEggL+yg4ujefoqdkSpCqZf1medpwh3KXcK76FcfSJuqEudik2PC6kQW/cqJXnnHofVrrDTzJmWMnK3hlqTMjig81DEPMAHbRnA5wn7Eu0irnmqqboWyOlQ0xTF+P4LVuxaOUFlQC8zPqkr1Gvzvix45paWtyuLCnS9YDWMvI1jIM4giMrTRCT0lG8F+vkuKMiK647KJp9QIsFdWQ0ecQhau3ODNQ03pcTzprVN72b9VObpv6FNBpjGKRAcA59xlZiM2l6fc"; + parameters.cameraDirection = VuforiaLocalizer.CameraDirection.BACK; + this.vuforia = ClassFactory.createVuforiaLocalizer(parameters); + + /** + * Load the data sets that for the trackable objects we wish to track. These particular data + * sets are stored in the 'assets' part of our application (you'll see them in the Android + * Studio 'Project' view over there on the left of the screen). You can make your own datasets + * with the Vuforia Target Manager: https://developer.vuforia.com/target-manager. PDFs for the + * example "StonesAndChips", datasets can be found in in this project in the + * documentation directory. + */ + + /* + VuforiaTrackables stonesAndChips = this.vuforia.loadTrackablesFromAsset("StonesAndChips"); + VuforiaTrackable redTarget = stonesAndChips.get(0); + redTarget.setName("RedTarget"); // Stones + VuforiaTrackable blueTarget = stonesAndChips.get(1); + blueTarget.setName("BlueTarget"); // Chips + */ + + FTC_2016_17 = this.vuforia.loadTrackablesFromAsset("FTC_2016-17"); + VuforiaTrackable wheelsTarget = FTC_2016_17.get(0); + wheelsTarget.setName("Wheels"); + VuforiaTrackable toolsTarget = FTC_2016_17.get(1); + toolsTarget.setName("Tools"); + VuforiaTrackable legosTarget = FTC_2016_17.get(2); + legosTarget.setName("Legos"); + VuforiaTrackable gearsTarget = FTC_2016_17.get(3); + gearsTarget.setName("Gears"); + + + /** For convenience, gather together all the trackable objects in one easily-iterable collection */ + allTrackables = new ArrayList(); + allTrackables.addAll(FTC_2016_17); + + /** + * We use units of mm here because that's the recommended units of measurement for the + * size values specified in the XML for the ImageTarget trackables in data sets. E.g.: + * + * You don't *have to* use mm here, but the units here and the units used in the XML + * target configuration files *must* correspond for the math to work out correctly. + */ + float mmPerInch = 25.4f; + float mmBotWidth = 18 * mmPerInch; // ... or whatever is right for your robot + float mmFTCFieldWidth = (12 * 12 - 2) * mmPerInch; // the FTC field is ~11'10" center-to-center of the glass panels + + /** + * In order for localization to work, we need to tell the system where each target we + * wish to use for navigation resides on the field, and we need to specify where on the robot + * the phone resides. These specifications are in the form of transformation matrices. + * Transformation matrices are a central, important concept in the math here involved in localization. + * See Transformation Matrix + * for detailed information. Commonly, you'll encounter transformation matrices as instances + * of the {@link OpenGLMatrix} class. + * + * For the most part, you don't need to understand the details of the math of how transformation + * matrices work inside (as fascinating as that is, truly). Just remember these key points: + *
    + * + *
  1. You can put two transformations together to produce a third that combines the effect of + * both of them. If, for example, you have a rotation transform R and a translation transform T, + * then the combined transformation matrix RT which does the rotation first and then the translation + * is given by {@code RT = T.multiplied(R)}. That is, the transforms are multiplied in the + * reverse of the chronological order in which they applied.
    2. + * + *
  2. A common way to create useful transforms is to use methods in the {@link OpenGLMatrix} + * class and the Orientation class. See, for example, {@link OpenGLMatrix#translation(float, + * float, float)}, {@link OpenGLMatrix#rotation(AngleUnit, float, float, float, float)}, and + * {@link Orientation#getRotationMatrix(AxesReference, AxesOrder, AngleUnit, float, float, float)}. + * Related methods in {@link OpenGLMatrix}, such as {@link OpenGLMatrix#rotated(AngleUnit, + * float, float, float, float)}, are syntactic shorthands for creating a new transform and + * then immediately multiplying the receiver by it, which can be convenient at times.
    3. + * + *
  3. If you want to break open the black box of a transformation matrix to understand + * what it's doing inside, use {@link MatrixF#getTranslation()} to fetch how much the + * transform will move you in x, y, and z, and use {@link Orientation#getOrientation(MatrixF, + * AxesReference, AxesOrder, AngleUnit)} to determine the rotational motion that the transform + * will impart. See {@link #format(OpenGLMatrix)} below for an example.
    4. + * + *
+ * + * This example places the "stones" image on the perimeter wall to the Left + * of the Red Driver station wall. Similar to the Red Beacon Location on the Res-Q + * + * This example places the "chips" image on the perimeter wall to the Right + * of the Blue Driver station. Similar to the Blue Beacon Location on the Res-Q + * + * See the doc folder of this project for a description of the field Axis conventions. + * + * Initially the target is conceptually lying at the origin of the field's coordinate system + * (the center of the field), facing up. + * + * In this configuration, the target's coordinate system aligns with that of the field. + * + * In a real situation we'd also account for the vertical (Z) offset of the target, + * but for simplicity, we ignore that here; for a real robot, you'll want to fix that. + * + * To place the Wheels Target on the wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it 90 around the field's Z axis to align it with the correct wall. + * - Finally, we translate it in X and Y to its position on the wall. + */ + OpenGLMatrix wheelsTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the RED WALL. Our translation here + is a negative translation in X.*/ + .translation(-mmFTCFieldWidth/2, mmFTCFieldWidth/12, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X, then 90 in Z */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 90, 0)); + wheelsTarget.setLocation(wheelsTargetLocationOnField); + RobotLog.ii(TAG, "Wheels Target=%s", format(wheelsTargetLocationOnField)); + + /* + * To place the Tools Target on the wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it 180 around the field's Z axis to align it with the correct wall. + * - Finally, we translate it in X and Y to its position on the wall. + */ + OpenGLMatrix toolsTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the Blue Audience wall. + Our translation here is a positive translation in Y.*/ + .translation(-mmFTCFieldWidth/4, -mmFTCFieldWidth/2, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 180, 0)); + toolsTarget.setLocation(toolsTargetLocationOnField); + RobotLog.ii(TAG, "Tools Target=%s", format(toolsTargetLocationOnField)); + + /* + * To place the Legos Target on the wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it 90 around the field's Z axis to align it with the correct wall. + * - Finally, we translate it in X and Y to its position on the wall. + */ + OpenGLMatrix legosTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the Blue Audience wall. + Our translation here is a positive translation in Y.*/ + .translation(-mmFTCFieldWidth/2, -mmFTCFieldWidth/4, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 90, 0)); + legosTarget.setLocation(legosTargetLocationOnField); + RobotLog.ii(TAG, "Legos Target=%s", format(legosTargetLocationOnField)); + + /* + * To place the Gears Target on the wall: + * - First we rotate it 90 around the field's X axis to flip it upright + * - Then we rotate it 180 around the field's Z axis to align it with the correct wall. + * - Finally, we translate it in X and Y to its position on the wall. + */ + OpenGLMatrix gearsTargetLocationOnField = OpenGLMatrix + /* Then we translate the target off to the Blue Audience wall. + Our translation here is a positive translation in Y.*/ + .translation(mmFTCFieldWidth/12, -mmFTCFieldWidth/2, 0) + .multiplied(Orientation.getRotationMatrix( + /* First, in the fixed (field) coordinate system, we rotate 90deg in X */ + AxesReference.EXTRINSIC, AxesOrder.XZX, + AngleUnit.DEGREES, 90, 180, 0)); + gearsTarget.setLocation(gearsTargetLocationOnField); + RobotLog.ii(TAG, "Gears Target=%s", format(gearsTargetLocationOnField)); + + /** + * Create a transformation matrix describing where the phone is on the robot. Here, we + * put the phone with the back camera facing the front of the robot (see our + * choice of BACK camera above) and in landscape mode. Starting from alignment between the + * robot's and phone's axes, assumed to be phone lying on the robot in portrait mode with + * the long axis point at the front of the robot this is a rotation of -90deg around the Y axis + * followed by 90 around Z, where robot axes are x->right, y->front, z->up. + * + * When determining whether a rotation is positive or negative, consider yourself as looking + * down the (positive) axis of rotation from the positive towards the origin. Positive rotations + * are then CCW, and negative rotations CW. An example: consider looking down the positive Z + * axis towards the origin. A positive rotation about Z (ie: a rotation parallel to the the X-Y + * plane) is then CCW, as one would normally expect from the usual classic 2D geometry. + */ + OpenGLMatrix phoneLocationOnRobot = OpenGLMatrix + .translation(0, 0, 0) + .multiplied(Orientation.getRotationMatrix( + AxesReference.EXTRINSIC, AxesOrder.YZX, + AngleUnit.DEGREES, 90, 90, 0)); + RobotLog.ii(TAG, "phone=%s", format(phoneLocationOnRobot)); + + /** + * Let the trackable listeners we care about know where the phone is. We know that each + * listener is a {@link VuforiaTrackableDefaultListener} and can so safely cast because + * we have not ourselves installed a listener of a different type. + */ + ((VuforiaTrackableDefaultListener) wheelsTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + ((VuforiaTrackableDefaultListener) toolsTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + ((VuforiaTrackableDefaultListener) legosTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + ((VuforiaTrackableDefaultListener) gearsTarget.getListener()).setPhoneInformation(phoneLocationOnRobot, parameters.cameraDirection); + + /** + * A brief tutorial: here's how all the math is going to work: + * + * C = phoneLocationOnRobot maps phone coords -> robot coords + * P = tracker.getPose() maps image target coords -> phone coords + * L = redTargetLocationOnField maps image target coords -> field coords + * + * So + * + * C.inverted() maps robot coords -> phone coords + * P.inverted() maps phone coords -> imageTarget coords + * + * Putting that all together, + * + * L x P.inverted() x C.inverted() maps robot coords to field coords. + * + * @see VuforiaTrackableDefaultListener#getRobotLocation() + */ + } + + @Override public void start() + { + /** Start tracking the data sets we care about. */ + FTC_2016_17.activate(); + } + + @Override public void loop() + { + for (VuforiaTrackable trackable : allTrackables) { + /** + * getUpdatedRobotLocation() will return null if no new information is available since + * the last time that call was made, or if the trackable is not currently visible. + * getRobotLocation() will return null if the trackable is not currently visible. + */ + telemetry.addData(trackable.getName(), ((VuforiaTrackableDefaultListener)trackable.getListener()).isVisible() ? "Visible" : "Not Visible"); // + + OpenGLMatrix robotLocationTransform = ((VuforiaTrackableDefaultListener)trackable.getListener()).getUpdatedRobotLocation(); + if (robotLocationTransform != null) { + lastLocation = robotLocationTransform; + } + } + /** + * Provide feedback as to where the robot was last located (if we know). + */ + if (lastLocation != null) { + // RobotLog.vv(TAG, "robot=%s", format(lastLocation)); + telemetry.addData("Position:", formatPosition(lastLocation)); + telemetry.addData("Orientation:", formatOrientation(lastLocation)); + } else { + telemetry.addData("Position:", "Unknown"); + telemetry.addData("Orientation:", "Unknown"); + } + } + + @Override public void stop() + { + } + + /** + * Some simple utilities that extract information from a transformation matrix + * and format it in a form palatable to a human being. + */ + String format(OpenGLMatrix transformationMatrix) { + //return transformationMatrix.formatAsTransform(); + VectorF translation = transformationMatrix.getTranslation(); + Orientation orientation = Orientation.getOrientation(transformationMatrix, AxesReference.EXTRINSIC, AxesOrder.XYZ, AngleUnit.DEGREES); + return String.format("%s %s", translation.toString(), orientation.toString()); + } + String formatPosition(OpenGLMatrix transformationMatrix) { + //return transformationMatrix.formatAsTransform(); + VectorF translation = transformationMatrix.getTranslation(); + return String.format("%s", translation.toString()); + } + String formatOrientation(OpenGLMatrix transformationMatrix) { + //return transformationMatrix.formatAsTransform(); + Orientation orientation = Orientation.getOrientation(transformationMatrix, AxesReference.EXTRINSIC, AxesOrder.XYZ, AngleUnit.DEGREES); + return String.format("%s", orientation.toString()); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalFlowDemo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalFlowDemo.java new file mode 100644 index 00000000000..3fcaad68c3e --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalFlowDemo.java @@ -0,0 +1,173 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.FilterLib; +import org.firstinspires.ftc.teamcode.libraries.MeccanumVelocityLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; +import org.opencv.android.CameraBridgeViewBase; +import org.opencv.core.Mat; +import org.opencv.core.MatOfByte; +import org.opencv.core.MatOfFloat; +import org.opencv.core.MatOfPoint; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.Point; +import org.opencv.imgproc.Imgproc; +import org.opencv.video.Video; + +import java.util.List; + +/** + * Created by Robotics on 10/28/2016. + */ + +@Autonomous(name = "Optical Flow 1", group = "Line Follow") +@Disabled +public class OpticalFlowDemo extends OpenCVLib { + + private int yVal; + private Mat lastMat; + private Mat lastMatGrey; + //private boolean firstCall = true; + + private double xPos = 0; + private double yPos = 0; + + boolean bDone = false; + + // parameters of the PID controller for this sequence's first part + float Kp = 0.035f; // degree heading proportional term correction per degree of deviation + float Ki = 0.02f; // ... integrator term + float Kd = 0; // ... derivative term + float KiCutoff = 3.0f; // maximum angle error for which we update integrator + + // parameters of the PID controller for the heading of the line following + float Kp2 = 0.125f; + float Ki2 = 0.000f; + float Kd2 = 0; + float Ki2Cutoff = 0.0f; + + private double headingVelocity = 0; + + private CameraVelocity sense = new CameraVelocity(); + + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + private SensorLib.PID mPid = new SensorLib.PID(Kp, Ki, Kd, KiCutoff); + + private SensorLib.PID vPid = new SensorLib.PID(Kp2, Ki2, Kd2, Ki2Cutoff); + + private BotHardwareOld bot; + + @Override + public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame frame){ + Mat ret = frame.rgba(); + Mat grey = frame.gray(); + + //submat the middle quarter to save proc power + Mat thing = ret.submat(ret.rows() / 4, (ret.rows() / 4) * 3, ret.cols() / 4, (ret.cols() / 4) * 3).clone(); + + MatOfPoint prev_corner = new MatOfPoint(); + MatOfPoint2f corner = new MatOfPoint2f(); + MatOfByte status = new MatOfByte(); + MatOfFloat err = new MatOfFloat(); + + Imgproc.goodFeaturesToTrack(lastMatGrey, prev_corner, 30, 0.25, 30); + + //RobotLog.vv(cvTAG, prev_corner.dump()); + + if(!prev_corner.empty()){ + Video.calcOpticalFlowPyrLK(lastMat, thing, new MatOfPoint2f(prev_corner.toArray()), corner, status, err); + + byte[] statusRay = status.toArray(); + + List prevRay = prev_corner.toList(); + + List ray = corner.toList(); + + double avgx = 0; + double avgy = 0; + int totalNum = 0; + + for(int i=0; i 0){ + avgx /= (double) totalNum; + avgy /= (double) totalNum; + + xPos += avgx; + yPos += avgy; + + telemetry.addData("Position", xPos + ", " + yPos); + if(Math.abs(avgx) > 1.2 || Math.abs(avgy) > 1.2){ + headingVelocity = SensorLib.Utils.wrapAngle(Math.toDegrees(Math.atan2(avgy, avgx)) - 90); + telemetry.addData("Heading", headingVelocity); + } + } + } + + + lastMat = ret.submat(ret.rows() / 4, (ret.rows() / 4) * 3, ret.cols() / 4, (ret.cols() / 4) * 3).clone(); + lastMatGrey = grey.submat(ret.rows() / 4, (ret.rows() / 4) * 3, ret.cols() / 4, (ret.cols() / 4) * 3).clone(); + + //if(frame != null) firstCall = false; + + return ret; + } + + private class CameraVelocity implements HeadingSensor { + + private FilterLib.MovingWindowAngleFilter filter = new FilterLib.MovingWindowAngleFilter(); + + public float getHeading(){ + filter.appendValue(headingVelocity); + return (float)filter.currentValue(); + } + + } + + @Override + public void init(){ + initOpenCV(); + + lastMat = new Mat(); + lastMatGrey = new Mat(); + + bot = new BotHardwareOld(); + bot.init(this, false); + + bot.startNavX(); + + mSeq.add(new MeccanumVelocityLib.SquirrleyAzimuthTimedAngledDriveStep(this, 45, bot.getNavXHeadingSensor(), sense, mPid, vPid, bot.getMotorArray(), 0.2f, 10.0f, true)); + mSeq.add(new MeccanumVelocityLib.SquirrleyAzimuthTimedAngledDriveStep(this, -135, bot.getNavXHeadingSensor(), sense, mPid, vPid, bot.getMotorArray(), 0.2f, 10.0f, true)); + } + + @Override + public void start(){ + startCamera(); + } + + @Override + public void loop(){ + if(!bDone) bDone = mSeq.loop(); + else telemetry.addData("Seq", "Done"); + } + + @Override + public void stop(){ + stopCamera(); + lastMat.release(); + bot.navX.close(); + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalMouseCanvasFun.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalMouseCanvasFun.java new file mode 100644 index 00000000000..1f91b338c70 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalMouseCanvasFun.java @@ -0,0 +1,248 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.app.Activity; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.hardware.usb.UsbDevice; +import android.hardware.usb.UsbDeviceConnection; +import android.hardware.usb.UsbEndpoint; +import android.hardware.usb.UsbInterface; +import android.hardware.usb.UsbManager; +import android.view.View; +import android.view.ViewGroup; +import android.widget.RelativeLayout; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.RobotLog; + +import org.firstinspires.ftc.robotcontroller.internal.FtcRobotControllerActivity; +import org.firstinspires.ftc.robotcore.external.Telemetry; +import org.firstinspires.ftc.teamcode.libraries.interfaces.PointHandler; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Vector; +import java.util.concurrent.TimeUnit; + +/** + * Created by Noah on 4/9/2017. + * Opmode which should take optical mouse input and draw its path on a canvas + * to see how accurate an optical mouse tracker actually is + */ + +@Autonomous(name = "Optical Mouse Path Drawing Demo", group = "Test") +@Disabled +public class OpticalMouseCanvasFun extends OpMode implements PointHandler{ + + private final RelativeLayout layout = (RelativeLayout)((Activity)hardwareMap.appContext).findViewById(com.qualcomm.ftcrobotcontroller.R.id.CheapCamera); + private LineView lineView; + private UsbManager usbManager; + private UsbDevice usbDevice; + private UsbEndpoint endpoint; + private UsbDeviceConnection usbDeviceConnection; + private final String TAG = "Optical Mouse Line"; + + private LinkedList pts = new LinkedList<>(); + private double lastTime = 0; + + private final PointHandler pointer = this; + + @Override + public void init(){ + telemetry.addData("Canvas test!", "Go!"); + telemetry.update(); + + //usb stuff + connect(hardwareMap.appContext); + + //canvas stuff + Runnable doCanvasSetup = new Runnable() { + @Override + public void run() { + Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); + paint.setColor(Color.RED); + lineView = new LineView(hardwareMap.appContext, pointer, paint); + + RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT); + layout.addView(lineView, params); + } + }; + + layout.getHandler().post(doCanvasSetup); + + //start out at 0,0 + pts.add(0.0); + pts.add(0.0); + } + + @Override + public void init_loop(){ + + } + + @Override + public void start(){ + + } + + @Override + public void loop(){ + int TIMEOUT = 10; + byte[] bytes = new byte[endpoint.getMaxPacketSize()]; + + usbDeviceConnection.bulkTransfer(endpoint, bytes, bytes.length, TIMEOUT); + + // depending on mouse firmware and vendor the information you're looking for may + // be in a different order or position. For some logitech devices the following + // is true: + + int x = (int) bytes[1]; + int y = (int) bytes[2]; + int scrollwheel = (int) bytes[3]; + + telemetry.addData(TAG, "X: " + x + " Y: " + y + " S: " + scrollwheel); + + if((x | y) > 0){ + //integrate position to velocity + if(lastTime == 0)lastTime = getRuntime(); + double deltaT = (getRuntime() - lastTime) / 1000.0; + //and add it to the array + pts.add(pts.get(pts.size() - 2) + deltaT * x); + pts.add(pts.get(pts.size() - 2) + deltaT * y); + + + } + + telemetry.addData("Point", "x: " + pts.get(pts.size() - 1) + " y: " + pts.get(pts.size() - 2)); + + if(pts.size() > 5000){ + pts.removeLast(); + pts.removeLast(); + } + } + + @Override + public void stop(){ + Runnable hideChart = new Runnable() { + @Override + public void run() { + layout.removeView(lineView); + } + }; + + layout.getHandler().post(hideChart); + } + + private void connect(Context context) { + this.usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE); + HashMap deviceList = usbManager.getDeviceList(); + + // just get the first enumerated USB device + Iterator deviceIterator = deviceList.values().iterator(); + + RobotLog.v(TAG, deviceIterator.toString()); + + if (deviceIterator.hasNext()) { + this.usbDevice = deviceIterator.next(); + } + + if (usbDevice == null) { + RobotLog.v(TAG, "no USB device found"); + return; + } + + // ask for permission + + final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"; + final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() { + + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (ACTION_USB_PERMISSION.equals(action)) { + synchronized (this) { + UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE); + + if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) { + if(device != null){ + // call method to set up device communication + RobotLog.v(TAG, "permission granted. access mouse."); + + // repeat in a different thread + transfer(device); + } + } + else { + RobotLog.e(TAG, "permission denied for device " + device); + } + } + } else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) { + UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE); + if (device != null) { + // TODO: + // call your method that cleans up and closes communication with the device + // usbInterface.releaseInterface(); + // usbDeviceConnection.close(); + } + } + } + }; + + PendingIntent mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0); + IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION); + context.registerReceiver(mUsbReceiver, filter); + + usbManager.requestPermission(usbDevice, mPermissionIntent); + } + + private void transfer(UsbDevice device) { + boolean forceClaim = true; + + // just grab the first endpoint + UsbInterface intf = device.getInterface(0); + endpoint = intf.getEndpoint(0); + usbDeviceConnection = this.usbManager.openDevice(device); + usbDeviceConnection.claimInterface(intf, forceClaim); + } + + @Override + public float[] getPoints() { + float[] ray = new float[pts.size()]; + for(int i = 0; i < pts.size(); i++){ + ray[i] = pts.get(i).floatValue(); + } + return ray; + } + + //draws on continous line given an array of points and a color + private static class LineView extends View { + Paint mPaint; + PointHandler mPts; + + public LineView(Context context, PointHandler pts, Paint paint){ + super(context); + + mPts = pts; + mPaint = paint; + } + + @Override + public void onDraw(Canvas canvas){ + this.setBackgroundColor(Color.WHITE); + + float[] pts = mPts.getPoints(); + for(int i = 0; i < pts.length-4; i+=2){ + //draw single line at offset i + canvas.drawLines(pts, i, 4, mPaint); + } + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalMouseFun.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalMouseFun.java new file mode 100644 index 00000000000..3bd454aa384 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/OpticalMouseFun.java @@ -0,0 +1,147 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.hardware.usb.*; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.RobotLog; + +import java.util.HashMap; +import java.util.Iterator; + +/** + * Created by Noah on 3/19/2017. + * This opmode should be a testbed for a usb optical mouse library + * by the time I read this again however there is a high likleyhood it will be something entirely different + * I never update my comments + * + * code stolen from: http://stackoverflow.com/questions/13280402/reading-raw-mouse-data-on-android + */ + +@Autonomous(name="USB Mouse Fun", group ="Test") +@Disabled +public class OpticalMouseFun extends OpMode { + UsbManager usbManager; + UsbDevice usbDevice; + + private static final String usbTAG = "Mouse Fun"; + private Context context; + + private void connect() { + this.usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE); + HashMap deviceList = usbManager.getDeviceList(); + + // just get the first enumerated USB device + Iterator deviceIterator = deviceList.values().iterator(); + + RobotLog.v(usbTAG, deviceIterator.toString()); + + if (deviceIterator.hasNext()) { + this.usbDevice = deviceIterator.next(); + } + + if (usbDevice == null) { + RobotLog.v(usbTAG, "no USB device found"); + return; + } + + // ask for permission + + final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"; + final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() { + + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (ACTION_USB_PERMISSION.equals(action)) { + synchronized (this) { + UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE); + + if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) { + if(device != null){ + // call method to set up device communication + RobotLog.v(usbTAG, "permission granted. access mouse."); + + // repeat in a different thread + transfer(device); + } + } + else { + RobotLog.e(usbTAG, "permission denied for device " + device); + } + } + } else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) { + UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE); + if (device != null) { + // TODO: + // call your method that cleans up and closes communication with the device + // usbInterface.releaseInterface(); + // usbDeviceConnection.close(); + } + } + } + }; + + PendingIntent mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0); + IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION); + context.registerReceiver(mUsbReceiver, filter); + + usbManager.requestPermission(usbDevice, mPermissionIntent); + } + + private void transfer(UsbDevice device) { + + int TIMEOUT = 0; + boolean forceClaim = true; + + // just grab the first endpoint + UsbInterface intf = device.getInterface(0); + UsbEndpoint endpoint = intf.getEndpoint(0); + UsbDeviceConnection connection = this.usbManager.openDevice(device); + connection.claimInterface(intf, forceClaim); + + byte[] bytes = new byte[endpoint.getMaxPacketSize()]; + + connection.bulkTransfer(endpoint, bytes, bytes.length, TIMEOUT); + + // depending on mouse firmware and vendor the information you're looking for may + // be in a different order or position. For some logitech devices the following + // is true: + + int x = (int) bytes[1]; + int y = (int) bytes[2]; + int scrollwheel = (int) bytes[3]; + + RobotLog.v(usbTAG, "X: " + x + " Y: " + y + " S: " + scrollwheel); + + // call a listener, process your data ... + } + + @Override + public void init(){ + connect(); + } + + @Override + public void init_loop(){ + + } + + @Override + public void start(){ + + } + + @Override + public void loop(){ + + } + + @Override + public void stop(){ + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/PilliarDemo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/PilliarDemo.java new file mode 100644 index 00000000000..abef92396e9 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/PilliarDemo.java @@ -0,0 +1,62 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.graphics.Bitmap; +import android.os.Environment; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.libraries.PilliarLib; + +import java.io.FileOutputStream; +import java.io.IOException; + +/** + * Created by Noah on 12/20/2017. + */ + +@Autonomous(name="Pilliar Demo", group="test") +@Disabled +public class PilliarDemo extends PilliarLib { + private boolean red = true; + private boolean lastA = false; + + public void init(){ + initVuforia(true); + } + + public void init_loop() { + if(lastA && !gamepad1.a) red = !red; + lastA = gamepad1.a; + telemetry.addData("Red", red); + + getPeaks(red); + } + + public void start() { + FileOutputStream out = null; + try{ + out = new FileOutputStream(Environment.getExternalStorageDirectory().getAbsolutePath() + "/pil" + getRuntime() + ".png"); + bm.compress(Bitmap.CompressFormat.PNG, 100, out); + + } + catch(Exception e) { + //oops + e.printStackTrace(); + } + finally { + try { + if (out != null) { + out.close(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + public void loop() { + getPeaks(red); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/PingCheck.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/PingCheck.java new file mode 100644 index 00000000000..4a35a5c6b5a --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/PingCheck.java @@ -0,0 +1,46 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; + +import org.firstinspires.ftc.teamcode.libraries.FilterLib; + +/** + * Created by Noah on 3/19/2018. + */ + +@TeleOp(name="Loop Timing") +@Disabled +public class PingCheck extends OpMode { + + long lastMillis = 0; + long lastStamp = 0; + boolean gamepadChanged = false; + FilterLib.MovingWindowFilter filter = new FilterLib.MovingWindowFilter(10); + + public void init() { + + } + + public void start() { + lastStamp = gamepad1.timestamp; + } + + public void loop() { + long nowTime = System.currentTimeMillis(); + filter.appendValue(nowTime - lastMillis); + telemetry.addData("Loop Time", filter.currentValue()); + telemetry.addData("Last Stamp", lastStamp); + telemetry.addData("Delta Time", nowTime - lastStamp); + telemetry.addData("Gamepad Changed", gamepadChanged); + lastMillis = nowTime; + if(!gamepadChanged && gamepad1.timestamp != lastStamp) gamepadChanged = true; + lastStamp = gamepad1.timestamp; + telemetry.addData("Interval", telemetry.getMsTransmissionInterval()); + } + + public void stop() { + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/RunTehServos.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/RunTehServos.java new file mode 100644 index 00000000000..1084f6d2e00 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/RunTehServos.java @@ -0,0 +1,42 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.CRServo; +import com.qualcomm.robotcore.hardware.DcMotorSimple; + +/** + * Created by Noah on 3/14/2018. + */ + + +@Autonomous(name="Run Servos") +@Disabled +public class RunTehServos extends OpMode { + CRServo left; + CRServo right; + + + public void init() { + left = hardwareMap.get(CRServo.class, "l"); + right = hardwareMap.get(CRServo.class, "r"); + left.setDirection(DcMotorSimple.Direction.REVERSE); + left.setPower(0); + right.setPower(0); + } + + public void start() { + + } + + public void loop() { + left.setPower(0.83); + right.setPower(0.83); + } + + public void stop() { + left.setPower(0); + right.setPower(0); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/SPIBitbang.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/SPIBitbang.java new file mode 100644 index 00000000000..e4611501293 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/SPIBitbang.java @@ -0,0 +1,87 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.AnalogInput; +import com.qualcomm.robotcore.hardware.AnalogInputController; +import com.qualcomm.robotcore.hardware.DigitalChannel; +import com.qualcomm.robotcore.hardware.DigitalChannelImpl; + +/** + * Created by Noah on 1/29/2018. + */ + +@Autonomous(name="SPI Bitbang") +@Disabled +public class SPIBitbang extends OpMode { + DigitalChannel SCK; + DigitalChannel CS; + DigitalChannel MISO; + DigitalChannel MOSI; + + AnalogInput input; + + private enum SPIState { + CLOCK_LOW, + DATA_SET, + CLOCK_HIGH; + } + + private final byte frame = (byte)(0b00000000); + byte recv = 0; + int index = 0; + SPIState state = SPIState.CLOCK_HIGH; + + public void init() { + SCK = hardwareMap.digitalChannel.get("sck"); + CS = hardwareMap.digitalChannel.get("cs"); + MISO = hardwareMap.digitalChannel.get("miso"); + MOSI = hardwareMap.digitalChannel.get("mosi"); + + SCK.setMode(DigitalChannel.Mode.OUTPUT); + CS.setMode(DigitalChannel.Mode.OUTPUT); + MISO.setMode(DigitalChannel.Mode.INPUT); + MOSI.setMode(DigitalChannel.Mode.OUTPUT); + + SCK.setState(true); + CS.setState(true); + //MISO.setState(true); + MOSI.setState(true); + } + + public void start() { + //Select + CS.setState(false); + //set write + for(int i = 0; i < 8; i++) { + MOSI.setState((frame & (1 << (7-i))) > 0); + SCK.setState(false); + SCK.setState(true); + } + //recieve read + for(int i = 0; i < 8; i++) { + SCK.setState(false); + recv |= ((MISO.getState() ? 1 : 0) << (7-i)); + SCK.setState(true); + } + CS.setState(true); + + } + + public void loop() { + /* + if(index < 8) { + if(state == SPIState.CLOCK_HIGH) SCK.setState(false); + else if(state == SPIState.CLOCK_LOW) { + + } + } + */ + telemetry.addData("recv", recv & 0xff); + } + + public void stop() { + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/TelemetryLogTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/TelemetryLogTest.java new file mode 100644 index 00000000000..6ff14be7ae6 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/TelemetryLogTest.java @@ -0,0 +1,43 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.TelemetryLogLib; + +/** + * Created by Noah on 4/2/2017. + */ +@Autonomous(name="Telemetry Fun", group="Test") +@Disabled +public class TelemetryLogTest extends OpMode { + + int stupid = 0; + + @Override + public void init(){ + telemetry = new TelemetryLogLib.TelemetryLog(this); + telemetry.addData("Broken?", "Guess not"); + } + + @Override + public void init_loop(){ + telemetry.addData("Stupid", stupid++); + } + + @Override + public void start(){ + + } + + @Override + public void loop(){ + + } + + @Override + public void stop(){ + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/UltraDistance.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/UltraDistance.java new file mode 100644 index 00000000000..617e163e920 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/UltraDistance.java @@ -0,0 +1,39 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; + +import org.firstinspires.ftc.teamcode.libraries.CrappyGraphLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; + +import java.util.LinkedList; + +/** + * Created by Noah on 3/19/2018. + */ + +@TeleOp(name="Graph Ultra") +public class UltraDistance extends CrappyGraphLib { + private LinkedList data = new LinkedList<>(); + private MatbotixUltra frontUltra; + + public void init() { + initGraph(data, true); + frontUltra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultrafront"), 100); + frontUltra.initDevice(); + } + + public void start() { + frontUltra.startDevice(); + } + + public void loop() { + //add graph stuff + int val = frontUltra.getReading(); + this.data.add((double)val); + if(this.data.size() > 100) this.data.remove(); + drawGraph(); + + telemetry.addData("Ultra", val); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/UltraTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/UltraTest.java new file mode 100644 index 00000000000..efab9586889 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/UltraTest.java @@ -0,0 +1,56 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.AnalogInput; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; +import com.qualcomm.robotcore.hardware.UltrasonicSensor; + +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; + +/** + * Created by Noah on 1/29/2018. + */ + +@Autonomous(name="Ultra Teleop", group="test") +@Disabled +public class UltraTest extends OpMode { + private MatbotixUltra ultra; + private MatbotixUltra ultraBack; + private MatbotixUltra ultraLeft; + private MatbotixUltra ultraRight; + + private MatbotixUltra[] ray; + + public void init() { + try { + ultra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultrafront"), 100); + ultraBack = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraback"), 100); + ultraRight = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraright"), 100); + ultraLeft = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraleft"), 100); + } + catch (Exception e) { /* hmmmm */ } + + ray = new MatbotixUltra[] {ultraLeft, ultra, ultraRight, ultraBack}; + + for(MatbotixUltra i : ray) { + if(i != null) { + i.initDevice(); + i.startDevice(); + } + } + } + + public void start() { + + } + + public void loop() { + for (MatbotixUltra i : ray) if(i != null) telemetry.addData(i.getDevice().getDeviceName(), i.getReading()); + } + + public void stop() { + for (MatbotixUltra i : ray) if(i != null) i.stopDevice(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaBallDemo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaBallDemo.java new file mode 100644 index 00000000000..4fb80d75df5 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaBallDemo.java @@ -0,0 +1,66 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.graphics.Bitmap; +import android.os.Environment; +import android.util.Log; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; + +import org.firstinspires.ftc.teamcode.libraries.VuforiaBallLib; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.logging.Logger; + +/** + * Created by Noah on 11/9/2017. + */ + +@Autonomous(name="Vuforia Ball Demo", group ="test") +public class VuforiaBallDemo extends VuforiaBallLib { + + @Override + public void init() { + initVuforia(true); + super.startTracking(); + } + + public void init_loop() { + getBallColor(); + } + + @Override + public void start() { + FileOutputStream out = null; + try{ + out = new FileOutputStream(Environment.getExternalStorageDirectory().getAbsolutePath() + "/balls.png"); + bm.compress(Bitmap.CompressFormat.PNG, 100, out); + + } + catch(Exception e) { + //oops + e.printStackTrace(); + } + finally { + try { + if (out != null) { + out.close(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Override + public void loop() { + telemetry.addData("Path", Environment.getExternalStorageDirectory().getAbsolutePath() + "/balls.png"); + telemetry.addData("Tracking", isTracking().toString()); + telemetry.addData("Ball Color", getBallColor()); + } + + @Override + public void stop() { + super.stopVuforia(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaNavigationTest1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaNavigationTest1.java new file mode 100644 index 00000000000..e071c09d6ce --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaNavigationTest1.java @@ -0,0 +1,93 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.vuforia.Image; + +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaLocalizer; +import org.firstinspires.ftc.teamcode.libraries.VuforiaLib_FTC2016; +import org.opencv.core.Mat; + +import java.nio.ByteBuffer; + +/** + * This OpMode illustrates the basics of using the VuforiaLib_FTC2016 library to determine + * positioning and orientation of robot on the FTC field. + */ + +@Autonomous(name="Test: Vuforia Navigation Test 1", group ="Test") +@Disabled +public class VuforiaNavigationTest1 extends OpMode { + + VuforiaLib_FTC2016 mVLib; + + @Override public void init() { + /** + * Start up Vuforia using VuforiaLib_FTC2016 + */ + mVLib = new VuforiaLib_FTC2016(); + mVLib.init(this, null); // pass it this OpMode (so it can do telemetry output) and use its license key for now + } + + @Override public void start() + { + /** Start tracking the data sets we care about. */ + mVLib.start(); + } + + @Override public void loop() + { + VuforiaLocalizer.CloseableFrame frame; + mVLib.loop(true); // update location info and do debug telemetry + if(!mVLib.getFrames().isEmpty()){ + frame = mVLib.getFrames().poll(); + + Image img = frame.getImage(0); + + ByteBuffer buf = img.getPixels(); + + Mat m = new Mat(); + m.put(0,0,buf.array()); + telemetry.addData("Mat Width:", m.width()); + telemetry.addData("Mat Height:", m.height()); + } + + } + + @Override public void stop() + { + mVLib.stop(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaSquirrelyDriveTestOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaSquirrelyDriveTestOp.java new file mode 100644 index 00000000000..d8064329f32 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VuforiaSquirrelyDriveTestOp.java @@ -0,0 +1,110 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.robotcore.external.matrices.VectorF; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.SquirrelyLib; +import org.firstinspires.ftc.teamcode.libraries.VuforiaLib_FTC2016; + + +/** + * simple example of using a Step that makes a bot with "squirrely wheels" drive to given locations on the field using Vuforia input + * Created by phanau on 11/01/16. + */ + + +// example sequence that tests VuforiaSquirrelyDriveStep to drive to a sequence of given locations on the field +// using Squirrely wheels. It should work regardless of the initial orientation of the robot, as long as at least +// one of the target images is visible. + +@Autonomous(name="Test: Vuforia Squirrely Drive Test 1", group ="Test") +@Disabled +public class VuforiaSquirrelyDriveTestOp extends OpMode { + + AutoLib.Sequence mSequence; // the root of the sequence tree + boolean bDone; // true when the programmed sequence is done + DcMotor mMotors[]; // motors, some of which can be null: assumed order is fr, br, fl, bl + VuforiaLib_FTC2016 mVLib; + + + @Override + public void init() { + + // Start up Vuforia using VuforiaLib_FTC2016 + mVLib = new VuforiaLib_FTC2016(); + mVLib.init(this, null); // pass it this OpMode (so it can do telemetry output) and use its license key for now + + // get physical or test hardware factory + AutoLib.HardwareFactory mf = null; + final boolean debug = false; + if (debug) + mf = new AutoLib.TestHardwareFactory(this); + else + mf = new AutoLib.RealHardwareFactory(this); + + // get the motors: depending on the factory we created above, these may be + // either dummy motors that just log data or real ones that drive the hardware + // assumed order is fr, br, fl, bl + mMotors = new DcMotor[4]; + mMotors[0] = mf.getDcMotor("front_right"); + mMotors[1] = mf.getDcMotor("back_right"); + (mMotors[2] = mf.getDcMotor("front_left")).setDirection(DcMotor.Direction.REVERSE); + (mMotors[3] = mf.getDcMotor("back_left")).setDirection(DcMotor.Direction.REVERSE); + + // create an autonomous sequence with the steps to drive + // several legs of a polygonal course --- + float power = 0.5f; + float error = 254.0f; // get us within 10" for this test + float targetZ = 6*25.4f; + + // create the root Sequence for this autonomous OpMode + mSequence = new AutoLib.LinearSequence(); + + // add a bunch of "legs" to the sequence - use Vuforia convention for locations on the field + // with X and Y axes pointing away from the walls with beacons and targets + + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(-1500,300,targetZ), mVLib, mVLib, mMotors, power, error)); // Wheels + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(-1500,-914,targetZ), mVLib, mVLib, mMotors, power, error)); // Legos + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(-914,-1500,targetZ), mVLib, mVLib, mMotors, power, error)); // Tools + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(300,-1500,targetZ), mVLib, mVLib, mMotors, power, error)); // Gears + + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(0,0,targetZ), mVLib, mVLib, mMotors, power, error)); + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(-1000,0,targetZ), mVLib, mVLib, mMotors, power, error)); + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(-1000,-1000,targetZ), mVLib, mVLib, mMotors, power, error)); + mSequence.add(new SquirrelyLib.VuforiaSquirrelyDriveStep(this, new VectorF(0,-1000,targetZ), mVLib, mVLib, mMotors, power, error)); + + // start out not-done + bDone = false; + } + + @Override public void start() + { + // Start tracking the data sets we care about. + mVLib.start(); + } + + @Override + public void loop() { + // update Vuforia location info and do debug telemetry + mVLib.loop(true); + + // until we're done, keep looping through the current Step(s) + if (!bDone) + bDone = mSequence.loop(); // returns true when we're done + else + telemetry.addData("sequence finished", ""); + } + + @Override + public void stop() { + super.stop(); + mVLib.stop(); + } + + +} + diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VumarkHiJackVideo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VumarkHiJackVideo.java new file mode 100644 index 00000000000..14df938c264 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VumarkHiJackVideo.java @@ -0,0 +1,424 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.app.Activity; +import android.graphics.Bitmap; +import android.support.annotation.Nullable; +import android.util.Log; +import android.widget.ImageView; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.vuforia.CameraCalibration; +import com.vuforia.Image; +import com.vuforia.Matrix34F; +import com.vuforia.PIXEL_FORMAT; +import com.vuforia.Tool; +import com.vuforia.Vec3F; +import com.vuforia.Vuforia; + +import org.firstinspires.ftc.robotcore.external.matrices.OpenGLMatrix; +import org.firstinspires.ftc.robotcore.external.navigation.RelicRecoveryVuMark; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaLocalizer; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackable; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackableDefaultListener; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackables; +import org.firstinspires.ftc.robotcore.internal.vuforia.VuforiaLocalizerImpl; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLoad; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.opencv.android.Utils; +import org.opencv.core.Core; +import org.opencv.core.Mat; +import org.opencv.core.Point; +import org.opencv.core.Scalar; +import org.opencv.imgproc.Imgproc; + +import java.util.concurrent.BlockingDeque; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingDeque; + +import static org.opencv.core.CvType.CV_8U; +import static org.opencv.core.CvType.CV_8UC3; + +/** + * Created by Noah on 9/12/2017. + * getting rid of warning + */ + +@Autonomous(name="Red Auto", group ="Auto") +@Disabled +public class VumarkHiJackVideo extends OpenCVLoad { + + private BlockingQueue ray; + private VuforiaLocalizerShim vuforia; + private VuforiaTrackable relicTemplate; + + private ImageView mView; + + //define the jewel platform relative to the image with a buncha vectors to add + //all units in vuforia are mm, so we multiply to inches to make it readable + private static final float inToMM = 25.4f; + + //units in inches, then converted to mm + private static final float boxLeftFromImage = 3.625f * inToMM; + private static final float boxBottomFromImage = 5.125f * inToMM; + private static final float boxWidth = 9.75f * inToMM; + private static final float boxLength = 3.75f * inToMM; + private static final float boxHeight = 3.75f * inToMM; + + private static final float ballCenterFromBoxEdge = 1.875f * inToMM; + + //identity mats to be constructed later in the project + private Vec3F[] point; + private float[] size; + //output bitmap + private Bitmap bm; + //Canvas canvas; + //Paint p; + + private BlockingDeque matQueue = new LinkedBlockingDeque<>(); + + //storage camera calibration + private CameraCalibration camCal; + + private Point[] imagePoints; + private int[] leftBall = new int[2]; + private int leftDist; + private int[] rightBall = new int[2]; + private int rightDist; + + private Scalar leftColor; + private Scalar rightColor; + + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + private BotHardware bot = new BotHardware(this); + + protected boolean RED = true; + + @Override + public void init() { + mView = (ImageView)((Activity)hardwareMap.appContext).findViewById(com.qualcomm.ftcrobotcontroller.R.id.OpenCVOverlay); + mView.setAlpha(1.0f); + + int cameraMonitorViewId = hardwareMap.appContext.getResources().getIdentifier("cameraMonitorViewId", "id", hardwareMap.appContext.getPackageName()); + VuforiaLocalizer.Parameters parameters = new VuforiaLocalizer.Parameters(cameraMonitorViewId); + parameters.vuforiaLicenseKey = "AZPbGaP/////AAAAGcIykH/KO0QNvZGSYxc0fDlVytYrk0HHv6OLmjHsswRvi/1l9RZCkepChaAZup3DIJlrjK2BV57DEz/noNO0oqT9iu2moP/svGmJ+pBG7FlfF4RHxu6UhvVLaKUZCsTJ1zTkd7XnMuRw8aSuIxowOiLJQYcgjmddi11LG26lAr6aRmoWJzr2pv6Yui2Gom0wt9J4+1g3kXqjngnH3h6NPA/6aUfpVngFaFPp5knyDJWZT88THttPsqcKW41QC/qgNh3CHIdADu15Rm51JNRlvG+2+sYstiHeHFQqCDwUkTgWor0v/Bk+xXoj3oUCb4REwT9w94E/VEI4qEAFPpmeo6YgxQ4LLFknu6tgNy8xdD6S"; + parameters.cameraDirection = VuforiaLocalizer.CameraDirection.BACK; + parameters.cameraMonitorFeedback = VuforiaLocalizer.Parameters.CameraMonitorFeedback.NONE; + //bwahaha java shim + this.vuforia = new VuforiaLocalizerShim(parameters); + Vuforia.setFrameFormat(PIXEL_FORMAT.RGB888, true); //enables RGB565 format for the image + camCal = vuforia.getCameraCalibration(); + + //constrt matrixes + //contruct top and bottom of both balls + final Vec3F ballLeftTop = new Vec3F(boxLeftFromImage + ballCenterFromBoxEdge, -boxBottomFromImage + boxHeight, ballCenterFromBoxEdge); + final Vec3F ballLeftBottom = new Vec3F(boxLeftFromImage + ballCenterFromBoxEdge, -boxBottomFromImage, ballCenterFromBoxEdge); + + final Vec3F ballRightTop = new Vec3F(boxLeftFromImage + boxWidth - ballCenterFromBoxEdge, -boxBottomFromImage + boxHeight, ballCenterFromBoxEdge); + final Vec3F ballRightBottom = new Vec3F(boxLeftFromImage + boxWidth - ballCenterFromBoxEdge, -boxBottomFromImage, ballCenterFromBoxEdge); + + //construct points like a box + final Vec3F botLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage, 0); + final Vec3F botRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage, 0); + final Vec3F botFrontLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage, boxLength); + final Vec3F botFrontRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage, boxLength); + + final Vec3F topLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage + boxHeight, 0); + final Vec3F topRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage + boxHeight, 0); + final Vec3F topFrontLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage + boxHeight, boxLength); + final Vec3F topFrontRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage + boxHeight, boxLength); + + point = new Vec3F[] { botLeft, botRight, botFrontRight, botFrontLeft, topLeft, topRight, topFrontRight, topFrontLeft, + ballLeftTop, ballLeftBottom, ballRightTop, ballRightBottom }; + + imagePoints = new Point[point.length]; + + size = camCal.getSize().getData(); + + bm = Bitmap.createBitmap((int)size[0], (int)size[1], Bitmap.Config.ARGB_8888); + + //setup view + mView.post(new Runnable() { + @Override + public void run() { + mView.setImageBitmap(bm); + } + }); + + telemetry.update(); + + initOpenCV(); + + telemetry.addData(">", "Press Play to start"); + telemetry.update(); + + bot.init(); + + VuforiaTrackables relicTrackables = this.vuforia.loadShimTrackablesFromAsset("RelicVuMark"); + relicTemplate = relicTrackables.get(0); + relicTemplate.setName("relicVuMarkTemplate"); // can help in debugging; otherwise not necessary + + relicTrackables.activate(); + + this.vuforia.setFrameQueueCapacity(1); + this.ray = this.vuforia.getFrameQueue(); + } + + @Override + public void init_loop() { + RelicRecoveryVuMark vuMark = RelicRecoveryVuMark.from(relicTemplate); + if (vuMark != RelicRecoveryVuMark.UNKNOWN) { + + /* Found an instance of the template. In the actual game, you will probably + * loop until this condition occurs, then move on to act accordingly depending + * on which VuMark was visible. */ + telemetry.addData("VuMark", "%s visible", vuMark); + + /* For fun, we also exhibit the navigational pose. In the Relic Recovery game, + * it is perhaps unlikely that you will actually need to act on this pose information, but + * we illustrate it nevertheless, for completeness. */ + //qualcomm is stupid and didn't let me see the real vuforia matrix, so I shimmed it + //heres where is gets good + VuforiaDefaultListenerShim writeGoodCode = (VuforiaDefaultListenerShim) relicTemplate.getListener(); + + OpenGLMatrix pose = writeGoodCode.getRawPose(); + telemetry.addData("Pose", format(pose)); + + /* We further illustrate how to decompose the pose into useful rotational and + * translational components */ + if (pose != null) { + //alternate projection! + //get vuforia's real position matrix + Matrix34F goodCodeWritten = writeGoodCode.getRealPose(); + + //reset imagePoints + final float[][] vufPoints = new float[point.length][2]; + + //use vuforias projectPoints method to project all those box points + for(int i = 0; i < point.length; i++){ + //project + vufPoints[i] = Tool.projectPoint(camCal, goodCodeWritten, point[i]).getData(); + //convert to opencv language + + //telemetry.addData("point", "num: %d, x: %f.2, y: %f.2", i, vufPoints[i][0], vufPoints[i][1]); + } + + //telemetry.addData("Camera Size", "w: %f.2, h: %f.2", camCal.getSize().getData()[0], camCal.getSize().getData()[1]); + + //get frame from vuforia + try{ + VuforiaLocalizer.CloseableFrame frame = ray.take(); + + int img = 0; + for(; img < frame.getNumImages(); img++){ + //telemetry.addData("Image format " + img, frame.getImage(img).getFormat()); + if(frame.getImage(img).getFormat() == PIXEL_FORMAT.RGB888) break; + } + + Image mImage = frame.getImage(img); + + //stick it in a Mat for "display purposes" + Mat out = new Mat(mImage.getHeight(), mImage.getWidth(), CV_8UC3); + + java.nio.ByteBuffer color = mImage.getPixels(); + byte[] ray = new byte[color.limit()]; + color.rewind(); + color.get(ray); + out.put(0, 0, ray); + + frame.close(); + + //convert points, halfing distances b/c vuforia does that internally so we gotta fix it + for(int i = 0; i < vufPoints.length; i++) imagePoints[i] = new Point((int)vufPoints[i][0], (int)vufPoints[i][1]); + + Scalar green = new Scalar(0, 255, 0); + for(int i = 0; i < 2; i++) + for(int o = 0; o < 4; o++) + Imgproc.line(out, imagePoints[o == 0 ? 3 + i * 4 : i * 4 + o - 1], imagePoints[i * 4 + o], green); + + //connect the rectangles + for(int i = 0; i < 4; i++) Imgproc.line(out, imagePoints[i], imagePoints[i + 4], green); + + for(int i = 8; i < imagePoints.length; i++) Imgproc.drawMarker(out, imagePoints[i], green); + + //calculate points from projection + //find the midpoint between the two points + int leftXPoint = (int)((imagePoints[8].x + imagePoints[9].x) / 2.0); + int leftYPoint = (int)((imagePoints[8].y + imagePoints[9].y) / 2.0); + //find the y distande between the two + leftDist = (int)(Math.abs(imagePoints[8].y - imagePoints[9].y) / 2.0); + leftBall = new int[] {leftXPoint - (leftDist / 2), leftYPoint - (leftDist / 2)}; + + //find the midpoint between the two points + int rightXPoint = (int)((imagePoints[10].x + imagePoints[11].x) / 2.0); + int rightYPoint = (int)((imagePoints[10].y + imagePoints[11].y) / 2.0); + //find the y distande between the two + rightDist = (int)(Math.abs(imagePoints[10].y - imagePoints[11].y) / 2.0); + rightBall = new int[] {rightXPoint - (rightDist / 2), rightYPoint - (rightDist / 2)}; + + //operation: subsquare + //take a square mat we are 100% sure will have a ball in it + //sum it up and find the average color + + leftColor = drawSquare(out, leftBall, leftDist); + rightColor = drawSquare(out, rightBall, rightDist); + + //flip it for display + Core.flip(out, out, -1); + + matQueue.add(out); + + //display! + mView.getHandler().post(new Runnable() { + @Override + public void run() { + try { + Mat frame = matQueue.take(); + //convert to bitmap + Utils.matToBitmap(frame, bm); + frame.release(); + mView.invalidate(); + } + catch (InterruptedException e) { + //huh + } + } + }); + } + catch (Exception e){ + Log.e("OPENCV", e.getLocalizedMessage()); + } + } + } else { + telemetry.addData("VuMark", "not visible"); + } + } + + @Override + public void start() { + if(leftColor != null && rightColor != null) { + if (leftColor.val[0] < leftColor.val[1] && rightColor.val[0] > rightColor.val[1]){ + telemetry.addData("Left", "Blue"); + + //construct sequence + mSeq.add(new AutoLib.TimedMotorStep(bot.getMotor("stick"), 0.2f, 0.7, true)); + if(RED) mSeq.add(new AutoLib.MoveByTimeStep(bot.getMotorRay(), -0.5f, 0.5, true)); + else mSeq.add(new AutoLib.MoveByTimeStep(bot.getMotorRay(), 0.5f, 0.5, true)); + mSeq.add(new AutoLib.TimedMotorStep(bot.getMotor("stick"), -0.2f, 0.7, true)); + } + else if (leftColor.val[0] > leftColor.val[1] && rightColor.val[0] < rightColor.val[1]) { + telemetry.addData("Left", "Red"); + + //construct sequence + mSeq.add(new AutoLib.TimedMotorStep(bot.getMotor("stick"), 0.2f, 0.7, true)); + if(RED) mSeq.add(new AutoLib.MoveByTimeStep(bot.getMotorRay(), 0.5f, 0.5, true)); + else mSeq.add(new AutoLib.MoveByTimeStep(bot.getMotorRay(), -0.5f, 0.5, true)); + mSeq.add(new AutoLib.TimedMotorStep(bot.getMotor("stick"), -0.2f, 0.7, true)); + } + else telemetry.addData("Left", "Indeterminate"); + } + else telemetry.addData("Left", "Undefined"); + } + + @Override + public void loop() { + if(mSeq.loop()) requestOpModeStop(); + } + + private static Scalar drawSquare(Mat src, int[] ballPoint, int ballDist) { + //find average left and right ball square + //find the average color for all the pixels in that square + if(ballPoint[0] >= 0 && ballPoint[1] >= 0 && ballPoint[0] + ballDist < src.cols() && ballPoint[1] + ballDist < src.rows()){ + double total[] = new double[3]; + for(int x = 0; x < ballDist; x++) + for(int y = 0; y < ballDist; y++) { + double[] pixel = src.get(y + ballPoint[1], x + ballPoint[0]); + total[0] += pixel[0]; + total[1] += pixel[1]; + total[2] += pixel[2]; + } + + //make average color + Scalar color = new Scalar(total[0] / (ballDist * ballDist), total[1] / (ballDist * ballDist), total[2] / (ballDist * ballDist)); + + Imgproc.rectangle(src, new Point(ballPoint[0], ballPoint[1]), new Point(ballPoint[0] + ballDist, ballPoint[1] + ballDist), color, -1); + + return color; + } + else return null; + } + + @Override + public void stop() { + mView.setAlpha(0.0f); + mView.post(new Runnable() { + @Override + public void run() { + mView.setImageDrawable(null); + mView.invalidate(); + if(bm != null) bm.recycle(); + if(matQueue != null) matQueue.clear(); + } + }); + this.ray.clear(); + } + + private String format(OpenGLMatrix transformationMatrix) { + return (transformationMatrix != null) ? transformationMatrix.formatAsTransform() : "null"; + } + + private Mat getMatFromImage(Image img) { + java.nio.ByteBuffer grey = img.getPixels(); + Mat thing = new Mat(img.getHeight(), img.getWidth(), CV_8U); + byte[] ray = new byte[grey.limit()]; + grey.rewind(); + + grey.get(ray); + thing.put(0, 0, ray); + //rotate -90 + //Core.transpose(thing, thing); + //Core.flip(thing, thing, 0); + + //fill color space + Imgproc.cvtColor(thing, thing, Imgproc.COLOR_GRAY2RGB); + + return thing; + } + + /** + * I'm so sorry + * Shims created so I can access the pose in vuforia matrix form + * they are protected variables, so I need to java fu my way into them + */ + //start from the very begining... + //vuforia localizer shim + private static class VuforiaLocalizerShim extends VuforiaLocalizerImpl { + //constructor + VuforiaLocalizerShim(Parameters params){ + super(params); + } + //the shim part + public VuforiaTrackables loadShimTrackablesFromAsset(String assetName){ + return loadTrackablesFromAsset(assetName, VuforiaDefaultListenerShim.class); + } + + public void stop() { + //god damn quallcomm + super.close(); + } + } + //vuforia default listener shim + public static class VuforiaDefaultListenerShim extends VuforiaTrackableDefaultListener { + //constructor shim + public VuforiaDefaultListenerShim(VuforiaTrackable trackable) { + super(trackable); + } + //and the jesus data gettums + @Nullable + public synchronized Matrix34F getRealPose() { + return this.currentPose; + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VumarkOpenCV.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VumarkOpenCV.java new file mode 100644 index 00000000000..10f8eaa6384 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/VumarkOpenCV.java @@ -0,0 +1,469 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import android.app.Activity; +import android.graphics.Bitmap; +import android.support.annotation.Nullable; +import android.util.Log; +import android.widget.ImageView; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.vuforia.CameraCalibration; +import com.vuforia.CameraDevice; +import com.vuforia.Image; + +import org.firstinspires.ftc.robotcore.external.matrices.OpenGLMatrix; +import org.firstinspires.ftc.robotcore.external.navigation.RelicRecoveryVuMark; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaLocalizer; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackable; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackableDefaultListener; +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaTrackables; +import org.firstinspires.ftc.robotcore.internal.vuforia.VuforiaLocalizerImpl; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLoad; +import org.opencv.android.CameraBridgeViewBase; +import org.opencv.android.Utils; +import org.opencv.core.Core; +import org.opencv.core.Mat; +import org.opencv.core.Point; +import org.opencv.core.Range; +import org.opencv.core.Scalar; +import org.opencv.imgproc.Imgproc; + +import java.util.concurrent.BlockingDeque; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingDeque; + +import static org.opencv.core.CvType.CV_8U; + +import com.vuforia.Matrix34F; +import com.vuforia.PIXEL_FORMAT; +import com.vuforia.Tool; +import com.vuforia.Vec3F; +import com.vuforia.Vuforia; + +/** + * Created by Noah on 9/12/2017. + * getting rid of warning + */ + +@Autonomous(name="Concept: VuMark OpenCV", group ="Concept") +@Disabled +public class VumarkOpenCV extends OpenCVLib { + + private BlockingQueue ray; + private VuforiaLocalizerShim vuforia; + private VuforiaTrackable relicTemplate; + + private ImageView mView; + + //bullshoot factors + private static final float horizBullFactor = -15.0f; + private static final float vertBullFactor = -7.0f; + + //viewing angles for nexus 5x (in degreres) + private static final float horizontalViewAngle = 53.2988f + horizBullFactor; + private static final float verticalViewAngle = 67.5747f + vertBullFactor; + + //viewport sizes + private static final int viewWidth = 360; + private static final int viewHeight = 640; + + //pixel constants + private static final float horizConst = (float)((viewWidth * 0.5) / Math.tan(Math.toRadians(0.5 * horizontalViewAngle))); + private static final float vertConst = -(float)((viewHeight * 0.5) / Math.tan(Math.toRadians(0.5 * verticalViewAngle))); + + //center points + private static final int centerX = viewWidth / 2; + private static final int centerY = viewHeight / 2; + + //define the jewel platform relative to the image with a buncha vectors to add + //all units in vuforia are mm, so we multiply to inches to make it readable + private static final float inToMM = 25.4f; + + //units in inches, then converted to mm + private static final float boxLeftFromImage = 3.625f * inToMM; + private static final float boxBottomFromImage = 5.125f * inToMM; + private static final float boxWidth = 9.75f * inToMM; + private static final float boxLength = 3.75f * inToMM; + private static final float boxHeight = 3.75f * inToMM; + + private static final float ballCenterFromBoxEdge = 1.875f * inToMM; + + //identity mats to be constructed later in the project + private Vec3F[] point; + private float[] size; + //output bitmap + private Bitmap bm; + //Canvas canvas; + //Paint p; + + private BlockingDeque matQueue = new LinkedBlockingDeque<>(); + + //storage camera calibration + private CameraCalibration camCal; + + private float[] sizeScalar; + private Point[] imagePoints; + private int[] leftBall = new int[2]; + private int leftDist; + private int[] rightBall = new int[2]; + private int rightDist; + + //vuforia -> opencv camera parameters + private int xOffset; + private int yOffset; + + @Override + public void init() { + mView = (ImageView)((Activity)hardwareMap.appContext).findViewById(com.qualcomm.ftcrobotcontroller.R.id.OpenCVOverlay); + mView.setAlpha(1.0f); + + int cameraMonitorViewId = hardwareMap.appContext.getResources().getIdentifier("cameraMonitorViewId", "id", hardwareMap.appContext.getPackageName()); + VuforiaLocalizer.Parameters parameters = new VuforiaLocalizer.Parameters(cameraMonitorViewId); + parameters.vuforiaLicenseKey = "AZPbGaP/////AAAAGcIykH/KO0QNvZGSYxc0fDlVytYrk0HHv6OLmjHsswRvi/1l9RZCkepChaAZup3DIJlrjK2BV57DEz/noNO0oqT9iu2moP/svGmJ+pBG7FlfF4RHxu6UhvVLaKUZCsTJ1zTkd7XnMuRw8aSuIxowOiLJQYcgjmddi11LG26lAr6aRmoWJzr2pv6Yui2Gom0wt9J4+1g3kXqjngnH3h6NPA/6aUfpVngFaFPp5knyDJWZT88THttPsqcKW41QC/qgNh3CHIdADu15Rm51JNRlvG+2+sYstiHeHFQqCDwUkTgWor0v/Bk+xXoj3oUCb4REwT9w94E/VEI4qEAFPpmeo6YgxQ4LLFknu6tgNy8xdD6S"; + parameters.cameraDirection = VuforiaLocalizer.CameraDirection.BACK; + parameters.cameraMonitorFeedback = VuforiaLocalizer.Parameters.CameraMonitorFeedback.NONE; + //bwahaha java shim + this.vuforia = new VuforiaLocalizerShim(parameters); + camCal = vuforia.getCameraCalibration(); + + //constrt matrixes + //contruct top and bottom of both balls + final Vec3F ballLeftTop = new Vec3F(boxLeftFromImage + ballCenterFromBoxEdge, -boxBottomFromImage + boxHeight, ballCenterFromBoxEdge); + final Vec3F ballLeftBottom = new Vec3F(boxLeftFromImage + ballCenterFromBoxEdge, -boxBottomFromImage, ballCenterFromBoxEdge); + + final Vec3F ballRightTop = new Vec3F(boxLeftFromImage + boxWidth - ballCenterFromBoxEdge, -boxBottomFromImage + boxHeight, ballCenterFromBoxEdge); + final Vec3F ballRightBottom = new Vec3F(boxLeftFromImage + boxWidth - ballCenterFromBoxEdge, -boxBottomFromImage, ballCenterFromBoxEdge); + + //construct points like a box + final Vec3F botLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage, 0); + final Vec3F botRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage, 0); + final Vec3F botFrontLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage, boxLength); + final Vec3F botFrontRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage, boxLength); + + final Vec3F topLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage + boxHeight, 0); + final Vec3F topRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage + boxHeight, 0); + final Vec3F topFrontLeft = new Vec3F(boxLeftFromImage, -boxBottomFromImage + boxHeight, boxLength); + final Vec3F topFrontRight = new Vec3F(boxLeftFromImage + boxWidth, -boxBottomFromImage + boxHeight, boxLength); + + point = new Vec3F[] { botLeft, botRight, botFrontRight, botFrontLeft, topLeft, topRight, topFrontRight, topFrontLeft, + ballLeftTop, ballLeftBottom, ballRightTop, ballRightBottom }; + + imagePoints = new Point[point.length]; + + size = camCal.getSize().getData(); + + //half size b/c vuforia does that internally + size[0] /= 2; + size[1] /= 2; + + bm = Bitmap.createBitmap((int)size[0], (int)size[1], Bitmap.Config.ARGB_8888); + + //setup view + mView.post(new Runnable() { + @Override + public void run() { + mView.setImageBitmap(bm); + } + }); + + telemetry.update(); + + initOpenCV(); + + telemetry.addData(">", "Press Play to start"); + telemetry.update(); + + VuforiaTrackables relicTrackables = this.vuforia.loadShimTrackablesFromAsset("RelicVuMark"); + relicTemplate = relicTrackables.get(0); + relicTemplate.setName("relicVuMarkTemplate"); // can help in debugging; otherwise not necessary + + relicTrackables.activate(); + + this.vuforia.setFrameQueueCapacity(1); + this.ray = this.vuforia.getFrameQueue(); + } + + @Override + public void init_loop() { + RelicRecoveryVuMark vuMark = RelicRecoveryVuMark.from(relicTemplate); + if (vuMark != RelicRecoveryVuMark.UNKNOWN) { + + /* Found an instance of the template. In the actual game, you will probably + * loop until this condition occurs, then move on to act accordingly depending + * on which VuMark was visible. */ + telemetry.addData("VuMark", "%s visible", vuMark); + + /* For fun, we also exhibit the navigational pose. In the Relic Recovery game, + * it is perhaps unlikely that you will actually need to act on this pose information, but + * we illustrate it nevertheless, for completeness. */ + //qualcomm is stupid and didn't let me see the real vuforia matrix, so I shimmed it + //heres where is gets good + VuforiaDefaultListenerShim writeGoodCode = (VuforiaDefaultListenerShim) relicTemplate.getListener(); + + OpenGLMatrix pose = writeGoodCode.getRawPose(); + telemetry.addData("Pose", format(pose)); + + /* We further illustrate how to decompose the pose into useful rotational and + * translational components */ + if (pose != null) { + //alternate projection! + //get vuforia's real position matrix + Matrix34F goodCodeWritten = writeGoodCode.getRealPose(); + + //reset imagePoints + final float[][] vufPoints = new float[point.length][2]; + + //use vuforias projectPoints method to project all those box points + for(int i = 0; i < point.length; i++){ + //project + vufPoints[i] = Tool.projectPoint(camCal, goodCodeWritten, point[i]).getData(); + //convert to opencv language + + //telemetry.addData("point", "num: %d, x: %f.2, y: %f.2", i, vufPoints[i][0], vufPoints[i][1]); + } + + //telemetry.addData("Camera Size", "w: %f.2, h: %f.2", camCal.getSize().getData()[0], camCal.getSize().getData()[1]); + + //get frame from vuforia + try{ + VuforiaLocalizer.CloseableFrame frame = ray.take(); + + int img = 0; + for(; img < frame.getNumImages(); img++){ + //Log.i("OPENCV", "Image " + img + " " + frame.getImage(img).getWidth()); + if(frame.getImage(img).getWidth() == size[0]) break; + } + + final Mat out; + if(img < frame.getNumImages()) out = getMatFromImage(frame.getImage(img)); + else throw new IllegalArgumentException("No frame with matching width!"); + + frame.close(); + + //convert points, halfing distances b/c vuforia does that internally so we gotta fix it + for(int i = 0; i < vufPoints.length; i++) imagePoints[i] = new Point((int)vufPoints[i][0] / 2, (int)vufPoints[i][1] / 2); + + Scalar color = new Scalar(0, 255, 0); + for(int i = 0; i < 2; i++) + for(int o = 0; o < 4; o++) + Imgproc.line(out, imagePoints[o == 0 ? 3 + i * 4 : i * 4 + o - 1], imagePoints[i * 4 + o], color); + + //connect the rectangles + for(int i = 0; i < 4; i++) Imgproc.line(out, imagePoints[i], imagePoints[i + 4], color); + + for(int i = 8; i < imagePoints.length; i++) Imgproc.drawMarker(out, imagePoints[i], color); + + //flip it for display + Core.flip(out, out, -1); + + matQueue.add(out); + + //display! + mView.getHandler().post(new Runnable() { + @Override + public void run() { + try { + Mat frame = matQueue.take(); + //convert to bitmap + Utils.matToBitmap(frame, bm); + frame.release(); + mView.invalidate(); + } + catch (InterruptedException e) { + //huh + } + } + }); + } + catch (Exception e){ + Log.e("OPENCV", e.getLocalizedMessage()); + } + } + } else { + telemetry.addData("VuMark", "not visible"); + } + } + + @Override + public void start() { + //die die die + mView.setAlpha(0.0f); + + mView.post(new Runnable() { + @Override + public void run() { + mView.setImageDrawable(null); + mView.invalidate(); + if(bm != null) bm.recycle(); + if(matQueue != null) matQueue.clear(); + } + }); + this.ray.clear(); + + vuforia.stop(); + + //calculate points from projection + //find the midpoint between the two points + int leftXPoint = (int)((imagePoints[8].x + imagePoints[9].x) / 2.0); + int leftYPoint = (int)((imagePoints[8].y + imagePoints[9].y) / 2.0); + //find the y distande between the two + leftDist = (int)(Math.abs(imagePoints[8].y - imagePoints[9].y) / 2.0); + leftBall = new int[] {leftXPoint - (leftDist / 2), leftYPoint - (leftDist / 2)}; + + //find the midpoint between the two points + int rightXPoint = (int)((imagePoints[10].x + imagePoints[11].x) / 2.0); + int rightYPoint = (int)((imagePoints[10].y + imagePoints[11].y) / 2.0); + //find the y distande between the two + rightDist = (int)(Math.abs(imagePoints[10].y - imagePoints[11].y) / 2.0); + rightBall = new int[] {rightXPoint - (rightDist / 2), rightYPoint - (rightDist / 2)}; + + //LIVE + startCamera(); + } + + @Override + public void loop() { + telemetry.addData("Left image point", "x: " + imagePoints[8].x + " y: " + imagePoints[8].y); + telemetry.addData("Left Point", "x: " + leftBall[0] + " y: " + leftBall[1]); + telemetry.addData("Left Dist", leftDist); + telemetry.addData("size", size[0] + " " + size[1]); + } + + @Override + public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame frame) { + Mat currentFrame = frame.rgba(); + + //if we haven't figured out how to scale the size, do that + if(xOffset == 0 || yOffset == 0){ + //find the offset to the sqaure of pixels vuforia looks at + xOffset = (int)((currentFrame.cols() - size[0]) / 2.0); + yOffset = (int)((currentFrame.rows() - size[1]) / 2.0); + + //add the offset to all points calculated + for(Point point : imagePoints) { + point.x += xOffset; + point.y += yOffset; + } + leftBall[0] += xOffset; + leftBall[1] += yOffset; + rightBall[0] += xOffset; + rightBall[1] += yOffset; + } + + //operation: subsquare + //take a square mat we are 100% sure will have a ball in it + //sum it up and find the average color + + drawSquare(currentFrame, leftBall, leftDist); + drawSquare(currentFrame, rightBall, rightDist); + + Scalar color = new Scalar(0, 255, 0); + + for(int i = 0; i < 2; i++) + for(int o = 0; o < 4; o++) + Imgproc.line(currentFrame, imagePoints[o == 0 ? 3 + i * 4 : i * 4 + o - 1], imagePoints[i * 4 + o], color); + + //connect the rectangles + for(int i = 0; i < 4; i++) Imgproc.line(currentFrame, imagePoints[i], imagePoints[i + 4], color); + + //flip it for display + Core.flip(currentFrame, currentFrame, -1); + + return currentFrame; + } + + private static void drawSquare(Mat src, int[] ballPoint, int ballDist) { + //find average left and right ball square + //find the average color for all the pixels in that square + if(ballPoint[0] >= 0 && ballPoint[1] >= 0 && ballPoint[0] + ballDist < src.cols() && ballPoint[1] + ballDist < src.rows()){ + double total[] = new double[3]; + for(int x = 0; x < ballDist; x++) + for(int y = 0; y < ballDist; y++) { + double[] pixel = src.get(y + ballPoint[1], x + ballPoint[0]); + total[0] += pixel[0]; + total[1] += pixel[1]; + total[2] += pixel[2]; + } + + //make average color + Scalar color = new Scalar(total[0] / (ballDist * ballDist), total[1] / (ballDist * ballDist), total[2] / (ballDist * ballDist)); + + Imgproc.rectangle(src, new Point(ballPoint[0], ballPoint[1]), new Point(ballPoint[0] + ballDist, ballPoint[1] + ballDist), color, -1); + } + } + + @Override + public void stop() { + mView.setAlpha(0.0f); + mView.post(new Runnable() { + @Override + public void run() { + mView.setImageDrawable(null); + mView.invalidate(); + if(bm != null) bm.recycle(); + if(matQueue != null) matQueue.clear(); + } + }); + this.ray.clear(); + stopCamera(); + } + + private String format(OpenGLMatrix transformationMatrix) { + return (transformationMatrix != null) ? transformationMatrix.formatAsTransform() : "null"; + } + + private Mat getMatFromImage(Image img) { + java.nio.ByteBuffer grey = img.getPixels(); + Mat thing = new Mat(img.getHeight(), img.getWidth(), CV_8U); + byte[] ray = new byte[grey.limit()]; + grey.rewind(); + + grey.get(ray); + thing.put(0, 0, ray); + //rotate -90 + //Core.transpose(thing, thing); + //Core.flip(thing, thing, 0); + + //fill color space + Imgproc.cvtColor(thing, thing, Imgproc.COLOR_GRAY2RGB); + + return thing; + } + + /** + * I'm so sorry + * Shims created so I can access the pose in vuforia matrix form + * they are protected variables, so I need to java fu my way into them + */ + //start from the very begining... + //vuforia localizer shim + private static class VuforiaLocalizerShim extends VuforiaLocalizerImpl { + //constructor + VuforiaLocalizerShim(VuforiaLocalizer.Parameters params){ + super(params); + } + //the shim part + public VuforiaTrackables loadShimTrackablesFromAsset(String assetName){ + return loadTrackablesFromAsset(assetName, VuforiaDefaultListenerShim.class); + } + + public void stop() { + //god damn quallcomm + this.stopAR(); + } + } + //vuforia default listener shim + public static class VuforiaDefaultListenerShim extends VuforiaTrackableDefaultListener { + //constructor shim + public VuforiaDefaultListenerShim(VuforiaTrackable trackable) { + super(trackable); + } + //and the jesus data gettums + @Nullable + public synchronized Matrix34F getRealPose() { + return this.currentPose; + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/WhackyDistDetect.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/WhackyDistDetect.java new file mode 100644 index 00000000000..35f48fa9880 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/demo/WhackyDistDetect.java @@ -0,0 +1,125 @@ +package org.firstinspires.ftc.teamcode.opmodes.demo; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; +import com.qualcomm.robotcore.hardware.Servo; + +import org.firstinspires.ftc.robotcore.external.matrices.VectorF; +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9960; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.FilterLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.WhackyDistLib; +import org.firstinspires.ftc.teamcode.libraries.interfaces.LocationSensor; + +/** + * Created by Noah on 12/28/2017. + */ + +@Autonomous(name="Stick Distance Measuring", group="test") +@Disabled +public class WhackyDistDetect extends OpMode { + private static final boolean red = true; + BotHardware bot = new BotHardware(this); + AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + APDS9960 dist; + APDS9960.Config config = new APDS9960.Config(); + + VectorF stupid = new VectorF(0,0); + + public void init() { + bot.init(); + + config.setPulse(APDS9960.Config.PulseLength.PULSE_16US, (byte)8, APDS9960.Config.LEDStrength.STREN_100MA, APDS9960.Config.LEDBoost.BOOST_1X, APDS9960.Config.DistGain.GAIN_2X); + dist = new APDS9960(config, hardwareMap.get(I2cDeviceSynch.class, "dist"), true, APDS9960.Config.DistGain.GAIN_2X); + dist.initDevice(); + + final WhackyDist step = new WhackyDist(this, bot.getStick(), dist, -1, 90, red); + mSeq.add(step); + mSeq.add(new AutoLib.RunCodeStep(new Runnable() { + @Override + public void run() { + stupid = step.getLocation(); + } + })); + } + + public void start() { + dist.startDevice(); + } + + public void loop() { + if(mSeq.loop()) telemetry.addData("Location", stupid.toString()); + } + + public static class WhackyDist extends AutoLib.Step implements LocationSensor { + //constants + private static final double DIST_START = 140; + private static final double SLOPE_MAX = 100; + //members + private final OpMode mode; + private final APDS9960 sensor; + private final Servo stick; + private final double inc; + private final double start; + private final boolean red; + + //storage + private double lastTime = 0; + private double lastDist; + private double currentAngle = 90; + + //to be referenced by the step that gets the location from this step + private VectorF location; + + private final FilterLib.MovingWindowFilter filter = new FilterLib.MovingWindowFilter(5, 600); + + WhackyDist(OpMode mode, Servo stick, APDS9960 measure, double increment, double start, boolean red) { + this.mode = mode; + this.stick = stick; + this.sensor = measure; + this.inc = increment; + this.currentAngle = start; + this.start = start; + this.red = red; + } + + public boolean loop() { + filter.appendValue(sensor.getLinearizedDistance(red)); + final double dist = filter.currentValue(); + if(firstLoopCall()) { + lastDist = dist; + } + + final double time = mode.getRuntime(); + final double slope = Math.abs(dist - lastDist) / (time - lastTime); + lastDist = dist; + lastTime = time; + + //check if done + + if(dist <= DIST_START && slope <= SLOPE_MAX) { + //store location from the whacky sticks position + location = new VectorF((float)dist, (float)WhackyDistLib.getWhackyDistance(currentAngle)); + //reset servo + stick.setPosition(WhackyDistLib.getWhackyPosFromDegrees(start)); + return true; + } + + //increment servo + currentAngle += inc; + stick.setPosition(WhackyDistLib.getWhackyPosFromDegrees(currentAngle)); + + mode.telemetry.addData("angle", currentAngle); + mode.telemetry.addData("position", stick.getPosition()); + + return false; + } + + public VectorF getLocation() { + return location; + } + } + } diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/BNO055.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/BNO055.java new file mode 100644 index 00000000000..e9f056a7e7f --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/BNO055.java @@ -0,0 +1,107 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.hardware.bosch.BNO055IMU; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.robotcore.external.Func; +import org.firstinspires.ftc.robotcore.external.navigation.Acceleration; +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder; +import org.firstinspires.ftc.robotcore.external.navigation.AxesReference; +import org.firstinspires.ftc.robotcore.external.navigation.Orientation; + +import java.util.Locale; + +/** + * Created by Noah on 11/18/2017. + */ + +@Autonomous(name="Gyro Test", group="test") +@Disabled +public class BNO055 extends OpMode{ + private BNO055IMU imu; + + // State used for updating telemetry + private Orientation angles; + private Acceleration gravity; + + @Override + public void init() { + imu = hardwareMap.get(BNO055IMU.class, "imu"); + BNO055IMU.Parameters par = new BNO055IMU.Parameters(); + par.mode = BNO055IMU.SensorMode.IMU; + par.angleUnit = BNO055IMU.AngleUnit.DEGREES; + imu.initialize(par); + + // At the beginning of each telemetry update, grab a bunch of data + // from the IMU that we will then display in separate lines. + telemetry.addAction(new Runnable() { @Override public void run() + { + // Acquiring the angles is relatively expensive; we don't want + // to do that in each of the three items that need that info, as that's + // three times the necessary expense. + angles = imu.getAngularOrientation(AxesReference.INTRINSIC, AxesOrder.ZYX, AngleUnit.DEGREES); + gravity = imu.getGravity(); + } + }); + + telemetry.addLine() + .addData("status", new Func() { + @Override public String value() { + return imu.getSystemStatus().toShortString(); + } + }) + .addData("calib", new Func() { + @Override public String value() { + return imu.getCalibrationStatus().toString(); + } + }); + + telemetry.addLine() + .addData("heading", new Func() { + @Override public String value() { + return formatAngle(angles.angleUnit, angles.firstAngle); + } + }) + .addData("roll", new Func() { + @Override public String value() { + return formatAngle(angles.angleUnit, angles.secondAngle); + } + }) + .addData("pitch", new Func() { + @Override public String value() { + return formatAngle(angles.angleUnit, angles.thirdAngle); + } + }); + + telemetry.addLine() + .addData("grvty", new Func() { + @Override public String value() { + return gravity.toString(); + } + }) + .addData("mag", new Func() { + @Override public String value() { + return String.format(Locale.getDefault(), "%.3f", + Math.sqrt(gravity.xAccel*gravity.xAccel + + gravity.yAccel*gravity.yAccel + + gravity.zAccel*gravity.zAccel)); + } + }); + } + + @Override + public void loop() { + + } + + private String formatAngle(AngleUnit angleUnit, double angle) { + return formatDegrees(AngleUnit.DEGREES.fromUnit(angleUnit, angle)); + } + + private String formatDegrees(double degrees){ + return String.format(Locale.getDefault(), "%.1f", AngleUnit.DEGREES.normalize(degrees)); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/CameraDriveTest1Op.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/CameraDriveTest1Op.java new file mode 100644 index 00000000000..5556f113b2a --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/CameraDriveTest1Op.java @@ -0,0 +1,181 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +/** + * a simple example of using the camera to steer in autonomous mode. + * Created by phanau on 12/30/15. + */ + +// a simple example of a camera-directed drive step that moves toward or away from a given +// pattern described by its "rgbcymw" signature until it is bigger or smaller than a given size + + /* + +class CameraDriveStep1 extends AutoLib.Step { + + CameraLib.CameraAcquireFrames mCamAcqFr; // the camera this step uses + int mPatternSize; // we're done when the (pattern) size crosses this number of bands + int mBandSize; // combine this many pixels into each band (using histogram to find most common rgbcymw value) + DcMotor mMotors[]; // the (4) motors we're controlling - assumed order is fr, br, fl, bl + Pattern mPattern; // compiled regexp pattern we'll use to find the pattern we're looking for + OpMode mOpMode; // needed so we can log output + float mPower; // basic power setting of all 4 motors -- adjusted for steering to/from target + + public CameraDriveStep1(OpMode opMode, CameraLib.CameraAcquireFrames camAcqFr, String pattern, DcMotor motors[], float power, int patternSize, int bandSize) { + mOpMode = opMode; + mCamAcqFr = camAcqFr; + mPattern = Pattern.compile(pattern); + mPower = power; + mPatternSize = patternSize; + mMotors = motors; + mBandSize = bandSize; + } + + public boolean loop() { + super.loop(); + + mOpMode.telemetry.addData("loop count: ", mLoopCount); + + // get the current frame from the camera (may be same as previous frame or null) + CameraLib.CameraImage frame = mCamAcqFr.loop(); + + // figure out where the target pattern is and steer toward it - + // for now, just use the horizontal midline of the frame, using bands of given number of pixels. + String scanline = frame.scanlineHue(frame.cameraSize().height / 2, mBandSize); + + // log some debug data -- show the raw scanline + mOpMode.telemetry.addData("scanline(raw): ", scanline); + + // left and right motor power settings based on computed target sighting -- + // default to stopping if we don't find anything. + double leftPower = 0.0; + double rightPower = 0.0; + + // search the scanline for the target pattern + int patternStart = 0; + int patternSize = 0; + for (int i=0; i 0) + mOpMode.telemetry.addData("scanline(det): ", + scanline.substring(0,patternStart) + + scanline.substring(patternStart,patternStart+patternSize).toUpperCase() + + scanline.substring(patternStart+patternSize) + ); + + // this step is done when the target reaches the desired size -- + // (i.e. we're at the desired distance from it) depending on whether we're going toward + // it (speed > 0) or away from it (speed < 0) + boolean bDone = (mPatternSize > 0) && // don't quit just because we "lost signal" + ((mPower > 0) ? (patternSize > mPatternSize) : (patternSize < mPatternSize)); + + // when the step is done, turn off all motors + if (bDone) { + for (DcMotor motor : mMotors) + motor.setPower(0); + } + + // return done-ness + return (bDone); + } + +} + +public class CameraDriveTest1Op extends OpMode { + + AutoLib.Sequence mSequence; // the root of the sequence tree + boolean bDone; // true when the programmed sequence is done + + CameraLib.CameraAcquireFrames mCamAcqFr; + DcMotor mMotors[]; + + public CameraDriveTest1Op() { + } + + public void init() { + // get the camera that our sequence will use + mCamAcqFr = new CameraLib.CameraAcquireFrames(); + if (mCamAcqFr.init(1) == false) // init camera at the smallest available size + telemetry.addData("error: ", "cannot initialize camera"); + + AutoLib.HardwareFactory mf = null; + final boolean debug = true; + if (debug) + mf = new AutoLib.TestHardwareFactory(this); + else + mf = new AutoLib.RealHardwareFactory(this); + + // get the motors: depending on the factory we created above, these may be + // either dummy motors that just log data or real ones that drive the hardware + // assumed order is fr, br, fl, bl + mMotors = new DcMotor[4]; + mMotors[0] = mf.getDcMotor("fr"); + mMotors[1] = mf.getDcMotor("br"); + mMotors[2] = mf.getDcMotor("fl"); + mMotors[3] = mf.getDcMotor("bl"); + mMotors[2].setDirection(DcMotor.Direction.REVERSE); + mMotors[3].setDirection(DcMotor.Direction.REVERSE); + + // create an autonomous sequence with two steps in it (for now) + // create the root Sequence for this autonomous OpMode + mSequence = new AutoLib.LinearSequence(); + + // define the color pattern we're looking for: + // String pattern = "r+[w0-7]+([cb]+)[^cb]*"; // RED, WHITE, CYAN/BLUE shelter lights pattern + String pattern = "r+([gc]+)b+"; // RGB stripes (where green may read as cyan) + + // add a camera-directed Step to the root Sequence that advances until the pattern is >5 bands of 6 pixels + mSequence.add(new CameraDriveStep1(this, mCamAcqFr, pattern, mMotors, 0.5f, 5, 6)); + + // add a second camera-directed Step that backs away until the pattern is <2 bands of 6 pixels + mSequence.add(new CameraDriveStep1(this, mCamAcqFr, pattern, mMotors, -0.5f, 2, 6)); + + // start out not-done + bDone = false; + } + + public void loop() { + // until we're done, keep looping through the current Step(s) + if (!bDone) + bDone = mSequence.loop(); // returns true when we're done + else + telemetry.addData("sequence finished", ""); + } + + public void stop() { + mCamAcqFr.stop(); + telemetry.addData("stop() called", ""); + } +} + +*/ + diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/CameraTestOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/CameraTestOp.java new file mode 100644 index 00000000000..3ed11d08a14 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/CameraTestOp.java @@ -0,0 +1,127 @@ +/** + * CameraTestOp - a simple operating mode that tries to acquire an image from the + * phone camera and get some data from the image + * Created by phanau on 12/9/15. + */ + +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import android.hardware.Camera; + +import org.firstinspires.ftc.teamcode.libraries.CameraLib; + + +@Autonomous(name="Test: CameraLib Test 1", group ="Test") +@Disabled +public class CameraTestOp extends OpMode { + + int mLoopCount; + CameraLib.CameraAcquireFrames mCamAcqFr; + + + // Constructor + public CameraTestOp() { + mCamAcqFr = new CameraLib.CameraAcquireFrames(); + } + + @Override + public void init() { + mLoopCount = 0; + + if (mCamAcqFr.init(2) == false) // init camera at 2nd smallest size + telemetry.addData("error: ", "cannot initialize camera"); + + } + + public void loop() { + // post some debug data + telemetry.addData("loop count:", mLoopCount++); + telemetry.addData("version: ", "1.3"); + + int[] topScan; + int[] middleScan; + int[] bottomScan; + + // get most recent frame from camera (may be same as last time or null) + CameraLib.CameraImage frame = mCamAcqFr.loop(); + + // log debug info ... + if (frame != null) { + + // process the current frame + // ... "move toward the light..." + + // log data about the most current image to driver station every loop so it stays up long enough to read + Camera.Size camSize = frame.cameraSize(); + telemetry.addData("preview camera size: ", String.valueOf(camSize.width) + "x" + String.valueOf(camSize.height)); + telemetry.addData("preview data size:", frame.dataSize()); + telemetry.addData("preview rgb(center):", String.format("%08X", frame.getPixel(camSize.width / 2, camSize.height / 2))); + telemetry.addData("frame number: ", mCamAcqFr.frameCount()); + + // log text representations of several significant scanlines + + topScan = frame.scanlineValue(camSize.height / 3); + middleScan = frame.scanlineValue(camSize.height / 2); + bottomScan = frame.scanlineValue(camSize.height * 2 / 3); + + //telemetry.addData("value a(1/3): ", topScan); + //telemetry.addData("value b(1/2): ", middleScan); + //telemetry.addData("value c(2/3): ", bottomScan); + + final int bandSize = 10; + telemetry.addData("hue a(1/3): ", frame.scanlineHue(camSize.height / 3, bandSize)); + telemetry.addData("hue b(1/2): ", frame.scanlineHue(camSize.height / 2, bandSize)); + telemetry.addData("hue c(2/3): ", frame.scanlineHue(2*camSize.height / 3, bandSize)); + + int topThresh = threshFind(topScan); + int middleThresh = threshFind(middleScan); + int bottomThresh = threshFind(bottomScan); + + telemetry.addData("Top Thresh", topThresh); + telemetry.addData("Middle Thresh", middleThresh); + telemetry.addData("Bottom Thresh", bottomThresh); + + int topPos = findAvgOverThresh(topScan, topThresh); + int middlePos = findAvgOverThresh(middleScan, middleThresh); + int bottomPos = findAvgOverThresh(bottomScan, bottomThresh); + + telemetry.addData("Top Pos", topPos); + telemetry.addData("Middle Pos", middlePos); + telemetry.addData("Bottom Pos", bottomPos); + } + } + + public void stop() { + mCamAcqFr.stop(); + } + + //takes a n array of bytes, and returns (min + max)/2 for a threshold + private int threshFind(int[] ray){ + int min = 0; + int max = 0; + for(int i = 0; i < ray.length; i++){ + if(min > ray[i]) min = ray[i]; + else if(max < ray[i]) max = ray[i]; + } + + return (min + max) / 2; + } + + private int findAvgOverThresh(int[] ray, int thresh){ + int totalPos = 0; + int totalNum = 0; + for(int i = 0; i < ray.length; i++){ + if(ray[i] >= thresh){ + totalPos += i; + totalNum++; + } + } + + return totalPos/totalNum; + } + + +} + diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContServoCalibrate.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContServoCalibrate.java new file mode 100644 index 00000000000..d6d2b0273cf --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContServoCalibrate.java @@ -0,0 +1,90 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 3/6/2018. + */ +/* +@TeleOp(name = "Intake Servo Calibrate", group = "Main") +@Disabled +public class ContServoCalibrate extends OpMode { + + private enum Incs { + SMALL(0.01), + MEDIUM(0.05), + EHH(0.1), + HOLYMOTHER(0.5); + + public double inc; + Incs(double inc) { + this.inc = inc; + } + } + + BotHardware bot = new BotHardware(this); + boolean lastDPad = false; + boolean lastA = false; + boolean front = false; + int incIndex = 0; + + double frontPower = 0; + double backPower = 0; + + @Override + public void init() { + + telemetry.addData("Status", "Initialized"); + + //currentServo = robot.leftServo; + + // hardware maps + bot.init(); + } + + @Override + public void start() {} + + @Override + public void loop() { + if(!lastDPad) { + if (gamepad1.dpad_up) { + if(front) frontPower = Range.clip(frontPower + Incs.values()[incIndex].inc, -1, 1); + else backPower = Range.clip(backPower + Incs.values()[incIndex].inc, -1, 1); + } + else if (gamepad1.dpad_down) { + if(front) frontPower = Range.clip(frontPower - Incs.values()[incIndex].inc, -1, 1); + else backPower = Range.clip(backPower - Incs.values()[incIndex].inc, -1, 1); + } + else if (gamepad1.dpad_left) incIndex = Range.clip(incIndex - 1, 0, Incs.values().length - 1); + else if (gamepad1.dpad_right) incIndex = Range.clip(incIndex + 1, 0, Incs.values().length - 1); + + if(gamepad1.dpad_up || gamepad1.dpad_down) { + if(front) { + BotHardware.ContiniuosServoE.FrontSuckLeft.servo.setPower(frontPower); + BotHardware.ContiniuosServoE.FrontSuckRight.servo.setPower(frontPower); + } + else { + BotHardware.ContiniuosServoE.SuckLeft.servo.setPower(backPower); + BotHardware.ContiniuosServoE.SuckRight.servo.setPower(backPower); + } + } + } + + lastDPad = gamepad1.dpad_up || gamepad1.dpad_right || gamepad1.dpad_left || gamepad1.dpad_down; + + if(!lastA && gamepad1.a) front = !front; + lastA = gamepad1.a; + + telemetry.addData("Intake", front ? "Front" : "Back"); + telemetry.addData("Servo Front", frontPower); + telemetry.addData("Servo Back", backPower); + telemetry.addData("Increment", Incs.values()[incIndex].inc); + } +} +*/ \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContiniousServoAdjust.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContiniousServoAdjust.java new file mode 100644 index 00000000000..04ce5f769d5 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContiniousServoAdjust.java @@ -0,0 +1,65 @@ +/* + Main robot teleop program + */ + +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/* +@TeleOp(name = "Cont Servo Calibrate", group = "Main") +@Disabled +public class ContiniousServoAdjust extends OpMode { + + private enum Incs { + SMALL(0.01), + MEDIUM(0.05), + EHH(0.1), + HOLYMOTHER(0.5); + + public double inc; + Incs(double inc) { + this.inc = inc; + } + } + + BotHardware bot = new BotHardware(this); + boolean lastDPad = false; + int incIndex = 0; + + @Override + public void init() { + + telemetry.addData("Status", "Initialized"); + + //currentServo = robot.leftServo; + + // hardware maps + bot.init(); + } + + @Override + public void start() {} + + @Override + public void loop() { + telemetry.addData("Servo", BotHardware.ContiniuosServoE.FrontSuckLeft.servo.getPower()); + telemetry.addData("Increment", Incs.values()[incIndex].inc); + if(!lastDPad) { + if (gamepad1.dpad_up) + BotHardware.ContiniuosServoE.FrontSuckLeft.servo.setPower(Range.clip(BotHardware.ContiniuosServoE.FrontSuckLeft.servo.getPower() + Incs.values()[incIndex].inc, -1, 1)); + else if (gamepad1.dpad_down) + BotHardware.ContiniuosServoE.FrontSuckLeft.servo.setPower(Range.clip(BotHardware.ContiniuosServoE.FrontSuckLeft.servo.getPower() - Incs.values()[incIndex].inc, -1, 1)); + else if (gamepad1.dpad_left) incIndex = Range.clip(incIndex - 1, 0, Incs.values().length - 1); + else if (gamepad1.dpad_right) incIndex = Range.clip(incIndex + 1, 0, Incs.values().length - 1); + } + + lastDPad = gamepad1.dpad_up || gamepad1.dpad_right || gamepad1.dpad_left || gamepad1.dpad_down; + } +} +*/ \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContiniuosMess.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContiniuosMess.java new file mode 100644 index 00000000000..bad8fc80f23 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ContiniuosMess.java @@ -0,0 +1,78 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.AnalogInput; +import com.qualcomm.robotcore.hardware.AnalogOutput; +import com.qualcomm.robotcore.hardware.CRServo; +import com.qualcomm.robotcore.hardware.DigitalChannel; +import com.qualcomm.robotcore.hardware.PwmControl; +import com.qualcomm.robotcore.hardware.Servo; +import com.qualcomm.robotcore.hardware.ServoControllerEx; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 3/6/2018. + */ + +@TeleOp(name="Servo Fix") +//@Disabled +public class ContiniuosMess extends OpMode { + private enum Incs { + SMALL(10), + MEDIUM(25), + EHH(100), + HOLYMOTHER(500); + + public double inc; + Incs(double inc) { + this.inc = inc; + } + } + + + private CRServo stupid; + private ServoControllerEx stupidControl; + private DigitalChannel out; + private int port; + private boolean lastDPad = false; + private boolean lastA; + private int incIndex = 0; + + public void init() { + stupid = hardwareMap.get(CRServo.class, "crl"); + stupidControl = (ServoControllerEx) stupid.getController(); + out = hardwareMap.get(DigitalChannel.class, "stupid"); + out.setMode(DigitalChannel.Mode.OUTPUT); + stupid.getPortNumber(); + } + + public void start() { + stupid.setPower(1); + } + + public void loop() { + PwmControl.PwmRange range = stupidControl.getServoPwmRange(port); + if(!lastDPad) { + if (gamepad1.dpad_up) range = new PwmControl.PwmRange(100, range.usPulseUpper + Incs.values()[incIndex].inc); + else if (gamepad1.dpad_down) range = new PwmControl.PwmRange(100, range.usPulseUpper - Incs.values()[incIndex].inc); + else if (gamepad1.dpad_left) incIndex = Range.clip(incIndex - 1, 0, Incs.values().length - 1); + else if (gamepad1.dpad_right) incIndex = Range.clip(incIndex + 1, 0, Incs.values().length - 1); + stupidControl.setServoPwmRange(port, range); + stupid.setPower(1); + } + + lastDPad = gamepad1.dpad_up || gamepad1.dpad_right || gamepad1.dpad_left || gamepad1.dpad_down; + + if(!lastA && gamepad1.a) out.setState(!out.getState()); + lastA = gamepad1.a; + + telemetry.addData("Servo Duty Cycle", range.usPulseUpper); + telemetry.addData("Increment", Incs.values()[incIndex].inc); + telemetry.addData("Digital Out", out.getState()); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/GyroTurnDemo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/GyroTurnDemo.java new file mode 100644 index 00000000000..c70e9a536db --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/GyroTurnDemo.java @@ -0,0 +1,63 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 12/1/2017. + */ + +@Autonomous(name="Turn Testing", group="test") +@Disabled +public class GyroTurnDemo extends OpMode { + BotHardware bot = new BotHardware(this); + + AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + //parameters for gyro PID, but cranked up + float Kp5 = 3.0f; // degree heading proportional term correction per degree of deviation + float Ki5 = 0.0f; // ... integrator term + float Kd5 = 0; // ... derivative term + float Ki5Cutoff = 0.0f; // maximum angle error for which we update integrator + + SensorLib.PID motorPID = new SensorLib.PID(Kp5, Ki5, Kd5, Ki5Cutoff); + + public void init() { + bot.init(); + + mSeq.add(new AutoLib.GyroTurnStep(this, 90, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 45.0f, 360.0f, motorPID, 1.0f, 3, true)); + + //mSeq.add(new AutoLib.AzimuthTimedDriveStep(this, 90, bot.getHeadingSensor(), motorPID, bot.getMotorVelocityShimArray(), 270.0f, 2.0f, true, -450.0f, 450.0f)); + + } + + public void start() { + + } + + public void loop() { + if(mSeq.loop()) requestOpModeStop(); + } + + private static class GyroStopStep extends AutoLib.Step { + private final HeadingSensor gyro; + private final float heading; + private final int error; + GyroStopStep(HeadingSensor gyro, float heading, int error) { + this.gyro = gyro; + this.heading = heading; + this.error = error; + } + + public boolean loop() { + return Math.abs(gyro.getHeading() - heading) <= error; + } + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/OpenCVDebug.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/OpenCVDebug.java new file mode 100644 index 00000000000..fa1b892f177 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/OpenCVDebug.java @@ -0,0 +1,47 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.LineFollowLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.opencv.core.Mat; + +/** + * Created by Robotics on 10/28/2016. + */ + +@Autonomous(name = "OpenCV Debug", group = "Line Follow") +@Disabled +public class OpenCVDebug extends OpenCVLib { + + private int[] yValStore = new int[3]; + + @Override + public void init(){ + initOpenCV(); + startCamera(); + + Mat frame = getCameraFrame(); + + //init scanline Y values + yValStore[0] = frame.rows() / 4; + yValStore[1] = frame.rows() / 2; + yValStore[2] = (frame.rows() * 3) / 4; + } + + @Override + public void start(){ + + } + + @Override + public void loop(){ + Mat frame = getCameraFrame(); + telemetry.addData("Find Avg", LineFollowLib.scanlineAvgDebug(frame, yValStore[1], this)); + } + + @Override + public void stop(){ + stopCamera(); + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/SensorTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/SensorTest.java new file mode 100644 index 00000000000..36f940536da --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/SensorTest.java @@ -0,0 +1,52 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + + +/** + * simple example of using a Step that makes a bot with "squirrely wheels" drive along a given course + * Created by phanau on 10/31/16. + */ + + +// simple example sequence that tests either of gyro-based AzimuthCountedDriveStep or AzimuthTimedDriveStep to drive along a square path +@Autonomous(name="Testing Sensor Code", group="Test") +@Disabled +public class SensorTest extends OpMode { + + BotHardwareOld bot; + + @Override + public void init(){ + bot = new BotHardwareOld(); + + bot.init(this, false); + + } + + @Override + public void start(){ + //Vuf.start(); + } + + @Override + public void loop() { + telemetry.addData("Color Sensor Left Red", bot.leftSensor.red()); + telemetry.addData("Color Sensor Left Blue", bot.leftSensor.blue()); + telemetry.addData("Color Sensor Right Red", bot.rightSensor.red()); + telemetry.addData("Color Sensor Right Blue", bot.rightSensor.blue()); + telemetry.addData("Ultra Left", bot.distSensorLeft.getUltrasonicLevel()); + telemetry.addData("Ultra Right", bot.distSensorRight.getUltrasonicLevel()); + } + + @Override + public void stop() { + super.stop(); + //Vuf.stop(); + } +} + + + diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ServoAdjust.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ServoAdjust.java new file mode 100644 index 00000000000..6cc02b3d0ae --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ServoAdjust.java @@ -0,0 +1,62 @@ +/* + Main robot teleop program + */ + +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +@TeleOp(name = "Servo Calibrate", group = "Main") +//@Disabled +public class ServoAdjust extends OpMode { + + private enum Incs { + SMALL(0.01), + MEDIUM(0.05), + EHH(0.1), + HOLYMOTHER(0.5); + + public double inc; + Incs(double inc) { + this.inc = inc; + } + } + + BotHardware bot = new BotHardware(this); + boolean lastDPad = false; + int incIndex = 0; + + @Override + public void init() { + + telemetry.addData("Status", "Initialized"); + + //currentServo = robot.leftServo; + + // hardware maps + bot.init(); + } + + @Override + public void start() {} + + @Override + public void loop() { + telemetry.addData("Servo", bot.getStick().getPosition()); + telemetry.addData("Increment", Incs.values()[incIndex].inc); + if(!lastDPad) { + if (gamepad1.dpad_up) + bot.getStick().setPosition(Range.clip(bot.getStick().getPosition() + Incs.values()[incIndex].inc, -1, 1)); + else if (gamepad1.dpad_down) + bot.getStick().setPosition(Range.clip(bot.getStick().getPosition() - Incs.values()[incIndex].inc, -1, 1)); + else if (gamepad1.dpad_left) incIndex = Range.clip(incIndex - 1, 0, Incs.values().length - 1); + else if (gamepad1.dpad_right) incIndex = Range.clip(incIndex + 1, 0, Incs.values().length - 1); + } + + lastDPad = gamepad1.dpad_up || gamepad1.dpad_right || gamepad1.dpad_left || gamepad1.dpad_down; + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ServoDegreeTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ServoDegreeTest.java new file mode 100644 index 00000000000..e67b54d47dc --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/ServoDegreeTest.java @@ -0,0 +1,70 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.WhackyDistLib; + +/** + * Created by Noah on 12/28/2017. + */ + +@TeleOp(name = "Stick Degrees Test", group = "Main") +@Disabled +public class ServoDegreeTest extends OpMode { + + private enum Incs { + SMALL(1), + MEDIUM(5), + EHH(10), + HOLYMOTHER(50); + + public double inc; + Incs(double inc) { + this.inc = inc; + } + } + + BotHardware bot = new BotHardware(this); + boolean lastDPad = false; + int incIndex = 0; + + double currentDegrees = 90; + + @Override + public void init() { + + telemetry.addData("Status", "Initialized"); + + //currentServo = robot.leftServo; + + // hardware maps + bot.init(); + } + + @Override + public void start() {} + + @Override + public void loop() { + telemetry.addData("Servo", bot.getStick().getPosition()); + telemetry.addData("Degrees", currentDegrees); + telemetry.addData("Distance", WhackyDistLib.getWhackyDistance(currentDegrees, DistanceUnit.INCH)); + telemetry.addData("Increment", Incs.values()[incIndex].inc); + if(!lastDPad) { + if (gamepad1.dpad_up) + bot.getStick().setPosition(Range.clip(WhackyDistLib.getWhackyPosFromDegrees(currentDegrees += Incs.values()[incIndex].inc), -1, 1)); + else if (gamepad1.dpad_down) + bot.getStick().setPosition(Range.clip(WhackyDistLib.getWhackyPosFromDegrees(currentDegrees -= Incs.values()[incIndex].inc), -1, 1)); + else if (gamepad1.dpad_left) incIndex = Range.clip(incIndex - 1, 0, Incs.values().length - 1); + else if (gamepad1.dpad_right) incIndex = Range.clip(incIndex + 1, 0, Incs.values().length - 1); + } + + lastDPad = gamepad1.dpad_up || gamepad1.dpad_right || gamepad1.dpad_left || gamepad1.dpad_down; + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/UltraHoneDebug.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/UltraHoneDebug.java new file mode 100644 index 00000000000..8c9102def97 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/UltraHoneDebug.java @@ -0,0 +1,155 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.GyroCorrectStep; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; + +/** + * Created by Noah on 2/14/2018. + */ + +@Autonomous(name="Ultra Calibrate") +@Disabled +public class UltraHoneDebug extends OpMode { + private static final int BACKUP_COUNTS = 980; + + AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + BotHardware bot = new BotHardware(this); + protected MatbotixUltra frontUltra; + protected MatbotixUltra backUltra; + + private int counts = 32; + private boolean lastDPad = false; + private boolean done = false; + + private int startCounts = 0; + private int endCounts = 0; + + //parameters for gyro turning + float Kp5 = 15.0f; // degree heading proportional term correction per degree of deviation + float Ki5 = 0.0f; // ... integrator term + float Kd5 = 0; // ... derivative term + float Ki5Cutoff = 0.0f; // maximum angle error for which we update integrator + + SensorLib.PID motorPID = new SensorLib.PID(Kp5, Ki5, Kd5, Ki5Cutoff); + + public void init() { + frontUltra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultrafront"), 100); + backUltra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraback"), 100); + frontUltra.initDevice(); + backUltra.initDevice(); + frontUltra.startDevice(); + backUltra.startDevice(); + bot.init(); + } + + public void init_loop() { + if(!lastDPad) { + if(gamepad1.dpad_up) counts++; + if(gamepad1.dpad_down) counts--; + } + lastDPad = gamepad1.dpad_up || gamepad1.dpad_down; + } + + public void start() { + //initialize sequence + mSeq.add(new UltraHoneStep(this, frontUltra, counts, 0, 5, + new SensorLib.PID(15f, 0.15f, 0, 10), + new GyroCorrectStep(this, 0, bot.getHeadingSensor(), new SensorLib.PID(-16, 0, 0, 0), bot.getMotorVelocityShimArray(), 0.0f, 55.0f, 400.0f))); + mSeq.add(new AutoLib.GyroTurnStep(this, 90, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 55.0f, 650.0f, motorPID, 0.5f, 10, true)); + mSeq.add(new AutoLib.TimedServoStep(BotHardware.ServoE.stickBase.servo, BotHardware.ServoE.stickBaseCenter, 0.25, false)); + mSeq.add(new AutoLib.TimedServoStep(BotHardware.ServoE.stick.servo, 0.85, 0.25, false)); + } + + public void loop() { + if(!done) done = mSeq.loop(); + telemetry.addData("Start Counts", startCounts); + telemetry.addData("End Counts", endCounts); + telemetry.addData("Total Distance", startCounts - endCounts); + } + + private class UltraHoneStep extends AutoLib.Step { + private final OpMode mode; + private final MatbotixUltra ultra; + private final int dist; + private final int error; + private final int count; + private final SensorLib.PID errorPid; + private final GyroCorrectStep gyroStep; + + private double lastTime = 0; + private int currentCount = 0; + + UltraHoneStep(OpMode mode, MatbotixUltra ultra, int dist, int error, int count, SensorLib.PID errorPid, GyroCorrectStep gyroStep) { + this.mode = mode; + this.ultra = ultra; + this.dist = dist; + this.error = error; + this.count = count; + this.errorPid = errorPid; + this.gyroStep = gyroStep; + } + + public boolean loop() { + super.loop(); + if(firstLoopCall()) { + lastTime = mode.getRuntime() - 1; + startCounts = BotHardware.Motor.frontLeft.motor.getCurrentPosition(); + } + //get the distance and error + final int read = ultra.getReading(); + final int curError = dist - read; + //if we found it, stop + //if the peak is within stopping margin, stop + if(Math.abs(curError) <= error) { + setMotorsWithoutGyro(0); + if (++currentCount >= count) { + endCounts = BotHardware.Motor.frontLeft.motor.getCurrentPosition(); + return true; + } + else return false; + } + else currentCount = 0; + //PID + final double time = mode.getRuntime(); + final float pError = errorPid.loop(curError, (float)(time - lastTime)); + lastTime = time; + mode.telemetry.addData("power error", pError); + //cut out a middle range, but handle positive and negative + final float power; + if(pError >= 0) power = Range.clip(pError, gyroStep.getMinPower(), gyroStep.getMaxPower()); + else power = Range.clip(pError, -gyroStep.getMaxPower(), -gyroStep.getMinPower()); + /* + if(gyroStep.getStartPower() >= 0){ + if(pError >= 0) power = Range.clip(gyroStep.getStartPower() + pError, gyroStep.getMinPower(), gyroStep.getMaxPower()); + else power = Range.clip(pError - gyroStep.getStartPower(), -gyroStep.getMaxPower(), -gyroStep.getMinPower()); + } + else { + if(pError >= 0) power = Range.clip(gyroStep.getStartPower() - pError, -gyroStep.getMaxPower(), -gyroStep.getMinPower()); + else power = Range.clip(Math.abs(gyroStep.getStartPower() + pError), gyroStep.getMinPower(), gyroStep.getMaxPower()); + } + */ + gyroStep.setPower(power); + gyroStep.loop(); + //telem + mode.telemetry.addData("Power", -power); + mode.telemetry.addData("Ultra error", curError); + mode.telemetry.addData("Ultra", read); + //return + return false; + } + + private void setMotorsWithoutGyro(float power) { + for(DcMotor motor : gyroStep.getMotors()) motor.setPower(power); + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/VelocityLatency.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/VelocityLatency.java new file mode 100644 index 00000000000..2de8c88910f --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/diagnostic/VelocityLatency.java @@ -0,0 +1,65 @@ +package org.firstinspires.ftc.teamcode.opmodes.diagnostic; + +import com.qualcomm.hardware.lynx.LynxModule; +import com.qualcomm.hardware.lynx.commands.core.LynxGetBulkInputDataCommand; +import com.qualcomm.hardware.lynx.commands.core.LynxGetBulkInputDataResponse; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotorEx; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; + +/** + * Created by Noah on 5/9/2018. + */ + +@TeleOp(name = "Velocity Latency") +public class VelocityLatency extends OpMode { + private LynxModule module; + private long lastMs; + private DcMotorEx backMotor; + private DcMotorEx frontMotor; + + + public void init() { + module = hardwareMap.get(LynxModule.class, "m"); + backMotor = hardwareMap.get(DcMotorEx.class, "bl"); + frontMotor = hardwareMap.get(DcMotorEx.class, "fl"); + lastMs = System.currentTimeMillis(); + } + + public void init_loop() { + long time = System.currentTimeMillis(); + + telemetry.addData("Position 0", backMotor.getCurrentPosition()); + telemetry.addData("Position 1", frontMotor.getCurrentPosition()); + telemetry.addData("Velocity 0", backMotor.getVelocity(AngleUnit.RADIANS)); + telemetry.addData("Velocity 1", frontMotor.getVelocity(AngleUnit.RADIANS)); + telemetry.addData("Latency", time - lastMs); + lastMs = time; + } + + public void start() { + + } + + public void loop() { + try { + LynxGetBulkInputDataCommand command = new LynxGetBulkInputDataCommand(module); + LynxGetBulkInputDataResponse resp = command.sendReceive(); + long time = System.currentTimeMillis(); + + telemetry.addData("Position 0", resp.getEncoder(0)); + telemetry.addData("Position 1", resp.getEncoder(1)); + telemetry.addData("Velocity 0", resp.getVelocity(0)); + telemetry.addData("Velocity 1", resp.getVelocity(1)); + telemetry.addData("Latency", time - lastMs); + lastMs = time; + } + catch (Exception e) { /* hmmmm */ } + } + + public void stop() { + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXCollisionDetectionOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXCollisionDetectionOp.java new file mode 100644 index 00000000000..8d9665d1545 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXCollisionDetectionOp.java @@ -0,0 +1,205 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.kauailabs.navx.ftc.IDataArrivalSubscriber; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/** + * navX-Micro Collision Detection Op + * + * This is a demo program showing the use of the navX-Micro to implement + * a collision detection feature, which can be used to detect events + * while driving a robot, such as bumping into a wall or being hit + * by another robot. + * + * The basic principle used within the Collision Detection example + * is the calculation of Jerk (which is defined as the change in + * acceleration). In the sample code shown below, both the X axis and + * the Y axis jerk are calculated, and if either exceeds a threshold, + * then a collision has occurred. + * + * The 'collision threshold' used in these samples will likely need to + * be tuned for your robot, since the amount of jerk which constitutes + * a collision will be dependent upon the robot mass and expected + * maximum velocity of either the robot, or any object which may strike + * the robot. + * + * Note that this example uses the "callback" mechanism to be informed + * precisely when new data is received from the navX-Micro. + */ +@TeleOp(name = "Concept: navX Collision Detection", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXCollisionDetectionOp extends OpMode implements IDataArrivalSubscriber { + + /* This is the port on the Core Device Interace Module */ + /* in which the navX-Micro is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + + /* Tune this threshold to adjust the sensitivy of the */ + /* Collision detection. */ + private final double COLLISION_THRESHOLD_DELTA_G = 0.5; + + double last_world_linear_accel_x; + double last_world_linear_accel_y; + private ElapsedTime runtime = new ElapsedTime(); + private AHRS navx_device; + private boolean collision_state; + + private final String COLLISION = "Collision"; + private final String NO_COLLISION = "--------"; + + private long last_system_timestamp = 0; + private long last_sensor_timestamp = 0; + + private long sensor_timestamp_delta = 0; + private long system_timestamp_delta = 0; + + @Override + public void init() { + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData); + last_world_linear_accel_x = 0.0; + last_world_linear_accel_y = 0.0; + setCollisionState(false); + } + +@Override + public void start() { + navx_device.registerCallback(this); +} + + @Override + public void stop() { + navx_device.close(); + } + /* + * Code to run when the op mode is first enabled goes here + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init_loop() { + telemetry.addData("navX Op Init Loop", runtime.toString()); + } + + /* + * This method will be called repeatedly in a loop + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#loop() + */ + @Override + public void loop() { + + boolean connected = navx_device.isConnected(); + telemetry.addData("1 navX-Device", connected ? + "Connected" : "Disconnected" ); + String gyrocal, motion; + DecimalFormat df = new DecimalFormat("#.##"); + + if ( connected ) { + gyrocal = (navx_device.isCalibrating() ? + "CALIBRATING" : "Calibration Complete"); + motion = (navx_device.isMoving() ? "Moving" : "Not Moving"); + if ( navx_device.isRotating() ) { + motion += ", Rotating"; + } + } else { + gyrocal = + motion = "-------"; + } + telemetry.addData("2 GyroAccel", gyrocal ); + telemetry.addData("3 Motion", motion); + telemetry.addData("4 Collision", getCollisionString()); + telemetry.addData("5 Timing", Long.toString(sensor_timestamp_delta) + ", " + + Long.toString(system_timestamp_delta) ); + telemetry.addData("6 Events", Double.toString(navx_device.getUpdateCount())); + } + + private String getCollisionString() { + return (this.collision_state ? COLLISION : NO_COLLISION); + } + + private void setCollisionState( boolean newValue ) { + this.collision_state = newValue; + } + + /* This callback is invoked by the AHRS class whenever new data is + received from the sensor. Note that this callback is occurring + within the context of the AHRS class IO thread, and it may + interrupt the thread running this opMode. Therefore, it is + very important to use thread synchronization techniques when + communicating between this callback and the rest of the + code in this opMode. + + The difference between the current linear acceleration data in + the X and Y axes and that in the last sample is compared. If + the absolute value of that difference is greater than the + "Collision Detection Threshold", a collision event is declared. + */ + + @Override + public void timestampedDataReceived(long curr_system_timestamp, long curr_sensor_timestamp, Object o) { + boolean collisionDetected = false; + + sensor_timestamp_delta = curr_sensor_timestamp - last_sensor_timestamp; + system_timestamp_delta = curr_system_timestamp - last_system_timestamp; + double curr_world_linear_accel_x = navx_device.getWorldLinearAccelX(); + double currentJerkX = curr_world_linear_accel_x - last_world_linear_accel_x; + last_world_linear_accel_x = curr_world_linear_accel_x; + double curr_world_linear_accel_y = navx_device.getWorldLinearAccelY(); + double currentJerkY = curr_world_linear_accel_y - last_world_linear_accel_y; + last_world_linear_accel_y = curr_world_linear_accel_y; + + if ( ( Math.abs(currentJerkX) > COLLISION_THRESHOLD_DELTA_G ) || + ( Math.abs(currentJerkY) > COLLISION_THRESHOLD_DELTA_G) ) { + collisionDetected = true; + } + + setCollisionState( collisionDetected ); + } + + @Override + public void untimestampedDataReceived(long l, Object o) { + + } + + @Override + public void yawReset() { + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXDriveStraightPIDLinearOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXDriveStraightPIDLinearOp.java new file mode 100644 index 00000000000..fd7031273cb --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXDriveStraightPIDLinearOp.java @@ -0,0 +1,177 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import android.util.Log; + +import com.kauailabs.navx.ftc.AHRS; +import com.kauailabs.navx.ftc.navXPIDController; +import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/* + * An example linear op mode where the robot will drive in + * a straight line (where the driving direction is guided by + * the Yaw angle from a navX-Model device). + * + * This example uses a simple PID controller configuration + * with a P coefficient, and will likely need tuning in order + * to achieve optimal performance. + * + * Note that for the best accuracy, a reasonably high update rate + * for the navX-Model sensor should be used. This example uses + * the default update rate (50Hz), which may be lowered in order + * to reduce the frequency of the updates to the drive system. + */ + +@TeleOp(name = "Concept: navX Drive Straight PID - Linear", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXDriveStraightPIDLinearOp extends LinearOpMode { + DcMotor leftMotor; + DcMotor rightMotor; + + /* This is the port on the Core Device Interface Module */ + /* in which the navX-Model Device is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + private AHRS navx_device; + private navXPIDController yawPIDController; + private ElapsedTime runtime = new ElapsedTime(); + + private final byte NAVX_DEVICE_UPDATE_RATE_HZ = 50; + + private final double TARGET_ANGLE_DEGREES = 0.0; + private final double TOLERANCE_DEGREES = 2.0; + private final double MIN_MOTOR_OUTPUT_VALUE = -1.0; + private final double MAX_MOTOR_OUTPUT_VALUE = 1.0; + private final double YAW_PID_P = 0.005; + private final double YAW_PID_I = 0.0; + private final double YAW_PID_D = 0.0; + + private boolean calibration_complete = false; + + public double limit(double a) { + return Math.min(Math.max(a, MIN_MOTOR_OUTPUT_VALUE), MAX_MOTOR_OUTPUT_VALUE); + } + + @Override + public void runOpMode() throws InterruptedException { + leftMotor = hardwareMap.dcMotor.get("left motor"); + rightMotor = hardwareMap.dcMotor.get("right motor"); + + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData, + NAVX_DEVICE_UPDATE_RATE_HZ); + + rightMotor.setDirection(DcMotor.Direction.REVERSE); + + /* If possible, use encoders when driving, as it results in more */ + /* predictable drive system response. */ + //leftMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + //rightMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + + /* Create a PID Controller which uses the Yaw Angle as input. */ + yawPIDController = new navXPIDController( navx_device, + navXPIDController.navXTimestampedDataSource.YAW); + + /* Configure the PID controller */ + yawPIDController.setSetpoint(TARGET_ANGLE_DEGREES); + yawPIDController.setContinuous(true); + yawPIDController.setOutputRange(MIN_MOTOR_OUTPUT_VALUE, MAX_MOTOR_OUTPUT_VALUE); + yawPIDController.setTolerance(navXPIDController.ToleranceType.ABSOLUTE, TOLERANCE_DEGREES); + yawPIDController.setPID(YAW_PID_P, YAW_PID_I, YAW_PID_D); + yawPIDController.enable(true); + + waitForStart(); + + while ( !calibration_complete ) { + /* navX-Micro Calibration completes automatically ~15 seconds after it is + powered on, as long as the device is still. To handle the case where the + navX-Micro has not been able to calibrate successfully, hold off using + the navX-Micro Yaw value until calibration is complete. + */ + calibration_complete = !navx_device.isCalibrating(); + if (!calibration_complete) { + telemetry.addData("navX-Micro", "Startup Calibration in Progress"); + } + } + navx_device.zeroYaw(); + + /* Wait for new Yaw PID output values, then update the motors + with the new PID value with each new output value. + */ + + final double TOTAL_RUN_TIME_SECONDS = 10.0; + int DEVICE_TIMEOUT_MS = 500; + navXPIDController.PIDResult yawPIDResult = new navXPIDController.PIDResult(); + + /* Drive straight forward at 1/2 of full drive speed */ + double drive_speed = 0.5; + + DecimalFormat df = new DecimalFormat("#.##"); + + try { + while ((runtime.time() < TOTAL_RUN_TIME_SECONDS) && + !Thread.currentThread().isInterrupted()) { + if (yawPIDController.waitForNewUpdate(yawPIDResult, DEVICE_TIMEOUT_MS)) { + if (yawPIDResult.isOnTarget()) { + leftMotor.setPower(drive_speed); + rightMotor.setPower(drive_speed); + telemetry.addData("PIDOutput", df.format(drive_speed) + ", " + + df.format(drive_speed)); + } else { + double output = yawPIDResult.getOutput(); + leftMotor.setPower(drive_speed + output); + rightMotor.setPower(drive_speed - output); + telemetry.addData("PIDOutput", df.format(limit(drive_speed + output)) + ", " + + df.format(limit(drive_speed - output))); + } + telemetry.addData("Yaw", df.format(navx_device.getYaw())); + } else{ + /* A timeout occurred */ + Log.w("navXDriveStraightOp", "Yaw PID waitForNewUpdate() TIMEOUT."); + } + } + } + catch(InterruptedException ex) { + Thread.currentThread().interrupt(); + } + finally { + navx_device.close(); + telemetry.addData("LinearOp", "Complete"); + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXDriveStraightPIDLoopOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXDriveStraightPIDLoopOp.java new file mode 100644 index 00000000000..fac038bff05 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXDriveStraightPIDLoopOp.java @@ -0,0 +1,177 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.kauailabs.navx.ftc.navXPIDController; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/* + * An example loop op mode where the robot will drive in + * a straight line (where the driving direction is guided by + * the Yaw angle from a navX-Model device). + * + * This example uses a simple PID controller configuration + * with a P coefficient, and will likely need tuning in order + * to achieve optimal performance. + * + * Note that for the best accuracy, a reasonably high update rate + * for the navX-Model sensor should be used. This example uses + * the default update rate (50Hz), which may be lowered in order + * to reduce the frequency of the updates to the drive system. + */ + +@TeleOp(name = "Concept: navX Drive Straight PID - Loop", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXDriveStraightPIDLoopOp extends OpMode { + DcMotor leftMotor; + DcMotor rightMotor; + + /* This is the port on the Core Device Interface Module */ + /* in which the navX-Model Device is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + private AHRS navx_device; + private navXPIDController yawPIDController; + private ElapsedTime runtime = new ElapsedTime(); + + private final byte NAVX_DEVICE_UPDATE_RATE_HZ = 50; + + private final double TARGET_ANGLE_DEGREES = 0.0; + private final double TOLERANCE_DEGREES = 2.0; + private final double MIN_MOTOR_OUTPUT_VALUE = -1.0; + private final double MAX_MOTOR_OUTPUT_VALUE = 1.0; + private final double YAW_PID_P = 0.005; + private final double YAW_PID_I = 0.0; + private final double YAW_PID_D = 0.0; + + private boolean calibration_complete = false; + + navXPIDController.PIDResult yawPIDResult; + DecimalFormat df; + + @Override + public void init() { + leftMotor = hardwareMap.dcMotor.get("left motor"); + rightMotor = hardwareMap.dcMotor.get("right motor"); + + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData, + NAVX_DEVICE_UPDATE_RATE_HZ); + + rightMotor.setDirection(DcMotor.Direction.REVERSE); + + /* If possible, use encoders when driving, as it results in more */ + /* predictable drive system response. */ + //leftMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + //rightMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + + /* Create a PID Controller which uses the Yaw Angle as input. */ + yawPIDController = new navXPIDController( navx_device, + navXPIDController.navXTimestampedDataSource.YAW); + + /* Configure the PID controller */ + yawPIDController.setSetpoint(TARGET_ANGLE_DEGREES); + yawPIDController.setContinuous(true); + yawPIDController.setOutputRange(MIN_MOTOR_OUTPUT_VALUE, MAX_MOTOR_OUTPUT_VALUE); + yawPIDController.setTolerance(navXPIDController.ToleranceType.ABSOLUTE, TOLERANCE_DEGREES); + yawPIDController.setPID(YAW_PID_P, YAW_PID_I, YAW_PID_D); + yawPIDController.enable(true); + + df = new DecimalFormat("#.##"); + } + + public double limit(double a) { + return Math.min(Math.max(a, MIN_MOTOR_OUTPUT_VALUE), MAX_MOTOR_OUTPUT_VALUE); + } + + @Override + public void start() { + /* reset the navX-Model device yaw angle so that whatever direction */ + /* it is currently pointing will be zero degrees. */ + navx_device.zeroYaw(); + yawPIDResult = new navXPIDController.PIDResult(); + } + + @Override + public void loop() { + if ( !calibration_complete ) { + /* navX-Micro Calibration completes automatically ~15 seconds after it is + powered on, as long as the device is still. To handle the case where the + navX-Micro has not been able to calibrate successfully, hold off using + the navX-Micro Yaw value until calibration is complete. + */ + calibration_complete = !navx_device.isCalibrating(); + if ( calibration_complete ) { + navx_device.zeroYaw(); + } else { + telemetry.addData("navX-Micro", "Startup Calibration in Progress"); + } + } else { + /* Wait for new Yaw PID output values, then update the motors + with the new PID value with each new output value. + */ + + /* Drive straight forward at 1/2 of full drive speed */ + double drive_speed = 0.5; + + if (yawPIDController.isNewUpdateAvailable(yawPIDResult)) { + if (yawPIDResult.isOnTarget()) { + leftMotor.setPower(drive_speed); + rightMotor.setPower(drive_speed); + telemetry.addData("Motor Output", df.format(drive_speed) + ", " + + df.format(drive_speed)); + } else { + double output = yawPIDResult.getOutput(); + leftMotor.setPower(limit(drive_speed + output)); + rightMotor.setPower(limit(drive_speed - output)); + telemetry.addData("Motor Output", df.format(limit(drive_speed + output)) + ", " + + df.format(limit(drive_speed - output))); + } + } else { + /* No sensor update has been received since the last time */ + /* the loop() function was invoked. Therefore, there's no */ + /* need to update the motors at this time. */ + } + telemetry.addData("Yaw", df.format(navx_device.getYaw())); + } + } + + @Override + public void stop() { + navx_device.close(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXMotionDetectionOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXMotionDetectionOp.java new file mode 100644 index 00000000000..b0157682558 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXMotionDetectionOp.java @@ -0,0 +1,108 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/** + * navX-Micro Processed Data Mode Op + *

+ * Acquires motion-in-progress indicator from navX-Micro + * and displays it in the Robot DriveStation + * as telemetry data. + */ +@TeleOp(name = "Concept: navX Motion Detection", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXMotionDetectionOp extends OpMode { + + /* This is the port on the Core Device Interace Module */ + /* in which the navX-Micro is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + + private String startDate; + private ElapsedTime runtime = new ElapsedTime(); + private AHRS navx_device; + + @Override + public void init() { + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData); + } + + @Override + public void stop() { + navx_device.close(); + } + /* + * Code to run when the op mode is first enabled goes here + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init_loop() { + telemetry.addData("navX Op Init Loop", runtime.toString()); + } + + /* + * This method will be called repeatedly in a loop + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#loop() + */ + @Override + public void loop() { + + boolean connected = navx_device.isConnected(); + telemetry.addData("1 navX-Device", connected ? + "Connected" : "Disconnected" ); + String gyrocal, motion; + DecimalFormat df = new DecimalFormat("#.##"); + + if ( connected ) { + gyrocal = (navx_device.isCalibrating() ? + "CALIBRATING" : "Calibration Complete"); + motion = (navx_device.isMoving() ? "Moving" : "Not Moving"); + if ( navx_device.isRotating() ) { + motion += ", Rotating"; + } + } else { + gyrocal = + motion = "-------"; + } + telemetry.addData("2 GyroAccel", gyrocal ); + telemetry.addData("3 Motion", motion); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXPerformanceTuningOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXPerformanceTuningOp.java new file mode 100644 index 00000000000..9275ccbdd57 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXPerformanceTuningOp.java @@ -0,0 +1,127 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.kauailabs.navx.ftc.navXPerformanceMonitor; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/** + * navX-Micro Performance Tuning Op + * + * This opmode provides insight into the peformance of the communication + * with the navX-Model sensor over the I2C bus via the Core Device Interface + * Module. Since the Android operating system is not a real-time + * operating system, and since communication w/the navX-Model sensor is + * occurring over a wifi-direct network which can be prone to interference, + * the actual performance (update rate) achieved may be less than + * one might expect. + * + * Since the navX-Model devices integrate sensor data onboard, to achieve + * the best performance for device control methods like a PID controller + * that work best with constant-time updates, the strategy is to: + * + * 1) Configure the navX-Model device to a high update rate (e.g., 50Hz) + * 2) Using this performance-tuning Op-Mode (with all other + * sensors connected, just as your robot will be configured for normal + * use) observe the "effective" update rate, and the number of missed + * samples over the last minute. + * 3) Lower the navX-Model device update rate until the number of missed + * samples over the last minute reaches zero. + */ +@TeleOp(name = "Concept: navX Performance Tuning", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXPerformanceTuningOp extends OpMode { + + /* This is the port on the Core Device Interface Module */ + /* in which the navX-Micro is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + + private AHRS navx_device; + private navXPerformanceMonitor navx_perfmon; + private byte sensor_update_rate_hz = 40; + private ElapsedTime runtime = new ElapsedTime(); + + @Override + public void init() { + AHRS.setLogging(true); + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData, + sensor_update_rate_hz); + navx_perfmon = new navXPerformanceMonitor(navx_device); + } + +@Override + public void start() { + navx_device.registerCallback(navx_perfmon); +} + + @Override + public void stop() { + navx_device.close(); + } + /* + * Code to run when the op mode is first enabled goes here + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init_loop() { + telemetry.addData("navX Op Init Loop", runtime.toString()); + } + + /* + * This method will be called repeatedly in a loop + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#loop() + */ + @Override + public void loop() { + + boolean connected = navx_device.isConnected(); + telemetry.addData("1 navX-Device...............:", connected ? + "Connected" : "Disconnected" ); + String gyrocal, motion; + DecimalFormat df = new DecimalFormat("#.##"); + + telemetry.addData("2 Sensor Rate (Hz)...", Byte.toString(navx_device.getActualUpdateRate())); + telemetry.addData("3 Transfer Rate (Hz).", Integer.toString(navx_device.getCurrentTransferRate())); + telemetry.addData("4 Delivvered Rate (Hz)", Integer.toString(navx_perfmon.getDeliveredRateHz())); + telemetry.addData("5 Missed Samples.....", Integer.toString(navx_perfmon.getNumMissedSensorTimestampedSamples())); + telemetry.addData("6 Duplicate Samples..", Integer.toString(navx_device.getDuplicateDataCount())); + telemetry.addData("7 Sensor deltaT (ms).", Long.toString(navx_perfmon.getLastSensorTimestampDeltaMS())); + telemetry.addData("8 System deltaT (ms).", Long.toString(navx_perfmon.getLastSystemTimestampDeltaMS())); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXRotateToAnglePIDLinearOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXRotateToAnglePIDLinearOp.java new file mode 100644 index 00000000000..f8c7fd9d1a2 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXRotateToAnglePIDLinearOp.java @@ -0,0 +1,166 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import android.util.Log; + +import com.kauailabs.navx.ftc.AHRS; +import com.kauailabs.navx.ftc.navXPIDController; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/* + * An example linear op mode where the robot will rotate + * to a specified angle an then stop. + * + * This example uses a simple PID controller configuration + * with a P coefficient, and will likely need tuning in order + * to achieve optimal performance. + * + * Note that for the best accuracy, a reasonably high update rate + * for the navX-Model sensor should be used. + */ +@TeleOp(name = "Concept: navX Rotate to Angle PID - Linear", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXRotateToAnglePIDLinearOp extends LinearOpMode { + DcMotor leftMotor; + DcMotor rightMotor; + + /* This is the port on the Core Device Interface Module */ + /* in which the navX-Model Device is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + private AHRS navx_device; + private navXPIDController yawPIDController; + private ElapsedTime runtime = new ElapsedTime(); + + private final byte NAVX_DEVICE_UPDATE_RATE_HZ = 50; + + private final double TARGET_ANGLE_DEGREES = 90.0; + private final double TOLERANCE_DEGREES = 2.0; + private final double MIN_MOTOR_OUTPUT_VALUE = -1.0; + private final double MAX_MOTOR_OUTPUT_VALUE = 1.0; + private final double YAW_PID_P = 0.005; + private final double YAW_PID_I = 0.0; + private final double YAW_PID_D = 0.0; + + private boolean calibration_complete = false; + + @Override + public void runOpMode() throws InterruptedException { + leftMotor = hardwareMap.dcMotor.get("left motor"); + rightMotor = hardwareMap.dcMotor.get("right motor"); + + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData, + NAVX_DEVICE_UPDATE_RATE_HZ); + + rightMotor.setDirection(DcMotor.Direction.REVERSE); + + /* If possible, use encoders when driving, as it results in more */ + /* predictable drive system response. */ + //leftMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + //rightMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + + /* Create a PID Controller which uses the Yaw Angle as input. */ + yawPIDController = new navXPIDController( navx_device, + navXPIDController.navXTimestampedDataSource.YAW); + + /* Configure the PID controller */ + yawPIDController.setSetpoint(TARGET_ANGLE_DEGREES); + yawPIDController.setContinuous(true); + yawPIDController.setOutputRange(MIN_MOTOR_OUTPUT_VALUE, MAX_MOTOR_OUTPUT_VALUE); + yawPIDController.setTolerance(navXPIDController.ToleranceType.ABSOLUTE, TOLERANCE_DEGREES); + yawPIDController.setPID(YAW_PID_P, YAW_PID_I, YAW_PID_D); + + waitForStart(); + + while ( !calibration_complete ) { + /* navX-Micro Calibration completes automatically ~15 seconds after it is + powered on, as long as the device is still. To handle the case where the + navX-Micro has not been able to calibrate successfully, hold off using + the navX-Micro Yaw value until calibration is complete. + */ + calibration_complete = !navx_device.isCalibrating(); + if (!calibration_complete) { + telemetry.addData("navX-Micro", "Startup Calibration in Progress"); + } + } + navx_device.zeroYaw(); + + try { + yawPIDController.enable(true); + + /* Wait for new Yaw PID output values, then update the motors + with the new PID value with each new output value. + */ + + final double TOTAL_RUN_TIME_SECONDS = 30.0; + int DEVICE_TIMEOUT_MS = 500; + navXPIDController.PIDResult yawPIDResult = new navXPIDController.PIDResult(); + + DecimalFormat df = new DecimalFormat("#.##"); + + while ( (runtime.time() < TOTAL_RUN_TIME_SECONDS) && + !Thread.currentThread().isInterrupted()) { + if (yawPIDController.waitForNewUpdate(yawPIDResult, DEVICE_TIMEOUT_MS)) { + if (yawPIDResult.isOnTarget()) { + leftMotor.setPowerFloat(); + rightMotor.setPowerFloat(); + telemetry.addData("PIDOutput", df.format(0.00)); + } else { + double output = yawPIDResult.getOutput(); + leftMotor.setPower(output); + rightMotor.setPower(-output); + telemetry.addData("PIDOutput", df.format(output) + ", " + + df.format(-output)); + } + } else { + /* A timeout occurred */ + Log.w("navXRotateOp", "Yaw PID waitForNewUpdate() TIMEOUT."); + } + telemetry.addData("Yaw", df.format(navx_device.getYaw())); + } + } + catch(InterruptedException ex) { + Thread.currentThread().interrupt(); + } + finally { + navx_device.close(); + telemetry.addData("LinearOp", "Complete"); + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXRotateToAnglePIDLoopOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXRotateToAnglePIDLoopOp.java new file mode 100644 index 00000000000..29a395826fb --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXRotateToAnglePIDLoopOp.java @@ -0,0 +1,162 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.kauailabs.navx.ftc.navXPIDController; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/* + * An example loop op mode where the robot will rotate + * to a specified angle an then stop. + * + * This example uses a simple PID controller configuration + * with a P coefficient, and will likely need tuning in order + * to achieve optimal performance. + * + * Note that for the best accuracy, a reasonably high update rate + * for the navX-Model sensor should be used. + */ +@TeleOp(name = "Concept: navX Rotate to Angle PID - Loop", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXRotateToAnglePIDLoopOp extends OpMode { + DcMotor leftMotor; + DcMotor rightMotor; + + /* This is the port on the Core Device Interface Module */ + /* in which the navX-Model Device is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + private AHRS navx_device; + private navXPIDController yawPIDController; + private ElapsedTime runtime = new ElapsedTime(); + + private final byte NAVX_DEVICE_UPDATE_RATE_HZ = 50; + + private final double TARGET_ANGLE_DEGREES = 90.0; + private final double TOLERANCE_DEGREES = 2.0; + private final double MIN_MOTOR_OUTPUT_VALUE = -1.0; + private final double MAX_MOTOR_OUTPUT_VALUE = 1.0; + private final double YAW_PID_P = 0.005; + private final double YAW_PID_I = 0.0; + private final double YAW_PID_D = 0.0; + + private boolean calibration_complete = false; + + navXPIDController.PIDResult yawPIDResult; + DecimalFormat df; + + @Override + public void init() { + leftMotor = hardwareMap.dcMotor.get("left motor"); + rightMotor = hardwareMap.dcMotor.get("right motor"); + + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData, + NAVX_DEVICE_UPDATE_RATE_HZ); + + rightMotor.setDirection(DcMotor.Direction.REVERSE); + + /* If possible, use encoders when driving, as it results in more */ + /* predictable drive system response. */ + //leftMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + //rightMotor.setChannelMode(DcMotorController.RunMode.RUN_USING_ENCODERS); + + /* Create a PID Controller which uses the Yaw Angle as input. */ + yawPIDController = new navXPIDController( navx_device, + navXPIDController.navXTimestampedDataSource.YAW); + + /* Configure the PID controller */ + yawPIDController.setSetpoint(TARGET_ANGLE_DEGREES); + yawPIDController.setContinuous(true); + yawPIDController.setOutputRange(MIN_MOTOR_OUTPUT_VALUE, MAX_MOTOR_OUTPUT_VALUE); + yawPIDController.setTolerance(navXPIDController.ToleranceType.ABSOLUTE, TOLERANCE_DEGREES); + yawPIDController.setPID(YAW_PID_P, YAW_PID_I, YAW_PID_D); + yawPIDController.enable(true); + + df = new DecimalFormat("#.##"); + } + + @Override + public void start() { + navx_device.zeroYaw(); + yawPIDResult = new navXPIDController.PIDResult(); + } + + @Override + public void loop() { + if ( !calibration_complete ) { + /* navX-Micro Calibration completes automatically ~15 seconds after it is + powered on, as long as the device is still. To handle the case where the + navX-Micro has not been able to calibrate successfully, hold off using + the navX-Micro Yaw value until calibration is complete. + */ + calibration_complete = !navx_device.isCalibrating(); + if ( calibration_complete ) { + navx_device.zeroYaw(); + } else { + telemetry.addData("navX-Micro", "Startup Calibration in Progress"); + } + } else { + /* Wait for new Yaw PID output values, then update the motors + with the new PID value with each new output value. + */ + if (yawPIDController.isNewUpdateAvailable(yawPIDResult)) { + if (yawPIDResult.isOnTarget()) { + leftMotor.setPowerFloat(); + rightMotor.setPowerFloat(); + telemetry.addData("Motor Output", df.format(0.00)); + } else { + double output = yawPIDResult.getOutput(); + leftMotor.setPower(output); + rightMotor.setPower(-output); + telemetry.addData("Motor Output", df.format(output) + ", " + + df.format(-output)); + } + } else { + /* No sensor update has been received since the last time */ + /* the loop() function was invoked. Therefore, there's no */ + /* need to update the motors at this time. */ + } + telemetry.addData("Yaw", df.format(navx_device.getYaw())); + } + } + + @Override + public void stop() { + navx_device.close(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXZeroYawOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXZeroYawOp.java new file mode 100644 index 00000000000..608b654c458 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/ConceptNavXZeroYawOp.java @@ -0,0 +1,147 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/** + * navX-Micro Zero Yaw Op + *

+ * Acquires processed data from navX-Micro + * and displays it in the Robot DriveStation + * as telemetry data. This opmode demonstrates how to "zero" + * (reset to zero degrees) the yaw. This causes whatever + * direction the navX-Model device is currently pointing to + * now be zero degrees, and is an effective method for dealing + * with accumulating Yaw Drift. + * + * For more information on Yaw drift, please see the online help at: + * http://navx-micro.kauailabs.com/guidance/yaw-drift/ + */ +@TeleOp(name = "Concept: navX Zero Yaw", group = "Concept") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class ConceptNavXZeroYawOp extends OpMode { + + /* This is the port on the Core Device Interace Module */ + /* in which the navX-Micro is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 0; + + private String startDate; + private ElapsedTime runtime = new ElapsedTime(); + private AHRS navx_device; + + @Override + public void init() { + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData); + } + + @Override + public void stop() { + navx_device.close(); + } + /* + * Code to run when the op mode is first enabled goes here + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init_loop() { + telemetry.addData("navX Op Init Loop", runtime.toString()); + } + + /* + * This method will be called repeatedly in a loop + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#loop() + */ + @Override + public void loop() { + + boolean connected = navx_device.isConnected(); + telemetry.addData("1 navX-Device", connected ? + "Connected" : "Disconnected" ); + String gyrocal, magcal, yaw, pitch, roll, compass_heading; + String fused_heading, ypr, cf, motion; + DecimalFormat df = new DecimalFormat("#.##"); + + if ( connected ) { + gyrocal = (navx_device.isCalibrating() ? + "CALIBRATING" : "Calibration Complete"); + magcal = (navx_device.isMagnetometerCalibrated() ? + "Calibrated" : "UNCALIBRATED"); + yaw = df.format(navx_device.getYaw()); + pitch = df.format(navx_device.getPitch()); + roll = df.format(navx_device.getRoll()); + ypr = yaw + ", " + pitch + ", " + roll; + compass_heading = df.format(navx_device.getCompassHeading()); + fused_heading = df.format(navx_device.getFusedHeading()); + if (!navx_device.isMagnetometerCalibrated()) { + compass_heading = "-------"; + } + cf = compass_heading + ", " + fused_heading; + if ( navx_device.isMagneticDisturbance()) { + cf += " (Mag. Disturbance)"; + } + motion = (navx_device.isMoving() ? "Moving" : "Not Moving"); + if ( navx_device.isRotating() ) { + motion += ", Rotating"; + } + } else { + gyrocal = + magcal = + ypr = + cf = + motion = "-------"; + } + telemetry.addData("2 GyroAccel", gyrocal ); + telemetry.addData("3 Y,P,R", ypr); + telemetry.addData("4 Magnetometer", magcal ); + telemetry.addData("5 Compass,9Axis", cf ); + telemetry.addData("6 Motion", motion); + + /* If the left 'bumper' button pressed, + reset (zero) the current yaw angle. This causes whatever + direction the navX-Model device is currently pointing to + now be zero degrees. + */ + //if ( gamepad1.left_bumper ) { + if ( ( navx_device.getUpdateCount() % 500 ) == 0 ) { + navx_device.zeroYaw(); + } + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/SensorNavXProcessedOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/SensorNavXProcessedOp.java new file mode 100644 index 00000000000..7918054c891 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/SensorNavXProcessedOp.java @@ -0,0 +1,133 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/** + * navX-Micro Processed Data Mode Op + *

+ * Acquires processed data from navX-Micro + * and displays it in the Robot DriveStation + * as telemetry data. This processed data includes + * Yaw, Pitch, Roll, Compass Heading, Fused (9-axis) Heading, + * Sensor Status and Timestamp, and World-Frame Linear + * Acceleration data. + */ +@TeleOp(name = "Sensor: navX Motion-processed Data", group = "Sensor") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class SensorNavXProcessedOp extends OpMode { + + /* This is the port on the Core Device Interace Module */ + /* in which the navX-Micro is connected. Modify this */ + /* depending upon which I2C port you are using. */ + private final int NAVX_DIM_I2C_PORT = 5; + + private String startDate; + private ElapsedTime runtime = new ElapsedTime(); + private AHRS navx_device; + + @Override + public void init() { + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kProcessedData); + } + + @Override + public void stop() { + navx_device.close(); + } + /* + * Code to run when the op mode is first enabled goes here + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init_loop() { + telemetry.addData("navX Op Init Loop", runtime.toString()); + } + + /* + * This method will be called repeatedly in a loop + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#loop() + */ + @Override + public void loop() { + + boolean connected = navx_device.isConnected(); + telemetry.addData("1 navX-Device", connected ? + "Connected" : "Disconnected" ); + String gyrocal, magcal, yaw, pitch, roll, compass_heading; + String fused_heading, ypr, cf, motion; + DecimalFormat df = new DecimalFormat("#.##"); + + if ( connected ) { + gyrocal = (navx_device.isCalibrating() ? + "CALIBRATING" : "Calibration Complete"); + magcal = (navx_device.isMagnetometerCalibrated() ? + "Calibrated" : "UNCALIBRATED"); + yaw = df.format(navx_device.getYaw()); + pitch = df.format(navx_device.getPitch()); + roll = df.format(navx_device.getRoll()); + ypr = yaw + ", " + pitch + ", " + roll; + compass_heading = df.format(navx_device.getCompassHeading()); + fused_heading = df.format(navx_device.getFusedHeading()); + if (!navx_device.isMagnetometerCalibrated()) { + compass_heading = "-------"; + } + cf = compass_heading + ", " + fused_heading; + if ( navx_device.isMagneticDisturbance()) { + cf += " (Mag. Disturbance)"; + } + motion = (navx_device.isMoving() ? "Moving" : "Not Moving"); + if ( navx_device.isRotating() ) { + motion += ", Rotating"; + } + } else { + gyrocal = + magcal = + ypr = + cf = + motion = "-------"; + } + telemetry.addData("2 GyroAccel", gyrocal ); + telemetry.addData("3 Y,P,R", ypr); + telemetry.addData("4 Magnetometer", magcal ); + telemetry.addData("5 Compass,9Axis", cf ); + telemetry.addData("6 Motion", motion); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/SensorNavXRawOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/SensorNavXRawOp.java new file mode 100644 index 00000000000..82030601c75 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/navx/SensorNavXRawOp.java @@ -0,0 +1,141 @@ +/* Copyright (c) 2014, 2015 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.navx; + +import com.kauailabs.navx.ftc.AHRS; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.util.ElapsedTime; + +import java.text.DecimalFormat; + +/** + * SensorNavXRawOp + *

+ * This sample demonstrates how to acquire the raw + * Gyroscope, Accelerometer and Magnetometer data. This raw + * data is typically not as useful as the "processed" data + * (see the navXProcessedOp for details), however is provided + * for those interested in accessing the raw data. + * + * Gyroscope data is units of Degrees/second. + * Accelerometer data is in units of G. + * Magnetometer data is in units if microTorr (uT) + * + * Magnetometer data is not valid unless magnetometer calibration + * has been performed. Without calibration, the magnetometer + * data will be all zeros. For details on how to calibrate the + * magnetometer, please see the Magnetometer Calibration documentation: + * http://navx-micro.kauailabs.com/guidance/magnetometer-calibration/ + * + * Note that due to limitations imposed by the Core Device + * Interface Module's I2C interface mechanisms, the acquisition + * of both processed data and raw data requires two separate + * I2C bus transfers, and thus takes longer than acquiring + * only the raw or only the processed data. + */ +@TeleOp(name = "Sensor: navX Raw Data", group = "Sensor") +@Disabled //Comment this in to remove this from the Driver Station OpMode List +public class SensorNavXRawOp extends OpMode { + + private final int NAVX_DIM_I2C_PORT = 5; + private String startDate; + private ElapsedTime runtime = new ElapsedTime(); + private AHRS navx_device; + @Override + public void init() { + navx_device = AHRS.getInstance(hardwareMap.deviceInterfaceModule.get("dim"), + NAVX_DIM_I2C_PORT, + AHRS.DeviceDataType.kQuatAndRawData); } + + @Override + public void stop() { + navx_device.close(); + } + /* + * Code to run when the op mode is first enabled goes here + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init_loop() { + telemetry.addData("navX Op Init Loop", runtime.toString()); + } + + /* + * This method will be called repeatedly in a loop + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#loop() + */ + + @Override + public void start(){ + navx_device.zeroYaw(); + } + + @Override + public void loop() { + + boolean connected = navx_device.isConnected(); + telemetry.addData("1 navX-Device", connected ? "Connected" : "Disconnected" ); + String gyrocal, gyro_raw, accel_raw, mag_raw, quat_raw; + boolean magnetometer_calibrated; + if ( connected ) { + DecimalFormat df = new DecimalFormat("#.##"); + magnetometer_calibrated = navx_device.isMagnetometerCalibrated(); + gyro_raw = df.format(navx_device.getRawGyroX()) + ", " + + df.format(navx_device.getRawGyroY()) + ", " + + df.format(navx_device.getRawGyroZ()); + accel_raw = df.format(navx_device.getRawAccelX()) + ", " + + df.format(navx_device.getRawAccelY()) + ", " + + df.format(navx_device.getRawAccelZ()); + quat_raw = df.format(navx_device.getQuaternionX()) + ", " + + df.format(navx_device.getQuaternionY()) + ", " + + df.format(navx_device.getQuaternionZ()) + ", " + + df.format(navx_device.getQuaternionW()); + if ( magnetometer_calibrated ) { + mag_raw = df.format(navx_device.getRawMagX()) + ", " + + df.format(navx_device.getRawMagY()) + ", " + + df.format(navx_device.getRawMagZ()); + } else { + mag_raw = "Uncalibrated"; + } + } else { + gyro_raw = + accel_raw = + quat_raw = + mag_raw = "-------"; + } + telemetry.addData("2 Gyros (Degrees/Sec):", gyro_raw); + telemetry.addData("3 Accelerometers (G):", accel_raw ); + telemetry.addData("4 Magnetometers (uT):", mag_raw ); + telemetry.addData("5 Quaternions (?)", quat_raw); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/neural/PictoClassify.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/neural/PictoClassify.java new file mode 100644 index 00000000000..b4a13df0fb6 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/neural/PictoClassify.java @@ -0,0 +1,21 @@ +package org.firstinspires.ftc.teamcode.opmodes.neural; + +/** + * Created by Noah on 2/9/2018. + * Simple pictogram classifier based on a neural netowrk build in Keras + * Designed to be called on asynchronously, since NN calculations are expensive + * Both OpenCV and Tensorflow must be initialized to use any of these functions! + */ + +public class PictoClassify { + int[] cropSize; + int[] scaleSize; + + public PictoClassify(String modelFPath, int[] cropSize, int[] scaleSize) { + this.cropSize = cropSize; + this.scaleSize = scaleSize; + //load model file from disk + + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/ADPSAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/ADPSAuto.java new file mode 100644 index 00000000000..be064194a54 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/ADPSAuto.java @@ -0,0 +1,525 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2018; + +import com.qualcomm.hardware.adafruit.AdafruitI2cColorSensor; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.DcMotorEx; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; +import com.qualcomm.robotcore.hardware.Servo; +import com.qualcomm.robotcore.util.Range; +import com.vuforia.CameraDevice; + +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; +import org.firstinspires.ftc.robotcore.external.navigation.RelicRecoveryVuMark; +import org.firstinspires.ftc.teamcode.libraries.GyroCorrectStep; +import org.firstinspires.ftc.teamcode.libraries.UltraHoneStep; +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9930; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.FilterLib; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.VuforiaBallLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.APDS9960; +import org.firstinspires.ftc.teamcode.libraries.hardware.BlinkyEffect; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; +import org.firstinspires.ftc.teamcode.libraries.hardware.StupidColor; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; +import org.firstinspires.ftc.teamcode.opmodes.demo.Color; +import org.firstinspires.ftc.teamcode.opmodes.diagnostic.UltraHoneDebug; + +import java.util.Arrays; +import java.util.LinkedList; +import java.util.concurrent.TimeUnit; + +/** + * Created by Noah on 12/20/2017. + * Take a guess + */ + +@Autonomous(name="Blue Front Auto", group="test") +public class ADPSAuto extends VuforiaBallLib { + private static final double BALL_WAIT_SEC = 2.0; + private static final int UNDERGLOW_PULSE_WAIT = 50; + private static final double UNDERGLOW_INC = 0.01; + private static final double UNDERGLOW_MAX = 0.5; + + protected APDS9960 backDist; //formerly redDist + protected final APDS9960.Config backConfig = new APDS9960.Config(); + protected APDS9960 frontDist; + protected final APDS9960.Config frontConfig = new APDS9960.Config(); + protected MatbotixUltra frontUltra; + protected MatbotixUltra backUltra; + protected boolean red = false; + protected boolean rear = false; + private BotHardware bot = new BotHardware(this); + + private BallColor color = BallColor.Undefined; + private BallColor altColor = BallColor.Undefined; + private double startLoop = 0; + private boolean firstLoop = false; + + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + //parameters for gyro steering + private static final float Kp4 = -8.0f; // degree heading proportional term correction per degree of deviation + private static final float Ki4 = 0.0f; // ... integrator term + private static final float Kd4 = 0; // ... derivative term + private static final float Ki4Cutoff = 0.0f; // maximum angle error for which we update integrator + + SensorLib.PID drivePID = new SensorLib.PID(Kp4, Ki4, Kd4, Ki4Cutoff); + + //parameters for gyro turning + private static final float Kp5 = 10.0f; // degree heading proportional term correction per degree of deviation + private static final float Ki5 = 0.0f; // ... integrator term + private static final float Kd5 = 0; // ... derivative term + private static final float Ki5Cutoff = 0.0f; // maximum angle error for which we update integrator + + private final SensorLib.PID motorPID = new SensorLib.PID(Kp5, Ki5, Kd5, Ki5Cutoff); + + private static final double MM_PER_ENCODE = 13.298; + private static final int APDS_DIST = 60; + + private boolean glowInc = true; + private double glowPower = 0.0; + private long glowLastTime; + + private enum AutoPath { + RED_FRONT_LEFT(true, false, RelicRecoveryVuMark.LEFT, 1, 125, 720, 32), + RED_FRONT_CENTER(true, false, RelicRecoveryVuMark.CENTER, 0, 125, 680, 32), + RED_FRONT_RIGHT(true, false, RelicRecoveryVuMark.RIGHT, 2, 55, 740, 32), + RED_REAR_LEFT(true, true, RelicRecoveryVuMark.LEFT, 1, 125, 590, 33), + RED_REAR_CENTER(true, true, RelicRecoveryVuMark.CENTER, 0, 125, 540, 33), + RED_REAR_RIGHT(true, true, RelicRecoveryVuMark.RIGHT, 2, 50, 640, 33), + + BLUE_FRONT_LEFT(false, false, RelicRecoveryVuMark.LEFT, 3, 130, 700, 32), + BLUE_FRONT_CENTER(false, false, RelicRecoveryVuMark.CENTER, 1, 55, 600, 32), + BLUE_FRONT_RIGHT(false, false, RelicRecoveryVuMark.RIGHT, 2, 55, 640, 32), + BLUE_REAR_LEFT(false, true, RelicRecoveryVuMark.LEFT, 1, 115, 320, 33), + BLUE_REAR_CENTER(false, true, RelicRecoveryVuMark.CENTER, 0, 55, 520, 33), + BLUE_REAR_RIGHT(false, true, RelicRecoveryVuMark.RIGHT, 1, 55, 520, 33); + + //robot and field constants (in cm) + private final double REAR_PILLAR_WALL_DIST = DistanceUnit.INCH.toCm(24); + private final double FRONT_PILLAR_WALL_DIST = DistanceUnit.INCH.toCm(48); + private final double PILLAR_COL_DIST = DistanceUnit.INCH.toCm(7.63); + private final double RED_WHACKY_TO_ULTRA = 12.265; + private final double BLUE_WHACKY_TO_ULTRA = 30.591; + + public final RelicRecoveryVuMark vuMark; + public final boolean red; + public final boolean rear; + public final int skipCount; + public final float turnAmount; + public final int driveCounts; + public final int ultraDist; + public final int apdsFailUltra; + AutoPath(boolean red, boolean rear, RelicRecoveryVuMark mark, int skipCount, float turnAmount, int driveCounts, int ultraDist) { + this.red = red; + this.rear = rear; + this.vuMark = mark; + this.skipCount = skipCount; + this.turnAmount = turnAmount; + this.driveCounts = driveCounts; + this.ultraDist = ultraDist; + //calculate the fallback ultrasonic distance based on known values on the robot and field + double fieldDist = this.rear ? REAR_PILLAR_WALL_DIST : FRONT_PILLAR_WALL_DIST; + double whackyUltra = this.red ? RED_WHACKY_TO_ULTRA : BLUE_WHACKY_TO_ULTRA; + double skipDist = this.skipCount * PILLAR_COL_DIST; + this.apdsFailUltra = (int)Math.round(fieldDist + skipDist*skipCount - DistanceUnit.MM.toCm(APDS_DIST) - whackyUltra); + } + + static AutoPath getPath(boolean red, boolean rear, RelicRecoveryVuMark mark) { + //return match + if(mark != null && mark != RelicRecoveryVuMark.UNKNOWN){ + for(AutoPath path : values()) if(path.red == red && path.rear == rear && path.vuMark == mark) return path; + throw new IllegalArgumentException("WTF Why"); + } + //else return default + if(red && rear) return RED_REAR_RIGHT; + if(red) return RED_FRONT_CENTER; + if(rear) return BLUE_REAR_CENTER; + return BLUE_FRONT_CENTER; + } + } + + public void init() { + initVuforia(true); + + backDist = new APDS9960(backConfig, hardwareMap.get(I2cDeviceSynch.class, "reddist")); + frontDist = new APDS9960(frontConfig, hardwareMap.get(I2cDeviceSynch.class, "bluedist")); + frontUltra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultrafront"), 100); + backUltra = new MatbotixUltra(hardwareMap.get(I2cDeviceSynch.class, "ultraback"), 100); + + backDist.initDevice(); + frontDist.initDevice(); + frontUltra.initDevice(); + backUltra.initDevice(); + + backDist.startDevice(); + frontDist.startDevice(); + frontUltra.startDevice(); + backUltra.startDevice(); + + bot.init(); + bot.start(); + bot.setDropPos(0.62); + + telemetry.update(); + + startTracking(); + } + + public void init_loop() { + telemetry.addData("Front Ultra", frontUltra.getReading()); + telemetry.addData("Back Ultra", backUltra.getReading()); + telemetry.addData("Front Infrared", frontDist.getDist()); + telemetry.addData("Back Infrared", backDist.getDist()); + telemetry.addData("Ball Color", getBallColor().toString()); + telemetry.addData("IMU", bot.getHeadingSensor().getHeading()); + telemetry.addData("Lift", BotHardware.Motor.lift.motor.getCurrentPosition()); + } + + public void start() { + + } + + public void loop() { + if(startLoop == 0) startLoop = getRuntime(); + if(getRuntime() - startLoop >= BALL_WAIT_SEC / 2 && !firstLoop) CameraDevice.getInstance().setFlashTorchMode(true); + if(getRuntime() - startLoop < BALL_WAIT_SEC && (color == BallColor.Indeterminate || color == BallColor.Undefined)) { + color = getBallColor(); + altColor = getCVBallColor(); + } + else if(!firstLoop){ + CameraDevice.getInstance().setFlashTorchMode(false); + //init whacky stick code here + AutoLib.Sequence whack = new AutoLib.LinearSequence(); + + if(red) whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed, 0.25, false)); + else whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue, 0.25, false)); + whack.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickDown, 0.5, false)); + + //hmmmmm + final AutoLib.Step whackLeft; + if(red) whackLeft = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed - BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + else whackLeft = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue - BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + final AutoLib.Step whackRight; + if(red) whackRight = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed + BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + else whackRight = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue + BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + whack.add(new APDSBallFind(red, (color != BallColor.Indeterminate && color != BallColor.Undefined) ? color : altColor, whackLeft, whackRight)); + + whack.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickUp, 0.25, false)); + whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseHidden, 0.25, false)); + + final int mul = red ? -1 : 1; + + AutoPath path = AutoPath.getPath(red, rear, getLastVuMark()); + + AutoLib.Sequence findPilliar = new AutoLib.LinearSequence(); + + GyroCorrectStep step; + if(!red) step = new GyroCorrectStep(this, 0, bot.getHeadingSensor(), new SensorLib.PID(-20, 0, 0, 0), bot.getMotorVelocityShimArray(), -250.0f, 45.0f, 360.0f); + else step = new GyroCorrectStep(this, 0, bot.getHeadingSensor(), new SensorLib.PID(-20, 0, 0, 0), bot.getMotorVelocityShimArray(), 250.0f, 45.0f, 360.0f); + + int heading = rear ? (red ? 90 : -90) : 0; + + if(!rear) { + findPilliar.add(new AutoLib.AzimuthCountedDriveStep(this, 0, bot.getHeadingSensor(), drivePID, bot.getMotorVelocityShimArray(), 250.0f * mul, 1200, true, -360.0f, 360.0f)); + findPilliar.add(new AutoLib.GyroTurnStep(this, 0, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 45.0f, 360.0f, motorPID, 0.5f, 10, true)); + } + else { + //TODO: implement encoder count backup automatically + findPilliar.add(new UltraHoneStep(this, red ? frontUltra : backUltra, path.ultraDist, 0, 5, new SensorLib.PID(11f, 0.15f, 0, 10), step)); + findPilliar.add(new AutoLib.GyroTurnStep(this, heading, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 45.0f, 360.0f, motorPID, 0.5f, 10, true)); + //findPilliar.add(new AutoLib.GyroTurnStep(this, heading, bot.getHeadingSensor(), bot.getMotorRay(), 0.04f, 0.4f, new SensorLib.PID(0.006f, 0, 0, 0), 0.5f, 10, true)); + //if(!red) findPilliar.add(new AutoLib.AzimuthCountedDriveStep(this, heading, bot.getHeadingSensor(), drivePID, bot.getMotorVelocityShimArray(), -360.0f, 100, true, -500.0f, 500.0f)); + } + + findPilliar.add(new AutoLib.TimedServoStep(BotHardware.ServoE.stickBase.servo, BotHardware.ServoE.stickBaseCenter, 0.25, false)); + findPilliar.add(new AutoLib.TimedServoStep(BotHardware.ServoE.stick.servo, 0.85, 0.25, false)); + + //reconstruct for saftey + if(!red) step = new GyroCorrectStep(this, heading, bot.getHeadingSensor(), new SensorLib.PID(-30, 0, 0, 0), bot.getMotorVelocityShimArray(), 250.0f, 25.0f, 150.0f); + else step = new GyroCorrectStep(this, heading, bot.getHeadingSensor(), new SensorLib.PID(-30, 0, 0, 0), bot.getMotorVelocityShimArray(), -250.0f, 25.0f, 150.0f); + final APDS9960 dist = red ? frontDist : backDist; + //TODO: add camera fallback + findPilliar.add(new APDSFind(BotHardware.ServoE.stick.servo, 0.85, 0.55, dist, new SensorLib.PID(1.0f, 0, 0, 10), step, + APDS_DIST, 8, path.skipCount, 100, this, red, rear)); + findPilliar.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickUp, 0.25, false)); + findPilliar.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseHidden, 0.25, false)); + AutoLib.ConcurrentSequence raiseWhile = new AutoLib.ConcurrentSequence(); + AutoLib.LinearSequence driveToBox = new AutoLib.LinearSequence(); + //findPilliar.add(new AutoLib.GyroTurnStep(this, path.turnAmount + heading, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 90.0f, 520.0f, motorPID, 2.0f, 5, true)); + driveToBox.add(new AutoLib.GyroTurnStep(this, path.turnAmount + heading, bot.getHeadingSensor(), bot.getMotorRay(), 0.04f, 0.4f, new SensorLib.PID(0.006f, 0, 0, 0), 2f, 5, true)); + driveToBox.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 250.0f, path.driveCounts, true)); + raiseWhile.add(driveToBox); + int liftPos = BotHardware.Motor.lift.motor.getCurrentPosition(); + raiseWhile.add(new MoveToPositionStep(BotHardware.Motor.lift.motor, liftPos + 400, 10, 1.0f, true)); + findPilliar.add(raiseWhile); + findPilliar.add(bot.getDropStep()); + findPilliar.add(bot.getReverseDropStep()); + AutoLib.ConcurrentSequence oneSideSeq = new AutoLib.ConcurrentSequence(); + DcMotor[] temp = bot.getMotorRay(); + if(path.turnAmount > 55) { + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[0], 0.5f, 1.0, true)); + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[1], 0.5f, 1.0, true)); + } + else { + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[2], 0.5f, 1.0, true)); + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[3], 0.5f, 1.0, true)); + } + oneSideSeq.add(new MoveToPositionStep(BotHardware.Motor.lift.motor, liftPos, 3, 1.0f, true)); + findPilliar.add(oneSideSeq); + findPilliar.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), -400.0f, 600, true)); + findPilliar.add(new AutoLib.GyroTurnStep(this,heading + 180, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 90.0f, 520.0f, motorPID, 10.0f, 10, true)); + + mSeq.add(whack); + mSeq.add(findPilliar); + + firstLoop = true; + } + + //logs! + if(color != null) telemetry.addData("Ball Color", color.toString()); + if(getLastVuMark() != null) telemetry.addData("VuMark", getLastVuMark().toString()); + + try { + if(firstLoop && mSeq.loop()) requestOpModeStop(); + } + catch (Exception e) { + backDist.stopDevice(); + frontDist.stopDevice(); + bot.stopAll(); + throw e; + } + } + + + public void stop() { + backDist.stopDevice(); + frontDist.stopDevice(); + backUltra.stopDevice(); + frontUltra.stopDevice(); + bot.stopAll(); + stopVuforia(); + } + + public static class APDSFind extends AutoLib.Step { + private final int mError; + private final int mDist; + private final APDS9960 sens; + private final OpMode mode; + private final SensorLib.PID errorPid; + private final GyroCorrectStep gyroStep; + private final Servo stick; + private final int pilliarDist; + private final boolean red; + private final boolean rear; + private int[] encoderCache = new int[4]; + private int[] startEncoderCache = new int[4]; + private int pilliarCount; + private boolean stickPulled = false; + private FilterLib.MovingWindowFilter movingAvg; + private final double stickDown; + private final double stickUp; + + private double lastTime = 0; + private int foundCount = 0; + + private static final int APDS_FOUND_COUNT = 4; + private static final int COUNTS_BETWEEN_PILLIAR = 250; + private static final int COUNT_OH_SHIT_REAR = COUNTS_BETWEEN_PILLIAR * 7; + private static final int COUNT_OH_SHIT_FRONT = COUNT_OH_SHIT_REAR * 9; + + APDSFind(Servo stick, double stickDown, double stickUp, APDS9960 sens, SensorLib.PID errorPid, + GyroCorrectStep correctIt, int dist, int error, int pilliarSkipCount, int skipDist, OpMode mode, boolean red, boolean rear) { + this.errorPid = errorPid; + this.sens = sens; + this.gyroStep = correctIt; + this.mError = error; + this.mDist = dist; + this.mode = mode; + this.stick = stick; + this.pilliarCount = pilliarSkipCount; + this.pilliarDist = skipDist; + this.stickDown = stickDown; + this.stickUp = stickUp; + this.red = red; + this.rear = rear; + } + + public boolean loop() { + super.loop(); + //get distance + double dist = this.sens.getLinearizedDistance(red); + if(Double.isInfinite(dist)) dist = 150; + if(movingAvg == null) { + movingAvg = new FilterLib.MovingWindowFilter(10, dist); + for (int i = 0; i < 4; i++) startEncoderCache[i] = gyroStep.getMotors()[i].getCurrentPosition(); + //check stick distance when we first drop to see if we need to p[ick up immediately + if(pilliarCount > 0 && dist <= pilliarDist) { + stick.setPosition(stickUp); + markEncoders(); + stickPulled = true; + try { TimeUnit.MILLISECONDS.sleep(250); } + catch (InterruptedException e) {} + return false; + } + } + movingAvg.appendValue(dist); + double filteredDist = movingAvg.currentValue(); + //stupid check + //if any of the encoders are past the OH SHIT threshold, abort + boolean shit = false; + for(int i = 0; i < 4; i++) { + shit |= Math.abs(gyroStep.getMotors()[i].getCurrentPosition() - startEncoderCache[i]) >= (rear ? COUNT_OH_SHIT_REAR : COUNT_OH_SHIT_FRONT); + mode.telemetry.addData("Motor " + i, Math.abs(gyroStep.getMotors()[i].getCurrentPosition() - startEncoderCache[i])); + } + if(shit) { + setMotorsWithoutGyro(0); + throw new IllegalStateException("Ur bumfucked m8"); + } + //if we aren't skipping any more pilliars + if(pilliarCount == 0) { + if(lastTime == 0) lastTime = mode.getRuntime() - 1; + //get the distance and error + float error = (float)(this.mDist - dist); + //if we found it, stop + //if the peak is within stopping margin, stop + if(Math.abs(error) <= mError) { + setMotorsWithoutGyro(0); + return ++foundCount >= APDS_FOUND_COUNT; + } + else foundCount = 0; + //PID + double time = mode.getRuntime(); + float pError = errorPid.loop((float)(this.mDist - filteredDist), (float)(time - lastTime)); + lastTime = time; + mode.telemetry.addData("power error", pError); + //cut out a middle range, but handle positive and negative + float power; + if(red) pError = -pError; + if(pError >= 0) power = Range.clip(gyroStep.getMinPower() + pError, gyroStep.getMinPower(), gyroStep.getMaxPower()); + else power = Range.clip(pError - gyroStep.getMinPower(), -gyroStep.getMaxPower(), -gyroStep.getMinPower()); + //if(pError >= 0) power = Range.clip(pError, 0, gyroStep.getMaxPower()); + //else power = Range.clip(pError, -gyroStep.getMaxPower(), 0); + gyroStep.setPower(-power); + gyroStep.loop(); + //telem + mode.telemetry.addData("APDS dist", error); + } + else { + //else skip them pilliars + //if stick is pulled, keep stick pulled until driving is done, then drop and decrement pilliars + if(stickPulled && checkEncoders(COUNTS_BETWEEN_PILLIAR)) { + stick.setPosition(stickDown); + pilliarCount--; + stickPulled = false; + } + //else if stick isn't pulled, but the sensor found a pilliar + //lift the stick and mark the encoders to drive + else if(!stickPulled && dist <= pilliarDist) { + stick.setPosition(stickUp); + markEncoders(); + stickPulled = true; + } + //set motors to corrected + gyroStep.loop(); + } + return false; + } + + private void setMotorsWithoutGyro(float power) { + for(DcMotor motor : gyroStep.getMotors()) motor.setPower(power); + } + + private boolean checkEncoders(int dist) { + boolean done = true; + DcMotor[] motorRay = gyroStep.getMotors(); + for(int i = 0; i < 4; i++) done &= (Math.abs(motorRay[i].getCurrentPosition() - encoderCache[i]) >= dist); + return done; + } + + private void markEncoders() { + DcMotor[] motorRay = gyroStep.getMotors(); + for (int i = 0; i < 4; i++) encoderCache[i] = motorRay[i].getCurrentPosition(); + } + } + + public static class APDSBallFind extends AutoLib.Step { + private final boolean red; + private BallColor color; + private final AutoLib.Step whackLeft; + private final AutoLib.Step whackRight; + + APDSBallFind(boolean red, BallColor color, AutoLib.Step whackLeft, AutoLib.Step whackRight) { + this.red = red; + this.color = color; + this.whackLeft = whackLeft; + this.whackRight = whackRight; + } + + public boolean loop() { + super.loop(); + //run appropriete sewunce + if(color == BallColor.LeftBlue) { + if(red) return whackLeft.loop(); + else return whackRight.loop(); + } + else if(color == BallColor.LeftRed) { + if(red) return whackRight.loop(); + else return whackLeft.loop(); + } + //or finish immedietly + return true; + } + } + + public static class MoveToPositionStep extends AutoLib.Step { + private final DcMotorEx motor; + private final int pos; + private final int tol; + private final float power; + private final boolean restoreMode; + private DcMotor.RunMode storeMode; + private DcMotor.ZeroPowerBehavior storeZero; + private int lastTol; + + MoveToPositionStep(DcMotorEx motor, int pos, int tol, float power, boolean restoreMode) { + this.motor = motor; + this.pos = pos; + this.tol = tol; + this.power = power; + this.restoreMode = restoreMode; + } + + public boolean loop() { + super.loop(); + + if(firstLoopCall()) { + storeMode = motor.getMode(); + if(storeMode == DcMotor.RunMode.RUN_TO_POSITION) lastTol = motor.getTargetPositionTolerance(); + storeZero = motor.getZeroPowerBehavior(); + motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + motor.setMode(DcMotor.RunMode.RUN_TO_POSITION); + motor.setTargetPositionTolerance(tol); + motor.setTargetPosition(pos); + motor.setPower(power); + } + + if(!motor.isBusy()) { + motor.setPower(0); + if(restoreMode) { + motor.setZeroPowerBehavior(storeZero); + motor.setMode(storeMode); + if(storeMode == DcMotor.RunMode.RUN_TO_POSITION) motor.setTargetPositionTolerance(lastTol); + } + return true; + } + return false; + } + + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/LiftFix.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/LiftFix.java new file mode 100644 index 00000000000..93564747100 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/LiftFix.java @@ -0,0 +1,40 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2018; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 2/23/2018. + */ + +@TeleOp(name="Motor Fixer") +//bwahahaha were going to worlds +public class LiftFix extends OpMode { + BotHardware bot = new BotHardware(this); + + public void init() { + bot.init(); + DcMotor[] ray = bot.getMotorRay(); + for(DcMotor motor : ray) + motor.setMode(DcMotor.RunMode.RUN_WITHOUT_ENCODER); + } + + public void start() { + + } + + public void loop() { + BotHardware.Motor.relic.motor.setPower(gamepad1.left_stick_y / 2.0); + BotHardware.Motor.lift.motor.setPower(gamepad1.right_stick_y / 2.0); + + telemetry.addData("Relic", BotHardware.Motor.relic.motor.getCurrentPosition()); + telemetry.addData("Lift", BotHardware.Motor.lift.motor.getCurrentPosition()); + } + + public void stop() { + bot.stopAll(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/RatBot.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/RatBot.java new file mode 100644 index 00000000000..bd90fcf7ddb --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/RatBot.java @@ -0,0 +1,95 @@ +/* + Basic rat bot program for testing + */ + +package org.firstinspires.ftc.teamcode.opmodes.old2018; + +import android.app.Activity; +import android.graphics.Color; +import android.view.ViewGroup; +import android.widget.RelativeLayout; + +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.DcMotorEx; +import com.qualcomm.robotcore.hardware.DcMotorSimple; +import com.qualcomm.robotcore.hardware.DigitalChannel; +import com.qualcomm.robotcore.hardware.DistanceSensor; +import com.qualcomm.robotcore.hardware.PIDCoefficients; +import com.qualcomm.robotcore.hardware.UltrasonicSensor; + +import org.firstinspires.ftc.robotcontroller.external.samples.SensorREVColorDistance; +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; + +import java.util.LinkedList; + +@TeleOp(name = "RatBot", group = "Misc.") +@Disabled +public class RatBot extends OpMode { + + private static final int DATA_MAX = 100; + + DcMotorEx frontLeftMotor; + DcMotorEx backLeftMotor; + DcMotorEx frontRightMotor; + DcMotorEx backRightMotor; + + ColorSensor mahColor; + DistanceSensor mahDistance; + DigitalChannel touch; + + UltrasonicSensor side; + UltrasonicSensor front; + + @Override + public void init() { + + telemetry.addData("Status", "Initialized"); + + // hardware maps frontLeftMotor = (DcMotorEx) hardwareMap.dcMotor.get("front_left"); + frontRightMotor = (DcMotorEx) hardwareMap.dcMotor.get("front_right"); + backLeftMotor = (DcMotorEx) hardwareMap.dcMotor.get("back_left"); + backRightMotor = (DcMotorEx) hardwareMap.dcMotor.get("back_right"); + + mahColor = hardwareMap.get(ColorSensor.class, "color"); + mahDistance = hardwareMap.get(DistanceSensor.class, "color"); + touch = hardwareMap.get(DigitalChannel.class, "touch"); + touch.setMode(DigitalChannel.Mode.INPUT); + + side = hardwareMap.get(UltrasonicSensor.class, "ul_side"); + front = hardwareMap.get(UltrasonicSensor.class, "ul_front"); + + // change directions if necessary + frontLeftMotor.setDirection(DcMotor.Direction.FORWARD); + frontRightMotor.setDirection(DcMotor.Direction.REVERSE); + backLeftMotor.setDirection(DcMotorSimple.Direction.FORWARD); + backRightMotor.setDirection(DcMotorSimple.Direction.REVERSE); + + } + + @Override + public void start() {} + + @Override + public void loop() { + // run the drive train motors + frontLeftMotor.setPower(gamepad1.left_stick_y); + frontRightMotor.setPower(gamepad1.right_stick_y); + backLeftMotor.setPower(gamepad1.left_stick_y); + backRightMotor.setPower(gamepad1.right_stick_y); + + telemetry.addData("color", mahColor.red()); + telemetry.addData("color distance", mahDistance.getDistance(DistanceUnit.MM)); + + telemetry.addData("touch", touch.getState()); + + telemetry.addData("side status", side.status()); + telemetry.addData("front status", front.status()); + telemetry.addData("side", side.getUltrasonicLevel()); + telemetry.addData("front", front.getUltrasonicLevel()); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/SimpleDriveAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/SimpleDriveAuto.java new file mode 100644 index 00000000000..893b022b134 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/SimpleDriveAuto.java @@ -0,0 +1,34 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2018; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 12/2/2017. + */ + +@Autonomous(name="Everything's Broken Drive", group="test") +@Disabled +public class SimpleDriveAuto extends OpMode { + private BotHardware bot = new BotHardware(this); + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + public void init() { + bot.init(); + mSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 270.0f, 1600, true)); + } + + @Override + public void start() { + //hmmm + } + + @Override + public void loop() { + if(mSeq.loop()) requestOpModeStop(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/Teleop.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/Teleop.java new file mode 100644 index 00000000000..da821516d92 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/Teleop.java @@ -0,0 +1,275 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2018; + +import com.qualcomm.hardware.adafruit.AdafruitI2cColorSensor; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.ColorSensor; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.StupidColor; +import org.firstinspires.ftc.teamcode.opmodes.demo.BlinkTest; + +import java.util.Random; +import java.util.concurrent.TimeUnit; + +/** + * Created by Noah on 10/27/2017. + * Teleop! + */ + +@TeleOp(name="Teleop") +public class Teleop extends OpMode { + private static final float slowFactor = 0.8f; + private static final float fastFactor = 1.0f; + private static final double SERVO_INC_SHAKE = 0.1; + private static final double SERVO_INC_MAX = 0.02; + private static final double SERVO_INC_MIN = 0.001; + private static final int LIFT_COUNTS = 2800; //4250 + private static final int LIFT_BOTTOM_COUNTS = 730; + private static final int LIFT_INC_COUNTS = 100; + private static final int RELIC_ARM_COUNTS = 6450; + private static final double BUCKET_SHAKE_INTERVAL = 0.04; //seconds + private static final double BUCKET_FLAT = 0.58; + //private static final int BUCKET_LIFT_COUNTS = 50; + //private static final int INTAKE_LIFT_COUNTS = 1200; + private static final int MIN_VELOCITY = 550; + private static final float ARM_GRAB = 0.39f; + + private static final double ARM_M_COFF = 0.0000472907349606521; + private static final double ARM_B_COFF = 0.0276268627304199; + private static final int ARM_MIN_COUNTS = 3000; + + private static final int RELIC_AUTO_ARM_COUNTS = 6200; + + protected BotHardware bot = new BotHardware(this); + private boolean lastA = false; + private boolean robotSlow = false; + private boolean motorsSet = false; + private boolean lastY = false; + private boolean grabOpen = true; + + private boolean suckMotorStopped = false; + private boolean suckLeftStopped = false; + private boolean suckMotorRamping = false; + private int suckMotorRampCount = 0; + + private int liftPos; + private int relicPos; + + private boolean servoSet = false; + private double lastTime = 0; + + private boolean xLock = false; + + public void init() { + bot.init(); + DcMotor[] ray = bot.getMotorRay(); + for(DcMotor motor : ray){ + motor.setMode(DcMotor.RunMode.RUN_WITHOUT_ENCODER); + motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + } + + bot.setLights(0.5); + } + + public void start() { + gamepad1.setJoystickDeadzone(0.05f); + gamepad2.setJoystickDeadzone(0.05f); + bot.start(); + bot.setDropPos(BotHardware.ServoE.backDropUp); + BotHardware.Motor.lift.motor.setMode(DcMotor.RunMode.RUN_TO_POSITION); + BotHardware.Motor.relic.motor.setMode(DcMotor.RunMode.RUN_TO_POSITION); + BotHardware.Motor.relic.motor.setTargetPositionTolerance(5); + BotHardware.Motor.relic.motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + liftPos = BotHardware.Motor.lift.motor.getCurrentPosition(); + relicPos = BotHardware.Motor.relic.motor.getCurrentPosition(); + BotHardware.Motor.suckRight.motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + BotHardware.Motor.suckLeft.motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + } + + public void loop() { + //calc deltas + final int liftPosDelta = BotHardware.Motor.lift.motor.getCurrentPosition() - liftPos; + + if(gamepad1.a && !lastA) robotSlow = !robotSlow; + lastA = gamepad1.a; + + if(gamepad1.b || gamepad2.b) bot.setDropPos(BUCKET_FLAT); + if(gamepad2.a) bot.setDropPos(BotHardware.ServoE.backDropUp); + + //lowering + if(gamepad2.left_bumper) { + bot.setLiftMotors(-1.0f); + BotHardware.Motor.lift.motor.setTargetPosition(liftPos); + } + else if(gamepad2.right_bumper) { + bot.setLiftMotors(1.0f); + BotHardware.Motor.lift.motor.setTargetPosition(liftPos + LIFT_COUNTS); + } + else bot.setLiftMotors(0); + + if(gamepad1.left_trigger > 0) + bot.setDropPos(Range.clip(bot.getDropPos() + Range.scale(gamepad1.left_trigger, 0, 1, SERVO_INC_MIN, SERVO_INC_MAX), BotHardware.ServoE.backDropDown, BotHardware.ServoE.backDropUp)); + else if(gamepad1.right_trigger > 0) { + if(liftPosDelta > LIFT_BOTTOM_COUNTS) bot.setDropPos(Range.clip(bot.getDropPos() - Range.scale(gamepad1.right_trigger, 0, 1, SERVO_INC_MIN, SERVO_INC_MAX), BotHardware.ServoE.backDropDown, BotHardware.ServoE.backDropUp)); + else { + BotHardware.Motor.lift.motor.setTargetPosition(liftPos + LIFT_BOTTOM_COUNTS + 50); + bot.setLiftMotors(1.0f); + } + } + + double time = getRuntime(); + if(gamepad1.x && time - lastTime >= BUCKET_SHAKE_INTERVAL) { + telemetry.addData("Interval", time - lastTime); + lastTime = time; + if(servoSet) bot.setDropPos(Range.clip(bot.getDropPos() - SERVO_INC_SHAKE, BotHardware.ServoE.backDropDown, BotHardware.ServoE.backDropUp)); + else bot.setDropPos(Range.clip(bot.getDropPos() + SERVO_INC_SHAKE, BotHardware.ServoE.backDropDown, BotHardware.ServoE.backDropUp)); + servoSet = !servoSet; + } + else if(!gamepad1.x) servoSet = false; + + telemetry.addData("Drop", BotHardware.ServoE.backDropLeft.servo.getPosition()); + + + if(gamepad2.start) { + /* + //relic automation! + telemetry.addData("Relic Automation!", true); + xLock = false; + //put arm to farthest point + BotHardware.Motor.relic.motor.setTargetPosition(relicPos + RELIC_ARM_COUNTS); + BotHardware.Motor.relic.motor.setPower(1.0f); + //if over first counts, drop arm servo to place + final int pos = Math.abs(BotHardware.Motor.relic.motor.getCurrentPosition() - relicPos); + if(pos >= RELIC_AUTO_ARM_COUNTS) BotHardware.ServoE.arm.servo.setPosition(pos * ARM_M_COFF + ARM_B_COFF); + if(pos > RELIC_ARM_COUNTS - 15) { + //open grab + BotHardware.ServoE.grab.servo.setPosition(BotHardware.ServoE.grabOpen); + grabOpen = true; + } + */ + xLock = false; + BotHardware.ServoE.arm.servo.setPosition(0.39); + } + else { + //driver control + if(gamepad2.dpad_up) { + BotHardware.ServoE.arm.servo.setPosition(Range.clip(BotHardware.ServoE.arm.servo.getPosition() + 0.01, BotHardware.ServoE.armClosed, BotHardware.ServoE.armOpen)); + xLock = false; + } + else if(gamepad2.dpad_down){ + BotHardware.ServoE.arm.servo.setPosition(Range.clip(BotHardware.ServoE.arm.servo.getPosition() - 0.01, BotHardware.ServoE.armClosed, BotHardware.ServoE.armOpen)); + xLock = false; + } + + if(xLock || gamepad2.x){ + final int relPos = Math.abs(BotHardware.Motor.relic.motor.getCurrentPosition() - relicPos); + final double pos = relPos * ARM_M_COFF + ARM_B_COFF; + if(relPos > ARM_MIN_COUNTS) BotHardware.ServoE.arm.servo.setPosition(pos); + else BotHardware.ServoE.arm.servo.setPosition(0.2); + //BotHardware.ServoE.arm.servo.setPosition(ARM_GRAB); + xLock = true; + } + + telemetry.addData("XLock", xLock); + + if(gamepad2.y && !lastY) { + if(grabOpen = !grabOpen) BotHardware.ServoE.grab.servo.setPosition(BotHardware.ServoE.grabOpen); + else BotHardware.ServoE.grab.servo.setPosition(BotHardware.ServoE.grabClosed); + } + lastY = gamepad2.y; + + if(gamepad2.left_trigger > 0) { + BotHardware.Motor.relic.motor.setTargetPosition(relicPos + 250); + BotHardware.Motor.relic.motor.setPower(-gamepad2.left_trigger); + } + else if(gamepad2.right_trigger > 0){ + BotHardware.Motor.relic.motor.setTargetPosition(relicPos + RELIC_ARM_COUNTS); + BotHardware.Motor.relic.motor.setPower(gamepad2.right_trigger); + } + else BotHardware.Motor.relic.motor.setPower(0); + } + + if(gamepad2.left_stick_y <= 0.95 || gamepad2.right_stick_y <= 0.95) { + bot.setSuckLeft(gamepad2.left_stick_y); + bot.setSuckRight(gamepad2.right_stick_y); + suckMotorRamping = true; + suckMotorStopped = false; + suckMotorRampCount = 5; + } + else { + telemetry.addData("Metering", true); + + double lastRight = BotHardware.Motor.suckRight.motor.getVelocity(AngleUnit.DEGREES); + double lastLeft = BotHardware.Motor.suckLeft.motor.getVelocity(AngleUnit.DEGREES); + + if(suckMotorRamping) { + BotHardware.Motor.suckLeft.motor.setPower(1); + BotHardware.Motor.suckRight.motor.setPower(1); + if(lastRight > MIN_VELOCITY && lastLeft > MIN_VELOCITY) suckMotorRampCount++; + else suckMotorRampCount = 0; + if(suckMotorRampCount >= 10) { + suckMotorRamping = false; + suckMotorRampCount = 0; + } + } + else if(!suckMotorStopped && (lastRight < MIN_VELOCITY || lastLeft < MIN_VELOCITY)) { + if(lastLeft < lastRight) { + BotHardware.Motor.suckRight.motor.setPower(0); + suckLeftStopped = false; + } + else { + BotHardware.Motor.suckLeft.motor.setPower(0); + suckLeftStopped = true; + } + suckMotorStopped = true; + } + else if(suckMotorStopped && ((suckLeftStopped && lastRight > MIN_VELOCITY) || (!suckLeftStopped && lastLeft > MIN_VELOCITY))) { + suckMotorStopped = false; + suckMotorRamping = true; + } + } + + //if(dropperDown) bot.dropBack(); + //else bot.raiseBack(); + + if(gamepad1.y) { + bot.setLeftDrive(gamepad1.left_stick_y); + bot.setRightDrive(gamepad1.right_stick_y); + } + else if(robotSlow) { + if(!motorsSet) { + DcMotor[] ray = bot.getMotorRay(); + for(DcMotor motor : ray) motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE); + motorsSet = true; + } + bot.setLeftDrive(gamepad1.left_stick_y * slowFactor); + bot.setRightDrive(gamepad1.right_stick_y * slowFactor); + } + else { + bot.setLeftDrive(gamepad1.left_stick_y * fastFactor); + bot.setRightDrive(gamepad1.right_stick_y * fastFactor); + if(motorsSet) { + DcMotor[] ray = bot.getMotorRay(); + for(DcMotor motor : ray) motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.FLOAT); + motorsSet = false; + } + } + + + bot.getStickBase().setPosition(BotHardware.ServoE.stickBaseHidden); + + telemetry.addData("Back Drop", bot.getDropPos()); + telemetry.addData("Robot Slow", robotSlow); + telemetry.addData("Lift", liftPos); + telemetry.addData("Arm", BotHardware.ServoE.arm.servo.getPosition()); + telemetry.addData("Relic Delta", Math.abs(BotHardware.Motor.relic.motor.getCurrentPosition() - relicPos)); + } + + public void stop() { + bot.stopAll(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/UltraAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/UltraAuto.java new file mode 100644 index 00000000000..3dbdfdf8b04 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017-18/UltraAuto.java @@ -0,0 +1,401 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2018; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.DcMotorEx; +import com.qualcomm.robotcore.hardware.I2cDeviceSynch; +import com.qualcomm.robotcore.util.Range; +import com.vuforia.CameraDevice; +import com.vuforia.Vec2F; + +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder; +import org.firstinspires.ftc.robotcore.external.navigation.AxesReference; +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; +import org.firstinspires.ftc.robotcore.external.navigation.RelicRecoveryVuMark; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.EncoderHoneStep; +import org.firstinspires.ftc.teamcode.libraries.GyroCorrectStep; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.VuforiaBallLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; +import org.firstinspires.ftc.teamcode.libraries.hardware.MatbotixUltra; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; +import org.opencv.core.Mat; + +import java.util.LinkedList; +import java.util.List; + +/** + * Created by Noah on 3/25/2018. + * Attempt at moving the cryptopox position sensor to ultrasonic for speed + * This opmode will work as fast as possible to get more points with multiple glyphs + */ + +@Autonomous(name="Ultra Auto") +@Disabled +public class UltraAuto extends VuforiaBallLib { + //CONSTANTS + private static final float PILLAR_SPACING_INCH = 7.63f; + private static final float ENCODE_PER_CM = 17.1f; + private static final float DRIVE_DUMP_CM = 16.5f; + private static final float ONE_SIDE_PUSH_TIME = 0.25f; + private static final int[] RED_ZERO = new int[] {33 /* the offset from the ultrasonic sensor to the wall when the robot is centered on the balance pad */, + 104 /* the ofsett from the back wall when front of robot is aligned with mat edge off balance pad */}; + private static final int[] BLUE_ZERO = new int[] {20, 80}; + private static final int Y_STUPID_MAX = 120; + private static final int Y_STUPID_MIN = 90; + private static final int Y_STUPID_COUNT = 4; + private static final int X_STUPID_MAX = 60; + private static final float X_ANGLE_MAX = 3.0f; + private static final double BALL_WAIT_SEC = 2.0; + + private final SensorLib.PID encoderHonePID = new SensorLib.PID(3.88f, 9.00f, 0, 50); + private final SensorLib.PID gyroDrivePID = new SensorLib.PID(-64.0f, 0, 0, 0); + private final SensorLib.PID gyroTurnPID = new SensorLib.PID(0.0056f, 0.0063f, 0, 7); + private final SensorLib.PID gyroTurnPIDFast = new SensorLib.PID(0.007f, 0.0063f, 0, 7); + + private enum AutoPath { + RED_FRONT_RIGHT(true, false, RelicRecoveryVuMark.RIGHT, (float)DistanceUnit.INCH.toCm(0), 125), + RED_FRONT_CENTER(true, false, RelicRecoveryVuMark.CENTER, (float)DistanceUnit.INCH.toCm(PILLAR_SPACING_INCH), 125), + RED_FRONT_LEFT(true, false, RelicRecoveryVuMark.LEFT, (float)DistanceUnit.INCH.toCm(2), 55); + + public final RelicRecoveryVuMark vuMark; + public final boolean red; + public final boolean rear; + public final float distanceCM; + public final float turnAmount; + AutoPath(boolean red, boolean rear, RelicRecoveryVuMark mark, float travelCM, float turnAmount) { + this.red = red; + this.rear = rear; + this.vuMark = mark; + this.distanceCM = travelCM; + this.turnAmount = turnAmount; + } + } + + private enum State { + JEWEL, + MEASURE, + BLOCK, + MULTIBLOCK + } + + //ADJUSTABLE VARIBLES + protected boolean red = true; + protected boolean rear = false; + + //DEVICES + private final BotHardware bot = new BotHardware(this); + + private enum UltraPos { + FRONT("ultrafront"), + BACK("ultraback"), + LEFT("ultraleft"), + RIGHT("ultraright"); + + public final String name; + public MatbotixUltra sensor; + + UltraPos(String name) { + this.name = name; + } + + public static void init(OpMode mode) { + for(UltraPos pos : values()) { + pos.sensor = new MatbotixUltra(mode.hardwareMap.get(I2cDeviceSynch.class, pos.name)); + pos.sensor.initDevice(); + pos.sensor.startDevice(); + } + } + + public static MatbotixUltra getXSensor() { + return RIGHT.sensor; + } + + public static MatbotixUltra getYSensor(boolean red, boolean rear) { + if(rear || red) return BACK.sensor; + return FRONT.sensor; + } + } + + //MEMBERS + private AutoLib.LinearSequence mSeq = new AutoLib.LinearSequence(); + private boolean firstRun = false; + private int xOffsetStart; + private int yOffsetStart; + private double startLoop = 0; + private BallColor color = BallColor.Undefined; + private BallColor altColor = BallColor.Undefined; + private State state = State.JEWEL; + + //CODE + public void init() { + bot.init(); + bot.start(); + UltraPos.init(this); + bot.setDropPos(0.62); + //TODO: Ball stuff + initVuforia(true); + startTracking(); + } + + public void init_loop() { + for(UltraPos ultra : UltraPos.values()) telemetry.addData(ultra.name, ultra.sensor.getReading()); + telemetry.addData("Ball Color", getBallColor().toString()); + telemetry.addData("IMU", bot.getHeadingSensor().getHeading()); + } + + public void start() { + + } + + public void loop() { + //detect jewels + if(state == State.JEWEL) { + if(startLoop == 0) startLoop = getRuntime(); + if(getRuntime() - startLoop >= BALL_WAIT_SEC / 2 && !firstRun) CameraDevice.getInstance().setFlashTorchMode(true); + if(getRuntime() - startLoop < BALL_WAIT_SEC && (color == BallColor.Indeterminate || color == BallColor.Undefined)) { + color = getBallColor(); + altColor = getCVBallColor(); + } + else state = State.MEASURE; + } + //drive and measure distances from walls + if(state == State.MEASURE) { + if(!firstRun) { + //initialize starting sequence + CameraDevice.getInstance().setFlashTorchMode(false); + //init whacky stick code here + if(color == BallColor.Indeterminate || color == BallColor.Undefined) color = altColor; + if(color == BallColor.LeftBlue || color == BallColor.LeftRed) { + final AutoLib.Sequence whack = new AutoLib.LinearSequence(); + if(red) whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed, 0.25, false)); + else whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue, 0.25, false)); + whack.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickDown, 0.5, false)); + mSeq.add(whack); + + //hmmmmm + final AutoLib.Step whackLeft; + if(red) whackLeft = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed - BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + else whackLeft = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue - BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + final AutoLib.Step whackRight; + if(red) whackRight = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed + BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + else whackRight = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue + BotHardware.ServoE.stickBaseSwingSize, 0.5, false); + if(color == BallColor.LeftBlue) { + if(red) mSeq.add(whackLeft); + else mSeq.add(whackRight); + } + else { + if(red) mSeq.add(whackRight); + else mSeq.add(whackLeft); + } + + final AutoLib.Sequence whackUp = new AutoLib.LinearSequence(); + whackUp.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickUp, 0.25, false)); + whackUp.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseHidden, 0, false)); + mSeq.add(whackUp); + } + //TODO: Auto path + //drive and measure + mSeq.add(new AutoLib.AzimuthCountedDriveStep(this, 0, bot.getHeadingSensor(), gyroDrivePID, bot.getMotorVelocityShimArray(), + -550, 500, false, -720, -55)); + mSeq.add(new DriveAndMeasureStep(this, 0, bot.getHeadingSensor(), gyroDrivePID, bot.getMotorVelocityShimArray(), + -550, 200, true, -720, -55)); + mSeq.add(new WaitMotorVelocityStep(new DcMotorEx[] {BotHardware.Motor.frontLeft.motor, BotHardware.Motor.frontRight.motor}, 10)); + firstRun = true; + } + if(mSeq.loop()) { + //measure y + final int yZero = red ? RED_ZERO[1] : BLUE_ZERO[1]; + int reading = UltraPos.getYSensor(red, rear).getReading(); + int count = 0; + while ((reading >= Y_STUPID_MAX || reading <= Y_STUPID_MIN) && ++count < Y_STUPID_COUNT) reading = UltraPos.getYSensor(red, rear).getReading(); + if(count >= Y_STUPID_COUNT); //TODO: Failure + yOffsetStart = reading - yZero; + //switch state + state = State.BLOCK; + firstRun = false; + } + } + //execute based on above values + if(state == State.BLOCK) { + if(!firstRun) { + //initialize sequence with found values + AutoPath path = AutoPath.RED_FRONT_RIGHT; + + mSeq = new AutoLib.LinearSequence(); + + final AutoLib.GyroTurnStep turn = new AutoLib.GyroTurnStep(this, path.turnAmount, bot.getHeadingSensor(), bot.getMotorRay(), 0.04f, 0.7f, gyroTurnPID, 2f, 5, true); + mSeq.add(makeDriveToBoxSeq(this, bot, encoderHonePID, + makeGyroDriveStep(0, gyroDrivePID, 100, 55, 720), + turn, + makeGyroDriveStep(path.turnAmount, gyroDrivePID, 500, 55, 720), + new DcMotor[] {BotHardware.Motor.frontLeft.motor, BotHardware.Motor.frontRight.motor}, + /*Math.round(path.distanceCM * ENCODE_PER_CM)*/0, Math.round(DRIVE_DUMP_CM * ENCODE_PER_CM), + 5, 10, xOffsetStart, yOffsetStart)); + mSeq.add(bot.getDropStep()); + final AutoLib.ConcurrentSequence backAndDown = new AutoLib.ConcurrentSequence(); + backAndDown.add(bot.getReverseDropStep()); + backAndDown.add(bot.getLiftLowerStep()); + AutoLib.ConcurrentSequence oneSideSeq = new AutoLib.ConcurrentSequence(); + DcMotor[] temp = bot.getMotorRay(); + if(path.turnAmount > 55) { + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[0], 0.7f, ONE_SIDE_PUSH_TIME, true)); + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[1], 0.7f, ONE_SIDE_PUSH_TIME, true)); + } + else { + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[2], 0.7f, ONE_SIDE_PUSH_TIME, true)); + oneSideSeq.add(new AutoLib.TimedMotorStep(temp[3], 0.7f, ONE_SIDE_PUSH_TIME, true)); + } + backAndDown.add(oneSideSeq); + mSeq.add(backAndDown); + + mSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), -720, 200, true)); + mSeq.add(new AutoLib.GyroTurnStep(this, red ? 90 : -90, bot.getHeadingSensor(), bot.getMotorRay(), 0.04f, 0.7f, gyroTurnPID, 3f, 5, true)); + + firstRun = true; + } + if(mSeq.loop()) { + //multiblock bby + state = State.MULTIBLOCK; + firstRun = false; + } + } + if(state == State.MULTIBLOCK) { + //TODO: this + if(!firstRun) { + + firstRun = true; + } + if(mSeq.loop()) { + requestOpModeStop(); + } + } + telemetry.addData("X Offset", xOffsetStart); + telemetry.addData("Y Offset", yOffsetStart); + telemetry.addData("State", state.name()); + } + + public void stop() { + bot.stopAll(); + } + + private GyroCorrectStep makeGyroDriveStep(float heading, SensorLib.PID pid, float power, float powerMin, float powerMax) { + return new GyroCorrectStep(this, heading, bot.getHeadingSensor(), pid, bot.getMotorVelocityShimArray(), power, powerMin, powerMax); + } + + private static AutoLib.Sequence makeDriveToBoxSeq(OpMode mode, BotHardware bot, + SensorLib.PID errorPid, + GyroCorrectStep firstDriveStep, + AutoLib.GyroTurnStep turnStep, + GyroCorrectStep secondDriveStep, + DcMotor[] encoderMotors, int firstLegCounts, int secondLegCounts, int error, int count, int xOffsett, int yOffsett) { + //step zero: calculate how far the robot must drive according to our x and y offset + //subtract the extra distance needed to be travelled in the second leg from the first leg + final double rad = Math.toRadians(90 - turnStep.getTargetHeading()); + firstLegCounts += Math.round(xOffsett * Math.tan(rad) * ENCODE_PER_CM); + firstLegCounts -= Math.round(yOffsett * ENCODE_PER_CM); + //calculate the 45degree leg delta + secondLegCounts += Math.round(xOffsett / Math.cos(rad) * ENCODE_PER_CM); + //construct sequence + final AutoLib.LinearSequence mSeq = new AutoLib.LinearSequence(); + //drive firstlegcounts + mSeq.add(new EncoderHoneStep(mode, firstLegCounts, error, count, errorPid, firstDriveStep, encoderMotors)); + //turn + mSeq.add(turnStep); + //drive secondlegcounts + AutoLib.ConcurrentSequence liftAndDrive = new AutoLib.ConcurrentSequence(); + liftAndDrive.add(bot.getLiftRaiseStep()); + //liftAndDrive.add(new EncoderHoneStep(mode, -secondLegCounts, error, count, errorPid, secondDriveStep, encoderMotors)); + liftAndDrive.add(new CheapEncoderGyroStep(secondDriveStep, encoderMotors, secondLegCounts - 30)); + mSeq.add(liftAndDrive); + return mSeq; + } + + private static class WaitMotorVelocityStep extends AutoLib.Step { + private final DcMotorEx[] motors; + private final float velThresh; + + WaitMotorVelocityStep(DcMotorEx[] motors, float velThresh) { + this.motors = motors; + this.velThresh = velThresh; + } + + WaitMotorVelocityStep(DcMotorEx motor, float velThresh) { + this.motors = new DcMotorEx[] {motor}; + this.velThresh = velThresh; + } + + public boolean loop() { + super.loop(); + boolean done = true; + for(DcMotorEx motor : motors) done &= Math.abs(motor.getVelocity(AngleUnit.DEGREES)) <= velThresh; + return done; + } + } + + private static class CheapEncoderGyroStep extends AutoLib.Step { + private final GyroCorrectStep gyroStep; + private final int count; + private final DcMotor[] encoders; + private int[] startPos; + + CheapEncoderGyroStep(GyroCorrectStep step, DcMotor[] encoders, int counts) { + this.gyroStep = step; + this.encoders = encoders; + this.count = counts; + } + + public boolean loop() { + super.loop(); + if(firstLoopCall()) { + gyroStep.reset(); + startPos = new int[encoders.length]; + for (int i = 0; i < encoders.length; i++) startPos[i] = encoders[i].getCurrentPosition(); + } + //get the distance delta + int total = 0; + for (int i = 0; i < encoders.length; i++) { + total += encoders[i].getCurrentPosition() - startPos[i]; + //mode.telemetry.addData("Delta " + i, encode[i].getCurrentPosition() - startPos[i]); + } + final float read = count - Math.abs((float)total / encoders.length); + if(read > 0) gyroStep.loop(); + else { + for(DcMotor motor : gyroStep.getMotors()) motor.setPower(0); + return true; + } + return false; + } + + } + + private class DriveAndMeasureStep extends AutoLib.AzimuthCountedDriveStep { + + private List data = new LinkedList<>(); + + DriveAndMeasureStep(OpMode mode, float heading, HeadingSensor gyro, SensorLib.PID pid, + DcMotor motors[], float power, int count, boolean stop, float powerMin, float powerMax) { + super(mode, heading, gyro, pid, motors, power, count, stop, powerMin, powerMax); + } + + @Override + public boolean loop() { + final int reading; + if(super.loop()) { + int max = 0; + for(Integer i : data) if(i < X_STUPID_MAX && i > max) max = i; + final int xZero = red ? RED_ZERO[0] : BLUE_ZERO[0]; + xOffsetStart = max - xZero; + return true; + } + else if(Math.abs(bot.getImu().getAngularOrientation(AxesReference.INTRINSIC, AxesOrder.ZYX, AngleUnit.DEGREES).secondAngle) < X_ANGLE_MAX + && (reading = UltraPos.getXSensor().getReadingNoDelay()) >= 0) + data.add(reading); + return false; + } + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/AutoMotorTest1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/AutoMotorTest1.java new file mode 100644 index 00000000000..5cc166acf3f --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/AutoMotorTest1.java @@ -0,0 +1,110 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +/** + * OpMode to test AutoLib driving of motors by time or encoder counts + * Created by phanau on 12/14/15. + */ + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; + + +/** + * A test example of autonomous opmode programming using AutoLib classes. + * Created by phanau on 12/14/15. + */ + + + +@Autonomous(name="Test: AutoLib Motor Step Test 1", group ="Test") +@Disabled +public class AutoMotorTest1 extends OpMode { + + AutoLib.Sequence mSequence; // the root of the sequence tree + boolean bDone; // true when the programmed sequence is done + boolean bFirst; // true first time loop() is called + + DcMotor mFr, mBr, mFl, mBl; // four drive motors (front right, back right, front left, back left) + DcMotor mIo, mUd; // two arm motors (in-out, up-down) OPTIONAL + + boolean debug = true; // run in test/debug mode with dummy motors and data logging + boolean haveEncoders = false; // robot has Encoder-based motors + + public AutoMotorTest1() { + } + + public void init() { + + AutoLib.HardwareFactory mf = null; + if (debug) + mf = new AutoLib.TestHardwareFactory(this); + else + mf = new AutoLib.RealHardwareFactory(this); + + // get the motors: depending on the factory we created above, these may be + // either dummy motors that just log data or real ones that drive the hardware + mFr = mf.getDcMotor("fr"); + mFl = mf.getDcMotor("fl"); + mBr = mf.getDcMotor("br"); + mBl = mf.getDcMotor("bl"); + + // OPTIONAL arm motors + try { + mIo = mf.getDcMotor("io"); + mUd = mf.getDcMotor("ud"); + } + catch (IllegalArgumentException iax) { + mIo = mUd = null; + } + + mFl.setDirection(DcMotor.Direction.REVERSE); + mBl.setDirection(DcMotor.Direction.REVERSE); + + // create the root Sequence for this autonomous OpMode + mSequence = new AutoLib.LinearSequence(); + + // add a Step (actually, a ConcurrentSequence under the covers) that + // drives all four motors forward at half power for 2 seconds + mSequence.add(new AutoLib.MoveByTimeStep(mFr, mBr, mFl, mBl, 0.5, 2.0, false)); + + // create a second sequence that drives motors at different speeds + // to turn left for 3 seconds, then stop all motors + mSequence.add(new AutoLib.TurnByTimeStep(mFr, mBr, mFl, mBl, 0.5, 0.2, 3.0, true)); + + // raise the arm using encoders while also extending it for 1 second + AutoLib.ConcurrentSequence cs1 = new AutoLib.ConcurrentSequence(); + if (mUd != null && (debug || !haveEncoders)) + cs1.add(new AutoLib.TimedMotorStep(mUd, 0.75, 1.0, true)); // we don't support encoders yet in debug mode + //else + // cs1.add(new AutoLib.EncoderMotorStep(new EncoderMotor(mUd), 0.75, 1000, true)); + if (mIo != null) + cs1.add(new AutoLib.TimedMotorStep(mIo, 0.5, 1.0, true)); + mSequence.add(cs1); + + // start out not-done, first time + bDone = false; + bFirst = true; + } + + public void loop() { + // reset the timer when we start looping + if (bFirst) { + this.resetStartTime(); // OpMode provides a timer + bFirst = false; + } + + // until we're done with the root Sequence, perform the current Step(s) each time through the loop + if (!bDone) { + bDone = mSequence.loop(); // returns true when we're done + + if (debug) + telemetry.addData("elapsed time", this.getRuntime()); + } + } + + public void stop() { + telemetry.addData("stop() called", ""); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAuto.java new file mode 100644 index 00000000000..998b6e9cbf0 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAuto.java @@ -0,0 +1,91 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +/** + * Created by Robotics on 3/7/2017. + */ + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; + +@Autonomous(name="Block Auto (Shoot Balls, Defense)", group="Main") +@Disabled +public class BlockAuto extends OpMode { + + BotHardwareOld robot = new BotHardwareOld(); + + AutoLib.Sequence mShoot; + + boolean bDone = false; + + boolean redColor; + + OpMode modePointer; + + // parameters of the PID controller for this sequence's first part + float Kp = 0.05f; // degree heading proportional term correction per degree of deviation + //float Ki = 0.02f; // ... integrator term + float Ki = 0.00f; + float Kd = 0; // ... derivative term + float KiCutoff = 3.0f; // maximum angle error for which we update integrator + + SensorLib.PID gPid = new SensorLib.PID(Kp, Ki, Kd, KiCutoff); + + public BlockAuto(OpMode mode, boolean isRed){ + modePointer = mode; + redColor = isRed; + } + + @Override + public void init(){ + //init hardware objects + final boolean debug = false; + robot = new BotHardwareOld(); + robot.init(modePointer, debug, true); + robot.setMaxSpeedAll(2500); + + mShoot = new AutoLib.LinearSequence(); + + mShoot.add(new AutoLib.LogTimeStep(modePointer, "Wait", 10.5)); + mShoot.add(new AutoLib.MoveByEncoderStep(robot.getMotorArray(), 0.4f, 1450, true)); + mShoot.add(new AutoLib.LogTimeStep(modePointer, "YAY", 0.5)); + mShoot.add(new AutoLib.EncoderMotorStep(robot.launcherMotor, 1.0f, 1500, true, modePointer)); + mShoot.add(new AutoLib.TimedServoStep(robot.ballServo, 0.6f, 0.8, false)); + mShoot.add(new AutoLib.EncoderMotorStep(robot.launcherMotor, 1.0f, 1500, true, modePointer)); + + int direction; + if(redColor) direction = 25; + else direction = -25; + + //mShoot.add(new AutoLib.GyroTurnStep(modePointer, direction, robot.getNavXHeadingSensor(), robot.getMotorArray(), 0.4f, 3.0f, true)); + mShoot.add(new AutoLib.MoveByEncoderStep(robot.getMotorArray(), 0.5f, 2000, true)); + } + + @Override + public void init_loop(){ + modePointer.telemetry.addData("NavX Connected", robot.navX.isConnected()); + modePointer.telemetry.addData("NavX Ready", robot.startNavX()); + } + + @Override + public void start(){ + robot.navX.zeroYaw(); + } + + @Override + public void loop(){ + // until we're done, keep looping through the current Step(s) + if (!bDone) + bDone = mShoot.loop(); // returns true when we're done + else + modePointer.telemetry.addData("sequence finished", ""); + } + + @Override + public void stop(){ + super.stop(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAutoBlue.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAutoBlue.java new file mode 100644 index 00000000000..7d242129ab9 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAutoBlue.java @@ -0,0 +1,42 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +/** + * Created by Robotics on 3/7/2017. + */ + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Blue Block Auto (Shoot Balls, Defense)", group="Main") +@Disabled +public class BlockAutoBlue extends OpMode { + BotHardwareOld robot = new BotHardwareOld(); + + BlockAuto auto = new BlockAuto(this, false); + + @Override + public void init(){ + auto.init(); + } + + @Override + public void init_loop(){ + auto.init_loop(); + } + + @Override + public void start(){ + auto.start(); + } + + @Override + public void loop(){ + auto.loop(); + } + + @Override + public void stop(){ + auto.stop(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAutoRed.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAutoRed.java new file mode 100644 index 00000000000..035c7595238 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlockAutoRed.java @@ -0,0 +1,43 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +/** + * Created by Robotics on 3/7/2017. + */ + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Red Block Auto (Shoot Balls, Defense)", group="Main") +@Disabled +public class BlockAutoRed extends OpMode { + BotHardwareOld robot = new BotHardwareOld(); + + BlockAuto auto = new BlockAuto(this, true); + + @Override + public void init(){ + auto.init(); + } + + @Override + public void init_loop(){ + auto.init_loop(); + } + + @Override + public void start(){ + auto.start(); + } + + @Override + public void loop(){ + auto.loop(); + } + + @Override + public void stop(){ + auto.stop(); + } +} + diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlueAutoPointer.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlueAutoPointer.java new file mode 100644 index 00000000000..87874700240 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/BlueAutoPointer.java @@ -0,0 +1,74 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Blue Auto (Push Beacons)", group="Main") +@Disabled +public class BlueAutoPointer extends OpMode { + + BotHardwareOld robot = new BotHardwareOld(); + + LineDrive auto = new LineDrive(this, false, false); + + @Override + public void init(){ + auto.init(); + } + + @Override + public void init_loop(){ + auto.init_loop(); + } + + @Override + public void start(){ + auto.start(); + } + + @Override + public void loop(){ + auto.loop(); + } + + @Override + public void stop(){ + auto.stop(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/DayZeroAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/DayZeroAuto.java new file mode 100644 index 00000000000..6e7a25a6c90 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/DayZeroAuto.java @@ -0,0 +1,73 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Old Auto", group="Main") +@Disabled +public class DayZeroAuto extends LinearOpMode { + + BotHardwareOld robot = new BotHardwareOld(); + + @Override + public void runOpMode() { + + robot.init(this, false); + + // launch first ball + robot.launcherMotor.setPower(1.0); + + robot.waitForTick(2000); + + robot.launcherMotor.setPower(0.0); + + // load second ball + //robot.lifterMotor.setPower(-1.0); + + robot.waitForTick(5000); + + //robot.lifterMotor.setPower(0.0); + + // launch second ball + robot.launcherMotor.setPower(1.0); + + robot.waitForTick(2000); + + robot.launcherMotor.setPower(0.0); + + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/GyroDriveTestOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/GyroDriveTestOp.java new file mode 100644 index 00000000000..5b84ad1528f --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/GyroDriveTestOp.java @@ -0,0 +1,145 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.hardware.modernrobotics.ModernRoboticsI2cGyro; +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; + + +/** + * simple example of using a Step that uses gyro input to drive along a given course for a given time + * Created by phanau on 1/3/16 as SensorDriveTestOp, modified 1/22/16 to use Gyro, renamed GyroDriveTestOp 2/16/16. + */ + + +// simple example sequence that tests either of gyro-based AzimuthCountedDriveStep or AzimuthTimedDriveStep to drive along a square path +@Autonomous(name="Test: Gyro Drive Test 1", group ="Test") +@Disabled +public class GyroDriveTestOp extends OpMode { + + AutoLib.Sequence mSequence; // the root of the sequence tree + boolean bDone; // true when the programmed sequence is done + DcMotor mMotors[]; // motors, some of which can be null: assumed order is fr, br, fl, bl + ModernRoboticsI2cGyro mGyro; // gyro to use for heading information + SensorLib.CorrectedMRGyro mCorrGyro; // gyro corrector object + boolean bSetup; // true when we're in "setup mode" where joysticks tweak parameters + SensorLib.PID mPid; // PID controller for the sequence + + // parameters of the PID controller for this sequence + float Kp = 0.035f; // motor power proportional term correction per degree of deviation + float Ki = 0.02f; // ... integrator term + float Kd = 0; // ... derivative term + float KiCutoff = 3.0f; // maximum angle error for which we update integrator + + @Override + public void init() { + bSetup = false; // start out in Kp/Ki setup mode + AutoLib.HardwareFactory mf = null; + final boolean debug = false; + if (debug) + mf = new AutoLib.TestHardwareFactory(this); + else + mf = new AutoLib.RealHardwareFactory(this); + + // get the motors: depending on the factory we created above, these may be + // either dummy motors that just log data or real ones that drive the hardware + // assumed order is fr, br, fl, bl + mMotors = new DcMotor[4]; + mMotors[0] = mf.getDcMotor("fr"); + mMotors[1] = mf.getDcMotor("br"); + (mMotors[2] = mf.getDcMotor("fl")).setDirection(DcMotor.Direction.REVERSE); + (mMotors[3] = mf.getDcMotor("bl")).setDirection(DcMotor.Direction.REVERSE); + + // get hardware gyro + mGyro = (ModernRoboticsI2cGyro) hardwareMap.gyroSensor.get("gyro"); + + // wrap gyro in an object that calibrates it and corrects its output + mCorrGyro = new SensorLib.CorrectedMRGyro(mGyro); + mCorrGyro.calibrate(); + + // create a PID controller for the sequence + mPid = new SensorLib.PID(Kp, Ki, Kd, KiCutoff); // make the object that implements PID control algorithm + + // create an autonomous sequence with the steps to drive + // several legs of a polygonal course --- + float power = 0.25f; + + // create the root Sequence for this autonomous OpMode + mSequence = new AutoLib.LinearSequence(); + + boolean bUseEncoders = true; + if (bUseEncoders) { + // add a bunch of encoder-counted "legs" to the sequence - use Gyro heading convention of positive degrees CCW from initial heading + int leg = 4000; // motor-encoder count along each leg of the polygon + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 180, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 270, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, -90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, -180, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, -270, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, -90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthCountedDriveStep(this, -180, mCorrGyro, mPid, mMotors, power, leg * 4, true)); + } + else { + // add a bunch of timed "legs" to the sequence - use Gyro heading convention of positive degrees CW from initial heading + float leg = debug ? 10.0f : 3.0f; // time along each leg of the polygon + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 180, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 270, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, -90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, -180, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, -270, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, 0, mCorrGyro, mPid, mMotors, power, leg * 2, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, -90, mCorrGyro, mPid, mMotors, power, leg, false)); + mSequence.add(new AutoLib.AzimuthTimedDriveStep(this, -180, mCorrGyro, mPid, mMotors, power, leg * 4, true)); + } + + // start out not-done + bDone = false; + } + + @Override + public void loop() { + + if (gamepad1.y) + bSetup = true; // enter "setup mode" using controller inputs to set Kp and Ki + if (gamepad1.x) + bSetup = false; // exit "setup mode" + + if (bSetup) { // "setup mode" + // adjust PID parameters by joystick inputs + Kp -= (gamepad1.left_stick_y * 0.0001f); + Ki -= (gamepad1.right_stick_y * 0.0001f); + // update the parameters of the PID used by all Steps in this test + mPid.setK(Kp, Ki, Kd, KiCutoff); + // log updated values to the operator's console + telemetry.addData("Kp = ", Kp); + telemetry.addData("Ki = ", Ki); + return; + } + + // until we're done, keep looping through the current Step(s) + if (!bDone) + bDone = mSequence.loop(); // returns true when we're done + else + telemetry.addData("sequence finished", ""); + } + + @Override + public void stop() { + super.stop(); + mCorrGyro.stop(); // release the physical sensor(s) we've been using for azimuth data + } +} + diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/LineDrive.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/LineDrive.java new file mode 100644 index 00000000000..a11a2aa14f0 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/LineDrive.java @@ -0,0 +1,595 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.UltrasonicSensor; +import com.qualcomm.robotcore.util.ElapsedTime; + +import org.firstinspires.ftc.teamcode.libraries.SquirrelyLib; +import org.firstinspires.ftc.teamcode.libraries.interfaces.FunctionCall; +import org.firstinspires.ftc.teamcode.libraries.interfaces.SetPower; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.LineFollowLib; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.firstinspires.ftc.teamcode.libraries.PushyLib; +import org.firstinspires.ftc.teamcode.libraries.interfaces.DisplacementSensor; +import org.firstinspires.ftc.teamcode.libraries.interfaces.FinishSensor; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; +import org.opencv.core.Mat; + +import java.util.ArrayList; + + +//I'm just going to pretend I am proud of this + +@Autonomous(name="Line Drive", group ="Line Follow") +@Disabled +public class LineDrive extends OpenCVLib { + AutoLib.Sequence mSequence; // the root of the sequence tree + AutoLib.Sequence mShoot; + AutoLib.Sequence mDrive; + AutoLib.Sequence mPushy; + AutoLib.Sequence mCharge; + boolean bDone; // true when the programmed sequence is done + BotHardwareOld robot; // robot hardware object + SensorLib.PID mPid; + SensorLib.PID mgPid; // PID controllers for the sequence + SensorLib.PID mdPid; + SensorLib.PID muPid; + SensorLib.PID mGPid; + // parameters of the PID controller for this sequence's first part + float Kp = 0.05f; // degree heading proportional term correction per degree of deviation + //float Ki = 0.02f; // ... integrator term + float Ki = 0.00f; + float Kd = 0; // ... derivative term + float KiCutoff = 3.0f; // maximum angle error for which we update integrator + + // parameters of the PID controller for the heading of the line following + float Kp2 = 0.35f; + float Ki2 = 0.000f; + float Kd2 = 0; + float Ki2Cutoff = 0.0f; + + // parameters of the PID controller for the displacement of the line following + float Kp3 = 5.00f; + float Ki3 = 0.0f; + float Kd3 = 0; + float Ki3Cutoff = 0.00f; + + // parameters of the PID controller for the ultrasonic sensor driving + float Kp4 = 0.025f; + float Ki4 = 0.00f; + float Kd4 = 0; + float Ki4Cutoff = 0.00f; + + //parameters for gyro PID, but cranked up + float Kp5 = 0.1f; // degree heading proportional term correction per degree of deviation + float Ki5 = 0.05f; // ... integrator term + float Kd5 = 0; // ... derivative term + float Ki5Cutoff = 3.0f; // maximum angle error for which we update integrator + + final float ultraDistS1 = 15; + final float ultraDistS2 = 11; + + //constants for pushy pushy + final double pushPos = 1.0; + final double pushyTime = 0.5; + boolean red = false; + final int colorThresh = 200; + final float driveTime = 0.10f; + final int driveLoopCount = 1; + final float pushyPower = 0.2f; + + final int countPerRotation = 280; + + OpMode modePointer = this; + boolean mJustShoot = false; + + AutoLib.Timer mWait = new AutoLib.Timer(20); + + public LineDrive(OpMode mode, boolean redColor, boolean justShoot){ + if(mode != null) modePointer = mode; + red = redColor; + mJustShoot = justShoot; + } + + @Override + public void init() { + //init hardware objects + final boolean debug = false; + robot = new BotHardwareOld(); + robot.init(modePointer, debug, true); + robot.setMaxSpeedAll(2500); + + // create a PID controller for the sequence + mPid = new SensorLib.PID(Kp, Ki, Kd, KiCutoff); + mgPid = new SensorLib.PID(Kp2, Ki2, Kd2, Ki2Cutoff); // make the object that implements PID control algorithm + mdPid = new SensorLib.PID(Kp3, Ki3, Kd3, Ki3Cutoff); + muPid = new SensorLib.PID(Kp4, Ki4, Kd4, Ki4Cutoff); + mGPid = new SensorLib.PID(Kp5, Ki5, Kd5, Ki5Cutoff); + + // create an autonomous sequence with the steps to drive + // several legs of a polygonal course --- + final float power = 0.5f; + initOpenCV(); + startCamera(); + + //start up opencv + + //catch a frame + Mat frame = getCameraFrame(); + + final OpMode thing = modePointer; + + mSequence = new AutoLib.LinearSequence(); + + mShoot = new AutoLib.LinearSequence(); + + mShoot.add(new AutoLib.MoveByEncoderStep(robot.getMotorArray(), 0.4f, 850, true)); + mShoot.add(new AutoLib.LogTimeStep(modePointer, "YAY", 0.5)); + mShoot.add(new AutoLib.EncoderMotorStep(robot.launcherMotor, 1.0f, 1500, true, modePointer)); + mShoot.add(new AutoLib.TimedServoStep(robot.ballServo, 0.6f, 0.8, false)); + mShoot.add(new AutoLib.EncoderMotorStep(robot.launcherMotor, 1.0f, 1500, true, modePointer)); + + mSequence.add(mShoot); + + mDrive = new AutoLib.LinearSequence(); + + mDrive.add(new AutoLib.MoveByEncoderStep(robot.getMotorArray(), 0.2f, 400, true)); + mDrive.add(new AutoLib.LogTimeStep(modePointer, "YAY!", 0.1)); + + int heading; + float turnPower; + + if(red){ + heading = -90; + turnPower = 0.3f; + } + else { + heading = 90; + turnPower = 0.3f; + } + + //mDrive.add(new AutoLib.GyroTurnStep(modePointer, heading, robot.getNavXHeadingSensor(), robot.getMotorArray(), turnPower, 3.0f, true)); + mDrive.add(new AutoLib.LogTimeStep(modePointer, "Yay!", 0.1)); + + mDrive.add(new AutoLib.RunCodeStep(new FunctionCall() { + public void run() { + robot.initMotors(thing, debug, true); + robot.setMaxSpeedAll(2800); + } + })); + + //mDrive.add(new AutoLib.SquirrleyAzimuthTimedDriveStep(modePointer, 0, heading, robot.getNavXHeadingSensor(), mPid, robot.getMotorArray(), 0.4f, 1.0f, false)); + mDrive.add(new SquirrelyLib.SquirrleyAzimuthFinDriveStep(modePointer, 0, heading, robot.getNavXHeadingSensor(), mPid, robot.getMotorArray(), 0.5f, new UltraSensors(robot.distSensorLeft, 70, 2.5), false)); + //if(red) mDrive.add(new UltraSquirrleyAzimuthTimedDriveStep(modePointer, heading, heading, robot.getNavXHeadingSensor(), new UltraCorrectedDisplacement(modePointer, robot.distSensorLeft, 50), mPid, muPid, robot.getMotorArray(), 0.7f, 1.0f, false)); + mDrive.add(new UltraSquirrleyAzimuthFinDriveStep(modePointer, heading, heading, robot.navXHeading, new UltraCorrectedDisplacement(modePointer, robot.distSensorLeft, 16, robot.distSensorRight), mPid, muPid, robot.getMotorArray(), 0.4f, new LineSensors(this, frame, 0.0f), true)); + + mSequence.add(mDrive); + + mPushy = new AutoLib.LinearSequence(); + + //two-stage line follow + + mPushy.add(new AutoLib.RunCodeStep(new FunctionCall() { + public void run() { + robot.initMotors(thing, debug, true); + //robot.setMaxSpeedAll(2500); + } + })); + + + //mPushy.add(new AutoLib.GyroTurnStep(modePointer, 0, new LineSensors(this, frame), robot.getMotorArray(), 0.1f, 0.05f, true, true)); + mPushy.add(new LineFollowLib.LineDriveStep(modePointer, 0, new LineSensors(this, frame), new LineSensors(this, frame), new UltraSensors(robot.distSensorLeft, ultraDistS1, 4.0, robot.distSensorRight), mgPid, mdPid, robot.getMotorArray(), 0.1f, false)); + mPushy.add(new LineFollowLib.LineDriveStep(modePointer, 0, new LineSensors(this, frame), new LineSensors(this, frame), new UltraSensors(robot.distSensorLeft, ultraDistS2, 4.0, robot.distSensorRight), mgPid, mdPid, robot.getMotorArray(), 0.05f, true)); + + /* + mPushy.add(new AutoLib.RunCodeStep(new AutoLib.FunctionCall() { + public void run() { + robot.navX.zeroYaw(); + } + })); + */ + + //pushy pushy + mPushy.add(new PushyLib.pushypushy(modePointer, robot.getMotorArray(), robot.leftSensor, robot.rightSensor, robot.leftServo, robot.rightServo, + pushPos, pushyTime, red, colorThresh, pushyPower, driveTime, driveLoopCount)); + + mPushy.add(new UltraSquirrleyAzimuthFinDriveStep(modePointer, heading, heading, robot.getNavXHeadingSensor(), new UltraCorrectedDisplacement(modePointer, robot.distSensorLeft, 25, robot.distSensorRight), mPid, muPid, robot.getMotorArray(), 0.4f, new LineSensors(this, frame, 3000.0f), true)); + + + mPushy.add(new AutoLib.RunCodeStep(new FunctionCall() { + public void run() { + robot.initMotors(thing, debug, true); + //robot.setMaxSpeedAll(2500); + } + })); + + //mPushy.add(new AutoLib.GyroTurnStep(modePointer, 0, new LineSensors(this, frame), robot.getMotorArray(), 0.1f, 0.5f, true, true)); + mPushy.add(new LineFollowLib.LineDriveStep(modePointer, 0, new LineSensors(this, frame), new LineSensors(this, frame), new UltraSensors(robot.distSensorLeft, ultraDistS1+1, 4.0, robot.distSensorRight), mgPid, mdPid, robot.getMotorArray(), 0.1f, false)); + mPushy.add(new LineFollowLib.LineDriveStep(modePointer, 0, new LineSensors(this, frame), new LineSensors(this, frame), new UltraSensors(robot.distSensorLeft, ultraDistS2+1, 4.0, robot.distSensorRight), mgPid, mdPid, robot.getMotorArray(), 0.05f, true)); + + /* + mPushy.add(new AutoLib.RunCodeStep(new AutoLib.FunctionCall() { + public void run() { + robot.navX.zeroYaw(); + } + })); + */ + + //pushy pushy + mPushy.add(new PushyLib.pushypushy(modePointer, robot.getMotorArray(), robot.leftSensor, robot.rightSensor, robot.leftServo, robot.rightServo, + pushPos, pushyTime, red, colorThresh, pushyPower, driveTime, driveLoopCount)); + + mSequence.add(mPushy); + + mCharge = new AutoLib.LinearSequence(); + + mCharge.add(new AutoLib.RunCodeStep(new FunctionCall() { + public void run() { + robot.initMotors(thing, debug, true); + robot.setMaxSpeedAll(2800); + } + })); + + mCharge.add(new UltraSquirrleyAzimuthFinDriveStep(modePointer, -heading, heading, robot.getNavXHeadingSensor(), new UltraCorrectedDisplacement(modePointer, robot.distSensorLeft, 30), mPid, muPid, robot.getMotorArray(), 1.0f, new TimerFinish(0.5), false)); + mCharge.add(new UltraSquirrleyAzimuthFinDriveStep(modePointer, -heading, heading, robot.getNavXHeadingSensor(), new UltraCorrectedDisplacement(modePointer, robot.distSensorLeft, 130), mPid, muPid, robot.getMotorArray(), 1.0f, new TimerFinish(2.25), true)); + + mSequence.add(mCharge); + // start out not-done + bDone = false; + } + + @Override + public void init_loop(){ + modePointer.telemetry.addData("NavX Connected", robot.navX.isConnected()); + modePointer.telemetry.addData("NavX Ready", robot.startNavX()); + } + + @Override + public void start(){ + robot.navX.zeroYaw(); + if(mJustShoot) mWait.start(); + } + + @Override + public void loop() { + try{ + if(mJustShoot){ + // until we're done, keep looping through the current Step(s) + if (!bDone && mWait.done()) + bDone = mShoot.loop(); // returns true when we're done + else + modePointer.telemetry.addData("sequence finished", ""); + } + else { + // until we're done, keep looping through the current Step(s) + if (!bDone) + bDone = mSequence.loop(); // returns true when we're done + else + modePointer.telemetry.addData("sequence finished", ""); + } + } + catch (Exception e){ + modePointer.telemetry.addData("Exception: ", e.getMessage()); + telemetry.update(); + robot.waitForTick(2000); + //init(); + } + } + + @Override + public void stop() { + super.stop(); + stopCamera(); + } + + static public class LineSensors implements HeadingSensor, DisplacementSensor, FinishSensor { + + OpenCVLib mMode; + int lineCount; + private double lastLinePos; + private double lastLineHeading; + private int yValStore[] = new int[3]; + float mWait; + ElapsedTime mTime; + + final float dispOffset = 0.1f; + + LineSensors(OpenCVLib mode, Mat calib){ + mMode = mode; + yValStore[0] = calib.rows() / 4; + yValStore[1] = calib.rows() / 2; + yValStore[2] = (calib.rows() * 3) / 4; + reset(); + } + + LineSensors(OpenCVLib mode, Mat calib, float wait){ + mMode = mode; + yValStore[0] = calib.rows() / 4; + yValStore[1] = calib.rows() / 2; + yValStore[2] = (calib.rows() * 3) / 4; + reset(); + mWait = wait; + } + + public void reset(){ + lineCount = 0; + lastLinePos = 0; + lastLineHeading = 0; + mWait = 0; + } + + //heading sensor code for line following + public float getHeading() { + Mat frame = mMode.getCameraFrame(); + //get line displacement + double linePos = -LineFollowLib.getAngle(frame, yValStore[0], yValStore[2]); + //if it's an error, turn to where line was last + if (linePos == LineFollowLib.ERROR_TOO_NOISY) { + if (lastLineHeading == 0) return 0.0f; + else if (lastLineHeading > 0) return 50.0f; + else return -50.0f; + } else lastLineHeading = linePos; + + return (float) linePos; + } + + public float getDisp() { + Mat frame = mMode.getCameraFrame(); + double linePos = -LineFollowLib.getDisplacment(frame, yValStore[1]); + //if it's an error, turn to where line was last + if (linePos == LineFollowLib.ERROR_TOO_NOISY) { + if(lastLinePos == 0) return 0.0f; + else if (lastLinePos > 0) return 0.8f; + else return -0.8f; + } else lastLinePos = linePos; + return (float) linePos + dispOffset; + } + + public boolean checkStop() { + if(mWait == 0){ + if (LineFollowLib.getDisplacment(mMode.getCameraFrame(), yValStore[2]) != LineFollowLib.ERROR_TOO_NOISY){ + //lineCount++; + return true; + } + //else lineCount = 0; + //return lineCount >= 3; + return false; + } + else { + if(mTime == null) mTime = new ElapsedTime(); + else if(mTime.milliseconds() > mWait) mWait = 0; + return false; + } + } + } + + public static class UltraSensors implements FinishSensor, DisplacementSensor { + UltrasonicSensor mSensor; + UltrasonicSensor mSensor2; + float mDist; + float mHeading; + double mSeconds; + AutoLib.Timer mTime = null; + + UltraSensors(UltrasonicSensor sensor, float dist, double time) { + mSensor = sensor; + mDist = dist; + mSeconds = time; + } + + UltraSensors(UltrasonicSensor sensor, float dist, double time, UltrasonicSensor sensor2) { + mSensor2 = sensor2; + mSensor = sensor; + mDist = dist; + mSeconds = time; + } + + public boolean checkStop() { + if(mTime == null) { + mTime = new AutoLib.Timer(mSeconds); + mTime.start(); + } + + //get ultrasonic distance + double dist; + if(mSensor2 == null) dist = mSensor.getUltrasonicLevel(); + else dist = (mSensor.getUltrasonicLevel() + mSensor2.getUltrasonicLevel()) / 2.0; + + //cutoff ridiculous values + if (mSensor.getUltrasonicLevel() > 200 || mSensor.getUltrasonicLevel() < 5 || mSensor2.getUltrasonicLevel() > 200 || mSensor2.getUltrasonicLevel() < 5) return false; + //now check if the robot is in range + else return (dist < mDist) || mTime.done(); + } + + public float getDisp(){ + //get ultrasonic level + float dist = (float)mSensor.getUltrasonicLevel(); + + //cutoff ridiculous values + if (dist > 200) return 100.0f - mDist; + if (dist < 5) return 5.0f - mDist; + return dist - mDist; + } + } + + public static class UltraCorrectedDisplacement{ + private final float Kp = 0.3f; + private float mDist; + private UltrasonicSensor mSensor; + private UltrasonicSensor mSensor2; + private OpMode mMode; + + UltraCorrectedDisplacement(OpMode mode, UltrasonicSensor sensor, float dist) { + mMode = mode; + mSensor = sensor; + mDist = dist; + } + + UltraCorrectedDisplacement(OpMode mode, UltrasonicSensor sensor, float dist, UltrasonicSensor sensor2) { + mSensor2 = sensor2; + mMode = mode; + mSensor = sensor; + mDist = dist; + } + + public float getDisp(float angleError){ + float dist; + if(mSensor2 == null) dist = (float)mSensor.getUltrasonicLevel(); + else dist = (float)((mSensor.getUltrasonicLevel() + mSensor2.getUltrasonicLevel()) / 2.0); + + mMode.telemetry.addData("Ultra", dist); + + if(dist > 200) dist = 200; + else if (dist < 5) dist = 5; + + //dist += angleError * Kp; + + return dist - mDist; + } + + } + + static public class TimerFinish implements FinishSensor { + private AutoLib.Timer mTimer; + + TimerFinish(double seconds){ + mTimer = new AutoLib.Timer(seconds); + } + + public boolean checkStop(){ + if(!mTimer.isStarted()) mTimer.start(); + return mTimer.done(); + } + + } + + static public class UltraSquirrleyGuideStep extends AutoLib.Step { + private float mPower; // basic power setting of all 4 motors -- adjusted for steering along path + private float mDirection; // compass heading to steer for (-180 .. +180 degrees + private float mHeading; + private OpMode mOpMode; // needed so we can log output (may be null) + private HeadingSensor mGyro; // sensor to use for heading information (e.g. Gyro or Vuforia) + private UltraCorrectedDisplacement mUltra; + private SensorLib.PID gPid; // proportional–integral–derivative controller (PID controller) + private SensorLib.PID dPid; + private double mPrevTime; // time of previous loop() call + private ArrayList mMotorSteps; // the motor steps we're guiding - assumed order is right ... left ... + + public UltraSquirrleyGuideStep(OpMode mode, float direction, float heading, HeadingSensor gyro, UltraCorrectedDisplacement ultra, SensorLib.PID gpid, + SensorLib.PID dpid, ArrayList motorsteps, float power) { + mOpMode = mode; + mDirection = direction; + mHeading = heading; + mGyro = gyro; + mUltra = ultra; + gPid = gpid; + dPid = dpid; + mMotorSteps = motorsteps; + mPower = power; + } + + public boolean loop() { + super.loop(); + // initialize previous-time on our first call -> dt will be zero on first call + if (firstLoopCall()) { + mPrevTime = mOpMode.getRuntime(); // use timer provided by OpMode + } + + final float heading = mGyro.getHeading(); // get latest reading from direction sensor + // convention is positive angles CCW, wrapping from 359-0 + + final float error = SensorLib.Utils.wrapAngle(heading - mHeading); // deviation from desired heading + // deviations to left are positive, to right are negative + + // compute delta time since last call -- used for integration time of PID step + final double time = mOpMode.getRuntime(); + final double dt = time - mPrevTime; + mPrevTime = time; + + // feed error through PID to get motor power correction value + final float gCorrection = -gPid.loop(error, (float) dt); + + final float dCorrection = -dPid.loop(mUltra.getDisp(error), (float) dt); + + //calculate motor powers for fancy wheels + SquirrelyLib.MotorPowers mp = SquirrelyLib.GetSquirrelyWheelMotorPowers(mDirection); + + final float leftPower = gCorrection; + final float rightPower = -gCorrection; + final float frontPower = -dCorrection; + final float backPower = -dCorrection; + + final float[] motorPowers = {frontPower + rightPower + (float)mp.Front(), + backPower + rightPower + (float)mp.Back(), + frontPower + leftPower + (float)mp.Front(), + backPower + leftPower + (float)mp.Back()}; + + final float scale = AutoLib.scaleMotorFactor(motorPowers); + + //set the powers + mMotorSteps.get(0).setPower(motorPowers[0] * scale * mPower); + mMotorSteps.get(1).setPower(motorPowers[1] * scale * mPower); + mMotorSteps.get(2).setPower(motorPowers[2] * scale * mPower); + mMotorSteps.get(3).setPower(motorPowers[3] * scale * mPower); + + // log some data + if (mOpMode != null) { + mOpMode.telemetry.addData("heading ", heading); + //mOpMode.telemetry.addData("front power ", mp.Front()); + //mOpMode.telemetry.addData("back power ", mp.Back()); + } + + // guidance step always returns "done" so the CS in which it is embedded completes when + // all the motors it's controlling are done + return true; + } + } + + static public class UltraSquirrleyAzimuthTimedDriveStep extends AutoLib.ConcurrentSequence { + + public UltraSquirrleyAzimuthTimedDriveStep(OpMode mode, float direction, float heading, HeadingSensor gyro, UltraCorrectedDisplacement ultra, SensorLib.PID gpid, SensorLib.PID dpid, + DcMotor motors[], float power, float time, boolean stop) { + // add a concurrent Step to control each motor + + ArrayList steps = new ArrayList(); + for (DcMotor em : motors) + if (em != null) { + AutoLib.TimedMotorStep step = new AutoLib.TimedMotorStep(em, 0, time, stop); + this.add(step); + steps.add(step); + } + + // add a concurrent Step to control the motor steps based on gyro input + this.preAdd(new UltraSquirrleyGuideStep(mode, direction, heading, gyro, ultra, gpid, dpid, steps, power)); + } + + // the base class loop function does all we need -- it will return "done" when + // all the motors are done. + } + + static public class UltraSquirrleyAzimuthFinDriveStep extends AutoLib.ConcurrentSequence { + + public UltraSquirrleyAzimuthFinDriveStep(OpMode mode, float direction, float heading, HeadingSensor gyro, UltraCorrectedDisplacement ultra, SensorLib.PID gpid, SensorLib.PID dpid, + DcMotor motors[], float power, FinishSensor fin, boolean stop) { + // add a concurrent Step to control each motor + + ArrayList steps = new ArrayList(); + for (DcMotor em : motors) + if (em != null) { + AutoLib.DriveUntilStopMotorStep step = new AutoLib.DriveUntilStopMotorStep(em, 0, fin, stop); + this.add(step); + steps.add(step); + } + + // add a concurrent Step to control the motor steps based on gyro input + this.preAdd(new UltraSquirrleyGuideStep(mode, direction, heading, gyro, ultra, gpid, dpid, steps, power)); + } + + // the base class loop function does all we need -- it will return "done" when + // all the motors are done. + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/MeccanumVelocityTest.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/MeccanumVelocityTest.java new file mode 100644 index 00000000000..1309b8898eb --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/MeccanumVelocityTest.java @@ -0,0 +1,135 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.PushyLib; + +/** + * This file contains an minimal example of a Linear "OpMode". An OpMode is a 'program' that runs in either + * the autonomous or the teleop period of an FTC match. The names of OpModes appear on the menu + * of the FTC Driver Station. When an selection is made from the menu, the corresponding OpMode + * class is instantiated on the Robot Controller and executed. + * + * This particular OpMode just executes a basic Tank Drive Teleop for a PushBot + * It includes all the skeletal structure that all linear OpModes contain. + * + * Use Android Studios to Copy this Class, and Paste it into your team's code folder with a new name. + * Remove or comment out the @Disabled line to add this opmode to the Driver Station OpMode list + */ + +@Autonomous(name="Blue Auto", group="Main") // @Autonomous(...) is the other common choice +@Disabled +public class MeccanumVelocityTest extends OpMode { + + BotHardwareOld robot = new BotHardwareOld(); + /* Declare OpMode members. */ + + //some constants to make navigating the field easier + static final double mmToEncode = 1; //TODO: Find this value + static final double inchToMm = 25.4; + static final double footToMm = inchToMm * 12; + static final double squareToMm = footToMm * 2; + + final float power = 0.2f; + + //constants for pushy pushy + final double pushPos = 1.0; + final double time = 2.0; + final boolean red = false; + final int colorThresh = 200; + final float driveTime = 0.1f; + final int driveLoopCount = 2; + + final boolean debug = false; + + // parameters of the PID controller for this sequence's first part + final float Kp = 1.0f; // degree heading proportional term correction per degree of deviation + final float Ki = 0.2f; // ... integrator term + final float Kd = 0; // ... derivative term + final float KiCutoff = 1.0f; // maximum angle error for which we update integrator + + SensorLib.PID mdPid = new SensorLib.PID(Kp, Ki, Kd, KiCutoff); + + // create the root Sequence for this autonomous OpMode + AutoLib.Sequence mSequence = new AutoLib.LinearSequence(); + + // start out not-done + boolean bDone = false; + + @Override + public void init(){ + robot.init(this, debug); + + // drive to the first beacon + //mSequence.add(new SquirrleyAzimuthTimedDriveStep(this, -90.0f, robot.getNavXHeadingSensor(), mdPid, robot.getMotorArray(), power, 10000, true)); + //mSequence.add(new SquirrleyAzimuthTimedDriveStep(this, 0, robot.getNavXHeadingSensor(), mdPid, robot.getMotorArray(), power, 5000, true)); + + //line following here + + mSequence.add(new AutoLib.MoveByTimeStep(robot.getMotorArray(), 0.0, 0, true)); + + //pushy pushy + mSequence.add(new PushyLib.pushypushy(this, robot.getMotorArray(), robot.leftSensor, robot.rightSensor, robot.leftServo, robot.rightServo, + pushPos, time, red, colorThresh, power, driveTime, driveLoopCount)); //SO. MANY. VARIABLES. + + telemetry.addData("Status", "Initialized"); + } + + @Override + public void start(){ + robot.startNavX(); + } + + @Override + public void loop(){ + // until we're done, keep looping through the current Step(s) + while (!bDone) { + bDone = mSequence.loop(); // returns true when we're done + telemetry.update(); + } + + telemetry.addData("Sequence finished!", ""); + } + + @Override + public void stop(){ + robot.navX.close(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/OpenCVVuforia.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/OpenCVVuforia.java new file mode 100644 index 00000000000..0452b807ef3 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/OpenCVVuforia.java @@ -0,0 +1,103 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.vuforia.Image; + +import org.firstinspires.ftc.robotcore.external.navigation.VuforiaLocalizer; +import org.firstinspires.ftc.teamcode.libraries.OpenCVLib; +import org.firstinspires.ftc.teamcode.libraries.VuforiaLib_FTC2016; +import org.opencv.android.CameraBridgeViewBase; +import org.opencv.core.Mat; + +import java.nio.ByteBuffer; + +/** + * This OpMode illustrates the basics of using the VuforiaLib_FTC2016 library to determine + * positioning and orientation of robot on the FTC field. + */ + +@Autonomous(name="OpenCV with Vuforia", group ="Test") +@Disabled +public class OpenCVVuforia extends OpenCVLib { + + VuforiaLib_FTC2016 mVLib; + + @Override public void init() { + /** + * Start up Vuforia using VuforiaLib_FTC2016 + */ + mVLib = new VuforiaLib_FTC2016(); + mVLib.init(this, null); // pass it this OpMode (so it can do telemetry output) and use its license key for now + + initOpenCV(); + } + + @Override public void start() + { + /** Start tracking the data sets we care about. */ + mVLib.start(); + } + + @Override public void loop() + { + VuforiaLocalizer.CloseableFrame frame; + mVLib.loop(true); // update location info and do debug telemetry + if(!mVLib.getFrames().isEmpty()){ + frame = mVLib.getFrames().poll(); + + Image img = frame.getImage(0); + + ByteBuffer buf = img.getPixels(); + + //this currently throws an unsupportedOperation exception + byte[] ray = buf.array(); + Mat m = new Mat(); + m.put(0,0,ray); + telemetry.addData("Mat Width:", m.width()); + telemetry.addData("Mat Height:", m.height()); + } + + } + + @Override public void stop() + { + mVLib.stop(); + } + + public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame frame){ + return frame.gray(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/RedAutoPointer.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/RedAutoPointer.java new file mode 100644 index 00000000000..5e1c63c4668 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/RedAutoPointer.java @@ -0,0 +1,74 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Red Auto (Push Beacons)", group="Main") +@Disabled +public class RedAutoPointer extends OpMode { + + BotHardwareOld robot = new BotHardwareOld(); + + LineDrive auto = new LineDrive(this, true, false); + + @Override + public void init(){ + auto.init(); + } + + @Override + public void init_loop(){ + auto.init_loop(); + } + + @Override + public void start(){ + auto.start(); + } + + @Override + public void loop(){ + auto.loop(); + } + + @Override + public void stop(){ + auto.stop(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/RedPilliar.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/RedPilliar.java new file mode 100644 index 00000000000..1329a6cd745 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/RedPilliar.java @@ -0,0 +1,154 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.robotcore.external.navigation.RelicRecoveryVuMark; +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.PilliarLib; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.interfaces.HeadingSensor; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 11/13/2017. + * Testing file for cryptobox pillar detection using camera + */ + +@Autonomous(name="Red Drive", group="test") +@Disabled +public class RedPilliar extends PilliarLib { + private static final double BALL_WAIT_SEC = 2.0;//10.0; + private static final int PILLIAR_COUNT_INC = 350; + private static final int PILLIAR_COUNT_START_BLUE = 40; + private static final int PILLIAR_COUNT_START_RED = 250; + private static final int PEAK_FIND_WINDOW = 40; + private static final int PEAK_FRAME_COUNT = 3; + + protected boolean red = true; + protected boolean justDrive = false; + private BotHardware bot = new BotHardware(this); + + private BallColor color = BallColor.Undefined; + private double startLoop = 0; + private boolean firstLoop = false; + + private AutoLib.Sequence mSeq = new AutoLib.LinearSequence(); + + //parameters for gyro PID, but cranked up + float Kp5 = 3.0f; // degree heading proportional term correction per degree of deviation + float Ki5 = 0.0f; // ... integrator term + float Kd5 = 0; // ... derivative term + float Ki5Cutoff = 0.0f; // maximum angle error for which we update integrator + + SensorLib.PID motorPID = new SensorLib.PID(Kp5, Ki5, Kd5, Ki5Cutoff); + + @Override + public void init() { + initVuforia(true); + bot.init(); + } + + @Override + public void start() { + //hmmm + startTracking(); + } + + @Override + public void loop() { + if(startLoop == 0) startLoop = getRuntime(); + if(getRuntime() - startLoop < BALL_WAIT_SEC && (color == BallColor.Indeterminate || color == BallColor.Undefined)) color = getBallColor(); + else if(!firstLoop){ + //init vars + int count; + if(red) count = PILLIAR_COUNT_START_RED; + else count = PILLIAR_COUNT_START_BLUE; + final int mul = red ? -1 : 1; + //init whacky stick code here + AutoLib.Sequence whack = new AutoLib.LinearSequence(); + //check detection + if(color != BallColor.Indeterminate && color != BallColor.Undefined) { + if(red) whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed, 0.25, false)); + else whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue, 0.25, false)); + whack.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickDown, 0.5, false)); + //hmmmmm + final AutoLib.Step whackLeft; + if(red) whackLeft = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed - BotHardware.ServoE.stickBaseSwingSize, 1.0, false); + else whackLeft = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue - BotHardware.ServoE.stickBaseSwingSize, 1.0, false); + final AutoLib.Step whackRight; + if(red) whackRight = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterRed + BotHardware.ServoE.stickBaseSwingSize, 1.0, false); + else whackRight = new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseCenterBlue + BotHardware.ServoE.stickBaseSwingSize, 1.0, false); + if(color == BallColor.LeftBlue) { + if(red) whack.add(whackLeft); + else whack.add(whackRight); + } + else if(color == BallColor.LeftRed) { + if(red) whack.add(whackRight); + else whack.add(whackLeft); + } + whack.add(new AutoLib.TimedServoStep(bot.getStick(), BotHardware.ServoE.stickUp, 0.25, false)); + whack.add(new AutoLib.TimedServoStep(bot.getStickBase(), BotHardware.ServoE.stickBaseHidden, 0.25, false)); + } + + if(getLastVuMark() != null) { + RelicRecoveryVuMark thing = getLastVuMark(); + //if we're on red it's the far one, else it's the close one + if(thing == RelicRecoveryVuMark.LEFT && red) count += PILLIAR_COUNT_INC * 2; + //if it's center, always increment + if(thing == RelicRecoveryVuMark.CENTER) count += PILLIAR_COUNT_INC; + //if its' on the right and we're on blue, go twice + if(thing == RelicRecoveryVuMark.RIGHT && !red) count += PILLIAR_COUNT_INC * 2; + //telemetry + telemetry.addData("Mark", thing.toString()); + } + + //contruct the block placing seq + AutoLib.LinearSequence blockSeq = new AutoLib.LinearSequence(); + + blockSeq.add( + new AutoLib.RunUntilStopStep( + new AutoLib.MoveByTimeStep(bot.getMotorVelocityShimArray(), 135.0f * mul, 5.0f, true), + new PeakFindStep(PEAK_FIND_WINDOW, PEAK_FRAME_COUNT, red) + ) + ); + blockSeq.add(new AutoLib.GyroTurnStep(this, 0, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 45.0f, 360.0f, motorPID, 0.5f, 10, true)); + blockSeq.add(new PeakHoneStep(bot.getMotorVelocityShimArray(), !red, new SensorLib.PID(-0.15f, -0.05f, 0, 15), 35.0f, 105.0f, 3, this, red)); + + blockSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 135.0f * mul, count, true)); + blockSeq.add(new AutoLib.GyroTurnStep(this, 90, bot.getHeadingSensor(), bot.getMotorVelocityShimArray(), 65.0f, 520.0f, motorPID, 2.0f, 10, true)); + blockSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 135.0f, 100, true)); + blockSeq.add(bot.getDropStep()); + blockSeq.add(new AutoLib.RunUntilStopStep( + new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 135.0f, 400, true), + new AutoLib.LogTimeStep(this, "huh", 2.0) + )); + blockSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), -135.0f, 150, true)); + //blockSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), -135.0f * mul, 100, true)); + //blockSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 270.0f, 1600, true)); + + AutoLib.LinearSequence driveSeq = new AutoLib.LinearSequence(); + + driveSeq.add(new AutoLib.MoveByEncoderStep(bot.getMotorVelocityShimArray(), 135.0 * mul, 1500, true)); + + //smash it all together + mSeq.add(whack); + if(!justDrive) mSeq.add(blockSeq); + else mSeq.add(driveSeq); + + firstLoop = true; + } + + //logs! + if(color != null) telemetry.addData("Ball Color", color.toString()); + if(getLastVuMark() != null) telemetry.addData("VuMark", getLastVuMark().toString()); + + if(firstLoop && mSeq.loop()) requestOpModeStop(); + } + + private class DebugHeading implements HeadingSensor { + public float getHeading() { + return 0; + } + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ScottsTeleOP.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ScottsTeleOP.java new file mode 100644 index 00000000000..c232f813dae --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ScottsTeleOP.java @@ -0,0 +1,52 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; + +import org.firstinspires.ftc.teamcode.libraries.hardware.HardwareRatbot; + +/** + * Created by bremm on 10/6/2017. + */ + +@TeleOp(name="ratbot2017", group="Ratbot") +@Disabled +public class ScottsTeleOP extends OpMode { + + HardwareRatbot robot = new HardwareRatbot(); + + @Override + public void init() { + + robot.init(hardwareMap); + + telemetry.addData("Say", "Hello Driver"); // + } + + @Override + public void init_loop() { + } + + + @Override + public void start() { + } + + + @Override + public void loop() { + double left; + double right; + + left = -gamepad1.left_stick_y; + right = -gamepad1.right_stick_y; + + robot.leftDrive.setPower(left); + robot.rightDrive.setPower(right); + + } + @Override + public void stop() { + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAuto.java new file mode 100644 index 00000000000..e94836cc03e --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAuto.java @@ -0,0 +1,119 @@ +/* +Copyright (c) 2016 Robert Atkinson + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Robert Atkinson nor the names of his contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESSFOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.SensorLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Shoot Auto (Shoot Balls)", group="Main") +@Disabled +public class ShootAuto extends OpMode { + + BotHardwareOld robot = new BotHardwareOld(); + + AutoLib.Sequence mShoot; + + boolean bDone = false; + + boolean redColor; + + OpMode modePointer; + + // parameters of the PID controller for this sequence's first part + float Kp = 0.05f; // degree heading proportional term correction per degree of deviation + //float Ki = 0.02f; // ... integrator term + float Ki = 0.00f; + float Kd = 0; // ... derivative term + float KiCutoff = 3.0f; // maximum angle error for which we update integrator + + SensorLib.PID gPid = new SensorLib.PID(Kp, Ki, Kd, KiCutoff); + + public ShootAuto(OpMode mode, boolean isRed){ + modePointer = mode; + redColor = isRed; + } + + @Override + public void init(){ + //init hardware objects + final boolean debug = false; + robot = new BotHardwareOld(); + robot.init(modePointer, debug, true); + robot.setMaxSpeedAll(2500); + + mShoot = new AutoLib.LinearSequence(); + + mShoot.add(new AutoLib.LogTimeStep(modePointer, "Wait", 15.0)); + mShoot.add(new AutoLib.MoveByEncoderStep(robot.getMotorArray(), 0.4f, 1450, true)); + mShoot.add(new AutoLib.LogTimeStep(modePointer, "YAY", 0.5)); + mShoot.add(new AutoLib.EncoderMotorStep(robot.launcherMotor, 1.0f, 1500, true, modePointer)); + mShoot.add(new AutoLib.TimedServoStep(robot.ballServo, 0.6f, 0.8, false)); + mShoot.add(new AutoLib.EncoderMotorStep(robot.launcherMotor, 1.0f, 1500, true, modePointer)); + + int direction; + if(redColor) direction = -50; + else direction = 50; + + //mShoot.add(new AutoLib.GyroTurnStep(modePointer, direction, robot.getNavXHeadingSensor(), robot.getMotorArray(), 0.4f, 3.0f, true)); + mShoot.add(new AutoLib.MoveByEncoderStep(robot.getMotorArray(), 0.5f, 2750, true)); + } + + @Override + public void init_loop(){ + modePointer.telemetry.addData("NavX Connected", robot.navX.isConnected()); + modePointer.telemetry.addData("NavX Ready", robot.startNavX()); + } + + @Override + public void start(){ + robot.navX.zeroYaw(); + } + + @Override + public void loop(){ + // until we're done, keep looping through the current Step(s) + if (!bDone) + bDone = mShoot.loop(); // returns true when we're done + else + modePointer.telemetry.addData("sequence finished", ""); + } + + @Override + public void stop(){ + super.stop(); + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAutoBlue.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAutoBlue.java new file mode 100644 index 00000000000..e813d03167a --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAutoBlue.java @@ -0,0 +1,42 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +/** + * Created by Robotics on 3/7/2017. + */ + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Blue Shoot Auto (Shoot Balls)", group="Main") +@Disabled +public class ShootAutoBlue extends OpMode { + BotHardwareOld robot = new BotHardwareOld(); + + ShootAuto auto = new ShootAuto(this, false); + + @Override + public void init(){ + auto.init(); + } + + @Override + public void init_loop(){ + auto.init_loop(); + } + + @Override + public void start(){ + auto.start(); + } + + @Override + public void loop(){ + auto.loop(); + } + + @Override + public void stop(){ + auto.stop(); + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAutoRed.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAutoRed.java new file mode 100644 index 00000000000..12fc654e46f --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/ShootAutoRed.java @@ -0,0 +1,42 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +/** + * Created by Robotics on 3/7/2017. + */ + +import com.qualcomm.robotcore.eventloop.opmode.*; + +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardwareOld; + +@Autonomous(name="Red Shoot Auto (Shoot Balls)", group="Main") +@Disabled +public class ShootAutoRed extends OpMode { + BotHardwareOld robot = new BotHardwareOld(); + + ShootAuto auto = new ShootAuto(this, true); + + @Override + public void init(){ + auto.init(); + } + + @Override + public void init_loop(){ + auto.init_loop(); + } + + @Override + public void start(){ + auto.start(); + } + + @Override + public void loop(){ + auto.loop(); + } + + @Override + public void stop(){ + auto.stop(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/SquirrelyDrive1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/SquirrelyDrive1.java new file mode 100644 index 00000000000..afff200a7bf --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/SquirrelyDrive1.java @@ -0,0 +1,190 @@ +/* Copyright (c) 2014 Qualcomm Technologies Inc + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +Neither the name of Qualcomm Technologies Inc nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS +LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.util.Range; + +import org.firstinspires.ftc.teamcode.libraries.SquirrelyLib; + +/** + * TeleOp Mode + *

+ * Enables control of the robot via the gamepad using Squirrely Wheels + */ +@TeleOp(name="Test: SquirrelyDrive1", group="Test") // @Autonomous(...) is the other common choice +@Disabled +public class SquirrelyDrive1 extends OpMode { + + DcMotor motorFrontRight; + DcMotor motorFrontLeft; + DcMotor motorBackRight; + DcMotor motorBackLeft; + + boolean bDebug = false; + + /** + * Constructor + */ + public SquirrelyDrive1() { + + } + + /* + * Code to run when the op mode is first enabled goes here + * + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#start() + */ + @Override + public void init() { + + /* + * Use the hardwareMap to get the dc motors and servos by name. Note + * that the names of the devices must match the names used when you + * configured your robot and created the configuration file. + */ + + /* + * For this test, we assume the following, + * There are four motors + * "fl" and "bl" are front and back left wheels + * "fr" and "br" are front and back right wheels + */ + try { + motorFrontRight = hardwareMap.dcMotor.get("front_right"); + motorFrontLeft = hardwareMap.dcMotor.get("front_left"); + motorBackRight = hardwareMap.dcMotor.get("back_right"); + motorBackLeft = hardwareMap.dcMotor.get("back_left"); + motorFrontRight.setDirection(DcMotor.Direction.REVERSE); + motorBackRight.setDirection(DcMotor.Direction.REVERSE); + } + catch (IllegalArgumentException iax) { + bDebug = true; + } + } + + + /* + * This method will be called repeatedly in a loop + * + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#run() + */ + @Override + public void loop() { + + // turning drive is on the left stick + float tx = gamepad1.left_stick_x; + float ty = -gamepad1.left_stick_y; // y is reversed :( + float left = (ty + tx/2); + float right = (ty - tx/2); + + // clip the right/left values so that the values never exceed +/- 1 + left = Range.clip(left, -1, 1); + right = Range.clip(right, -1, 1); + + // scale the joystick values to make it easier to control + // the robot more precisely at slower speeds. + //left = (float)scaleInput(left); + //right = (float)scaleInput(right); + + // squirrely drive is on the right stick + float x = gamepad1.right_stick_x; + float y = -gamepad1.right_stick_y; // y is reversed :( + + // clip the values so that the values never exceed +/- 1 + x = Range.clip(x, -1, 1); + y = Range.clip(y, -1, 1); + + // direction angle of stick >> the relative direction we want to move + double theta = Math.atan2(-x, y); // stick angle: zero = +y, positive CCW, range +-pi + double heading = theta * 180.0/Math.PI; // radians to degrees + + // compute front and back wheel relative speeds needed to go in desired direction + SquirrelyLib.MotorPowers mp = SquirrelyLib.GetSquirrelyWheelMotorPowers(heading); + double front = mp.Front(); + double back = mp.Back(); + + // power is the magnitude of the stick vector + double power = Math.sqrt(x*x + y*y); + + // scale the values by the desired power + front *= power; + back *= power; + + // combine turning and squirrely drive inputs and + double fr = Range.clip(front+right, -1, 1); + double br = Range.clip(back+right, -1, 1); + double fl = Range.clip(front+left, -1, 1); + double bl = Range.clip(back+left, -1, 1); + + // write the values to the motors + if (!bDebug) { + motorFrontRight.setPower(fr); + motorBackRight.setPower(br); + motorFrontLeft.setPower(fl); + motorBackLeft.setPower(bl); + } + + /* + * Send telemetry data back to driver station. + */ + telemetry.addData("Text", "*** v1.1 ***"); + telemetry.addData("front left/right power:", "%.2f %.2f", fl, fr); + telemetry.addData("back left/right power:", "%.2f %.2f", bl, br); + telemetry.addData("heading:", "%.2f", heading); + telemetry.addData("gamepad1:", gamepad1); + //telemetry.addData("gamepad2", gamepad2); + } + + /* + * Code to run when the op mode is first disabled goes here + * + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#stop() + */ + @Override + public void stop() { + + } + + /* + * This method scales the joystick input so for low joystick values, the + * scaled value is less than linear. This is to make it easier to drive + * the robot more precisely at slower speeds. + */ + double scaleInput(double dVal) { + return dVal*dVal*dVal; // maps {-1,1} -> {-1,1} + } + +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/SquirrelyDriveTestOp.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/SquirrelyDriveTestOp.java new file mode 100644 index 00000000000..1887ea6feac --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/SquirrelyDriveTestOp.java @@ -0,0 +1,99 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.*; +import com.qualcomm.robotcore.hardware.DcMotor; + +import org.firstinspires.ftc.teamcode.libraries.AutoLib; +import org.firstinspires.ftc.teamcode.libraries.SquirrelyLib; + + +/** + * simple example of using a Step that makes a bot with "squirrely wheels" drive along a given course + * Created by phanau on 10/31/16. + */ + + +// simple example sequence that tests either of gyro-based AzimuthCountedDriveStep or AzimuthTimedDriveStep to drive along a square path +@Autonomous(name="Test: Squirrely Drive Test 1", group ="Test") +@Disabled +public class SquirrelyDriveTestOp extends OpMode { + + AutoLib.Sequence mSequence; // the root of the sequence tree + boolean bDone; // true when the programmed sequence is done + DcMotor mMotors[]; // motors, some of which can be null: assumed order is fr, br, fl, bl + + // parameters of the PID controller for this sequence + float Kp = 0.035f; // motor power proportional term correction per degree of deviation + float Ki = 0.02f; // ... integrator term + float Kd = 0; // ... derivative term + float KiCutoff = 3.0f; // maximum angle error for which we update integrator + + @Override + public void init() { + AutoLib.HardwareFactory mf = null; + final boolean debug = false; + if (debug) + mf = new AutoLib.TestHardwareFactory(this); + else + mf = new AutoLib.RealHardwareFactory(this); + + // get the motors: depending on the factory we created above, these may be + // either dummy motors that just log data or real ones that drive the hardware + // assumed order is fr, br, fl, bl + mMotors = new DcMotor[4]; + mMotors[0] = mf.getDcMotor("front_right"); + mMotors[1] = mf.getDcMotor("back_right"); + (mMotors[2] = mf.getDcMotor("front_left")).setDirection(DcMotor.Direction.REVERSE); + (mMotors[3] = mf.getDcMotor("back_left")).setDirection(DcMotor.Direction.REVERSE); + + // create an autonomous sequence with the steps to drive + // several legs of a polygonal course --- + float power = 1.0f; + + // create the root Sequence for this autonomous OpMode + mSequence = new AutoLib.LinearSequence(); + + // add a bunch of timed "legs" to the sequence - use Gyro heading convention of positive degrees CCW from initial heading + float leg = debug ? 6.0f : 3.0f; // time along each leg of the polygon + + // drive a square + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, -90, power, leg/2, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 0, power, leg, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 90, power, leg, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 180, power, leg, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 270, power, leg/2, false)); + + // ... and then a diamond + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, -45, power, leg, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 45, power, leg, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 135, power, leg, false)); + mSequence.add(new SquirrelyLib.MoveSquirrelyByTimeStep(mMotors, 225, power, leg, false)); + + // ... and then sort of a polygonal circle + int n = 20; // number of sides + for (int i=0; i= 0) ? 1 : -1; + + float frontPower = (ySign * x > 0) ? ySign : (ySign * Math.abs(x) * -2 + ySign); + float backPower = (ySign * x < 0) ? ySign : (ySign * Math.abs(x) * -2 + ySign); + + */ + + + int heading = -1; + // run drivetrain motors + // dpad steering + /* + if(gamepad1.dpad_up && gamepad1.dpad_left) { + heading = 45; + //robot.setFrontPower(0.0); + //robot.setBackPower(1.0); + } + else if(gamepad1.dpad_up && gamepad1.dpad_right) { + heading = -45; + //robot.setFrontPower(1.0); + //robot.setBackPower(0.0); + } + else if(gamepad1.dpad_down && gamepad1.dpad_left) { + heading = 135; + //robot.setFrontPower(-1.0); + //robot.setBackPower(0.0); + } + else if(gamepad1.dpad_down && gamepad1.dpad_right) { + heading = -135; + //robot.setFrontPower(0.0); + //robot.setBackPower(-1.0); + } + */ + if(gamepad1.dpad_up) { + heading = 0; + //robot.setFrontPower(1.0); + //robot.setBackPower(1.0); + } + else if(gamepad1.dpad_left) { + heading = 90; + //robot.setFrontPower(-1.0); + //robot.setBackPower(1.0); + } + else if(gamepad1.dpad_right) { + heading = -90; + //robot.setFrontPower(1.0); + //robot.setBackPower(-1.0); + } + else if(gamepad1.dpad_down) { + heading = 180; + //robot.setFrontPower(-1.0); + //robot.setBackPower(-1.0); + } + else { + // joystick tank steering + robot.frontLeftMotor.setPower((-gamepad1.left_stick_y) * powerMult); + robot.frontRightMotor.setPower((-gamepad1.right_stick_y) * powerMult); + robot.backLeftMotor.setPower((-gamepad1.left_stick_y) * powerMult); + robot.backRightMotor.setPower((-gamepad1.right_stick_y) * powerMult); + } + + if(heading != -1){ + //if(!robot.isReversed()) heading = -heading; + SquirrelyLib.MotorPowers mp = SquirrelyLib.GetSquirrelyWheelMotorPowers(heading); + robot.setFrontPower(mp.Front()); + robot.setBackPower(mp.Back()); + } + + // run lifter motor + if(gamepad1.left_trigger > 0.2 || gamepad2.left_trigger > 0.2) { + robot.sweeperMotor.setPower(-1.0); + } + else if(gamepad1.right_trigger > 0.2 || gamepad2.right_trigger > 0.2) { + robot.sweeperMotor.setPower(1.0); + } + else { + robot.sweeperMotor.setPower(0.0); + } + + // run launcher motor + + if(gamepad2.x) { + robot.launcherMotor.setPower(1.0); + } + else { + robot.launcherMotor.setPower(0.0); + } + + if(gamepad2.b) { + robot.ballServo.setPosition(0.6); + } + else { + robot.ballServo.setPosition(0.0); + } + + //halfspeed + if(gamepad1.left_bumper || gamepad1.right_bumper){ + powerMult = 0.5; + } + else { + powerMult = 1.0; + } + + // toggle button pushers + if(!lastBButtonState && gamepad1.b) { + leftPusherState *= -1.0; + rightPusherState *= -1.0; + } + + robot.leftServo.setPosition(leftPusherState); + robot.rightServo.setPosition(rightPusherState); + + lastBButtonState = gamepad1.b; + + //lastLeftBumperState = gamepad1.left_bumper; + //lastRightBumperState = gamepad1.right_bumper; + + //toggle reversed steering + if(!lastAButtonState && gamepad1.a) { + robot.initMotors(this, false, !robot.isReversed()); + if(robot.isReversed()){ + robot.dim.setLED(0, true); + telemetry.addData("Reversed", "True"); + } + else{ + robot.dim.setLED(0, false); + telemetry.addData("Reversed", "False"); + } + } + lastAButtonState = gamepad1.a; + + //some fun telemetery + /* + final double dt = getRuntime() - mLastTime; + final double jerkX = (robot.navX.getWorldLinearAccelX() - mLastAccelX) / dt; + final double jerkY = (robot.navX.getWorldLinearAccelY() - mLastAccelY) / dt; + final double vel = (robot.backLeftMotor.getCurrentPosition() - mLastEncoderCount) / dt; + if(mMaxEncoderCount < vel) mMaxEncoderCount = vel; + mLastEncoderCount = robot.backLeftMotor.getCurrentPosition(); + mLastAccelX = robot.navX.getWorldLinearAccelX(); + mLastAccelY = robot.navX.getWorldLinearAccelY(); + telemetry.addData("X Axis Accel", robot.navX.getWorldLinearAccelX()); + telemetry.addData("Y Axis Accel", robot.navX.getWorldLinearAccelY()); + telemetry.addData("X Axis Jerk", jerkX); + telemetry.addData("Y Axis Jerk", jerkY); + telemetry.addData("Encode per second", vel); + telemetry.addData("Max Encode per second", mMaxEncoderCount); + */ + //} + } + + public static class UltraHeading implements HeadingSensor { + UltrasonicSensor mLeft; + UltrasonicSensor mRight; + + UltraHeading(UltrasonicSensor left, UltrasonicSensor right){ + mLeft = left; + mRight = right; + } + + public float getHeading(){ + return (float)(mRight.getUltrasonicLevel() - mLeft.getUltrasonicLevel()); + } + + } + + private static class JerkCorrect { + OpMode mMode; + SensorLib.PID mPid; + DcMotor mMotor; + AHRS mAccel; + double mThresh; + double mLastEncoderCount = 0; + double mLastTime = 0; + double mLastAccel; + + JerkCorrect(OpMode mode, DcMotor motor, AHRS accel, double thresh, SensorLib.PID pid){ + mMode = mode; + mMotor = motor; + mAccel = accel; + mPid = pid; + mThresh = thresh; + } + + public double loopCorrection(){ + if(mLastEncoderCount == 0){ + mLastEncoderCount = mMotor.getCurrentPosition(); + mLastTime = mMode.getRuntime(); + mLastAccel = mAccel.getRawAccelY(); + } + + //calculate delta time + final double dt = mMode.getRuntime() - mLastTime; + mLastTime = mMode.getRuntime(); + //calculate current velocity + final double vel = (mMotor.getCurrentPosition() - mLastEncoderCount) / dt; + mLastEncoderCount = mMotor.getCurrentPosition(); + //calculate current jerk, negative and y axis due to sensor mounting + final double jerk = -(mAccel.getWorldLinearAccelY() - mLastAccel) / dt; + mLastAccel = mAccel.getWorldLinearAccelY(); + + + //check if jerk is beyond thresh + if(Math.abs(jerk) > mThresh){ + //attempt to correct speed towards actual value if so + //final double error = vel - (mMotor.getMaxSpeed() * mMotor.getPower()); + final double error = vel - mMotor.getPower(); + //and return the correction + return -mPid.loop((float)error, (float)dt); + } + + //else return 0 + return 0; + } + } + + public static float[] getCorrectedSquirrleyMotorPowers(float dt, float mDirection, float mHeading, HeadingSensor mGyro, SensorLib.PID mPid, float mPower) { + final float heading = mGyro.getHeading(); // get latest reading from direction sensor + // convention is positive angles CCW, wrapping from 359-0 + + final float error = SensorLib.Utils.wrapAngle(heading - mHeading); // deviation from desired heading + // deviations to left are positive, to right are negative + + // feed error through PID to get motor power correction value + final float correction = -mPid.loop(error, dt); + + //calculate motor powers for fancy wheels + SquirrelyLib.MotorPowers mp = SquirrelyLib.GetSquirrelyWheelMotorPowers(mDirection); + + final float leftPower = correction; + final float rightPower = -correction; + + //fr, br, fl, bl + final float[] ret = { + (rightPower + (float)mp.Front()) * mPower, + (rightPower + (float)mp.Back()) * mPower, + (leftPower + (float)mp.Front()) * mPower, + (leftPower + (float)mp.Back()) * mPower}; + + return ret; + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/TeleopWithFilter.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/TeleopWithFilter.java new file mode 100644 index 00000000000..a4a49beb136 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/old2017/TeleopWithFilter.java @@ -0,0 +1,55 @@ +package org.firstinspires.ftc.teamcode.opmodes.old2017; + +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; + +import org.firstinspires.ftc.teamcode.libraries.FilterLib; +import org.firstinspires.ftc.teamcode.libraries.hardware.BotHardware; + +/** + * Created by Noah on 10/27/2017. + * Teleop! + */ + +@TeleOp(name="Teleop with Filter") +@Disabled +public class TeleopWithFilter extends OpMode { + BotHardware bot = new BotHardware(this); + FilterLib.MovingWindowFilter leftStick; + FilterLib.MovingWindowFilter rightStick; + + private int SIZE = 10; + + private boolean pressedUp = false; + private boolean pressedDown = false; + + public void init() { + bot.init(); + } + + public void init_loop() { + if(!pressedUp && gamepad1.dpad_up) SIZE++; + if(!pressedDown && gamepad1.dpad_down) SIZE--; + pressedUp = gamepad1.dpad_up; + pressedDown = gamepad1.dpad_down; + telemetry.addData("SIZE", SIZE); + } + + public void start() { + leftStick = new FilterLib.MovingWindowFilter(SIZE); + rightStick = new FilterLib.MovingWindowAngleFilter(SIZE); + } + + public void loop() { + //leftStick.appendValue(gamepad1.left_stick_y); + //rightStick.appendValue(gamepad1.right_stick_y); + + bot.setLeftDrive(gamepad1.left_stick_y * 0.5); + bot.setRightDrive(gamepad1.right_stick_y * 0.5); + } + + public void stop() { + bot.stopAll(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BlueJustDrive.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BlueJustDrive.java new file mode 100644 index 00000000000..4cc2053491b --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BlueJustDrive.java @@ -0,0 +1,20 @@ +package org.firstinspires.ftc.teamcode.opmodes.pointer; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.opmodes.old2017.RedPilliar; + +/** + * Created by Noah on 12/15/2017. + */ + +@Autonomous(name="Blue No Block", group="test") +@Disabled +public class BlueJustDrive extends RedPilliar { + public void init() { + this.red = false; + this.justDrive = true; + super.init(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BluePilliar.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BluePilliar.java new file mode 100644 index 00000000000..29d48e571f7 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BluePilliar.java @@ -0,0 +1,19 @@ +package org.firstinspires.ftc.teamcode.opmodes.pointer; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.opmodes.old2017.RedPilliar; + +/** + * Created by Noah on 12/2/2017. + */ + +@Autonomous(name="Blue Drive", group="test") +@Disabled +public class BluePilliar extends RedPilliar { + public void init() { + this.red = false; + super.init(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BlueRearAPDSAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BlueRearAPDSAuto.java new file mode 100644 index 00000000000..59f00fab757 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/BlueRearAPDSAuto.java @@ -0,0 +1,18 @@ +/* package org.firstinspires.ftc.teamcode.opmodes.pointer; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; + +import org.firstinspires.ftc.teamcode.opmodes.old2018.ADPSAuto; + +* + * Created by Noah on 12/31/2017. + + +@Autonomous(name="Blue Rear Auto", group="test") +public class BlueRearAPDSAuto extends ADPSAuto { + @Override + public void init() { + red = false; + rear = true; + super.init(); + } +} */ \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedAPDSAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedAPDSAuto.java new file mode 100644 index 00000000000..647d849299d --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedAPDSAuto.java @@ -0,0 +1,18 @@ +package org.firstinspires.ftc.teamcode.opmodes.pointer; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; + +import org.firstinspires.ftc.teamcode.opmodes.old2018.ADPSAuto; + +/** + * Created by Noah on 12/31/2017. + */ + +@Autonomous(name="Red Front Auto", group="test") +public class RedAPDSAuto extends ADPSAuto { + @Override + public void init() { + red = true; + super.init(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedBallDrive.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedBallDrive.java new file mode 100644 index 00000000000..6fa35a14b2c --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedBallDrive.java @@ -0,0 +1,20 @@ +package org.firstinspires.ftc.teamcode.opmodes.pointer; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; + +import org.firstinspires.ftc.teamcode.opmodes.old2017.RedPilliar; + +/** + * Created by Noah on 12/15/2017. + */ + +@Autonomous(name="Red No Block", group="test") +@Disabled +public class RedBallDrive extends RedPilliar { + public void init(){ + this.justDrive = true; + this.red = true; + super.init(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedRearAPDSAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedRearAPDSAuto.java new file mode 100644 index 00000000000..d3c250ae97b --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/RedRearAPDSAuto.java @@ -0,0 +1,18 @@ +package org.firstinspires.ftc.teamcode.opmodes.pointer; +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; + +import org.firstinspires.ftc.teamcode.opmodes.old2018.ADPSAuto; + +/** + * Created by Noah on 12/31/2017. + */ + +@Autonomous(name="Red Rear Auto", group="test") +public class RedRearAPDSAuto extends ADPSAuto { + @Override + public void init() { + red = true; + rear = true; + super.init(); + } +} \ No newline at end of file diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/VuMarkAutoBlue.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/VuMarkAutoBlue.java new file mode 100644 index 00000000000..64d10606f3b --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/pointer/VuMarkAutoBlue.java @@ -0,0 +1,21 @@ +package org.firstinspires.ftc.teamcode.opmodes.pointer; + +import com.qualcomm.robotcore.eventloop.opmode.Autonomous; +import com.qualcomm.robotcore.eventloop.opmode.Disabled; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; + +import org.firstinspires.ftc.teamcode.opmodes.demo.VumarkHiJackVideo; + +/** + * Created by Noah on 11/3/2017. + */ + +@Autonomous(name="Blue Auto", group ="Auto") +@Disabled +public class VuMarkAutoBlue extends VumarkHiJackVideo { + @Override + public void init() { + this.RED = false; + super.init(); + } +} diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/profiling/FastAsPossible.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/profiling/FastAsPossible.java new file mode 100644 index 00000000000..4dcb3c1b867 --- /dev/null +++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/opmodes/profiling/FastAsPossible.java @@ -0,0 +1,153 @@ +package org.firstinspires.ftc.teamcode.opmodes.profiling; + +import android.content.Context; +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; + +import com.qualcomm.hardware.lynx.LynxModule; +import com.qualcomm.hardware.lynx.commands.core.LynxGetBulkInputDataCommand; +import com.qualcomm.hardware.lynx.commands.core.LynxGetBulkInputDataResponse; +import com.qualcomm.robotcore.eventloop.opmode.TeleOp; +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotorEx; + +import org.firstinspires.ftc.robotcore.external.Func; +import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit; +import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit; +import org.opencv.core.Mat; + +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; + +/** + * Created by Noah on 4/25/2018. + * Designed for a ratbot using neverest 3.7s + * drives forward as fast as possible without slipping the wheels + * Direction of accel: + * + * *----* + * | ^ | + * | Y | X > + * | | + * *----* + */ + +@TeleOp(name = "Fast as Possible") +public class FastAsPossible extends OpMode implements SensorEventListener { + private static final double WHEEL_CIRCUMFRENCE_M = DistanceUnit.INCH.toCm(2.875) / 100.0 * Math.PI; + private static final double Ka = 0.00001; + + private DcMotorEx leftMotor; + private DcMotorEx rightMotor; + private LynxModule module; + private SensorManager man; + + private float[] lastVal; + + private double lastLeftPos; + private double lastRightPos; + private double lastLeftVel; + private double lastRightVel; + private double lastRuntime; + + public void init() { + leftMotor = hardwareMap.get(DcMotorEx.class, "l"); + rightMotor = hardwareMap.get(DcMotorEx.class, "r"); + module = hardwareMap.get(LynxModule.class, "m"); + + man = (SensorManager)hardwareMap.appContext.getSystemService(Context.SENSOR_SERVICE); + final Sensor accel = man.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); + man.registerListener(this, accel, 1000); + + /* + telemetry.addLine().addData("Accel", new Func() { + @Override public String value() { + final float[] ray = new float[3]; + for(float[] val : lastVal) { + ray[0] += val[0]; + ray[1] += val[1]; + ray[2] += val[2]; + } + ray[0] /= (float)lastVal.size(); + ray[1] /= (float)lastVal.size(); + ray[2] /= (float)lastVal.size(); + lastVal.clear(); + return Arrays.toString(ray); + } + }); + */ + } + + public void init_loop() { + + } + + public void start() { + + } + + public void loop() { + try{ + LynxGetBulkInputDataCommand command = new LynxGetBulkInputDataCommand(module); + LynxGetBulkInputDataResponse resp = command.sendReceive(); + final double leftPos = resp.getEncoder(1); + final double rightPos = resp.getEncoder(0); + final double runtime = getRuntime(); + final double phoneAccel = getAverageAccel(); + final double delta = runtime - lastRuntime; + final double leftVel = resp.getVelocity(1); + final double rightVel = resp.getVelocity(0); + final double leftAccel = (leftVel - lastLeftVel) / delta * WHEEL_CIRCUMFRENCE_M; + final double rightAccel = (rightVel - lastRightVel) / delta * WHEEL_CIRCUMFRENCE_M; + //apply kA term to joystick + if(gamepad1.left_stick_y > 0) leftMotor.setPower(-gamepad1.left_stick_y - Ka * (phoneAccel - leftAccel)); + if(gamepad1.right_stick_y > 0) rightMotor.setPower(-gamepad1.right_stick_y - Ka * (phoneAccel - rightAccel)); + //set + lastRuntime = runtime; + lastLeftPos = leftPos; + lastRightPos = rightPos; + lastLeftVel = leftVel; + lastRightVel = rightVel; + //logs + telemetry.addData("Pos Left", leftPos); + telemetry.addData("Pos Right", rightPos); + telemetry.addData("Vel Left", leftVel); + telemetry.addData("Vel Right", rightVel); + telemetry.addData("Phone Accel", phoneAccel); + telemetry.addData("Left Accel", leftAccel); + telemetry.addData("Right Accel", rightAccel); + + } + catch (Exception e) { + /* hmmmm */ + } + + + + + } + + public void stop() { + leftMotor.setPower(0); + rightMotor.setPower(0); + man.unregisterListener(this); + } + + @Override + public void onSensorChanged(SensorEvent sensorEvent) { + lastVal = sensorEvent.values; + } + + @Override + public void onAccuracyChanged(Sensor sensor, int i) { + + } + + private double getAverageAccel() { + //return lastVal[2] * 9.80665; + return lastVal[2]; + } +} diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 00000000000..d72861d28d9 --- /dev/null +++ b/gradle.properties @@ -0,0 +1 @@ +android.useDeprecatedNdk=true \ No newline at end of file diff --git a/import-summary.txt b/import-summary.txt new file mode 100644 index 00000000000..0fc96693a31 --- /dev/null +++ b/import-summary.txt @@ -0,0 +1,244 @@ +ECLIPSE ANDROID PROJECT IMPORT SUMMARY +====================================== + +Ignored Files: +-------------- +The following files were *not* copied into the new Gradle project; you +should evaluate whether these are still needed in your project and if +so manually move them: + +* javadoc\ +* javadoc\allclasses-frame.html +* javadoc\allclasses-noframe.html +* javadoc\constant-values.html +* javadoc\help-doc.html +* javadoc\index-all.html +* javadoc\index.html +* javadoc\org\ +* javadoc\org\opencv\ +* javadoc\org\opencv\android\ +* javadoc\org\opencv\android\BaseLoaderCallback.html +* javadoc\org\opencv\android\CameraBridgeViewBase.CvCameraViewFrame.html +* javadoc\org\opencv\android\CameraBridgeViewBase.CvCameraViewListener.html +* javadoc\org\opencv\android\CameraBridgeViewBase.CvCameraViewListener2.html +* javadoc\org\opencv\android\CameraBridgeViewBase.ListItemAccessor.html +* javadoc\org\opencv\android\CameraBridgeViewBase.html +* javadoc\org\opencv\android\FpsMeter.html +* javadoc\org\opencv\android\InstallCallbackInterface.html +* javadoc\org\opencv\android\JavaCameraView.JavaCameraSizeAccessor.html +* javadoc\org\opencv\android\JavaCameraView.html +* javadoc\org\opencv\android\LoaderCallbackInterface.html +* javadoc\org\opencv\android\OpenCVLoader.html +* javadoc\org\opencv\android\Utils.html +* javadoc\org\opencv\android\package-frame.html +* javadoc\org\opencv\android\package-summary.html +* javadoc\org\opencv\android\package-tree.html +* javadoc\org\opencv\calib3d\ +* javadoc\org\opencv\calib3d\Calib3d.html +* javadoc\org\opencv\calib3d\StereoBM.html +* javadoc\org\opencv\calib3d\StereoMatcher.html +* javadoc\org\opencv\calib3d\StereoSGBM.html +* javadoc\org\opencv\calib3d\package-frame.html +* javadoc\org\opencv\calib3d\package-summary.html +* javadoc\org\opencv\calib3d\package-tree.html +* javadoc\org\opencv\core\ +* javadoc\org\opencv\core\Algorithm.html +* javadoc\org\opencv\core\Core.MinMaxLocResult.html +* javadoc\org\opencv\core\Core.html +* javadoc\org\opencv\core\CvException.html +* javadoc\org\opencv\core\CvType.html +* javadoc\org\opencv\core\DMatch.html +* javadoc\org\opencv\core\KeyPoint.html +* javadoc\org\opencv\core\Mat.html +* javadoc\org\opencv\core\MatOfByte.html +* javadoc\org\opencv\core\MatOfDMatch.html +* javadoc\org\opencv\core\MatOfDouble.html +* javadoc\org\opencv\core\MatOfFloat.html +* javadoc\org\opencv\core\MatOfFloat4.html +* javadoc\org\opencv\core\MatOfFloat6.html +* javadoc\org\opencv\core\MatOfInt.html +* javadoc\org\opencv\core\MatOfInt4.html +* javadoc\org\opencv\core\MatOfKeyPoint.html +* javadoc\org\opencv\core\MatOfPoint.html +* javadoc\org\opencv\core\MatOfPoint2f.html +* javadoc\org\opencv\core\MatOfPoint3.html +* javadoc\org\opencv\core\MatOfPoint3f.html +* javadoc\org\opencv\core\MatOfRect.html +* javadoc\org\opencv\core\MatOfRect2d.html +* javadoc\org\opencv\core\Point.html +* javadoc\org\opencv\core\Point3.html +* javadoc\org\opencv\core\Range.html +* javadoc\org\opencv\core\Rect.html +* javadoc\org\opencv\core\Rect2d.html +* javadoc\org\opencv\core\RotatedRect.html +* javadoc\org\opencv\core\Scalar.html +* javadoc\org\opencv\core\Size.html +* javadoc\org\opencv\core\TermCriteria.html +* javadoc\org\opencv\core\TickMeter.html +* javadoc\org\opencv\core\package-frame.html +* javadoc\org\opencv\core\package-summary.html +* javadoc\org\opencv\core\package-tree.html +* javadoc\org\opencv\dnn\ +* javadoc\org\opencv\dnn\DictValue.html +* javadoc\org\opencv\dnn\Dnn.html +* javadoc\org\opencv\dnn\Importer.html +* javadoc\org\opencv\dnn\Layer.html +* javadoc\org\opencv\dnn\Net.html +* javadoc\org\opencv\dnn\package-frame.html +* javadoc\org\opencv\dnn\package-summary.html +* javadoc\org\opencv\dnn\package-tree.html +* javadoc\org\opencv\engine\ +* javadoc\org\opencv\engine\package-frame.html +* javadoc\org\opencv\engine\package-summary.html +* javadoc\org\opencv\engine\package-tree.html +* javadoc\org\opencv\features2d\ +* javadoc\org\opencv\features2d\AKAZE.html +* javadoc\org\opencv\features2d\AgastFeatureDetector.html +* javadoc\org\opencv\features2d\BFMatcher.html +* javadoc\org\opencv\features2d\BOWImgDescriptorExtractor.html +* javadoc\org\opencv\features2d\BOWKMeansTrainer.html +* javadoc\org\opencv\features2d\BOWTrainer.html +* javadoc\org\opencv\features2d\BRISK.html +* javadoc\org\opencv\features2d\DescriptorExtractor.html +* javadoc\org\opencv\features2d\DescriptorMatcher.html +* javadoc\org\opencv\features2d\FastFeatureDetector.html +* javadoc\org\opencv\features2d\Feature2D.html +* javadoc\org\opencv\features2d\FeatureDetector.html +* javadoc\org\opencv\features2d\Features2d.html +* javadoc\org\opencv\features2d\FlannBasedMatcher.html +* javadoc\org\opencv\features2d\GFTTDetector.html +* javadoc\org\opencv\features2d\KAZE.html +* javadoc\org\opencv\features2d\MSER.html +* javadoc\org\opencv\features2d\ORB.html +* javadoc\org\opencv\features2d\Params.html +* javadoc\org\opencv\features2d\package-frame.html +* javadoc\org\opencv\features2d\package-summary.html +* javadoc\org\opencv\features2d\package-tree.html +* javadoc\org\opencv\imgcodecs\ +* javadoc\org\opencv\imgcodecs\Imgcodecs.html +* javadoc\org\opencv\imgcodecs\package-frame.html +* javadoc\org\opencv\imgcodecs\package-summary.html +* javadoc\org\opencv\imgcodecs\package-tree.html +* javadoc\org\opencv\imgproc\ +* javadoc\org\opencv\imgproc\CLAHE.html +* javadoc\org\opencv\imgproc\Imgproc.html +* javadoc\org\opencv\imgproc\LineSegmentDetector.html +* javadoc\org\opencv\imgproc\Moments.html +* javadoc\org\opencv\imgproc\Subdiv2D.html +* javadoc\org\opencv\imgproc\package-frame.html +* javadoc\org\opencv\imgproc\package-summary.html +* javadoc\org\opencv\imgproc\package-tree.html +* javadoc\org\opencv\ml\ +* javadoc\org\opencv\ml\ANN_MLP.html +* javadoc\org\opencv\ml\Boost.html +* javadoc\org\opencv\ml\DTrees.html +* javadoc\org\opencv\ml\EM.html +* javadoc\org\opencv\ml\KNearest.html +* javadoc\org\opencv\ml\LogisticRegression.html +* javadoc\org\opencv\ml\Ml.html +* javadoc\org\opencv\ml\NormalBayesClassifier.html +* javadoc\org\opencv\ml\ParamGrid.html +* javadoc\org\opencv\ml\RTrees.html +* javadoc\org\opencv\ml\SVM.html +* javadoc\org\opencv\ml\SVMSGD.html +* javadoc\org\opencv\ml\StatModel.html +* javadoc\org\opencv\ml\TrainData.html +* javadoc\org\opencv\ml\package-frame.html +* javadoc\org\opencv\ml\package-summary.html +* javadoc\org\opencv\ml\package-tree.html +* javadoc\org\opencv\objdetect\ +* javadoc\org\opencv\objdetect\BaseCascadeClassifier.html +* javadoc\org\opencv\objdetect\CascadeClassifier.html +* javadoc\org\opencv\objdetect\HOGDescriptor.html +* javadoc\org\opencv\objdetect\Objdetect.html +* javadoc\org\opencv\objdetect\package-frame.html +* javadoc\org\opencv\objdetect\package-summary.html +* javadoc\org\opencv\objdetect\package-tree.html +* javadoc\org\opencv\osgi\ +* javadoc\org\opencv\osgi\OpenCVInterface.html +* javadoc\org\opencv\osgi\OpenCVNativeLoader.html +* javadoc\org\opencv\osgi\package-frame.html +* javadoc\org\opencv\osgi\package-summary.html +* javadoc\org\opencv\osgi\package-tree.html +* javadoc\org\opencv\photo\ +* javadoc\org\opencv\photo\AlignExposures.html +* javadoc\org\opencv\photo\AlignMTB.html +* javadoc\org\opencv\photo\CalibrateCRF.html +* javadoc\org\opencv\photo\CalibrateDebevec.html +* javadoc\org\opencv\photo\CalibrateRobertson.html +* javadoc\org\opencv\photo\MergeDebevec.html +* javadoc\org\opencv\photo\MergeExposures.html +* javadoc\org\opencv\photo\MergeMertens.html +* javadoc\org\opencv\photo\MergeRobertson.html +* javadoc\org\opencv\photo\Photo.html +* javadoc\org\opencv\photo\Tonemap.html +* javadoc\org\opencv\photo\TonemapDrago.html +* javadoc\org\opencv\photo\TonemapDurand.html +* javadoc\org\opencv\photo\TonemapMantiuk.html +* javadoc\org\opencv\photo\TonemapReinhard.html +* javadoc\org\opencv\photo\package-frame.html +* javadoc\org\opencv\photo\package-summary.html +* javadoc\org\opencv\photo\package-tree.html +* javadoc\org\opencv\utils\ +* javadoc\org\opencv\utils\Converters.html +* javadoc\org\opencv\utils\package-frame.html +* javadoc\org\opencv\utils\package-summary.html +* javadoc\org\opencv\utils\package-tree.html +* javadoc\org\opencv\video\ +* javadoc\org\opencv\video\BackgroundSubtractor.html +* javadoc\org\opencv\video\BackgroundSubtractorKNN.html +* javadoc\org\opencv\video\BackgroundSubtractorMOG2.html +* javadoc\org\opencv\video\DenseOpticalFlow.html +* javadoc\org\opencv\video\DualTVL1OpticalFlow.html +* javadoc\org\opencv\video\FarnebackOpticalFlow.html +* javadoc\org\opencv\video\KalmanFilter.html +* javadoc\org\opencv\video\SparseOpticalFlow.html +* javadoc\org\opencv\video\SparsePyrLKOpticalFlow.html +* javadoc\org\opencv\video\Video.html +* javadoc\org\opencv\video\package-frame.html +* javadoc\org\opencv\video\package-summary.html +* javadoc\org\opencv\video\package-tree.html +* javadoc\org\opencv\videoio\ +* javadoc\org\opencv\videoio\VideoCapture.html +* javadoc\org\opencv\videoio\VideoWriter.html +* javadoc\org\opencv\videoio\Videoio.html +* javadoc\org\opencv\videoio\package-frame.html +* javadoc\org\opencv\videoio\package-summary.html +* javadoc\org\opencv\videoio\package-tree.html +* javadoc\overview-frame.html +* javadoc\overview-summary.html +* javadoc\overview-tree.html +* javadoc\package-list +* javadoc\resources\ +* javadoc\resources\background.gif +* javadoc\resources\tab.gif +* javadoc\resources\titlebar.gif +* javadoc\resources\titlebar_end.gif +* javadoc\serialized-form.html +* javadoc\stylesheet.css + +Moved Files: +------------ +Android Gradle projects use a different directory structure than ADT +Eclipse projects. Here's how the projects were restructured: + +* AndroidManifest.xml => openCVLibrary330\src\main\AndroidManifest.xml +* lint.xml => openCVLibrary330\lint.xml +* res\ => openCVLibrary330\src\main\res\ +* src\ => openCVLibrary330\src\main\java\ +* src\org\opencv\engine\OpenCVEngineInterface.aidl => openCVLibrary330\src\main\aidl\org\opencv\engine\OpenCVEngineInterface.aidl + +Next Steps: +----------- +You can now build the project. The Gradle project needs network +connectivity to download dependencies. + +Bugs: +----- +If for some reason your project does not build, and you determine that +it is due to a bug or limitation of the Eclipse to Gradle importer, +please file a bug at http://b.android.com with category +Component-Tools. + +(This import summary is for your information only, and can be deleted +after import once you are satisfied with the results.) diff --git a/libs/armeabi-v7a/libopencv_calib3d.a b/libs/armeabi-v7a/libopencv_calib3d.a new file mode 100644 index 00000000000..1f06a50bbb1 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_calib3d.a differ diff --git a/libs/armeabi-v7a/libopencv_core.a b/libs/armeabi-v7a/libopencv_core.a new file mode 100644 index 00000000000..2801ee08484 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_core.a differ diff --git a/libs/armeabi-v7a/libopencv_dnn.a b/libs/armeabi-v7a/libopencv_dnn.a new file mode 100644 index 00000000000..358e8fd3ed9 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_dnn.a differ diff --git a/libs/armeabi-v7a/libopencv_features2d.a b/libs/armeabi-v7a/libopencv_features2d.a new file mode 100644 index 00000000000..01ed76acfbe Binary files /dev/null and b/libs/armeabi-v7a/libopencv_features2d.a differ diff --git a/libs/armeabi-v7a/libopencv_flann.a b/libs/armeabi-v7a/libopencv_flann.a new file mode 100644 index 00000000000..612ef1da799 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_flann.a differ diff --git a/libs/armeabi-v7a/libopencv_highgui.a b/libs/armeabi-v7a/libopencv_highgui.a new file mode 100644 index 00000000000..b5a9710fc0c Binary files /dev/null and b/libs/armeabi-v7a/libopencv_highgui.a differ diff --git a/libs/armeabi-v7a/libopencv_imgcodecs.a b/libs/armeabi-v7a/libopencv_imgcodecs.a new file mode 100644 index 00000000000..e39238d65e4 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_imgcodecs.a differ diff --git a/libs/armeabi-v7a/libopencv_imgproc.a b/libs/armeabi-v7a/libopencv_imgproc.a new file mode 100644 index 00000000000..c1e211cfef7 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_imgproc.a differ diff --git a/libs/armeabi-v7a/libopencv_java3.so b/libs/armeabi-v7a/libopencv_java3.so new file mode 100644 index 00000000000..82b92390ae7 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_java3.so differ diff --git a/libs/armeabi-v7a/libopencv_ml.a b/libs/armeabi-v7a/libopencv_ml.a new file mode 100644 index 00000000000..8c8973ae994 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_ml.a differ diff --git a/libs/armeabi-v7a/libopencv_objdetect.a b/libs/armeabi-v7a/libopencv_objdetect.a new file mode 100644 index 00000000000..06b88a0ee5d Binary files /dev/null and b/libs/armeabi-v7a/libopencv_objdetect.a differ diff --git a/libs/armeabi-v7a/libopencv_photo.a b/libs/armeabi-v7a/libopencv_photo.a new file mode 100644 index 00000000000..30923d0a118 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_photo.a differ diff --git a/libs/armeabi-v7a/libopencv_shape.a b/libs/armeabi-v7a/libopencv_shape.a new file mode 100644 index 00000000000..5c98796dda0 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_shape.a differ diff --git a/libs/armeabi-v7a/libopencv_stitching.a b/libs/armeabi-v7a/libopencv_stitching.a new file mode 100644 index 00000000000..20c795925d1 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_stitching.a differ diff --git a/libs/armeabi-v7a/libopencv_superres.a b/libs/armeabi-v7a/libopencv_superres.a new file mode 100644 index 00000000000..a6807a52f76 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_superres.a differ diff --git a/libs/armeabi-v7a/libopencv_video.a b/libs/armeabi-v7a/libopencv_video.a new file mode 100644 index 00000000000..e23e6b15ab2 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_video.a differ diff --git a/libs/armeabi-v7a/libopencv_videoio.a b/libs/armeabi-v7a/libopencv_videoio.a new file mode 100644 index 00000000000..fffb1d74247 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_videoio.a differ diff --git a/libs/armeabi-v7a/libopencv_videostab.a b/libs/armeabi-v7a/libopencv_videostab.a new file mode 100644 index 00000000000..365d852b5a6 Binary files /dev/null and b/libs/armeabi-v7a/libopencv_videostab.a differ diff --git a/libs/navx_ftc-release.aar b/libs/navx_ftc-release.aar new file mode 100644 index 00000000000..0ae9d96858c Binary files /dev/null and b/libs/navx_ftc-release.aar differ diff --git a/openCVLibrary330/build.gradle b/openCVLibrary330/build.gradle new file mode 100644 index 00000000000..20096872683 --- /dev/null +++ b/openCVLibrary330/build.gradle @@ -0,0 +1,18 @@ +apply plugin: 'com.android.library' + +android { + compileSdkVersion 23 + buildToolsVersion "25.0.3" + + defaultConfig { + minSdkVersion 19 + targetSdkVersion 23 + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt' + } + } +} diff --git a/openCVLibrary330/lint.xml b/openCVLibrary330/lint.xml new file mode 100644 index 00000000000..6a5c9c61900 --- /dev/null +++ b/openCVLibrary330/lint.xml @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/openCVLibrary330/src/main/AndroidManifest.xml b/openCVLibrary330/src/main/AndroidManifest.xml new file mode 100644 index 00000000000..664c637551a --- /dev/null +++ b/openCVLibrary330/src/main/AndroidManifest.xml @@ -0,0 +1,8 @@ + + + + + diff --git a/openCVLibrary330/src/main/aidl/org/opencv/engine/OpenCVEngineInterface.aidl b/openCVLibrary330/src/main/aidl/org/opencv/engine/OpenCVEngineInterface.aidl new file mode 100644 index 00000000000..21fe5f716ba --- /dev/null +++ b/openCVLibrary330/src/main/aidl/org/opencv/engine/OpenCVEngineInterface.aidl @@ -0,0 +1,33 @@ +package org.opencv.engine; + +/** +* Class provides a Java interface for OpenCV Engine Service. It's synchronous with native OpenCVEngine class. +*/ +interface OpenCVEngineInterface +{ + /** + * @return Returns service version. + */ + int getEngineVersion(); + + /** + * Finds an installed OpenCV library. + * @param OpenCV version. + * @return Returns path to OpenCV native libs or an empty string if OpenCV can not be found. + */ + String getLibPathByVersion(String version); + + /** + * Tries to install defined version of OpenCV from Google Play Market. + * @param OpenCV version. + * @return Returns true if installation was successful or OpenCV package has been already installed. + */ + boolean installVersion(String version); + + /** + * Returns list of libraries in loading order, separated by semicolon. + * @param OpenCV version. + * @return Returns names of OpenCV libraries, separated by semicolon. + */ + String getLibraryList(String version); +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/AsyncServiceHelper.java b/openCVLibrary330/src/main/java/org/opencv/android/AsyncServiceHelper.java new file mode 100644 index 00000000000..ebee2bb7f59 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/AsyncServiceHelper.java @@ -0,0 +1,391 @@ +package org.opencv.android; + +import java.io.File; +import java.util.StringTokenizer; + +import org.opencv.core.Core; +import org.opencv.engine.OpenCVEngineInterface; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.net.Uri; +import android.os.IBinder; +import android.os.RemoteException; +import android.util.Log; + +class AsyncServiceHelper +{ + public static boolean initOpenCV(String Version, final Context AppContext, + final LoaderCallbackInterface Callback) + { + AsyncServiceHelper helper = new AsyncServiceHelper(Version, AppContext, Callback); + Intent intent = new Intent("org.opencv.engine.BIND"); + intent.setPackage("org.opencv.engine"); + if (AppContext.bindService(intent, helper.mServiceConnection, Context.BIND_AUTO_CREATE)) + { + return true; + } + else + { + AppContext.unbindService(helper.mServiceConnection); + InstallService(AppContext, Callback); + return false; + } + } + + protected AsyncServiceHelper(String Version, Context AppContext, LoaderCallbackInterface Callback) + { + mOpenCVersion = Version; + mUserAppCallback = Callback; + mAppContext = AppContext; + } + + protected static final String TAG = "OpenCVManager/Helper"; + protected static final int MINIMUM_ENGINE_VERSION = 2; + protected OpenCVEngineInterface mEngineService; + protected LoaderCallbackInterface mUserAppCallback; + protected String mOpenCVersion; + protected Context mAppContext; + protected static boolean mServiceInstallationProgress = false; + protected static boolean mLibraryInstallationProgress = false; + + protected static boolean InstallServiceQuiet(Context context) + { + boolean result = true; + try + { + Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(OPEN_CV_SERVICE_URL)); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + context.startActivity(intent); + } + catch(Exception e) + { + result = false; + } + + return result; + } + + protected static void InstallService(final Context AppContext, final LoaderCallbackInterface Callback) + { + if (!mServiceInstallationProgress) + { + Log.d(TAG, "Request new service installation"); + InstallCallbackInterface InstallQuery = new InstallCallbackInterface() { + private LoaderCallbackInterface mUserAppCallback = Callback; + public String getPackageName() + { + return "OpenCV Manager"; + } + public void install() { + Log.d(TAG, "Trying to install OpenCV Manager via Google Play"); + + boolean result = InstallServiceQuiet(AppContext); + if (result) + { + mServiceInstallationProgress = true; + Log.d(TAG, "Package installation started"); + } + else + { + Log.d(TAG, "OpenCV package was not installed!"); + int Status = LoaderCallbackInterface.MARKET_ERROR; + Log.d(TAG, "Init finished with status " + Status); + Log.d(TAG, "Unbind from service"); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(Status); + } + } + + public void cancel() + { + Log.d(TAG, "OpenCV library installation was canceled"); + int Status = LoaderCallbackInterface.INSTALL_CANCELED; + Log.d(TAG, "Init finished with status " + Status); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(Status); + } + + public void wait_install() + { + Log.e(TAG, "Instalation was not started! Nothing to wait!"); + } + }; + + Callback.onPackageInstall(InstallCallbackInterface.NEW_INSTALLATION, InstallQuery); + } + else + { + Log.d(TAG, "Waiting current installation process"); + InstallCallbackInterface WaitQuery = new InstallCallbackInterface() { + private LoaderCallbackInterface mUserAppCallback = Callback; + public String getPackageName() + { + return "OpenCV Manager"; + } + public void install() + { + Log.e(TAG, "Nothing to install we just wait current installation"); + } + public void cancel() + { + Log.d(TAG, "Waiting for OpenCV canceled by user"); + mServiceInstallationProgress = false; + int Status = LoaderCallbackInterface.INSTALL_CANCELED; + Log.d(TAG, "Init finished with status " + Status); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(Status); + } + public void wait_install() + { + InstallServiceQuiet(AppContext); + } + }; + + Callback.onPackageInstall(InstallCallbackInterface.INSTALLATION_PROGRESS, WaitQuery); + } + } + + /** + * URL of OpenCV Manager page on Google Play Market. + */ + protected static final String OPEN_CV_SERVICE_URL = "market://details?id=org.opencv.engine"; + + protected ServiceConnection mServiceConnection = new ServiceConnection() + { + public void onServiceConnected(ComponentName className, IBinder service) + { + Log.d(TAG, "Service connection created"); + mEngineService = OpenCVEngineInterface.Stub.asInterface(service); + if (null == mEngineService) + { + Log.d(TAG, "OpenCV Manager Service connection fails. May be service was not installed?"); + InstallService(mAppContext, mUserAppCallback); + } + else + { + mServiceInstallationProgress = false; + try + { + if (mEngineService.getEngineVersion() < MINIMUM_ENGINE_VERSION) + { + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION); + return; + } + + Log.d(TAG, "Trying to get library path"); + String path = mEngineService.getLibPathByVersion(mOpenCVersion); + if ((null == path) || (path.length() == 0)) + { + if (!mLibraryInstallationProgress) + { + InstallCallbackInterface InstallQuery = new InstallCallbackInterface() { + public String getPackageName() + { + return "OpenCV library"; + } + public void install() { + Log.d(TAG, "Trying to install OpenCV lib via Google Play"); + try + { + if (mEngineService.installVersion(mOpenCVersion)) + { + mLibraryInstallationProgress = true; + Log.d(TAG, "Package installation started"); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + } + else + { + Log.d(TAG, "OpenCV package was not installed!"); + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.MARKET_ERROR); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.MARKET_ERROR); + } + } catch (RemoteException e) { + e.printStackTrace();; + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INIT_FAILED); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INIT_FAILED); + } + } + public void cancel() { + Log.d(TAG, "OpenCV library installation was canceled"); + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INSTALL_CANCELED); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INSTALL_CANCELED); + } + public void wait_install() { + Log.e(TAG, "Installation was not started! Nothing to wait!"); + } + }; + + mUserAppCallback.onPackageInstall(InstallCallbackInterface.NEW_INSTALLATION, InstallQuery); + } + else + { + InstallCallbackInterface WaitQuery = new InstallCallbackInterface() { + public String getPackageName() + { + return "OpenCV library"; + } + + public void install() { + Log.e(TAG, "Nothing to install we just wait current installation"); + } + public void cancel() + { + Log.d(TAG, "OpenCV library installation was canceled"); + mLibraryInstallationProgress = false; + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INSTALL_CANCELED); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INSTALL_CANCELED); + } + public void wait_install() { + Log.d(TAG, "Waiting for current installation"); + try + { + if (!mEngineService.installVersion(mOpenCVersion)) + { + Log.d(TAG, "OpenCV package was not installed!"); + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.MARKET_ERROR); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.MARKET_ERROR); + } + else + { + Log.d(TAG, "Wating for package installation"); + } + + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + + } catch (RemoteException e) { + e.printStackTrace(); + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INIT_FAILED); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INIT_FAILED); + } + } + }; + + mUserAppCallback.onPackageInstall(InstallCallbackInterface.INSTALLATION_PROGRESS, WaitQuery); + } + return; + } + else + { + Log.d(TAG, "Trying to get library list"); + mLibraryInstallationProgress = false; + String libs = mEngineService.getLibraryList(mOpenCVersion); + Log.d(TAG, "Library list: \"" + libs + "\""); + Log.d(TAG, "First attempt to load libs"); + int status; + if (initOpenCVLibs(path, libs)) + { + Log.d(TAG, "First attempt to load libs is OK"); + String eol = System.getProperty("line.separator"); + for (String str : Core.getBuildInformation().split(eol)) + Log.i(TAG, str); + + status = LoaderCallbackInterface.SUCCESS; + } + else + { + Log.d(TAG, "First attempt to load libs fails"); + status = LoaderCallbackInterface.INIT_FAILED; + } + + Log.d(TAG, "Init finished with status " + status); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(status); + } + } + catch (RemoteException e) + { + e.printStackTrace(); + Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INIT_FAILED); + Log.d(TAG, "Unbind from service"); + mAppContext.unbindService(mServiceConnection); + Log.d(TAG, "Calling using callback"); + mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INIT_FAILED); + } + } + } + + public void onServiceDisconnected(ComponentName className) + { + mEngineService = null; + } + }; + + private boolean loadLibrary(String AbsPath) + { + boolean result = true; + + Log.d(TAG, "Trying to load library " + AbsPath); + try + { + System.load(AbsPath); + Log.d(TAG, "OpenCV libs init was ok!"); + } + catch(UnsatisfiedLinkError e) + { + Log.d(TAG, "Cannot load library \"" + AbsPath + "\""); + e.printStackTrace(); + result &= false; + } + + return result; + } + + private boolean initOpenCVLibs(String Path, String Libs) + { + Log.d(TAG, "Trying to init OpenCV libs"); + if ((null != Path) && (Path.length() != 0)) + { + boolean result = true; + if ((null != Libs) && (Libs.length() != 0)) + { + Log.d(TAG, "Trying to load libs by dependency list"); + StringTokenizer splitter = new StringTokenizer(Libs, ";"); + while(splitter.hasMoreTokens()) + { + String AbsLibraryPath = Path + File.separator + splitter.nextToken(); + result &= loadLibrary(AbsLibraryPath); + } + } + else + { + // If the dependencies list is not defined or empty. + String AbsLibraryPath = Path + File.separator + "libopencv_java3.so"; + result &= loadLibrary(AbsLibraryPath); + } + + return result; + } + else + { + Log.d(TAG, "Library path \"" + Path + "\" is empty"); + return false; + } + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/BaseLoaderCallback.java b/openCVLibrary330/src/main/java/org/opencv/android/BaseLoaderCallback.java new file mode 100644 index 00000000000..0b8aeedc6a2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/BaseLoaderCallback.java @@ -0,0 +1,141 @@ +package org.opencv.android; + +import android.app.Activity; +import android.app.AlertDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.DialogInterface.OnClickListener; +import android.util.Log; + +/** + * Basic implementation of LoaderCallbackInterface. + */ +public abstract class BaseLoaderCallback implements LoaderCallbackInterface { + + public BaseLoaderCallback(Context AppContext) { + mAppContext = AppContext; + } + + public void onManagerConnected(int status) + { + switch (status) + { + /** OpenCV initialization was successful. **/ + case LoaderCallbackInterface.SUCCESS: + { + /** Application must override this method to handle successful library initialization. **/ + } break; + /** OpenCV loader can not start Google Play Market. **/ + case LoaderCallbackInterface.MARKET_ERROR: + { + Log.e(TAG, "Package installation failed!"); + AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create(); + MarketErrorMessage.setTitle("OpenCV Manager"); + MarketErrorMessage.setMessage("Package installation failed!"); + MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button + MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + finish(); + } + }); + MarketErrorMessage.show(); + } break; + /** Package installation has been canceled. **/ + case LoaderCallbackInterface.INSTALL_CANCELED: + { + Log.d(TAG, "OpenCV library installation was canceled by user"); + finish(); + } break; + /** Application is incompatible with this version of OpenCV Manager. Possibly, a service update is required. **/ + case LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION: + { + Log.d(TAG, "OpenCV Manager Service is uncompatible with this app!"); + AlertDialog IncomatibilityMessage = new AlertDialog.Builder(mAppContext).create(); + IncomatibilityMessage.setTitle("OpenCV Manager"); + IncomatibilityMessage.setMessage("OpenCV Manager service is incompatible with this app. Try to update it via Google Play."); + IncomatibilityMessage.setCancelable(false); // This blocks the 'BACK' button + IncomatibilityMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + finish(); + } + }); + IncomatibilityMessage.show(); + } break; + /** Other status, i.e. INIT_FAILED. **/ + default: + { + Log.e(TAG, "OpenCV loading failed!"); + AlertDialog InitFailedDialog = new AlertDialog.Builder(mAppContext).create(); + InitFailedDialog.setTitle("OpenCV error"); + InitFailedDialog.setMessage("OpenCV was not initialised correctly. Application will be shut down"); + InitFailedDialog.setCancelable(false); // This blocks the 'BACK' button + InitFailedDialog.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() { + + public void onClick(DialogInterface dialog, int which) { + finish(); + } + }); + + InitFailedDialog.show(); + } break; + } + } + + public void onPackageInstall(final int operation, final InstallCallbackInterface callback) + { + switch (operation) + { + case InstallCallbackInterface.NEW_INSTALLATION: + { + AlertDialog InstallMessage = new AlertDialog.Builder(mAppContext).create(); + InstallMessage.setTitle("Package not found"); + InstallMessage.setMessage(callback.getPackageName() + " package was not found! Try to install it?"); + InstallMessage.setCancelable(false); // This blocks the 'BACK' button + InstallMessage.setButton(AlertDialog.BUTTON_POSITIVE, "Yes", new OnClickListener() + { + public void onClick(DialogInterface dialog, int which) + { + callback.install(); + } + }); + + InstallMessage.setButton(AlertDialog.BUTTON_NEGATIVE, "No", new OnClickListener() { + + public void onClick(DialogInterface dialog, int which) + { + callback.cancel(); + } + }); + + InstallMessage.show(); + } break; + case InstallCallbackInterface.INSTALLATION_PROGRESS: + { + AlertDialog WaitMessage = new AlertDialog.Builder(mAppContext).create(); + WaitMessage.setTitle("OpenCV is not ready"); + WaitMessage.setMessage("Installation is in progress. Wait or exit?"); + WaitMessage.setCancelable(false); // This blocks the 'BACK' button + WaitMessage.setButton(AlertDialog.BUTTON_POSITIVE, "Wait", new OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + callback.wait_install(); + } + }); + WaitMessage.setButton(AlertDialog.BUTTON_NEGATIVE, "Exit", new OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + callback.cancel(); + } + }); + + WaitMessage.show(); + } break; + } + } + + void finish() + { + ((Activity) mAppContext).finish(); + } + + protected Context mAppContext; + private final static String TAG = "OpenCVLoader/BaseLoaderCallback"; +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/Camera2Renderer.java b/openCVLibrary330/src/main/java/org/opencv/android/Camera2Renderer.java new file mode 100644 index 00000000000..408214057a9 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/Camera2Renderer.java @@ -0,0 +1,302 @@ +package org.opencv.android; + +import java.util.Arrays; +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; +import android.annotation.TargetApi; +import android.content.Context; +import android.graphics.SurfaceTexture; +import android.hardware.camera2.CameraAccessException; +import android.hardware.camera2.CameraCaptureSession; +import android.hardware.camera2.CameraCharacteristics; +import android.hardware.camera2.CameraDevice; +import android.hardware.camera2.CameraManager; +import android.hardware.camera2.CaptureRequest; +import android.hardware.camera2.params.StreamConfigurationMap; +import android.os.Handler; +import android.os.HandlerThread; +import android.util.Log; +import android.util.Size; +import android.view.Surface; + +@TargetApi(21) +public class Camera2Renderer extends CameraGLRendererBase { + + protected final String LOGTAG = "Camera2Renderer"; + private CameraDevice mCameraDevice; + private CameraCaptureSession mCaptureSession; + private CaptureRequest.Builder mPreviewRequestBuilder; + private String mCameraID; + private Size mPreviewSize = new Size(-1, -1); + + private HandlerThread mBackgroundThread; + private Handler mBackgroundHandler; + private Semaphore mCameraOpenCloseLock = new Semaphore(1); + + Camera2Renderer(CameraGLSurfaceView view) { + super(view); + } + + @Override + protected void doStart() { + Log.d(LOGTAG, "doStart"); + startBackgroundThread(); + super.doStart(); + } + + + @Override + protected void doStop() { + Log.d(LOGTAG, "doStop"); + super.doStop(); + stopBackgroundThread(); + } + + boolean cacPreviewSize(final int width, final int height) { + Log.i(LOGTAG, "cacPreviewSize: "+width+"x"+height); + if(mCameraID == null) { + Log.e(LOGTAG, "Camera isn't initialized!"); + return false; + } + CameraManager manager = (CameraManager) mView.getContext() + .getSystemService(Context.CAMERA_SERVICE); + try { + CameraCharacteristics characteristics = manager + .getCameraCharacteristics(mCameraID); + StreamConfigurationMap map = characteristics + .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); + int bestWidth = 0, bestHeight = 0; + float aspect = (float)width / height; + for (Size psize : map.getOutputSizes(SurfaceTexture.class)) { + int w = psize.getWidth(), h = psize.getHeight(); + Log.d(LOGTAG, "trying size: "+w+"x"+h); + if ( width >= w && height >= h && + bestWidth <= w && bestHeight <= h && + Math.abs(aspect - (float)w/h) < 0.2 ) { + bestWidth = w; + bestHeight = h; + } + } + Log.i(LOGTAG, "best size: "+bestWidth+"x"+bestHeight); + if( bestWidth == 0 || bestHeight == 0 || + mPreviewSize.getWidth() == bestWidth && + mPreviewSize.getHeight() == bestHeight ) + return false; + else { + mPreviewSize = new Size(bestWidth, bestHeight); + return true; + } + } catch (CameraAccessException e) { + Log.e(LOGTAG, "cacPreviewSize - Camera Access Exception"); + } catch (IllegalArgumentException e) { + Log.e(LOGTAG, "cacPreviewSize - Illegal Argument Exception"); + } catch (SecurityException e) { + Log.e(LOGTAG, "cacPreviewSize - Security Exception"); + } + return false; + } + + @Override + protected void openCamera(int id) { + Log.i(LOGTAG, "openCamera"); + CameraManager manager = (CameraManager) mView.getContext().getSystemService(Context.CAMERA_SERVICE); + try { + String camList[] = manager.getCameraIdList(); + if(camList.length == 0) { + Log.e(LOGTAG, "Error: camera isn't detected."); + return; + } + if(id == CameraBridgeViewBase.CAMERA_ID_ANY) { + mCameraID = camList[0]; + } else { + for (String cameraID : camList) { + CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraID); + if( id == CameraBridgeViewBase.CAMERA_ID_BACK && + characteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_BACK || + id == CameraBridgeViewBase.CAMERA_ID_FRONT && + characteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT) { + mCameraID = cameraID; + break; + } + } + } + if(mCameraID != null) { + if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) { + throw new RuntimeException( + "Time out waiting to lock camera opening."); + } + Log.i(LOGTAG, "Opening camera: " + mCameraID); + manager.openCamera(mCameraID, mStateCallback, mBackgroundHandler); + } + } catch (CameraAccessException e) { + Log.e(LOGTAG, "OpenCamera - Camera Access Exception"); + } catch (IllegalArgumentException e) { + Log.e(LOGTAG, "OpenCamera - Illegal Argument Exception"); + } catch (SecurityException e) { + Log.e(LOGTAG, "OpenCamera - Security Exception"); + } catch (InterruptedException e) { + Log.e(LOGTAG, "OpenCamera - Interrupted Exception"); + } + } + + @Override + protected void closeCamera() { + Log.i(LOGTAG, "closeCamera"); + try { + mCameraOpenCloseLock.acquire(); + if (null != mCaptureSession) { + mCaptureSession.close(); + mCaptureSession = null; + } + if (null != mCameraDevice) { + mCameraDevice.close(); + mCameraDevice = null; + } + } catch (InterruptedException e) { + throw new RuntimeException("Interrupted while trying to lock camera closing.", e); + } finally { + mCameraOpenCloseLock.release(); + } + } + + private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() { + + @Override + public void onOpened(CameraDevice cameraDevice) { + mCameraDevice = cameraDevice; + mCameraOpenCloseLock.release(); + createCameraPreviewSession(); + } + + @Override + public void onDisconnected(CameraDevice cameraDevice) { + cameraDevice.close(); + mCameraDevice = null; + mCameraOpenCloseLock.release(); + } + + @Override + public void onError(CameraDevice cameraDevice, int error) { + cameraDevice.close(); + mCameraDevice = null; + mCameraOpenCloseLock.release(); + } + + }; + + private void createCameraPreviewSession() { + int w=mPreviewSize.getWidth(), h=mPreviewSize.getHeight(); + Log.i(LOGTAG, "createCameraPreviewSession("+w+"x"+h+")"); + if(w<0 || h<0) + return; + try { + mCameraOpenCloseLock.acquire(); + if (null == mCameraDevice) { + mCameraOpenCloseLock.release(); + Log.e(LOGTAG, "createCameraPreviewSession: camera isn't opened"); + return; + } + if (null != mCaptureSession) { + mCameraOpenCloseLock.release(); + Log.e(LOGTAG, "createCameraPreviewSession: mCaptureSession is already started"); + return; + } + if(null == mSTexture) { + mCameraOpenCloseLock.release(); + Log.e(LOGTAG, "createCameraPreviewSession: preview SurfaceTexture is null"); + return; + } + mSTexture.setDefaultBufferSize(w, h); + + Surface surface = new Surface(mSTexture); + + mPreviewRequestBuilder = mCameraDevice + .createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); + mPreviewRequestBuilder.addTarget(surface); + + mCameraDevice.createCaptureSession(Arrays.asList(surface), + new CameraCaptureSession.StateCallback() { + @Override + public void onConfigured( CameraCaptureSession cameraCaptureSession) { + mCaptureSession = cameraCaptureSession; + try { + mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); + mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH); + + mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler); + Log.i(LOGTAG, "CameraPreviewSession has been started"); + } catch (CameraAccessException e) { + Log.e(LOGTAG, "createCaptureSession failed"); + } + mCameraOpenCloseLock.release(); + } + + @Override + public void onConfigureFailed( + CameraCaptureSession cameraCaptureSession) { + Log.e(LOGTAG, "createCameraPreviewSession failed"); + mCameraOpenCloseLock.release(); + } + }, mBackgroundHandler); + } catch (CameraAccessException e) { + Log.e(LOGTAG, "createCameraPreviewSession"); + } catch (InterruptedException e) { + throw new RuntimeException( + "Interrupted while createCameraPreviewSession", e); + } + finally { + //mCameraOpenCloseLock.release(); + } + } + + private void startBackgroundThread() { + Log.i(LOGTAG, "startBackgroundThread"); + stopBackgroundThread(); + mBackgroundThread = new HandlerThread("CameraBackground"); + mBackgroundThread.start(); + mBackgroundHandler = new Handler(mBackgroundThread.getLooper()); + } + + private void stopBackgroundThread() { + Log.i(LOGTAG, "stopBackgroundThread"); + if(mBackgroundThread == null) + return; + mBackgroundThread.quitSafely(); + try { + mBackgroundThread.join(); + mBackgroundThread = null; + mBackgroundHandler = null; + } catch (InterruptedException e) { + Log.e(LOGTAG, "stopBackgroundThread"); + } + } + + @Override + protected void setCameraPreviewSize(int width, int height) { + Log.i(LOGTAG, "setCameraPreviewSize("+width+"x"+height+")"); + if(mMaxCameraWidth > 0 && mMaxCameraWidth < width) width = mMaxCameraWidth; + if(mMaxCameraHeight > 0 && mMaxCameraHeight < height) height = mMaxCameraHeight; + try { + mCameraOpenCloseLock.acquire(); + + boolean needReconfig = cacPreviewSize(width, height); + mCameraWidth = mPreviewSize.getWidth(); + mCameraHeight = mPreviewSize.getHeight(); + + if( !needReconfig ) { + mCameraOpenCloseLock.release(); + return; + } + if (null != mCaptureSession) { + Log.d(LOGTAG, "closing existing previewSession"); + mCaptureSession.close(); + mCaptureSession = null; + } + mCameraOpenCloseLock.release(); + createCameraPreviewSession(); + } catch (InterruptedException e) { + mCameraOpenCloseLock.release(); + throw new RuntimeException("Interrupted while setCameraPreviewSize.", e); + } + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/CameraBridgeViewBase.java b/openCVLibrary330/src/main/java/org/opencv/android/CameraBridgeViewBase.java new file mode 100644 index 00000000000..54871057e2d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/CameraBridgeViewBase.java @@ -0,0 +1,495 @@ +package org.opencv.android; + +import java.util.List; + +import org.opencv.BuildConfig; +import org.opencv.R; +import org.opencv.core.Mat; +import org.opencv.core.Size; + +import android.app.Activity; +import android.app.AlertDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.res.TypedArray; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Rect; +import android.util.AttributeSet; +import android.util.Log; +import android.view.SurfaceHolder; +import android.view.SurfaceView; + +/** + * This is a basic class, implementing the interaction with Camera and OpenCV library. + * The main responsibility of it - is to control when camera can be enabled, process the frame, + * call external listener to make any adjustments to the frame and then draw the resulting + * frame to the screen. + * The clients shall implement CvCameraViewListener. + */ +public abstract class CameraBridgeViewBase extends SurfaceView implements SurfaceHolder.Callback { + + private static final String TAG = "CameraBridge"; + private static final int MAX_UNSPECIFIED = -1; + private static final int STOPPED = 0; + private static final int STARTED = 1; + + private int mState = STOPPED; + private Bitmap mCacheBitmap; + private CvCameraViewListener2 mListener; + private boolean mSurfaceExist; + private final Object mSyncObject = new Object(); + + protected int mFrameWidth; + protected int mFrameHeight; + protected int mMaxHeight; + protected int mMaxWidth; + protected float mScale = 0; + protected int mPreviewFormat = RGBA; + protected int mCameraIndex = CAMERA_ID_ANY; + protected boolean mEnabled; + protected FpsMeter mFpsMeter = null; + + public static final int CAMERA_ID_ANY = -1; + public static final int CAMERA_ID_BACK = 99; + public static final int CAMERA_ID_FRONT = 98; + public static final int RGBA = 1; + public static final int GRAY = 2; + + public CameraBridgeViewBase(Context context, int cameraId) { + super(context); + mCameraIndex = cameraId; + getHolder().addCallback(this); + mMaxWidth = MAX_UNSPECIFIED; + mMaxHeight = MAX_UNSPECIFIED; + } + + public CameraBridgeViewBase(Context context, AttributeSet attrs) { + super(context, attrs); + + int count = attrs.getAttributeCount(); + Log.d(TAG, "Attr count: " + Integer.valueOf(count)); + + TypedArray styledAttrs = getContext().obtainStyledAttributes(attrs, R.styleable.CameraBridgeViewBase); + if (styledAttrs.getBoolean(R.styleable.CameraBridgeViewBase_show_fps, false)) + enableFpsMeter(); + + mCameraIndex = styledAttrs.getInt(R.styleable.CameraBridgeViewBase_camera_id, -1); + + getHolder().addCallback(this); + mMaxWidth = MAX_UNSPECIFIED; + mMaxHeight = MAX_UNSPECIFIED; + styledAttrs.recycle(); + } + + /** + * Sets the camera index + * @param cameraIndex new camera index + */ + public void setCameraIndex(int cameraIndex) { + this.mCameraIndex = cameraIndex; + } + + public interface CvCameraViewListener { + /** + * This method is invoked when camera preview has started. After this method is invoked + * the frames will start to be delivered to client via the onCameraFrame() callback. + * @param width - the width of the frames that will be delivered + * @param height - the height of the frames that will be delivered + */ + public void onCameraViewStarted(int width, int height); + + /** + * This method is invoked when camera preview has been stopped for some reason. + * No frames will be delivered via onCameraFrame() callback after this method is called. + */ + public void onCameraViewStopped(); + + /** + * This method is invoked when delivery of the frame needs to be done. + * The returned values - is a modified frame which needs to be displayed on the screen. + * TODO: pass the parameters specifying the format of the frame (BPP, YUV or RGB and etc) + */ + public Mat onCameraFrame(Mat inputFrame); + } + + public interface CvCameraViewListener2 { + /** + * This method is invoked when camera preview has started. After this method is invoked + * the frames will start to be delivered to client via the onCameraFrame() callback. + * @param width - the width of the frames that will be delivered + * @param height - the height of the frames that will be delivered + */ + public void onCameraViewStarted(int width, int height); + + /** + * This method is invoked when camera preview has been stopped for some reason. + * No frames will be delivered via onCameraFrame() callback after this method is called. + */ + public void onCameraViewStopped(); + + /** + * This method is invoked when delivery of the frame needs to be done. + * The returned values - is a modified frame which needs to be displayed on the screen. + * TODO: pass the parameters specifying the format of the frame (BPP, YUV or RGB and etc) + */ + public Mat onCameraFrame(CvCameraViewFrame inputFrame); + }; + + protected class CvCameraViewListenerAdapter implements CvCameraViewListener2 { + public CvCameraViewListenerAdapter(CvCameraViewListener oldStypeListener) { + mOldStyleListener = oldStypeListener; + } + + public void onCameraViewStarted(int width, int height) { + mOldStyleListener.onCameraViewStarted(width, height); + } + + public void onCameraViewStopped() { + mOldStyleListener.onCameraViewStopped(); + } + + public Mat onCameraFrame(CvCameraViewFrame inputFrame) { + Mat result = null; + switch (mPreviewFormat) { + case RGBA: + result = mOldStyleListener.onCameraFrame(inputFrame.rgba()); + break; + case GRAY: + result = mOldStyleListener.onCameraFrame(inputFrame.gray()); + break; + default: + Log.e(TAG, "Invalid frame format! Only RGBA and Gray Scale are supported!"); + }; + + return result; + } + + public void setFrameFormat(int format) { + mPreviewFormat = format; + } + + private int mPreviewFormat = RGBA; + private CvCameraViewListener mOldStyleListener; + }; + + /** + * This class interface is abstract representation of single frame from camera for onCameraFrame callback + * Attention: Do not use objects, that represents this interface out of onCameraFrame callback! + */ + public interface CvCameraViewFrame { + + /** + * This method returns RGBA Mat with frame + */ + public Mat rgba(); + + /** + * This method returns single channel gray scale Mat with frame + */ + public Mat gray(); + }; + + public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) { + Log.d(TAG, "call surfaceChanged event"); + synchronized(mSyncObject) { + if (!mSurfaceExist) { + mSurfaceExist = true; + checkCurrentState(); + } else { + /** Surface changed. We need to stop camera and restart with new parameters */ + /* Pretend that old surface has been destroyed */ + mSurfaceExist = false; + checkCurrentState(); + /* Now use new surface. Say we have it now */ + mSurfaceExist = true; + checkCurrentState(); + } + } + } + + public void surfaceCreated(SurfaceHolder holder) { + /* Do nothing. Wait until surfaceChanged delivered */ + } + + public void surfaceDestroyed(SurfaceHolder holder) { + synchronized(mSyncObject) { + mSurfaceExist = false; + checkCurrentState(); + } + } + + /** + * This method is provided for clients, so they can enable the camera connection. + * The actual onCameraViewStarted callback will be delivered only after both this method is called and surface is available + */ + public void enableView() { + synchronized(mSyncObject) { + mEnabled = true; + checkCurrentState(); + } + } + + /** + * This method is provided for clients, so they can disable camera connection and stop + * the delivery of frames even though the surface view itself is not destroyed and still stays on the scren + */ + public void disableView() { + synchronized(mSyncObject) { + mEnabled = false; + checkCurrentState(); + } + } + + /** + * This method enables label with fps value on the screen + */ + public void enableFpsMeter() { + if (mFpsMeter == null) { + mFpsMeter = new FpsMeter(); + mFpsMeter.setResolution(mFrameWidth, mFrameHeight); + } + } + + public void disableFpsMeter() { + mFpsMeter = null; + } + + /** + * + * @param listener + */ + + public void setCvCameraViewListener(CvCameraViewListener2 listener) { + mListener = listener; + } + + public void setCvCameraViewListener(CvCameraViewListener listener) { + CvCameraViewListenerAdapter adapter = new CvCameraViewListenerAdapter(listener); + adapter.setFrameFormat(mPreviewFormat); + mListener = adapter; + } + + /** + * This method sets the maximum size that camera frame is allowed to be. When selecting + * size - the biggest size which less or equal the size set will be selected. + * As an example - we set setMaxFrameSize(200,200) and we have 176x152 and 320x240 sizes. The + * preview frame will be selected with 176x152 size. + * This method is useful when need to restrict the size of preview frame for some reason (for example for video recording) + * @param maxWidth - the maximum width allowed for camera frame. + * @param maxHeight - the maximum height allowed for camera frame + */ + public void setMaxFrameSize(int maxWidth, int maxHeight) { + mMaxWidth = maxWidth; + mMaxHeight = maxHeight; + } + + public void SetCaptureFormat(int format) + { + mPreviewFormat = format; + if (mListener instanceof CvCameraViewListenerAdapter) { + CvCameraViewListenerAdapter adapter = (CvCameraViewListenerAdapter) mListener; + adapter.setFrameFormat(mPreviewFormat); + } + } + + /** + * Called when mSyncObject lock is held + */ + private void checkCurrentState() { + Log.d(TAG, "call checkCurrentState"); + int targetState; + + if (mEnabled && mSurfaceExist && getVisibility() == VISIBLE) { + targetState = STARTED; + } else { + targetState = STOPPED; + } + + if (targetState != mState) { + /* The state change detected. Need to exit the current state and enter target state */ + processExitState(mState); + mState = targetState; + processEnterState(mState); + } + } + + private void processEnterState(int state) { + Log.d(TAG, "call processEnterState: " + state); + switch(state) { + case STARTED: + onEnterStartedState(); + if (mListener != null) { + mListener.onCameraViewStarted(mFrameWidth, mFrameHeight); + } + break; + case STOPPED: + onEnterStoppedState(); + if (mListener != null) { + mListener.onCameraViewStopped(); + } + break; + }; + } + + private void processExitState(int state) { + Log.d(TAG, "call processExitState: " + state); + switch(state) { + case STARTED: + onExitStartedState(); + break; + case STOPPED: + onExitStoppedState(); + break; + }; + } + + private void onEnterStoppedState() { + /* nothing to do */ + } + + private void onExitStoppedState() { + /* nothing to do */ + } + + // NOTE: The order of bitmap constructor and camera connection is important for android 4.1.x + // Bitmap must be constructed before surface + private void onEnterStartedState() { + Log.d(TAG, "call onEnterStartedState"); + /* Connect camera */ + if (!connectCamera(getWidth(), getHeight())) { + AlertDialog ad = new AlertDialog.Builder(getContext()).create(); + ad.setCancelable(false); // This blocks the 'BACK' button + ad.setMessage("It seems that you device does not support camera (or it is locked). Application will be closed."); + ad.setButton(DialogInterface.BUTTON_NEUTRAL, "OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + dialog.dismiss(); + ((Activity) getContext()).finish(); + } + }); + ad.show(); + + } + } + + private void onExitStartedState() { + disconnectCamera(); + if (mCacheBitmap != null) { + mCacheBitmap.recycle(); + } + } + + /** + * This method shall be called by the subclasses when they have valid + * object and want it to be delivered to external client (via callback) and + * then displayed on the screen. + * @param frame - the current frame to be delivered + */ + protected void deliverAndDrawFrame(CvCameraViewFrame frame) { + Mat modified; + + if (mListener != null) { + modified = mListener.onCameraFrame(frame); + } else { + modified = frame.rgba(); + } + + boolean bmpValid = true; + if (modified != null) { + try { + Utils.matToBitmap(modified, mCacheBitmap); + } catch(Exception e) { + Log.e(TAG, "Mat type: " + modified); + Log.e(TAG, "Bitmap type: " + mCacheBitmap.getWidth() + "*" + mCacheBitmap.getHeight()); + Log.e(TAG, "Utils.matToBitmap() throws an exception: " + e.getMessage()); + bmpValid = false; + } + } + + if (bmpValid && mCacheBitmap != null) { + Canvas canvas = getHolder().lockCanvas(); + if (canvas != null) { + canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR); + if (BuildConfig.DEBUG) + Log.d(TAG, "mStretch value: " + mScale); + + if (mScale != 0) { + canvas.drawBitmap(mCacheBitmap, new Rect(0,0,mCacheBitmap.getWidth(), mCacheBitmap.getHeight()), + new Rect((int)((canvas.getWidth() - mScale*mCacheBitmap.getWidth()) / 2), + (int)((canvas.getHeight() - mScale*mCacheBitmap.getHeight()) / 2), + (int)((canvas.getWidth() - mScale*mCacheBitmap.getWidth()) / 2 + mScale*mCacheBitmap.getWidth()), + (int)((canvas.getHeight() - mScale*mCacheBitmap.getHeight()) / 2 + mScale*mCacheBitmap.getHeight())), null); + } else { + canvas.drawBitmap(mCacheBitmap, new Rect(0,0,mCacheBitmap.getWidth(), mCacheBitmap.getHeight()), + new Rect((canvas.getWidth() - mCacheBitmap.getWidth()) / 2, + (canvas.getHeight() - mCacheBitmap.getHeight()) / 2, + (canvas.getWidth() - mCacheBitmap.getWidth()) / 2 + mCacheBitmap.getWidth(), + (canvas.getHeight() - mCacheBitmap.getHeight()) / 2 + mCacheBitmap.getHeight()), null); + } + + if (mFpsMeter != null) { + mFpsMeter.measure(); + mFpsMeter.draw(canvas, 20, 30); + } + getHolder().unlockCanvasAndPost(canvas); + } + } + } + + /** + * This method is invoked shall perform concrete operation to initialize the camera. + * CONTRACT: as a result of this method variables mFrameWidth and mFrameHeight MUST be + * initialized with the size of the Camera frames that will be delivered to external processor. + * @param width - the width of this SurfaceView + * @param height - the height of this SurfaceView + */ + protected abstract boolean connectCamera(int width, int height); + + /** + * Disconnects and release the particular camera object being connected to this surface view. + * Called when syncObject lock is held + */ + protected abstract void disconnectCamera(); + + // NOTE: On Android 4.1.x the function must be called before SurfaceTexture constructor! + protected void AllocateCache() + { + mCacheBitmap = Bitmap.createBitmap(mFrameWidth, mFrameHeight, Bitmap.Config.ARGB_8888); + } + + public interface ListItemAccessor { + public int getWidth(Object obj); + public int getHeight(Object obj); + }; + + /** + * This helper method can be called by subclasses to select camera preview size. + * It goes over the list of the supported preview sizes and selects the maximum one which + * fits both values set via setMaxFrameSize() and surface frame allocated for this view + * @param supportedSizes + * @param surfaceWidth + * @param surfaceHeight + * @return optimal frame size + */ + protected Size calculateCameraFrameSize(List supportedSizes, ListItemAccessor accessor, int surfaceWidth, int surfaceHeight) { + int calcWidth = 0; + int calcHeight = 0; + + int maxAllowedWidth = (mMaxWidth != MAX_UNSPECIFIED && mMaxWidth < surfaceWidth)? mMaxWidth : surfaceWidth; + int maxAllowedHeight = (mMaxHeight != MAX_UNSPECIFIED && mMaxHeight < surfaceHeight)? mMaxHeight : surfaceHeight; + + for (Object size : supportedSizes) { + int width = accessor.getWidth(size); + int height = accessor.getHeight(size); + + if (width <= maxAllowedWidth && height <= maxAllowedHeight) { + if (width >= calcWidth && height >= calcHeight) { + calcWidth = (int) width; + calcHeight = (int) height; + } + } + } + + return new Size(calcWidth, calcHeight); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/CameraGLRendererBase.java b/openCVLibrary330/src/main/java/org/opencv/android/CameraGLRendererBase.java new file mode 100644 index 00000000000..60c37c304e2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/CameraGLRendererBase.java @@ -0,0 +1,440 @@ +package org.opencv.android; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; + +import javax.microedition.khronos.egl.EGLConfig; +import javax.microedition.khronos.opengles.GL10; + +import org.opencv.android.CameraGLSurfaceView.CameraTextureListener; + +import android.annotation.TargetApi; +import android.graphics.SurfaceTexture; +import android.opengl.GLES11Ext; +import android.opengl.GLES20; +import android.opengl.GLSurfaceView; +import android.util.Log; +import android.view.View; + +@TargetApi(15) +public abstract class CameraGLRendererBase implements GLSurfaceView.Renderer, SurfaceTexture.OnFrameAvailableListener { + + protected final String LOGTAG = "CameraGLRendererBase"; + + // shaders + private final String vss = "" + + "attribute vec2 vPosition;\n" + + "attribute vec2 vTexCoord;\n" + "varying vec2 texCoord;\n" + + "void main() {\n" + " texCoord = vTexCoord;\n" + + " gl_Position = vec4 ( vPosition.x, vPosition.y, 0.0, 1.0 );\n" + + "}"; + + private final String fssOES = "" + + "#extension GL_OES_EGL_image_external : require\n" + + "precision mediump float;\n" + + "uniform samplerExternalOES sTexture;\n" + + "varying vec2 texCoord;\n" + + "void main() {\n" + + " gl_FragColor = texture2D(sTexture,texCoord);\n" + "}"; + + private final String fss2D = "" + + "precision mediump float;\n" + + "uniform sampler2D sTexture;\n" + + "varying vec2 texCoord;\n" + + "void main() {\n" + + " gl_FragColor = texture2D(sTexture,texCoord);\n" + "}"; + + // coord-s + private final float vertices[] = { + -1, -1, + -1, 1, + 1, -1, + 1, 1 }; + private final float texCoordOES[] = { + 0, 1, + 0, 0, + 1, 1, + 1, 0 }; + private final float texCoord2D[] = { + 0, 0, + 0, 1, + 1, 0, + 1, 1 }; + + private int[] texCamera = {0}, texFBO = {0}, texDraw = {0}; + private int[] FBO = {0}; + private int progOES = -1, prog2D = -1; + private int vPosOES, vTCOES, vPos2D, vTC2D; + + private FloatBuffer vert, texOES, tex2D; + + protected int mCameraWidth = -1, mCameraHeight = -1; + protected int mFBOWidth = -1, mFBOHeight = -1; + protected int mMaxCameraWidth = -1, mMaxCameraHeight = -1; + protected int mCameraIndex = CameraBridgeViewBase.CAMERA_ID_ANY; + + protected SurfaceTexture mSTexture; + + protected boolean mHaveSurface = false; + protected boolean mHaveFBO = false; + protected boolean mUpdateST = false; + protected boolean mEnabled = true; + protected boolean mIsStarted = false; + + protected CameraGLSurfaceView mView; + + protected abstract void openCamera(int id); + protected abstract void closeCamera(); + protected abstract void setCameraPreviewSize(int width, int height); // updates mCameraWidth & mCameraHeight + + public CameraGLRendererBase(CameraGLSurfaceView view) { + mView = view; + int bytes = vertices.length * Float.SIZE / Byte.SIZE; + vert = ByteBuffer.allocateDirect(bytes).order(ByteOrder.nativeOrder()).asFloatBuffer(); + texOES = ByteBuffer.allocateDirect(bytes).order(ByteOrder.nativeOrder()).asFloatBuffer(); + tex2D = ByteBuffer.allocateDirect(bytes).order(ByteOrder.nativeOrder()).asFloatBuffer(); + vert.put(vertices).position(0); + texOES.put(texCoordOES).position(0); + tex2D.put(texCoord2D).position(0); + } + + @Override + public synchronized void onFrameAvailable(SurfaceTexture surfaceTexture) { + //Log.i(LOGTAG, "onFrameAvailable"); + mUpdateST = true; + mView.requestRender(); + } + + @Override + public void onDrawFrame(GL10 gl) { + //Log.i(LOGTAG, "onDrawFrame start"); + + if (!mHaveFBO) + return; + + synchronized(this) { + if (mUpdateST) { + mSTexture.updateTexImage(); + mUpdateST = false; + } + + GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); + + CameraTextureListener texListener = mView.getCameraTextureListener(); + if(texListener != null) { + //Log.d(LOGTAG, "haveUserCallback"); + // texCamera(OES) -> texFBO + drawTex(texCamera[0], true, FBO[0]); + + // call user code (texFBO -> texDraw) + boolean modified = texListener.onCameraTexture(texFBO[0], texDraw[0], mCameraWidth, mCameraHeight); + + if(modified) { + // texDraw -> screen + drawTex(texDraw[0], false, 0); + } else { + // texFBO -> screen + drawTex(texFBO[0], false, 0); + } + } else { + Log.d(LOGTAG, "texCamera(OES) -> screen"); + // texCamera(OES) -> screen + drawTex(texCamera[0], true, 0); + } + //Log.i(LOGTAG, "onDrawFrame end"); + } + } + + @Override + public void onSurfaceChanged(GL10 gl, int surfaceWidth, int surfaceHeight) { + Log.i(LOGTAG, "onSurfaceChanged("+surfaceWidth+"x"+surfaceHeight+")"); + mHaveSurface = true; + updateState(); + setPreviewSize(surfaceWidth, surfaceHeight); + } + + @Override + public void onSurfaceCreated(GL10 gl, EGLConfig config) { + Log.i(LOGTAG, "onSurfaceCreated"); + initShaders(); + } + + private void initShaders() { + String strGLVersion = GLES20.glGetString(GLES20.GL_VERSION); + if (strGLVersion != null) + Log.i(LOGTAG, "OpenGL ES version: " + strGLVersion); + + GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + + progOES = loadShader(vss, fssOES); + vPosOES = GLES20.glGetAttribLocation(progOES, "vPosition"); + vTCOES = GLES20.glGetAttribLocation(progOES, "vTexCoord"); + GLES20.glEnableVertexAttribArray(vPosOES); + GLES20.glEnableVertexAttribArray(vTCOES); + + prog2D = loadShader(vss, fss2D); + vPos2D = GLES20.glGetAttribLocation(prog2D, "vPosition"); + vTC2D = GLES20.glGetAttribLocation(prog2D, "vTexCoord"); + GLES20.glEnableVertexAttribArray(vPos2D); + GLES20.glEnableVertexAttribArray(vTC2D); + } + + private void initSurfaceTexture() { + Log.d(LOGTAG, "initSurfaceTexture"); + deleteSurfaceTexture(); + initTexOES(texCamera); + mSTexture = new SurfaceTexture(texCamera[0]); + mSTexture.setOnFrameAvailableListener(this); + } + + private void deleteSurfaceTexture() { + Log.d(LOGTAG, "deleteSurfaceTexture"); + if(mSTexture != null) { + mSTexture.release(); + mSTexture = null; + deleteTex(texCamera); + } + } + + private void initTexOES(int[] tex) { + if(tex.length == 1) { + GLES20.glGenTextures(1, tex, 0); + GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, tex[0]); + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE); + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE); + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST); + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST); + } + } + + private static void deleteTex(int[] tex) { + if(tex.length == 1) { + GLES20.glDeleteTextures(1, tex, 0); + } + } + + private static int loadShader(String vss, String fss) { + Log.d("CameraGLRendererBase", "loadShader"); + int vshader = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); + GLES20.glShaderSource(vshader, vss); + GLES20.glCompileShader(vshader); + int[] status = new int[1]; + GLES20.glGetShaderiv(vshader, GLES20.GL_COMPILE_STATUS, status, 0); + if (status[0] == 0) { + Log.e("CameraGLRendererBase", "Could not compile vertex shader: "+GLES20.glGetShaderInfoLog(vshader)); + GLES20.glDeleteShader(vshader); + vshader = 0; + return 0; + } + + int fshader = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); + GLES20.glShaderSource(fshader, fss); + GLES20.glCompileShader(fshader); + GLES20.glGetShaderiv(fshader, GLES20.GL_COMPILE_STATUS, status, 0); + if (status[0] == 0) { + Log.e("CameraGLRendererBase", "Could not compile fragment shader:"+GLES20.glGetShaderInfoLog(fshader)); + GLES20.glDeleteShader(vshader); + GLES20.glDeleteShader(fshader); + fshader = 0; + return 0; + } + + int program = GLES20.glCreateProgram(); + GLES20.glAttachShader(program, vshader); + GLES20.glAttachShader(program, fshader); + GLES20.glLinkProgram(program); + GLES20.glDeleteShader(vshader); + GLES20.glDeleteShader(fshader); + GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, status, 0); + if (status[0] == 0) { + Log.e("CameraGLRendererBase", "Could not link shader program: "+GLES20.glGetProgramInfoLog(program)); + program = 0; + return 0; + } + GLES20.glValidateProgram(program); + GLES20.glGetProgramiv(program, GLES20.GL_VALIDATE_STATUS, status, 0); + if (status[0] == 0) + { + Log.e("CameraGLRendererBase", "Shader program validation error: "+GLES20.glGetProgramInfoLog(program)); + GLES20.glDeleteProgram(program); + program = 0; + return 0; + } + + Log.d("CameraGLRendererBase", "Shader program is built OK"); + + return program; + } + + private void deleteFBO() + { + Log.d(LOGTAG, "deleteFBO("+mFBOWidth+"x"+mFBOHeight+")"); + GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0); + GLES20.glDeleteFramebuffers(1, FBO, 0); + + deleteTex(texFBO); + deleteTex(texDraw); + mFBOWidth = mFBOHeight = 0; + } + + private void initFBO(int width, int height) + { + Log.d(LOGTAG, "initFBO("+width+"x"+height+")"); + + deleteFBO(); + + GLES20.glGenTextures(1, texDraw, 0); + GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texDraw[0]); + GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, width, height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST); + + GLES20.glGenTextures(1, texFBO, 0); + GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texFBO[0]); + GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, width, height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST); + GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST); + + //int hFBO; + GLES20.glGenFramebuffers(1, FBO, 0); + GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, FBO[0]); + GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, texFBO[0], 0); + Log.d(LOGTAG, "initFBO error status: " + GLES20.glGetError()); + + int FBOstatus = GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER); + if (FBOstatus != GLES20.GL_FRAMEBUFFER_COMPLETE) + Log.e(LOGTAG, "initFBO failed, status: " + FBOstatus); + + mFBOWidth = width; + mFBOHeight = height; + } + + // draw texture to FBO or to screen if fbo == 0 + private void drawTex(int tex, boolean isOES, int fbo) + { + GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fbo); + + if(fbo == 0) + GLES20.glViewport(0, 0, mView.getWidth(), mView.getHeight()); + else + GLES20.glViewport(0, 0, mFBOWidth, mFBOHeight); + + GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); + + if(isOES) { + GLES20.glUseProgram(progOES); + GLES20.glVertexAttribPointer(vPosOES, 2, GLES20.GL_FLOAT, false, 4*2, vert); + GLES20.glVertexAttribPointer(vTCOES, 2, GLES20.GL_FLOAT, false, 4*2, texOES); + } else { + GLES20.glUseProgram(prog2D); + GLES20.glVertexAttribPointer(vPos2D, 2, GLES20.GL_FLOAT, false, 4*2, vert); + GLES20.glVertexAttribPointer(vTC2D, 2, GLES20.GL_FLOAT, false, 4*2, tex2D); + } + + GLES20.glActiveTexture(GLES20.GL_TEXTURE0); + + if(isOES) { + GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, tex); + GLES20.glUniform1i(GLES20.glGetUniformLocation(progOES, "sTexture"), 0); + } else { + GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, tex); + GLES20.glUniform1i(GLES20.glGetUniformLocation(prog2D, "sTexture"), 0); + } + + GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4); + GLES20.glFlush(); + } + + public synchronized void enableView() { + Log.d(LOGTAG, "enableView"); + mEnabled = true; + updateState(); + } + + public synchronized void disableView() { + Log.d(LOGTAG, "disableView"); + mEnabled = false; + updateState(); + } + + protected void updateState() { + Log.d(LOGTAG, "updateState"); + Log.d(LOGTAG, "mEnabled="+mEnabled+", mHaveSurface="+mHaveSurface); + boolean willStart = mEnabled && mHaveSurface && mView.getVisibility() == View.VISIBLE; + if (willStart != mIsStarted) { + if(willStart) doStart(); + else doStop(); + } else { + Log.d(LOGTAG, "keeping State unchanged"); + } + Log.d(LOGTAG, "updateState end"); + } + + protected synchronized void doStart() { + Log.d(LOGTAG, "doStart"); + initSurfaceTexture(); + openCamera(mCameraIndex); + mIsStarted = true; + if(mCameraWidth>0 && mCameraHeight>0) + setPreviewSize(mCameraWidth, mCameraHeight); // start preview and call listener.onCameraViewStarted() + } + + + protected void doStop() { + Log.d(LOGTAG, "doStop"); + synchronized(this) { + mUpdateST = false; + mIsStarted = false; + mHaveFBO = false; + closeCamera(); + deleteSurfaceTexture(); + } + CameraTextureListener listener = mView.getCameraTextureListener(); + if(listener != null) listener.onCameraViewStopped(); + + } + + protected void setPreviewSize(int width, int height) { + synchronized(this) { + mHaveFBO = false; + mCameraWidth = width; + mCameraHeight = height; + setCameraPreviewSize(width, height); // can change mCameraWidth & mCameraHeight + initFBO(mCameraWidth, mCameraHeight); + mHaveFBO = true; + } + + CameraTextureListener listener = mView.getCameraTextureListener(); + if(listener != null) listener.onCameraViewStarted(mCameraWidth, mCameraHeight); + } + + public void setCameraIndex(int cameraIndex) { + disableView(); + mCameraIndex = cameraIndex; + enableView(); + } + + public void setMaxCameraPreviewSize(int maxWidth, int maxHeight) { + disableView(); + mMaxCameraWidth = maxWidth; + mMaxCameraHeight = maxHeight; + enableView(); + } + + public void onResume() { + Log.i(LOGTAG, "onResume"); + } + + public void onPause() { + Log.i(LOGTAG, "onPause"); + mHaveSurface = false; + updateState(); + mCameraWidth = mCameraHeight = -1; + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/CameraGLSurfaceView.java b/openCVLibrary330/src/main/java/org/opencv/android/CameraGLSurfaceView.java new file mode 100644 index 00000000000..05f950b4713 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/CameraGLSurfaceView.java @@ -0,0 +1,119 @@ +package org.opencv.android; + +import org.opencv.R; + +import android.content.Context; +import android.content.res.TypedArray; +import android.opengl.GLSurfaceView; +import android.util.AttributeSet; +import android.util.Log; +import android.view.SurfaceHolder; + +public class CameraGLSurfaceView extends GLSurfaceView { + + private static final String LOGTAG = "CameraGLSurfaceView"; + + public interface CameraTextureListener { + /** + * This method is invoked when camera preview has started. After this method is invoked + * the frames will start to be delivered to client via the onCameraFrame() callback. + * @param width - the width of the frames that will be delivered + * @param height - the height of the frames that will be delivered + */ + public void onCameraViewStarted(int width, int height); + + /** + * This method is invoked when camera preview has been stopped for some reason. + * No frames will be delivered via onCameraFrame() callback after this method is called. + */ + public void onCameraViewStopped(); + + /** + * This method is invoked when a new preview frame from Camera is ready. + * @param texIn - the OpenGL texture ID that contains frame in RGBA format + * @param texOut - the OpenGL texture ID that can be used to store modified frame image t display + * @param width - the width of the frame + * @param height - the height of the frame + * @return `true` if `texOut` should be displayed, `false` - to show `texIn` + */ + public boolean onCameraTexture(int texIn, int texOut, int width, int height); + }; + + private CameraTextureListener mTexListener; + private CameraGLRendererBase mRenderer; + + public CameraGLSurfaceView(Context context, AttributeSet attrs) { + super(context, attrs); + + TypedArray styledAttrs = getContext().obtainStyledAttributes(attrs, R.styleable.CameraBridgeViewBase); + int cameraIndex = styledAttrs.getInt(R.styleable.CameraBridgeViewBase_camera_id, -1); + styledAttrs.recycle(); + + if(android.os.Build.VERSION.SDK_INT >= 21) + mRenderer = new Camera2Renderer(this); + else + mRenderer = new CameraRenderer(this); + + setCameraIndex(cameraIndex); + + setEGLContextClientVersion(2); + setRenderer(mRenderer); + setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); + } + + public void setCameraTextureListener(CameraTextureListener texListener) + { + mTexListener = texListener; + } + + public CameraTextureListener getCameraTextureListener() + { + return mTexListener; + } + + public void setCameraIndex(int cameraIndex) { + mRenderer.setCameraIndex(cameraIndex); + } + + public void setMaxCameraPreviewSize(int maxWidth, int maxHeight) { + mRenderer.setMaxCameraPreviewSize(maxWidth, maxHeight); + } + + @Override + public void surfaceCreated(SurfaceHolder holder) { + super.surfaceCreated(holder); + } + + @Override + public void surfaceDestroyed(SurfaceHolder holder) { + mRenderer.mHaveSurface = false; + super.surfaceDestroyed(holder); + } + + @Override + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + } + + @Override + public void onResume() { + Log.i(LOGTAG, "onResume"); + super.onResume(); + mRenderer.onResume(); + } + + @Override + public void onPause() { + Log.i(LOGTAG, "onPause"); + mRenderer.onPause(); + super.onPause(); + } + + public void enableView() { + mRenderer.enableView(); + } + + public void disableView() { + mRenderer.disableView(); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/CameraRenderer.java b/openCVLibrary330/src/main/java/org/opencv/android/CameraRenderer.java new file mode 100644 index 00000000000..2d668ffa6e6 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/CameraRenderer.java @@ -0,0 +1,166 @@ +package org.opencv.android; + +import java.io.IOException; +import java.util.List; + +import android.annotation.TargetApi; +import android.hardware.Camera; +import android.hardware.Camera.Size; +import android.os.Build; +import android.util.Log; + +@TargetApi(15) +@SuppressWarnings("deprecation") +public class CameraRenderer extends CameraGLRendererBase { + + public static final String LOGTAG = "CameraRenderer"; + + private Camera mCamera; + private boolean mPreviewStarted = false; + + CameraRenderer(CameraGLSurfaceView view) { + super(view); + } + + @Override + protected synchronized void closeCamera() { + Log.i(LOGTAG, "closeCamera"); + if(mCamera != null) { + mCamera.stopPreview(); + mPreviewStarted = false; + mCamera.release(); + mCamera = null; + } + } + + @Override + protected synchronized void openCamera(int id) { + Log.i(LOGTAG, "openCamera"); + closeCamera(); + if (id == CameraBridgeViewBase.CAMERA_ID_ANY) { + Log.d(LOGTAG, "Trying to open camera with old open()"); + try { + mCamera = Camera.open(); + } + catch (Exception e){ + Log.e(LOGTAG, "Camera is not available (in use or does not exist): " + e.getLocalizedMessage()); + } + + if(mCamera == null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { + boolean connected = false; + for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) { + Log.d(LOGTAG, "Trying to open camera with new open(" + camIdx + ")"); + try { + mCamera = Camera.open(camIdx); + connected = true; + } catch (RuntimeException e) { + Log.e(LOGTAG, "Camera #" + camIdx + "failed to open: " + e.getLocalizedMessage()); + } + if (connected) break; + } + } + } else { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { + int localCameraIndex = mCameraIndex; + if (mCameraIndex == CameraBridgeViewBase.CAMERA_ID_BACK) { + Log.i(LOGTAG, "Trying to open BACK camera"); + Camera.CameraInfo cameraInfo = new Camera.CameraInfo(); + for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) { + Camera.getCameraInfo( camIdx, cameraInfo ); + if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) { + localCameraIndex = camIdx; + break; + } + } + } else if (mCameraIndex == CameraBridgeViewBase.CAMERA_ID_FRONT) { + Log.i(LOGTAG, "Trying to open FRONT camera"); + Camera.CameraInfo cameraInfo = new Camera.CameraInfo(); + for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) { + Camera.getCameraInfo( camIdx, cameraInfo ); + if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) { + localCameraIndex = camIdx; + break; + } + } + } + if (localCameraIndex == CameraBridgeViewBase.CAMERA_ID_BACK) { + Log.e(LOGTAG, "Back camera not found!"); + } else if (localCameraIndex == CameraBridgeViewBase.CAMERA_ID_FRONT) { + Log.e(LOGTAG, "Front camera not found!"); + } else { + Log.d(LOGTAG, "Trying to open camera with new open(" + localCameraIndex + ")"); + try { + mCamera = Camera.open(localCameraIndex); + } catch (RuntimeException e) { + Log.e(LOGTAG, "Camera #" + localCameraIndex + "failed to open: " + e.getLocalizedMessage()); + } + } + } + } + if(mCamera == null) { + Log.e(LOGTAG, "Error: can't open camera"); + return; + } + Camera.Parameters params = mCamera.getParameters(); + List FocusModes = params.getSupportedFocusModes(); + if (FocusModes != null && FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) + { + params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO); + } + mCamera.setParameters(params); + + try { + mCamera.setPreviewTexture(mSTexture); + } catch (IOException ioe) { + Log.e(LOGTAG, "setPreviewTexture() failed: " + ioe.getMessage()); + } + } + + @Override + public synchronized void setCameraPreviewSize(int width, int height) { + Log.i(LOGTAG, "setCameraPreviewSize: "+width+"x"+height); + if(mCamera == null) { + Log.e(LOGTAG, "Camera isn't initialized!"); + return; + } + + if(mMaxCameraWidth > 0 && mMaxCameraWidth < width) width = mMaxCameraWidth; + if(mMaxCameraHeight > 0 && mMaxCameraHeight < height) height = mMaxCameraHeight; + + Camera.Parameters param = mCamera.getParameters(); + List psize = param.getSupportedPreviewSizes(); + int bestWidth = 0, bestHeight = 0; + if (psize.size() > 0) { + float aspect = (float)width / height; + for (Size size : psize) { + int w = size.width, h = size.height; + Log.d(LOGTAG, "checking camera preview size: "+w+"x"+h); + if ( w <= width && h <= height && + w >= bestWidth && h >= bestHeight && + Math.abs(aspect - (float)w/h) < 0.2 ) { + bestWidth = w; + bestHeight = h; + } + } + if(bestWidth <= 0 || bestHeight <= 0) { + bestWidth = psize.get(0).width; + bestHeight = psize.get(0).height; + Log.e(LOGTAG, "Error: best size was not selected, using "+bestWidth+" x "+bestHeight); + } else { + Log.i(LOGTAG, "Selected best size: "+bestWidth+" x "+bestHeight); + } + + if(mPreviewStarted) { + mCamera.stopPreview(); + mPreviewStarted = false; + } + mCameraWidth = bestWidth; + mCameraHeight = bestHeight; + param.setPreviewSize(bestWidth, bestHeight); + } + param.set("orientation", "landscape"); + mCamera.setParameters(param); + mCamera.startPreview(); + mPreviewStarted = true; + } +} \ No newline at end of file diff --git a/openCVLibrary330/src/main/java/org/opencv/android/FpsMeter.java b/openCVLibrary330/src/main/java/org/opencv/android/FpsMeter.java new file mode 100644 index 00000000000..88e826cf965 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/FpsMeter.java @@ -0,0 +1,66 @@ +package org.opencv.android; + +import java.text.DecimalFormat; + +import org.opencv.core.Core; + +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.util.Log; + +public class FpsMeter { + private static final String TAG = "FpsMeter"; + private static final int STEP = 20; + private static final DecimalFormat FPS_FORMAT = new DecimalFormat("0.00"); + + private int mFramesCouner; + private double mFrequency; + private long mprevFrameTime; + private String mStrfps; + Paint mPaint; + boolean mIsInitialized = false; + int mWidth = 0; + int mHeight = 0; + + public void init() { + mFramesCouner = 0; + mFrequency = Core.getTickFrequency(); + mprevFrameTime = Core.getTickCount(); + mStrfps = ""; + + mPaint = new Paint(); + mPaint.setColor(Color.BLUE); + mPaint.setTextSize(20); + } + + public void measure() { + if (!mIsInitialized) { + init(); + mIsInitialized = true; + } else { + mFramesCouner++; + if (mFramesCouner % STEP == 0) { + long time = Core.getTickCount(); + double fps = STEP * mFrequency / (time - mprevFrameTime); + mprevFrameTime = time; + if (mWidth != 0 && mHeight != 0) + mStrfps = FPS_FORMAT.format(fps) + " FPS@" + Integer.valueOf(mWidth) + "x" + Integer.valueOf(mHeight); + else + mStrfps = FPS_FORMAT.format(fps) + " FPS"; + Log.i(TAG, mStrfps); + } + } + } + + public void setResolution(int width, int height) { + mWidth = width; + mHeight = height; + } + + public void draw(Canvas canvas, float offsetx, float offsety) { + Log.d(TAG, mStrfps); + canvas.drawText(mStrfps, offsetx, offsety, mPaint); + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/InstallCallbackInterface.java b/openCVLibrary330/src/main/java/org/opencv/android/InstallCallbackInterface.java new file mode 100644 index 00000000000..f68027a7ba2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/InstallCallbackInterface.java @@ -0,0 +1,34 @@ +package org.opencv.android; + +/** + * Installation callback interface. + */ +public interface InstallCallbackInterface +{ + /** + * New package installation is required. + */ + static final int NEW_INSTALLATION = 0; + /** + * Current package installation is in progress. + */ + static final int INSTALLATION_PROGRESS = 1; + + /** + * Target package name. + * @return Return target package name. + */ + public String getPackageName(); + /** + * Installation is approved. + */ + public void install(); + /** + * Installation is canceled. + */ + public void cancel(); + /** + * Wait for package installation. + */ + public void wait_install(); +}; diff --git a/openCVLibrary330/src/main/java/org/opencv/android/JavaCameraView.java b/openCVLibrary330/src/main/java/org/opencv/android/JavaCameraView.java new file mode 100644 index 00000000000..c9b2e2dfc9a --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/JavaCameraView.java @@ -0,0 +1,385 @@ +package org.opencv.android; + +import java.util.List; +import java.util.logging.Logger; + +import android.content.Context; +import android.graphics.ImageFormat; +import android.graphics.SurfaceTexture; +import android.hardware.Camera; +import android.hardware.Camera.PreviewCallback; +import android.os.Build; +import android.util.AttributeSet; +import android.util.Log; +import android.view.ViewGroup.LayoutParams; + +import org.opencv.BuildConfig; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.Size; +import org.opencv.imgproc.Imgproc; + +/** + * This class is an implementation of the Bridge View between OpenCV and Java Camera. + * This class relays on the functionality available in base class and only implements + * required functions: + * connectCamera - opens Java camera and sets the PreviewCallback to be delivered. + * disconnectCamera - closes the camera and stops preview. + * When frame is delivered via callback from Camera - it processed via OpenCV to be + * converted to RGBA32 and then passed to the external callback for modifications if required. + */ +public class JavaCameraView extends CameraBridgeViewBase implements PreviewCallback { + + private static final int MAGIC_TEXTURE_ID = 10; + private static final String TAG = "JavaCameraView"; + + private byte mBuffer[]; + private Mat[] mFrameChain; + private int mChainIdx = 0; + private Thread mThread; + private boolean mStopThread; + + protected Camera mCamera; + protected JavaCameraFrame[] mCameraFrame; + private SurfaceTexture mSurfaceTexture; + private int mPreviewFormat = ImageFormat.NV21; + + public static class JavaCameraSizeAccessor implements ListItemAccessor { + + @Override + public int getWidth(Object obj) { + Camera.Size size = (Camera.Size) obj; + return size.width; + } + + @Override + public int getHeight(Object obj) { + Camera.Size size = (Camera.Size) obj; + return size.height; + } + } + + public JavaCameraView(Context context, int cameraId) { + super(context, cameraId); + } + + public JavaCameraView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + protected boolean initializeCamera(int width, int height) { + Log.d(TAG, "Initialize java camera"); + boolean result = true; + synchronized (this) { + mCamera = null; + + if (mCameraIndex == CAMERA_ID_ANY) { + Log.d(TAG, "Trying to open camera with old open()"); + try { + mCamera = Camera.open(); + } + catch (Exception e){ + Log.e(TAG, "Camera is not available (in use or does not exist): " + e.getLocalizedMessage()); + } + + if(mCamera == null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { + boolean connected = false; + for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) { + Log.d(TAG, "Trying to open camera with new open(" + Integer.valueOf(camIdx) + ")"); + try { + mCamera = Camera.open(camIdx); + connected = true; + } catch (RuntimeException e) { + Log.e(TAG, "Camera #" + camIdx + "failed to open: " + e.getLocalizedMessage()); + } + if (connected) break; + } + } + } else { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { + int localCameraIndex = mCameraIndex; + if (mCameraIndex == CAMERA_ID_BACK) { + Log.i(TAG, "Trying to open back camera"); + Camera.CameraInfo cameraInfo = new Camera.CameraInfo(); + for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) { + Camera.getCameraInfo( camIdx, cameraInfo ); + if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) { + localCameraIndex = camIdx; + break; + } + } + } else if (mCameraIndex == CAMERA_ID_FRONT) { + Log.i(TAG, "Trying to open front camera"); + Camera.CameraInfo cameraInfo = new Camera.CameraInfo(); + for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) { + Camera.getCameraInfo( camIdx, cameraInfo ); + if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) { + localCameraIndex = camIdx; + break; + } + } + } + if (localCameraIndex == CAMERA_ID_BACK) { + Log.e(TAG, "Back camera not found!"); + } else if (localCameraIndex == CAMERA_ID_FRONT) { + Log.e(TAG, "Front camera not found!"); + } else { + Log.d(TAG, "Trying to open camera with new open(" + Integer.valueOf(localCameraIndex) + ")"); + try { + mCamera = Camera.open(localCameraIndex); + } catch (RuntimeException e) { + Log.e(TAG, "Camera #" + localCameraIndex + "failed to open: " + e.getLocalizedMessage()); + } + } + } + } + + if (mCamera == null) + return false; + + /* Now set camera parameters */ + try { + /* Focal length debug logging for funsizes */ + Camera.Parameters params = mCamera.getParameters(); + + Log.i("TEST", "Horizontal angle:" + Float.toString(params.getHorizontalViewAngle())); + Log.i("TEST", "Vertical angle:" + Float.toString(params.getVerticalViewAngle())); + + Log.d(TAG, "getSupportedPreviewSizes()"); + List sizes = params.getSupportedPreviewSizes(); + + if (sizes != null) { + /* Select the size that fits surface considering maximum size allowed */ + Size frameSize = calculateCameraFrameSize(sizes, new JavaCameraSizeAccessor(), width, height); + + /* Image format NV21 causes issues in the Android emulators */ + if (Build.FINGERPRINT.startsWith("generic") + || Build.FINGERPRINT.startsWith("unknown") + || Build.MODEL.contains("google_sdk") + || Build.MODEL.contains("Emulator") + || Build.MODEL.contains("Android SDK built for x86") + || Build.MANUFACTURER.contains("Genymotion") + || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")) + || "google_sdk".equals(Build.PRODUCT)) + params.setPreviewFormat(ImageFormat.YV12); // "generic" or "android" = android emulator + else + params.setPreviewFormat(ImageFormat.NV21); + + mPreviewFormat = params.getPreviewFormat(); + + Log.d(TAG, "Set preview size to " + Integer.valueOf((int)frameSize.width) + "x" + Integer.valueOf((int)frameSize.height)); + params.setPreviewSize((int)frameSize.width, (int)frameSize.height); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH && !android.os.Build.MODEL.equals("GT-I9100")) + params.setRecordingHint(true); + + List FocusModes = params.getSupportedFocusModes(); + if (FocusModes != null && FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) + { + params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO); + } + + mCamera.setParameters(params); + params = mCamera.getParameters(); + + mFrameWidth = params.getPreviewSize().width; + mFrameHeight = params.getPreviewSize().height; + + if ((getLayoutParams().width == LayoutParams.MATCH_PARENT) && (getLayoutParams().height == LayoutParams.MATCH_PARENT)) + mScale = Math.min(((float)height)/mFrameHeight, ((float)width)/mFrameWidth); + else + mScale = 0; + + if (mFpsMeter != null) { + mFpsMeter.setResolution(mFrameWidth, mFrameHeight); + } + + int size = mFrameWidth * mFrameHeight; + size = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8; + mBuffer = new byte[size]; + + mCamera.addCallbackBuffer(mBuffer); + mCamera.setPreviewCallbackWithBuffer(this); + + mFrameChain = new Mat[2]; + mFrameChain[0] = new Mat(mFrameHeight + (mFrameHeight/2), mFrameWidth, CvType.CV_8UC1); + mFrameChain[1] = new Mat(mFrameHeight + (mFrameHeight/2), mFrameWidth, CvType.CV_8UC1); + + AllocateCache(); + + mCameraFrame = new JavaCameraFrame[2]; + mCameraFrame[0] = new JavaCameraFrame(mFrameChain[0], mFrameWidth, mFrameHeight); + mCameraFrame[1] = new JavaCameraFrame(mFrameChain[1], mFrameWidth, mFrameHeight); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { + mSurfaceTexture = new SurfaceTexture(MAGIC_TEXTURE_ID); + mCamera.setPreviewTexture(mSurfaceTexture); + } else + mCamera.setPreviewDisplay(null); + + /* Finally we are ready to start the preview */ + Log.d(TAG, "startPreview"); + mCamera.startPreview(); + } + else + result = false; + } catch (Exception e) { + result = false; + e.printStackTrace(); + } + } + + return result; + } + + protected void releaseCamera() { + synchronized (this) { + if (mCamera != null) { + mCamera.stopPreview(); + mCamera.setPreviewCallback(null); + + mCamera.release(); + } + mCamera = null; + if (mFrameChain != null) { + mFrameChain[0].release(); + mFrameChain[1].release(); + } + if (mCameraFrame != null) { + mCameraFrame[0].release(); + mCameraFrame[1].release(); + } + } + } + + private boolean mCameraFrameReady = false; + + @Override + protected boolean connectCamera(int width, int height) { + + /* 1. We need to instantiate camera + * 2. We need to start thread which will be getting frames + */ + /* First step - initialize camera connection */ + Log.d(TAG, "Connecting to camera"); + if (!initializeCamera(width, height)) + return false; + + mCameraFrameReady = false; + + /* now we can start update thread */ + Log.d(TAG, "Starting processing thread"); + mStopThread = false; + mThread = new Thread(new CameraWorker()); + mThread.start(); + + return true; + } + + @Override + protected void disconnectCamera() { + /* 1. We need to stop thread which updating the frames + * 2. Stop camera and release it + */ + Log.d(TAG, "Disconnecting from camera"); + try { + mStopThread = true; + Log.d(TAG, "Notify thread"); + synchronized (this) { + this.notify(); + } + Log.d(TAG, "Waiting for thread"); + if (mThread != null) + mThread.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + mThread = null; + } + + /* Now release camera */ + releaseCamera(); + + mCameraFrameReady = false; + } + + @Override + public void onPreviewFrame(byte[] frame, Camera arg1) { + if (BuildConfig.DEBUG) + Log.d(TAG, "Preview Frame received. Frame size: " + frame.length); + synchronized (this) { + mFrameChain[mChainIdx].put(0, 0, frame); + mCameraFrameReady = true; + this.notify(); + } + if (mCamera != null) + mCamera.addCallbackBuffer(mBuffer); + } + + private class JavaCameraFrame implements CvCameraViewFrame { + @Override + public Mat gray() { + return mYuvFrameData.submat(0, mHeight, 0, mWidth); + } + + @Override + public Mat rgba() { + if (mPreviewFormat == ImageFormat.NV21) + Imgproc.cvtColor(mYuvFrameData, mRgba, Imgproc.COLOR_YUV2RGBA_NV21, 4); + else if (mPreviewFormat == ImageFormat.YV12) + Imgproc.cvtColor(mYuvFrameData, mRgba, Imgproc.COLOR_YUV2RGB_I420, 4); // COLOR_YUV2RGBA_YV12 produces inverted colors + else + throw new IllegalArgumentException("Preview Format can be NV21 or YV12"); + + return mRgba; + } + + public JavaCameraFrame(Mat Yuv420sp, int width, int height) { + super(); + mWidth = width; + mHeight = height; + mYuvFrameData = Yuv420sp; + mRgba = new Mat(); + } + + public void release() { + mRgba.release(); + } + + private Mat mYuvFrameData; + private Mat mRgba; + private int mWidth; + private int mHeight; + }; + + private class CameraWorker implements Runnable { + + @Override + public void run() { + do { + boolean hasFrame = false; + synchronized (JavaCameraView.this) { + try { + while (!mCameraFrameReady && !mStopThread) { + JavaCameraView.this.wait(); + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + if (mCameraFrameReady) + { + mChainIdx = 1 - mChainIdx; + mCameraFrameReady = false; + hasFrame = true; + } + } + + if (!mStopThread && hasFrame) { + if (!mFrameChain[1 - mChainIdx].empty()) + deliverAndDrawFrame(mCameraFrame[1 - mChainIdx]); + } + } while (!mStopThread); + Log.d(TAG, "Finish processing thread"); + } + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/LoaderCallbackInterface.java b/openCVLibrary330/src/main/java/org/opencv/android/LoaderCallbackInterface.java new file mode 100644 index 00000000000..a941e8377b6 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/LoaderCallbackInterface.java @@ -0,0 +1,40 @@ +package org.opencv.android; + +/** + * Interface for callback object in case of asynchronous initialization of OpenCV. + */ +public interface LoaderCallbackInterface +{ + /** + * OpenCV initialization finished successfully. + */ + static final int SUCCESS = 0; + /** + * Google Play Market cannot be invoked. + */ + static final int MARKET_ERROR = 2; + /** + * OpenCV library installation has been canceled by the user. + */ + static final int INSTALL_CANCELED = 3; + /** + * This version of OpenCV Manager Service is incompatible with the app. Possibly, a service update is required. + */ + static final int INCOMPATIBLE_MANAGER_VERSION = 4; + /** + * OpenCV library initialization has failed. + */ + static final int INIT_FAILED = 0xff; + + /** + * Callback method, called after OpenCV library initialization. + * @param status status of initialization (see initialization status constants). + */ + public void onManagerConnected(int status); + + /** + * Callback method, called in case the package installation is needed. + * @param callback answer object with approve and cancel methods and the package description. + */ + public void onPackageInstall(final int operation, InstallCallbackInterface callback); +}; diff --git a/openCVLibrary330/src/main/java/org/opencv/android/OpenCVLoader.java b/openCVLibrary330/src/main/java/org/opencv/android/OpenCVLoader.java new file mode 100644 index 00000000000..947b9b89746 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/OpenCVLoader.java @@ -0,0 +1,127 @@ +package org.opencv.android; + +import android.content.Context; + +/** + * Helper class provides common initialization methods for OpenCV library. + */ +public class OpenCVLoader +{ + /** + * OpenCV Library version 2.4.2. + */ + public static final String OPENCV_VERSION_2_4_2 = "2.4.2"; + + /** + * OpenCV Library version 2.4.3. + */ + public static final String OPENCV_VERSION_2_4_3 = "2.4.3"; + + /** + * OpenCV Library version 2.4.4. + */ + public static final String OPENCV_VERSION_2_4_4 = "2.4.4"; + + /** + * OpenCV Library version 2.4.5. + */ + public static final String OPENCV_VERSION_2_4_5 = "2.4.5"; + + /** + * OpenCV Library version 2.4.6. + */ + public static final String OPENCV_VERSION_2_4_6 = "2.4.6"; + + /** + * OpenCV Library version 2.4.7. + */ + public static final String OPENCV_VERSION_2_4_7 = "2.4.7"; + + /** + * OpenCV Library version 2.4.8. + */ + public static final String OPENCV_VERSION_2_4_8 = "2.4.8"; + + /** + * OpenCV Library version 2.4.9. + */ + public static final String OPENCV_VERSION_2_4_9 = "2.4.9"; + + /** + * OpenCV Library version 2.4.10. + */ + public static final String OPENCV_VERSION_2_4_10 = "2.4.10"; + + /** + * OpenCV Library version 2.4.11. + */ + public static final String OPENCV_VERSION_2_4_11 = "2.4.11"; + + /** + * OpenCV Library version 2.4.12. + */ + public static final String OPENCV_VERSION_2_4_12 = "2.4.12"; + + /** + * OpenCV Library version 2.4.13. + */ + public static final String OPENCV_VERSION_2_4_13 = "2.4.13"; + + /** + * OpenCV Library version 3.0.0. + */ + public static final String OPENCV_VERSION_3_0_0 = "3.0.0"; + + /** + * OpenCV Library version 3.1.0. + */ + public static final String OPENCV_VERSION_3_1_0 = "3.1.0"; + + /** + * OpenCV Library version 3.2.0. + */ + public static final String OPENCV_VERSION_3_2_0 = "3.2.0"; + + /** + * OpenCV Library version 3.3.0. + */ + public static final String OPENCV_VERSION_3_3_0 = "3.3.0"; + + /** + * Current OpenCV Library version + */ + public static final String OPENCV_VERSION = "3.3.0"; + + + /** + * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java"). + * @return Returns true is initialization of OpenCV was successful. + */ + public static boolean initDebug() + { + return StaticHelper.initOpenCV(false); + } + + /** + * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java"). + * @param InitCuda load and initialize CUDA runtime libraries. + * @return Returns true is initialization of OpenCV was successful. + */ + public static boolean initDebug(boolean InitCuda) + { + return StaticHelper.initOpenCV(InitCuda); + } + + /** + * Loads and initializes OpenCV library using OpenCV Engine service. + * @param Version OpenCV library version. + * @param AppContext application context for connecting to the service. + * @param Callback object, that implements LoaderCallbackInterface for handling the connection status. + * @return Returns true if initialization of OpenCV is successful. + */ + public static boolean initAsync(String Version, Context AppContext, + LoaderCallbackInterface Callback) + { + return AsyncServiceHelper.initOpenCV(Version, AppContext, Callback); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/StaticHelper.java b/openCVLibrary330/src/main/java/org/opencv/android/StaticHelper.java new file mode 100644 index 00000000000..36f9f6f64a4 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/StaticHelper.java @@ -0,0 +1,104 @@ +package org.opencv.android; + +import org.opencv.core.Core; + +import java.util.StringTokenizer; +import android.util.Log; + +class StaticHelper { + + public static boolean initOpenCV(boolean InitCuda) + { + boolean result; + String libs = ""; + + if(InitCuda) + { + loadLibrary("cudart"); + loadLibrary("nppc"); + loadLibrary("nppi"); + loadLibrary("npps"); + loadLibrary("cufft"); + loadLibrary("cublas"); + } + + Log.d(TAG, "Trying to get library list"); + + try + { + System.loadLibrary("opencv_info"); + libs = getLibraryList(); + } + catch(UnsatisfiedLinkError e) + { + Log.e(TAG, "OpenCV error: Cannot load info library for OpenCV"); + } + + Log.d(TAG, "Library list: \"" + libs + "\""); + Log.d(TAG, "First attempt to load libs"); + if (initOpenCVLibs(libs)) + { + Log.d(TAG, "First attempt to load libs is OK"); + String eol = System.getProperty("line.separator"); + for (String str : Core.getBuildInformation().split(eol)) + Log.i(TAG, str); + + result = true; + } + else + { + Log.d(TAG, "First attempt to load libs fails"); + result = false; + } + + return result; + } + + private static boolean loadLibrary(String Name) + { + boolean result = true; + + Log.d(TAG, "Trying to load library " + Name); + try + { + System.loadLibrary(Name); + Log.d(TAG, "Library " + Name + " loaded"); + } + catch(UnsatisfiedLinkError e) + { + Log.d(TAG, "Cannot load library \"" + Name + "\""); + e.printStackTrace(); + result &= false; + } + + return result; + } + + private static boolean initOpenCVLibs(String Libs) + { + Log.d(TAG, "Trying to init OpenCV libs"); + + boolean result = true; + + if ((null != Libs) && (Libs.length() != 0)) + { + Log.d(TAG, "Trying to load libs by dependency list"); + StringTokenizer splitter = new StringTokenizer(Libs, ";"); + while(splitter.hasMoreTokens()) + { + result &= loadLibrary(splitter.nextToken()); + } + } + else + { + // If dependencies list is not defined or empty. + result &= loadLibrary("opencv_java3"); + } + + return result; + } + + private static final String TAG = "OpenCV/StaticHelper"; + + private static native String getLibraryList(); +} diff --git a/openCVLibrary330/src/main/java/org/opencv/android/Utils.java b/openCVLibrary330/src/main/java/org/opencv/android/Utils.java new file mode 100644 index 00000000000..404c986da80 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/android/Utils.java @@ -0,0 +1,139 @@ +package org.opencv.android; + +import android.content.Context; +import android.graphics.Bitmap; + +import org.opencv.core.CvException; +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.imgcodecs.Imgcodecs; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; + +public class Utils { + + public static String exportResource(Context context, int resourceId) { + return exportResource(context, resourceId, "OpenCV_data"); + } + + public static String exportResource(Context context, int resourceId, String dirname) { + String fullname = context.getResources().getString(resourceId); + String resName = fullname.substring(fullname.lastIndexOf("/") + 1); + try { + InputStream is = context.getResources().openRawResource(resourceId); + File resDir = context.getDir(dirname, Context.MODE_PRIVATE); + File resFile = new File(resDir, resName); + + FileOutputStream os = new FileOutputStream(resFile); + + byte[] buffer = new byte[4096]; + int bytesRead; + while ((bytesRead = is.read(buffer)) != -1) { + os.write(buffer, 0, bytesRead); + } + is.close(); + os.close(); + + return resFile.getAbsolutePath(); + } catch (IOException e) { + e.printStackTrace(); + throw new CvException("Failed to export resource " + resName + + ". Exception thrown: " + e); + } + } + + public static Mat loadResource(Context context, int resourceId) throws IOException + { + return loadResource(context, resourceId, -1); + } + + public static Mat loadResource(Context context, int resourceId, int flags) throws IOException + { + InputStream is = context.getResources().openRawResource(resourceId); + ByteArrayOutputStream os = new ByteArrayOutputStream(is.available()); + + byte[] buffer = new byte[4096]; + int bytesRead; + while ((bytesRead = is.read(buffer)) != -1) { + os.write(buffer, 0, bytesRead); + } + is.close(); + + Mat encoded = new Mat(1, os.size(), CvType.CV_8U); + encoded.put(0, 0, os.toByteArray()); + os.close(); + + Mat decoded = Imgcodecs.imdecode(encoded, flags); + encoded.release(); + + return decoded; + } + + /** + * Converts Android Bitmap to OpenCV Mat. + *

+ * This function converts an Android Bitmap image to the OpenCV Mat. + *
'ARGB_8888' and 'RGB_565' input Bitmap formats are supported. + *
The output Mat is always created of the same size as the input Bitmap and of the 'CV_8UC4' type, + * it keeps the image in RGBA format. + *
This function throws an exception if the conversion fails. + * @param bmp is a valid input Bitmap object of the type 'ARGB_8888' or 'RGB_565'. + * @param mat is a valid output Mat object, it will be reallocated if needed, so it may be empty. + * @param unPremultiplyAlpha is a flag, that determines, whether the bitmap needs to be converted from alpha premultiplied format (like Android keeps 'ARGB_8888' ones) to regular one; this flag is ignored for 'RGB_565' bitmaps. + */ + public static void bitmapToMat(Bitmap bmp, Mat mat, boolean unPremultiplyAlpha) { + if (bmp == null) + throw new java.lang.IllegalArgumentException("bmp == null"); + if (mat == null) + throw new java.lang.IllegalArgumentException("mat == null"); + nBitmapToMat2(bmp, mat.nativeObj, unPremultiplyAlpha); + } + + /** + * Short form of the bitmapToMat(bmp, mat, unPremultiplyAlpha=false). + * @param bmp is a valid input Bitmap object of the type 'ARGB_8888' or 'RGB_565'. + * @param mat is a valid output Mat object, it will be reallocated if needed, so Mat may be empty. + */ + public static void bitmapToMat(Bitmap bmp, Mat mat) { + bitmapToMat(bmp, mat, false); + } + + + /** + * Converts OpenCV Mat to Android Bitmap. + *

+ *
This function converts an image in the OpenCV Mat representation to the Android Bitmap. + *
The input Mat object has to be of the types 'CV_8UC1' (gray-scale), 'CV_8UC3' (RGB) or 'CV_8UC4' (RGBA). + *
The output Bitmap object has to be of the same size as the input Mat and of the types 'ARGB_8888' or 'RGB_565'. + *
This function throws an exception if the conversion fails. + * + * @param mat is a valid input Mat object of types 'CV_8UC1', 'CV_8UC3' or 'CV_8UC4'. + * @param bmp is a valid Bitmap object of the same size as the Mat and of type 'ARGB_8888' or 'RGB_565'. + * @param premultiplyAlpha is a flag, that determines, whether the Mat needs to be converted to alpha premultiplied format (like Android keeps 'ARGB_8888' bitmaps); the flag is ignored for 'RGB_565' bitmaps. + */ + public static void matToBitmap(Mat mat, Bitmap bmp, boolean premultiplyAlpha) { + if (mat == null) + throw new java.lang.IllegalArgumentException("mat == null"); + if (bmp == null) + throw new java.lang.IllegalArgumentException("bmp == null"); + nMatToBitmap2(mat.nativeObj, bmp, premultiplyAlpha); + } + + /** + * Short form of the matToBitmap(mat, bmp, premultiplyAlpha=false) + * @param mat is a valid input Mat object of the types 'CV_8UC1', 'CV_8UC3' or 'CV_8UC4'. + * @param bmp is a valid Bitmap object of the same size as the Mat and of type 'ARGB_8888' or 'RGB_565'. + */ + public static void matToBitmap(Mat mat, Bitmap bmp) { + matToBitmap(mat, bmp, false); + } + + + private static native void nBitmapToMat2(Bitmap b, long m_addr, boolean unPremultiplyAlpha); + + private static native void nMatToBitmap2(long m_addr, Bitmap b, boolean premultiplyAlpha); +} diff --git a/openCVLibrary330/src/main/java/org/opencv/calib3d/Calib3d.java b/openCVLibrary330/src/main/java/org/opencv/calib3d/Calib3d.java new file mode 100644 index 00000000000..4ac7a200e6c --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/calib3d/Calib3d.java @@ -0,0 +1,1564 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.calib3d; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfDouble; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.MatOfPoint3f; +import org.opencv.core.Point; +import org.opencv.core.Rect; +import org.opencv.core.Size; +import org.opencv.core.TermCriteria; +import org.opencv.utils.Converters; + +public class Calib3d { + + public static final int + CALIB_USE_INTRINSIC_GUESS = 1, + CALIB_RECOMPUTE_EXTRINSIC = 2, + CALIB_CHECK_COND = 4, + CALIB_FIX_SKEW = 8, + CALIB_FIX_K1 = 16, + CALIB_FIX_K2 = 32, + CALIB_FIX_K3 = 64, + CALIB_FIX_K4 = 128, + CALIB_FIX_INTRINSIC = 256, + CV_ITERATIVE = 0, + CV_EPNP = 1, + CV_P3P = 2, + CV_DLS = 3, + LMEDS = 4, + RANSAC = 8, + RHO = 16, + SOLVEPNP_ITERATIVE = 0, + SOLVEPNP_EPNP = 1, + SOLVEPNP_P3P = 2, + SOLVEPNP_DLS = 3, + SOLVEPNP_UPNP = 4, + SOLVEPNP_AP3P = 5, + SOLVEPNP_MAX_COUNT = 5+1, + CALIB_CB_ADAPTIVE_THRESH = 1, + CALIB_CB_NORMALIZE_IMAGE = 2, + CALIB_CB_FILTER_QUADS = 4, + CALIB_CB_FAST_CHECK = 8, + CALIB_CB_SYMMETRIC_GRID = 1, + CALIB_CB_ASYMMETRIC_GRID = 2, + CALIB_CB_CLUSTERING = 4, + CALIB_FIX_ASPECT_RATIO = 0x00002, + CALIB_FIX_PRINCIPAL_POINT = 0x00004, + CALIB_ZERO_TANGENT_DIST = 0x00008, + CALIB_FIX_FOCAL_LENGTH = 0x00010, + CALIB_FIX_K5 = 0x01000, + CALIB_FIX_K6 = 0x02000, + CALIB_RATIONAL_MODEL = 0x04000, + CALIB_THIN_PRISM_MODEL = 0x08000, + CALIB_FIX_S1_S2_S3_S4 = 0x10000, + CALIB_TILTED_MODEL = 0x40000, + CALIB_FIX_TAUX_TAUY = 0x80000, + CALIB_USE_QR = 0x100000, + CALIB_FIX_TANGENT_DIST = 0x200000, + CALIB_SAME_FOCAL_LENGTH = 0x00200, + CALIB_ZERO_DISPARITY = 0x00400, + CALIB_USE_LU = (1 << 17), + FM_7POINT = 1, + FM_8POINT = 2, + FM_LMEDS = 4, + FM_RANSAC = 8; + + + // + // C++: Mat estimateAffine2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10) + // + + //javadoc: estimateAffine2D(from, to, inliers, method, ransacReprojThreshold, maxIters, confidence, refineIters) + public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters) + { + + Mat retVal = new Mat(estimateAffine2D_0(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters, confidence, refineIters)); + + return retVal; + } + + //javadoc: estimateAffine2D(from, to) + public static Mat estimateAffine2D(Mat from, Mat to) + { + + Mat retVal = new Mat(estimateAffine2D_1(from.nativeObj, to.nativeObj)); + + return retVal; + } + + + // + // C++: Mat estimateAffinePartial2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10) + // + + //javadoc: estimateAffinePartial2D(from, to, inliers, method, ransacReprojThreshold, maxIters, confidence, refineIters) + public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters) + { + + Mat retVal = new Mat(estimateAffinePartial2D_0(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters, confidence, refineIters)); + + return retVal; + } + + //javadoc: estimateAffinePartial2D(from, to) + public static Mat estimateAffinePartial2D(Mat from, Mat to) + { + + Mat retVal = new Mat(estimateAffinePartial2D_1(from.nativeObj, to.nativeObj)); + + return retVal; + } + + + // + // C++: Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat()) + // + + //javadoc: findEssentialMat(points1, points2, cameraMatrix, method, prob, threshold, mask) + public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, Mat mask) + { + + Mat retVal = new Mat(findEssentialMat_0(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, method, prob, threshold, mask.nativeObj)); + + return retVal; + } + + //javadoc: findEssentialMat(points1, points2, cameraMatrix, method, prob, threshold) + public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold) + { + + Mat retVal = new Mat(findEssentialMat_1(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, method, prob, threshold)); + + return retVal; + } + + //javadoc: findEssentialMat(points1, points2, cameraMatrix) + public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix) + { + + Mat retVal = new Mat(findEssentialMat_2(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj)); + + return retVal; + } + + + // + // C++: Mat findEssentialMat(Mat points1, Mat points2, double focal = 1.0, Point2d pp = Point2d(0, 0), int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat()) + // + + //javadoc: findEssentialMat(points1, points2, focal, pp, method, prob, threshold, mask) + public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold, Mat mask) + { + + Mat retVal = new Mat(findEssentialMat_3(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y, method, prob, threshold, mask.nativeObj)); + + return retVal; + } + + //javadoc: findEssentialMat(points1, points2, focal, pp, method, prob, threshold) + public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold) + { + + Mat retVal = new Mat(findEssentialMat_4(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y, method, prob, threshold)); + + return retVal; + } + + //javadoc: findEssentialMat(points1, points2) + public static Mat findEssentialMat(Mat points1, Mat points2) + { + + Mat retVal = new Mat(findEssentialMat_5(points1.nativeObj, points2.nativeObj)); + + return retVal; + } + + + // + // C++: Mat findFundamentalMat(vector_Point2f points1, vector_Point2f points2, int method = FM_RANSAC, double param1 = 3., double param2 = 0.99, Mat& mask = Mat()) + // + + //javadoc: findFundamentalMat(points1, points2, method, param1, param2, mask) + public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double param1, double param2, Mat mask) + { + Mat points1_mat = points1; + Mat points2_mat = points2; + Mat retVal = new Mat(findFundamentalMat_0(points1_mat.nativeObj, points2_mat.nativeObj, method, param1, param2, mask.nativeObj)); + + return retVal; + } + + //javadoc: findFundamentalMat(points1, points2, method, param1, param2) + public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double param1, double param2) + { + Mat points1_mat = points1; + Mat points2_mat = points2; + Mat retVal = new Mat(findFundamentalMat_1(points1_mat.nativeObj, points2_mat.nativeObj, method, param1, param2)); + + return retVal; + } + + //javadoc: findFundamentalMat(points1, points2) + public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2) + { + Mat points1_mat = points1; + Mat points2_mat = points2; + Mat retVal = new Mat(findFundamentalMat_2(points1_mat.nativeObj, points2_mat.nativeObj)); + + return retVal; + } + + + // + // C++: Mat findHomography(vector_Point2f srcPoints, vector_Point2f dstPoints, int method = 0, double ransacReprojThreshold = 3, Mat& mask = Mat(), int maxIters = 2000, double confidence = 0.995) + // + + //javadoc: findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, mask, maxIters, confidence) + public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence) + { + Mat srcPoints_mat = srcPoints; + Mat dstPoints_mat = dstPoints; + Mat retVal = new Mat(findHomography_0(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method, ransacReprojThreshold, mask.nativeObj, maxIters, confidence)); + + return retVal; + } + + //javadoc: findHomography(srcPoints, dstPoints, method, ransacReprojThreshold) + public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold) + { + Mat srcPoints_mat = srcPoints; + Mat dstPoints_mat = dstPoints; + Mat retVal = new Mat(findHomography_1(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method, ransacReprojThreshold)); + + return retVal; + } + + //javadoc: findHomography(srcPoints, dstPoints) + public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints) + { + Mat srcPoints_mat = srcPoints; + Mat dstPoints_mat = dstPoints; + Mat retVal = new Mat(findHomography_2(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj)); + + return retVal; + } + + + // + // C++: Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize = Size(), Rect* validPixROI = 0, bool centerPrincipalPoint = false) + // + + //javadoc: getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newImgSize, validPixROI, centerPrincipalPoint) + public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint) + { + double[] validPixROI_out = new double[4]; + Mat retVal = new Mat(getOptimalNewCameraMatrix_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha, newImgSize.width, newImgSize.height, validPixROI_out, centerPrincipalPoint)); + if(validPixROI!=null){ validPixROI.x = (int)validPixROI_out[0]; validPixROI.y = (int)validPixROI_out[1]; validPixROI.width = (int)validPixROI_out[2]; validPixROI.height = (int)validPixROI_out[3]; } + return retVal; + } + + //javadoc: getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha) + public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha) + { + + Mat retVal = new Mat(getOptimalNewCameraMatrix_1(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha)); + + return retVal; + } + + + // + // C++: Mat initCameraMatrix2D(vector_vector_Point3f objectPoints, vector_vector_Point2f imagePoints, Size imageSize, double aspectRatio = 1.0) + // + + //javadoc: initCameraMatrix2D(objectPoints, imagePoints, imageSize, aspectRatio) + public static Mat initCameraMatrix2D(List objectPoints, List imagePoints, Size imageSize, double aspectRatio) + { + List objectPoints_tmplm = new ArrayList((objectPoints != null) ? objectPoints.size() : 0); + Mat objectPoints_mat = Converters.vector_vector_Point3f_to_Mat(objectPoints, objectPoints_tmplm); + List imagePoints_tmplm = new ArrayList((imagePoints != null) ? imagePoints.size() : 0); + Mat imagePoints_mat = Converters.vector_vector_Point2f_to_Mat(imagePoints, imagePoints_tmplm); + Mat retVal = new Mat(initCameraMatrix2D_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, aspectRatio)); + + return retVal; + } + + //javadoc: initCameraMatrix2D(objectPoints, imagePoints, imageSize) + public static Mat initCameraMatrix2D(List objectPoints, List imagePoints, Size imageSize) + { + List objectPoints_tmplm = new ArrayList((objectPoints != null) ? objectPoints.size() : 0); + Mat objectPoints_mat = Converters.vector_vector_Point3f_to_Mat(objectPoints, objectPoints_tmplm); + List imagePoints_tmplm = new ArrayList((imagePoints != null) ? imagePoints.size() : 0); + Mat imagePoints_mat = Converters.vector_vector_Point2f_to_Mat(imagePoints, imagePoints_tmplm); + Mat retVal = new Mat(initCameraMatrix2D_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height)); + + return retVal; + } + + + // + // C++: Rect getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) + // + + //javadoc: getValidDisparityROI(roi1, roi2, minDisparity, numberOfDisparities, SADWindowSize) + public static Rect getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) + { + + Rect retVal = new Rect(getValidDisparityROI_0(roi1.x, roi1.y, roi1.width, roi1.height, roi2.x, roi2.y, roi2.width, roi2.height, minDisparity, numberOfDisparities, SADWindowSize)); + + return retVal; + } + + + // + // C++: Vec3d RQDecomp3x3(Mat src, Mat& mtxR, Mat& mtxQ, Mat& Qx = Mat(), Mat& Qy = Mat(), Mat& Qz = Mat()) + // + + //javadoc: RQDecomp3x3(src, mtxR, mtxQ, Qx, Qy, Qz) + public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz) + { + + double[] retVal = RQDecomp3x3_0(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj, Qx.nativeObj, Qy.nativeObj, Qz.nativeObj); + + return retVal; + } + + //javadoc: RQDecomp3x3(src, mtxR, mtxQ) + public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ) + { + + double[] retVal = RQDecomp3x3_1(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj); + + return retVal; + } + + + // + // C++: bool findChessboardCorners(Mat image, Size patternSize, vector_Point2f& corners, int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE) + // + + //javadoc: findChessboardCorners(image, patternSize, corners, flags) + public static boolean findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, int flags) + { + Mat corners_mat = corners; + boolean retVal = findChessboardCorners_0(image.nativeObj, patternSize.width, patternSize.height, corners_mat.nativeObj, flags); + + return retVal; + } + + //javadoc: findChessboardCorners(image, patternSize, corners) + public static boolean findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners) + { + Mat corners_mat = corners; + boolean retVal = findChessboardCorners_1(image.nativeObj, patternSize.width, patternSize.height, corners_mat.nativeObj); + + return retVal; + } + + + // + // C++: bool findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags, Ptr_FeatureDetector blobDetector, CirclesGridFinderParameters parameters) + // + + // Unknown type 'Ptr_FeatureDetector' (I), skipping the function + + + // + // C++: bool findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags = CALIB_CB_SYMMETRIC_GRID, Ptr_FeatureDetector blobDetector = SimpleBlobDetector::create()) + // + + //javadoc: findCirclesGrid(image, patternSize, centers, flags) + public static boolean findCirclesGrid(Mat image, Size patternSize, Mat centers, int flags) + { + + boolean retVal = findCirclesGrid_0(image.nativeObj, patternSize.width, patternSize.height, centers.nativeObj, flags); + + return retVal; + } + + //javadoc: findCirclesGrid(image, patternSize, centers) + public static boolean findCirclesGrid(Mat image, Size patternSize, Mat centers) + { + + boolean retVal = findCirclesGrid_1(image.nativeObj, patternSize.width, patternSize.height, centers.nativeObj); + + return retVal; + } + + + // + // C++: bool solvePnP(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE) + // + + //javadoc: solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, flags) + public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags) + { + Mat objectPoints_mat = objectPoints; + Mat imagePoints_mat = imagePoints; + Mat distCoeffs_mat = distCoeffs; + boolean retVal = solvePnP_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, flags); + + return retVal; + } + + //javadoc: solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec) + public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec) + { + Mat objectPoints_mat = objectPoints; + Mat imagePoints_mat = imagePoints; + Mat distCoeffs_mat = distCoeffs; + boolean retVal = solvePnP_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj); + + return retVal; + } + + + // + // C++: bool solvePnPRansac(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0, double confidence = 0.99, Mat& inliers = Mat(), int flags = SOLVEPNP_ITERATIVE) + // + + //javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, iterationsCount, reprojectionError, confidence, inliers, flags) + public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags) + { + Mat objectPoints_mat = objectPoints; + Mat imagePoints_mat = imagePoints; + Mat distCoeffs_mat = distCoeffs; + boolean retVal = solvePnPRansac_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, iterationsCount, reprojectionError, confidence, inliers.nativeObj, flags); + + return retVal; + } + + //javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec) + public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec) + { + Mat objectPoints_mat = objectPoints; + Mat imagePoints_mat = imagePoints; + Mat distCoeffs_mat = distCoeffs; + boolean retVal = solvePnPRansac_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj); + + return retVal; + } + + + // + // C++: bool stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat& H1, Mat& H2, double threshold = 5) + // + + //javadoc: stereoRectifyUncalibrated(points1, points2, F, imgSize, H1, H2, threshold) + public static boolean stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2, double threshold) + { + + boolean retVal = stereoRectifyUncalibrated_0(points1.nativeObj, points2.nativeObj, F.nativeObj, imgSize.width, imgSize.height, H1.nativeObj, H2.nativeObj, threshold); + + return retVal; + } + + //javadoc: stereoRectifyUncalibrated(points1, points2, F, imgSize, H1, H2) + public static boolean stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2) + { + + boolean retVal = stereoRectifyUncalibrated_1(points1.nativeObj, points2.nativeObj, F.nativeObj, imgSize.width, imgSize.height, H1.nativeObj, H2.nativeObj); + + return retVal; + } + + + // + // C++: double calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& stdDeviationsIntrinsics, Mat& stdDeviationsExtrinsics, Mat& perViewErrors, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON)) + // + + //javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors, flags, criteria) + public static double calibrateCameraExtended(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrateCameraExtended_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, stdDeviationsIntrinsics.nativeObj, stdDeviationsExtrinsics.nativeObj, perViewErrors.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + //javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors, flags) + public static double calibrateCameraExtended(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrateCameraExtended_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, stdDeviationsIntrinsics.nativeObj, stdDeviationsExtrinsics.nativeObj, perViewErrors.nativeObj, flags); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + //javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors) + public static double calibrateCameraExtended(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrateCameraExtended_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, stdDeviationsIntrinsics.nativeObj, stdDeviationsExtrinsics.nativeObj, perViewErrors.nativeObj); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + + // + // C++: double calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON)) + // + + //javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags, criteria) + public static double calibrateCamera(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, int flags, TermCriteria criteria) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrateCamera_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + //javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags) + public static double calibrateCamera(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, int flags) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrateCamera_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + //javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs) + public static double calibrateCamera(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrateCamera_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + + // + // C++: double sampsonDistance(Mat pt1, Mat pt2, Mat F) + // + + //javadoc: sampsonDistance(pt1, pt2, F) + public static double sampsonDistance(Mat pt1, Mat pt2, Mat F) + { + + double retVal = sampsonDistance_0(pt1.nativeObj, pt2.nativeObj, F.nativeObj); + + return retVal; + } + + + // + // C++: double stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)) + // + + //javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, flags, criteria) + public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags, TermCriteria criteria) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1); + Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2); + double retVal = stereoCalibrate_0(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon); + + return retVal; + } + + //javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, flags) + public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1); + Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2); + double retVal = stereoCalibrate_1(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, flags); + + return retVal; + } + + //javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F) + public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1); + Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2); + double retVal = stereoCalibrate_2(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj); + + return retVal; + } + + + // + // C++: double calibrate(vector_Mat objectPoints, vector_Mat imagePoints, Size image_size, Mat& K, Mat& D, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON)) + // + + //javadoc: calibrate(objectPoints, imagePoints, image_size, K, D, rvecs, tvecs, flags, criteria) + public static double calibrate(List objectPoints, List imagePoints, Size image_size, Mat K, Mat D, List rvecs, List tvecs, int flags, TermCriteria criteria) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrate_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, image_size.width, image_size.height, K.nativeObj, D.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + //javadoc: calibrate(objectPoints, imagePoints, image_size, K, D, rvecs, tvecs, flags) + public static double calibrate(List objectPoints, List imagePoints, Size image_size, Mat K, Mat D, List rvecs, List tvecs, int flags) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrate_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, image_size.width, image_size.height, K.nativeObj, D.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + //javadoc: calibrate(objectPoints, imagePoints, image_size, K, D, rvecs, tvecs) + public static double calibrate(List objectPoints, List imagePoints, Size image_size, Mat K, Mat D, List rvecs, List tvecs) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints); + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + double retVal = calibrate_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, image_size.width, image_size.height, K.nativeObj, D.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + + // + // C++: double stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& K1, Mat& D1, Mat& K2, Mat& D2, Size imageSize, Mat& R, Mat& T, int flags = fisheye::CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON)) + // + + //javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T, flags, criteria) + public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags, TermCriteria criteria) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1); + Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2); + double retVal = stereoCalibrate_3(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon); + + return retVal; + } + + //javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T, flags) + public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1); + Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2); + double retVal = stereoCalibrate_4(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, flags); + + return retVal; + } + + //javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T) + public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T) + { + Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints); + Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1); + Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2); + double retVal = stereoCalibrate_5(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj); + + return retVal; + } + + + // + // C++: float rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, vector_Mat imgpt1, vector_Mat imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q, double alpha, Size newImgSize, Rect* roi1, Rect* roi2, int flags) + // + + //javadoc: rectify3Collinear(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, cameraMatrix3, distCoeffs3, imgpt1, imgpt3, imageSize, R12, T12, R13, T13, R1, R2, R3, P1, P2, P3, Q, alpha, newImgSize, roi1, roi2, flags) + public static float rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, List imgpt1, List imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags) + { + Mat imgpt1_mat = Converters.vector_Mat_to_Mat(imgpt1); + Mat imgpt3_mat = Converters.vector_Mat_to_Mat(imgpt3); + double[] roi1_out = new double[4]; + double[] roi2_out = new double[4]; + float retVal = rectify3Collinear_0(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, cameraMatrix3.nativeObj, distCoeffs3.nativeObj, imgpt1_mat.nativeObj, imgpt3_mat.nativeObj, imageSize.width, imageSize.height, R12.nativeObj, T12.nativeObj, R13.nativeObj, T13.nativeObj, R1.nativeObj, R2.nativeObj, R3.nativeObj, P1.nativeObj, P2.nativeObj, P3.nativeObj, Q.nativeObj, alpha, newImgSize.width, newImgSize.height, roi1_out, roi2_out, flags); + if(roi1!=null){ roi1.x = (int)roi1_out[0]; roi1.y = (int)roi1_out[1]; roi1.width = (int)roi1_out[2]; roi1.height = (int)roi1_out[3]; } + if(roi2!=null){ roi2.x = (int)roi2_out[0]; roi2.y = (int)roi2_out[1]; roi2.width = (int)roi2_out[2]; roi2.height = (int)roi2_out[3]; } + return retVal; + } + + + // + // C++: int decomposeHomographyMat(Mat H, Mat K, vector_Mat& rotations, vector_Mat& translations, vector_Mat& normals) + // + + //javadoc: decomposeHomographyMat(H, K, rotations, translations, normals) + public static int decomposeHomographyMat(Mat H, Mat K, List rotations, List translations, List normals) + { + Mat rotations_mat = new Mat(); + Mat translations_mat = new Mat(); + Mat normals_mat = new Mat(); + int retVal = decomposeHomographyMat_0(H.nativeObj, K.nativeObj, rotations_mat.nativeObj, translations_mat.nativeObj, normals_mat.nativeObj); + Converters.Mat_to_vector_Mat(rotations_mat, rotations); + rotations_mat.release(); + Converters.Mat_to_vector_Mat(translations_mat, translations); + translations_mat.release(); + Converters.Mat_to_vector_Mat(normals_mat, normals); + normals_mat.release(); + return retVal; + } + + + // + // C++: int estimateAffine3D(Mat src, Mat dst, Mat& out, Mat& inliers, double ransacThreshold = 3, double confidence = 0.99) + // + + //javadoc: estimateAffine3D(src, dst, out, inliers, ransacThreshold, confidence) + public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence) + { + + int retVal = estimateAffine3D_0(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj, ransacThreshold, confidence); + + return retVal; + } + + //javadoc: estimateAffine3D(src, dst, out, inliers) + public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers) + { + + int retVal = estimateAffine3D_1(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj); + + return retVal; + } + + + // + // C++: int recoverPose(Mat E, Mat points1, Mat points2, Mat& R, Mat& t, double focal = 1.0, Point2d pp = Point2d(0, 0), Mat& mask = Mat()) + // + + //javadoc: recoverPose(E, points1, points2, R, t, focal, pp, mask) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point pp, Mat mask) + { + + int retVal = recoverPose_0(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj, focal, pp.x, pp.y, mask.nativeObj); + + return retVal; + } + + //javadoc: recoverPose(E, points1, points2, R, t, focal, pp) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point pp) + { + + int retVal = recoverPose_1(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj, focal, pp.x, pp.y); + + return retVal; + } + + //javadoc: recoverPose(E, points1, points2, R, t) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t) + { + + int retVal = recoverPose_2(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj); + + return retVal; + } + + + // + // C++: int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, Mat& mask = Mat()) + // + + //javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, mask) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, Mat mask) + { + + int retVal = recoverPose_3(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, mask.nativeObj); + + return retVal; + } + + //javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t) + { + + int retVal = recoverPose_4(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj); + + return retVal; + } + + + // + // C++: int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, double distanceThresh, Mat& mask = Mat(), Mat& triangulatedPoints = Mat()) + // + + //javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, distanceThresh, mask, triangulatedPoints) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh, Mat mask, Mat triangulatedPoints) + { + + int retVal = recoverPose_5(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, distanceThresh, mask.nativeObj, triangulatedPoints.nativeObj); + + return retVal; + } + + //javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, distanceThresh) + public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh) + { + + int retVal = recoverPose_6(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, distanceThresh); + + return retVal; + } + + + // + // C++: int solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags) + // + + //javadoc: solveP3P(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvecs, tvecs, flags) + public static int solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, int flags) + { + Mat rvecs_mat = new Mat(); + Mat tvecs_mat = new Mat(); + int retVal = solveP3P_0(objectPoints.nativeObj, imagePoints.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags); + Converters.Mat_to_vector_Mat(rvecs_mat, rvecs); + rvecs_mat.release(); + Converters.Mat_to_vector_Mat(tvecs_mat, tvecs); + tvecs_mat.release(); + return retVal; + } + + + // + // C++: void Rodrigues(Mat src, Mat& dst, Mat& jacobian = Mat()) + // + + //javadoc: Rodrigues(src, dst, jacobian) + public static void Rodrigues(Mat src, Mat dst, Mat jacobian) + { + + Rodrigues_0(src.nativeObj, dst.nativeObj, jacobian.nativeObj); + + return; + } + + //javadoc: Rodrigues(src, dst) + public static void Rodrigues(Mat src, Mat dst) + { + + Rodrigues_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio) + // + + //javadoc: calibrationMatrixValues(cameraMatrix, imageSize, apertureWidth, apertureHeight, fovx, fovy, focalLength, principalPoint, aspectRatio) + public static void calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point principalPoint, double[] aspectRatio) + { + double[] fovx_out = new double[1]; + double[] fovy_out = new double[1]; + double[] focalLength_out = new double[1]; + double[] principalPoint_out = new double[2]; + double[] aspectRatio_out = new double[1]; + calibrationMatrixValues_0(cameraMatrix.nativeObj, imageSize.width, imageSize.height, apertureWidth, apertureHeight, fovx_out, fovy_out, focalLength_out, principalPoint_out, aspectRatio_out); + if(fovx!=null) fovx[0] = (double)fovx_out[0]; + if(fovy!=null) fovy[0] = (double)fovy_out[0]; + if(focalLength!=null) focalLength[0] = (double)focalLength_out[0]; + if(principalPoint!=null){ principalPoint.x = principalPoint_out[0]; principalPoint.y = principalPoint_out[1]; } + if(aspectRatio!=null) aspectRatio[0] = (double)aspectRatio_out[0]; + return; + } + + + // + // C++: void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat& rvec3, Mat& tvec3, Mat& dr3dr1 = Mat(), Mat& dr3dt1 = Mat(), Mat& dr3dr2 = Mat(), Mat& dr3dt2 = Mat(), Mat& dt3dr1 = Mat(), Mat& dt3dt1 = Mat(), Mat& dt3dr2 = Mat(), Mat& dt3dt2 = Mat()) + // + + //javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2) + public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2, Mat dt3dt2) + { + + composeRT_0(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj, dt3dr1.nativeObj, dt3dt1.nativeObj, dt3dr2.nativeObj, dt3dt2.nativeObj); + + return; + } + + //javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3) + public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3) + { + + composeRT_1(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj); + + return; + } + + + // + // C++: void computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat& lines) + // + + //javadoc: computeCorrespondEpilines(points, whichImage, F, lines) + public static void computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines) + { + + computeCorrespondEpilines_0(points.nativeObj, whichImage, F.nativeObj, lines.nativeObj); + + return; + } + + + // + // C++: void convertPointsFromHomogeneous(Mat src, Mat& dst) + // + + //javadoc: convertPointsFromHomogeneous(src, dst) + public static void convertPointsFromHomogeneous(Mat src, Mat dst) + { + + convertPointsFromHomogeneous_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void convertPointsToHomogeneous(Mat src, Mat& dst) + // + + //javadoc: convertPointsToHomogeneous(src, dst) + public static void convertPointsToHomogeneous(Mat src, Mat dst) + { + + convertPointsToHomogeneous_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void correctMatches(Mat F, Mat points1, Mat points2, Mat& newPoints1, Mat& newPoints2) + // + + //javadoc: correctMatches(F, points1, points2, newPoints1, newPoints2) + public static void correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2) + { + + correctMatches_0(F.nativeObj, points1.nativeObj, points2.nativeObj, newPoints1.nativeObj, newPoints2.nativeObj); + + return; + } + + + // + // C++: void decomposeEssentialMat(Mat E, Mat& R1, Mat& R2, Mat& t) + // + + //javadoc: decomposeEssentialMat(E, R1, R2, t) + public static void decomposeEssentialMat(Mat E, Mat R1, Mat R2, Mat t) + { + + decomposeEssentialMat_0(E.nativeObj, R1.nativeObj, R2.nativeObj, t.nativeObj); + + return; + } + + + // + // C++: void decomposeProjectionMatrix(Mat projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect, Mat& rotMatrixX = Mat(), Mat& rotMatrixY = Mat(), Mat& rotMatrixZ = Mat(), Mat& eulerAngles = Mat()) + // + + //javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ, eulerAngles) + public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles) + { + + decomposeProjectionMatrix_0(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj, rotMatrixX.nativeObj, rotMatrixY.nativeObj, rotMatrixZ.nativeObj, eulerAngles.nativeObj); + + return; + } + + //javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect) + public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect) + { + + decomposeProjectionMatrix_1(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj); + + return; + } + + + // + // C++: void drawChessboardCorners(Mat& image, Size patternSize, vector_Point2f corners, bool patternWasFound) + // + + //javadoc: drawChessboardCorners(image, patternSize, corners, patternWasFound) + public static void drawChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, boolean patternWasFound) + { + Mat corners_mat = corners; + drawChessboardCorners_0(image.nativeObj, patternSize.width, patternSize.height, corners_mat.nativeObj, patternWasFound); + + return; + } + + + // + // C++: void filterSpeckles(Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf = Mat()) + // + + //javadoc: filterSpeckles(img, newVal, maxSpeckleSize, maxDiff, buf) + public static void filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf) + { + + filterSpeckles_0(img.nativeObj, newVal, maxSpeckleSize, maxDiff, buf.nativeObj); + + return; + } + + //javadoc: filterSpeckles(img, newVal, maxSpeckleSize, maxDiff) + public static void filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff) + { + + filterSpeckles_1(img.nativeObj, newVal, maxSpeckleSize, maxDiff); + + return; + } + + + // + // C++: void matMulDeriv(Mat A, Mat B, Mat& dABdA, Mat& dABdB) + // + + //javadoc: matMulDeriv(A, B, dABdA, dABdB) + public static void matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB) + { + + matMulDeriv_0(A.nativeObj, B.nativeObj, dABdA.nativeObj, dABdB.nativeObj); + + return; + } + + + // + // C++: void projectPoints(vector_Point3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, vector_double distCoeffs, vector_Point2f& imagePoints, Mat& jacobian = Mat(), double aspectRatio = 0) + // + + //javadoc: projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints, jacobian, aspectRatio) + public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian, double aspectRatio) + { + Mat objectPoints_mat = objectPoints; + Mat distCoeffs_mat = distCoeffs; + Mat imagePoints_mat = imagePoints; + projectPoints_0(objectPoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, imagePoints_mat.nativeObj, jacobian.nativeObj, aspectRatio); + + return; + } + + //javadoc: projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints) + public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints) + { + Mat objectPoints_mat = objectPoints; + Mat distCoeffs_mat = distCoeffs; + Mat imagePoints_mat = imagePoints; + projectPoints_1(objectPoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, imagePoints_mat.nativeObj); + + return; + } + + + // + // C++: void reprojectImageTo3D(Mat disparity, Mat& _3dImage, Mat Q, bool handleMissingValues = false, int ddepth = -1) + // + + //javadoc: reprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues, ddepth) + public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth) + { + + reprojectImageTo3D_0(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj, handleMissingValues, ddepth); + + return; + } + + //javadoc: reprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues) + public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues) + { + + reprojectImageTo3D_1(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj, handleMissingValues); + + return; + } + + //javadoc: reprojectImageTo3D(disparity, _3dImage, Q) + public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q) + { + + reprojectImageTo3D_2(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj); + + return; + } + + + // + // C++: void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags = CALIB_ZERO_DISPARITY, double alpha = -1, Size newImageSize = Size(), Rect* validPixROI1 = 0, Rect* validPixROI2 = 0) + // + + //javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q, flags, alpha, newImageSize, validPixROI1, validPixROI2) + public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1, Rect validPixROI2) + { + double[] validPixROI1_out = new double[4]; + double[] validPixROI2_out = new double[4]; + stereoRectify_0(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, alpha, newImageSize.width, newImageSize.height, validPixROI1_out, validPixROI2_out); + if(validPixROI1!=null){ validPixROI1.x = (int)validPixROI1_out[0]; validPixROI1.y = (int)validPixROI1_out[1]; validPixROI1.width = (int)validPixROI1_out[2]; validPixROI1.height = (int)validPixROI1_out[3]; } + if(validPixROI2!=null){ validPixROI2.x = (int)validPixROI2_out[0]; validPixROI2.y = (int)validPixROI2_out[1]; validPixROI2.width = (int)validPixROI2_out[2]; validPixROI2.height = (int)validPixROI2_out[3]; } + return; + } + + //javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q) + public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q) + { + + stereoRectify_1(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj); + + return; + } + + + // + // C++: void triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat& points4D) + // + + //javadoc: triangulatePoints(projMatr1, projMatr2, projPoints1, projPoints2, points4D) + public static void triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat points4D) + { + + triangulatePoints_0(projMatr1.nativeObj, projMatr2.nativeObj, projPoints1.nativeObj, projPoints2.nativeObj, points4D.nativeObj); + + return; + } + + + // + // C++: void validateDisparity(Mat& disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1) + // + + //javadoc: validateDisparity(disparity, cost, minDisparity, numberOfDisparities, disp12MaxDisp) + public static void validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp) + { + + validateDisparity_0(disparity.nativeObj, cost.nativeObj, minDisparity, numberOfDisparities, disp12MaxDisp); + + return; + } + + //javadoc: validateDisparity(disparity, cost, minDisparity, numberOfDisparities) + public static void validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities) + { + + validateDisparity_1(disparity.nativeObj, cost.nativeObj, minDisparity, numberOfDisparities); + + return; + } + + + // + // C++: void distortPoints(Mat undistorted, Mat& distorted, Mat K, Mat D, double alpha = 0) + // + + //javadoc: distortPoints(undistorted, distorted, K, D, alpha) + public static void distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha) + { + + distortPoints_0(undistorted.nativeObj, distorted.nativeObj, K.nativeObj, D.nativeObj, alpha); + + return; + } + + //javadoc: distortPoints(undistorted, distorted, K, D) + public static void distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D) + { + + distortPoints_1(undistorted.nativeObj, distorted.nativeObj, K.nativeObj, D.nativeObj); + + return; + } + + + // + // C++: void estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat& P, double balance = 0.0, Size new_size = Size(), double fov_scale = 1.0) + // + + //javadoc: estimateNewCameraMatrixForUndistortRectify(K, D, image_size, R, P, balance, new_size, fov_scale) + public static void estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size, double fov_scale) + { + + estimateNewCameraMatrixForUndistortRectify_0(K.nativeObj, D.nativeObj, image_size.width, image_size.height, R.nativeObj, P.nativeObj, balance, new_size.width, new_size.height, fov_scale); + + return; + } + + //javadoc: estimateNewCameraMatrixForUndistortRectify(K, D, image_size, R, P) + public static void estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P) + { + + estimateNewCameraMatrixForUndistortRectify_1(K.nativeObj, D.nativeObj, image_size.width, image_size.height, R.nativeObj, P.nativeObj); + + return; + } + + + // + // C++: void initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat& map1, Mat& map2) + // + + //javadoc: initUndistortRectifyMap(K, D, R, P, size, m1type, map1, map2) + public static void initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat map1, Mat map2) + { + + initUndistortRectifyMap_0(K.nativeObj, D.nativeObj, R.nativeObj, P.nativeObj, size.width, size.height, m1type, map1.nativeObj, map2.nativeObj); + + return; + } + + + // + // C++: void projectPoints(vector_Point3f objectPoints, vector_Point2f& imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha = 0, Mat& jacobian = Mat()) + // + + //javadoc: projectPoints(objectPoints, imagePoints, rvec, tvec, K, D, alpha, jacobian) + public static void projectPoints(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha, Mat jacobian) + { + Mat objectPoints_mat = objectPoints; + Mat imagePoints_mat = imagePoints; + projectPoints_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, K.nativeObj, D.nativeObj, alpha, jacobian.nativeObj); + + return; + } + + //javadoc: projectPoints(objectPoints, imagePoints, rvec, tvec, K, D) + public static void projectPoints(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat rvec, Mat tvec, Mat K, Mat D) + { + Mat objectPoints_mat = objectPoints; + Mat imagePoints_mat = imagePoints; + projectPoints_3(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, K.nativeObj, D.nativeObj); + + return; + } + + + // + // C++: void stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags, Size newImageSize = Size(), double balance = 0.0, double fov_scale = 1.0) + // + + //javadoc: stereoRectify(K1, D1, K2, D2, imageSize, R, tvec, R1, R2, P1, P2, Q, flags, newImageSize, balance, fov_scale) + public static void stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize, double balance, double fov_scale) + { + + stereoRectify_2(K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, tvec.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, newImageSize.width, newImageSize.height, balance, fov_scale); + + return; + } + + //javadoc: stereoRectify(K1, D1, K2, D2, imageSize, R, tvec, R1, R2, P1, P2, Q, flags) + public static void stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags) + { + + stereoRectify_3(K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, tvec.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags); + + return; + } + + + // + // C++: void undistortImage(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat Knew = cv::Mat(), Size new_size = Size()) + // + + //javadoc: undistortImage(distorted, undistorted, K, D, Knew, new_size) + public static void undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew, Size new_size) + { + + undistortImage_0(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj, Knew.nativeObj, new_size.width, new_size.height); + + return; + } + + //javadoc: undistortImage(distorted, undistorted, K, D) + public static void undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D) + { + + undistortImage_1(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj); + + return; + } + + + // + // C++: void undistortPoints(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat R = Mat(), Mat P = Mat()) + // + + //javadoc: undistortPoints(distorted, undistorted, K, D, R, P) + public static void undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P) + { + + undistortPoints_0(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj, R.nativeObj, P.nativeObj); + + return; + } + + //javadoc: undistortPoints(distorted, undistorted, K, D) + public static void undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D) + { + + undistortPoints_1(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj); + + return; + } + + + + + // C++: Mat estimateAffine2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10) + private static native long estimateAffine2D_0(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters); + private static native long estimateAffine2D_1(long from_nativeObj, long to_nativeObj); + + // C++: Mat estimateAffinePartial2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10) + private static native long estimateAffinePartial2D_0(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters); + private static native long estimateAffinePartial2D_1(long from_nativeObj, long to_nativeObj); + + // C++: Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat()) + private static native long findEssentialMat_0(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, int method, double prob, double threshold, long mask_nativeObj); + private static native long findEssentialMat_1(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, int method, double prob, double threshold); + private static native long findEssentialMat_2(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj); + + // C++: Mat findEssentialMat(Mat points1, Mat points2, double focal = 1.0, Point2d pp = Point2d(0, 0), int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat()) + private static native long findEssentialMat_3(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y, int method, double prob, double threshold, long mask_nativeObj); + private static native long findEssentialMat_4(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y, int method, double prob, double threshold); + private static native long findEssentialMat_5(long points1_nativeObj, long points2_nativeObj); + + // C++: Mat findFundamentalMat(vector_Point2f points1, vector_Point2f points2, int method = FM_RANSAC, double param1 = 3., double param2 = 0.99, Mat& mask = Mat()) + private static native long findFundamentalMat_0(long points1_mat_nativeObj, long points2_mat_nativeObj, int method, double param1, double param2, long mask_nativeObj); + private static native long findFundamentalMat_1(long points1_mat_nativeObj, long points2_mat_nativeObj, int method, double param1, double param2); + private static native long findFundamentalMat_2(long points1_mat_nativeObj, long points2_mat_nativeObj); + + // C++: Mat findHomography(vector_Point2f srcPoints, vector_Point2f dstPoints, int method = 0, double ransacReprojThreshold = 3, Mat& mask = Mat(), int maxIters = 2000, double confidence = 0.995) + private static native long findHomography_0(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method, double ransacReprojThreshold, long mask_nativeObj, int maxIters, double confidence); + private static native long findHomography_1(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method, double ransacReprojThreshold); + private static native long findHomography_2(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj); + + // C++: Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize = Size(), Rect* validPixROI = 0, bool centerPrincipalPoint = false) + private static native long getOptimalNewCameraMatrix_0(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, double alpha, double newImgSize_width, double newImgSize_height, double[] validPixROI_out, boolean centerPrincipalPoint); + private static native long getOptimalNewCameraMatrix_1(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, double alpha); + + // C++: Mat initCameraMatrix2D(vector_vector_Point3f objectPoints, vector_vector_Point2f imagePoints, Size imageSize, double aspectRatio = 1.0) + private static native long initCameraMatrix2D_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, double aspectRatio); + private static native long initCameraMatrix2D_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height); + + // C++: Rect getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) + private static native double[] getValidDisparityROI_0(int roi1_x, int roi1_y, int roi1_width, int roi1_height, int roi2_x, int roi2_y, int roi2_width, int roi2_height, int minDisparity, int numberOfDisparities, int SADWindowSize); + + // C++: Vec3d RQDecomp3x3(Mat src, Mat& mtxR, Mat& mtxQ, Mat& Qx = Mat(), Mat& Qy = Mat(), Mat& Qz = Mat()) + private static native double[] RQDecomp3x3_0(long src_nativeObj, long mtxR_nativeObj, long mtxQ_nativeObj, long Qx_nativeObj, long Qy_nativeObj, long Qz_nativeObj); + private static native double[] RQDecomp3x3_1(long src_nativeObj, long mtxR_nativeObj, long mtxQ_nativeObj); + + // C++: bool findChessboardCorners(Mat image, Size patternSize, vector_Point2f& corners, int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE) + private static native boolean findChessboardCorners_0(long image_nativeObj, double patternSize_width, double patternSize_height, long corners_mat_nativeObj, int flags); + private static native boolean findChessboardCorners_1(long image_nativeObj, double patternSize_width, double patternSize_height, long corners_mat_nativeObj); + + // C++: bool findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags = CALIB_CB_SYMMETRIC_GRID, Ptr_FeatureDetector blobDetector = SimpleBlobDetector::create()) + private static native boolean findCirclesGrid_0(long image_nativeObj, double patternSize_width, double patternSize_height, long centers_nativeObj, int flags); + private static native boolean findCirclesGrid_1(long image_nativeObj, double patternSize_width, double patternSize_height, long centers_nativeObj); + + // C++: bool solvePnP(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE) + private static native boolean solvePnP_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int flags); + private static native boolean solvePnP_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj); + + // C++: bool solvePnPRansac(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0, double confidence = 0.99, Mat& inliers = Mat(), int flags = SOLVEPNP_ITERATIVE) + private static native boolean solvePnPRansac_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, long inliers_nativeObj, int flags); + private static native boolean solvePnPRansac_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj); + + // C++: bool stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat& H1, Mat& H2, double threshold = 5) + private static native boolean stereoRectifyUncalibrated_0(long points1_nativeObj, long points2_nativeObj, long F_nativeObj, double imgSize_width, double imgSize_height, long H1_nativeObj, long H2_nativeObj, double threshold); + private static native boolean stereoRectifyUncalibrated_1(long points1_nativeObj, long points2_nativeObj, long F_nativeObj, double imgSize_width, double imgSize_height, long H1_nativeObj, long H2_nativeObj); + + // C++: double calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& stdDeviationsIntrinsics, Mat& stdDeviationsExtrinsics, Mat& perViewErrors, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON)) + private static native double calibrateCameraExtended_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, long stdDeviationsIntrinsics_nativeObj, long stdDeviationsExtrinsics_nativeObj, long perViewErrors_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon); + private static native double calibrateCameraExtended_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, long stdDeviationsIntrinsics_nativeObj, long stdDeviationsExtrinsics_nativeObj, long perViewErrors_nativeObj, int flags); + private static native double calibrateCameraExtended_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, long stdDeviationsIntrinsics_nativeObj, long stdDeviationsExtrinsics_nativeObj, long perViewErrors_nativeObj); + + // C++: double calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON)) + private static native double calibrateCamera_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon); + private static native double calibrateCamera_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags); + private static native double calibrateCamera_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj); + + // C++: double sampsonDistance(Mat pt1, Mat pt2, Mat F) + private static native double sampsonDistance_0(long pt1_nativeObj, long pt2_nativeObj, long F_nativeObj); + + // C++: double stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)) + private static native double stereoCalibrate_0(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon); + private static native double stereoCalibrate_1(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, int flags); + private static native double stereoCalibrate_2(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj); + + // C++: double calibrate(vector_Mat objectPoints, vector_Mat imagePoints, Size image_size, Mat& K, Mat& D, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON)) + private static native double calibrate_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double image_size_width, double image_size_height, long K_nativeObj, long D_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon); + private static native double calibrate_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double image_size_width, double image_size_height, long K_nativeObj, long D_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags); + private static native double calibrate_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double image_size_width, double image_size_height, long K_nativeObj, long D_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj); + + // C++: double stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& K1, Mat& D1, Mat& K2, Mat& D2, Size imageSize, Mat& R, Mat& T, int flags = fisheye::CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON)) + private static native double stereoCalibrate_3(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon); + private static native double stereoCalibrate_4(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, int flags); + private static native double stereoCalibrate_5(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj); + + // C++: float rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, vector_Mat imgpt1, vector_Mat imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q, double alpha, Size newImgSize, Rect* roi1, Rect* roi2, int flags) + private static native float rectify3Collinear_0(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, long cameraMatrix3_nativeObj, long distCoeffs3_nativeObj, long imgpt1_mat_nativeObj, long imgpt3_mat_nativeObj, double imageSize_width, double imageSize_height, long R12_nativeObj, long T12_nativeObj, long R13_nativeObj, long T13_nativeObj, long R1_nativeObj, long R2_nativeObj, long R3_nativeObj, long P1_nativeObj, long P2_nativeObj, long P3_nativeObj, long Q_nativeObj, double alpha, double newImgSize_width, double newImgSize_height, double[] roi1_out, double[] roi2_out, int flags); + + // C++: int decomposeHomographyMat(Mat H, Mat K, vector_Mat& rotations, vector_Mat& translations, vector_Mat& normals) + private static native int decomposeHomographyMat_0(long H_nativeObj, long K_nativeObj, long rotations_mat_nativeObj, long translations_mat_nativeObj, long normals_mat_nativeObj); + + // C++: int estimateAffine3D(Mat src, Mat dst, Mat& out, Mat& inliers, double ransacThreshold = 3, double confidence = 0.99) + private static native int estimateAffine3D_0(long src_nativeObj, long dst_nativeObj, long out_nativeObj, long inliers_nativeObj, double ransacThreshold, double confidence); + private static native int estimateAffine3D_1(long src_nativeObj, long dst_nativeObj, long out_nativeObj, long inliers_nativeObj); + + // C++: int recoverPose(Mat E, Mat points1, Mat points2, Mat& R, Mat& t, double focal = 1.0, Point2d pp = Point2d(0, 0), Mat& mask = Mat()) + private static native int recoverPose_0(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj, double focal, double pp_x, double pp_y, long mask_nativeObj); + private static native int recoverPose_1(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj, double focal, double pp_x, double pp_y); + private static native int recoverPose_2(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj); + + // C++: int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, Mat& mask = Mat()) + private static native int recoverPose_3(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, long mask_nativeObj); + private static native int recoverPose_4(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj); + + // C++: int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, double distanceThresh, Mat& mask = Mat(), Mat& triangulatedPoints = Mat()) + private static native int recoverPose_5(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, double distanceThresh, long mask_nativeObj, long triangulatedPoints_nativeObj); + private static native int recoverPose_6(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, double distanceThresh); + + // C++: int solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags) + private static native int solveP3P_0(long objectPoints_nativeObj, long imagePoints_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags); + + // C++: void Rodrigues(Mat src, Mat& dst, Mat& jacobian = Mat()) + private static native void Rodrigues_0(long src_nativeObj, long dst_nativeObj, long jacobian_nativeObj); + private static native void Rodrigues_1(long src_nativeObj, long dst_nativeObj); + + // C++: void calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio) + private static native void calibrationMatrixValues_0(long cameraMatrix_nativeObj, double imageSize_width, double imageSize_height, double apertureWidth, double apertureHeight, double[] fovx_out, double[] fovy_out, double[] focalLength_out, double[] principalPoint_out, double[] aspectRatio_out); + + // C++: void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat& rvec3, Mat& tvec3, Mat& dr3dr1 = Mat(), Mat& dr3dt1 = Mat(), Mat& dr3dr2 = Mat(), Mat& dr3dt2 = Mat(), Mat& dt3dr1 = Mat(), Mat& dt3dt1 = Mat(), Mat& dt3dr2 = Mat(), Mat& dt3dt2 = Mat()) + private static native void composeRT_0(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj, long dr3dt2_nativeObj, long dt3dr1_nativeObj, long dt3dt1_nativeObj, long dt3dr2_nativeObj, long dt3dt2_nativeObj); + private static native void composeRT_1(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj); + + // C++: void computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat& lines) + private static native void computeCorrespondEpilines_0(long points_nativeObj, int whichImage, long F_nativeObj, long lines_nativeObj); + + // C++: void convertPointsFromHomogeneous(Mat src, Mat& dst) + private static native void convertPointsFromHomogeneous_0(long src_nativeObj, long dst_nativeObj); + + // C++: void convertPointsToHomogeneous(Mat src, Mat& dst) + private static native void convertPointsToHomogeneous_0(long src_nativeObj, long dst_nativeObj); + + // C++: void correctMatches(Mat F, Mat points1, Mat points2, Mat& newPoints1, Mat& newPoints2) + private static native void correctMatches_0(long F_nativeObj, long points1_nativeObj, long points2_nativeObj, long newPoints1_nativeObj, long newPoints2_nativeObj); + + // C++: void decomposeEssentialMat(Mat E, Mat& R1, Mat& R2, Mat& t) + private static native void decomposeEssentialMat_0(long E_nativeObj, long R1_nativeObj, long R2_nativeObj, long t_nativeObj); + + // C++: void decomposeProjectionMatrix(Mat projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect, Mat& rotMatrixX = Mat(), Mat& rotMatrixY = Mat(), Mat& rotMatrixZ = Mat(), Mat& eulerAngles = Mat()) + private static native void decomposeProjectionMatrix_0(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj, long rotMatrixX_nativeObj, long rotMatrixY_nativeObj, long rotMatrixZ_nativeObj, long eulerAngles_nativeObj); + private static native void decomposeProjectionMatrix_1(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj); + + // C++: void drawChessboardCorners(Mat& image, Size patternSize, vector_Point2f corners, bool patternWasFound) + private static native void drawChessboardCorners_0(long image_nativeObj, double patternSize_width, double patternSize_height, long corners_mat_nativeObj, boolean patternWasFound); + + // C++: void filterSpeckles(Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf = Mat()) + private static native void filterSpeckles_0(long img_nativeObj, double newVal, int maxSpeckleSize, double maxDiff, long buf_nativeObj); + private static native void filterSpeckles_1(long img_nativeObj, double newVal, int maxSpeckleSize, double maxDiff); + + // C++: void matMulDeriv(Mat A, Mat B, Mat& dABdA, Mat& dABdB) + private static native void matMulDeriv_0(long A_nativeObj, long B_nativeObj, long dABdA_nativeObj, long dABdB_nativeObj); + + // C++: void projectPoints(vector_Point3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, vector_double distCoeffs, vector_Point2f& imagePoints, Mat& jacobian = Mat(), double aspectRatio = 0) + private static native void projectPoints_0(long objectPoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long imagePoints_mat_nativeObj, long jacobian_nativeObj, double aspectRatio); + private static native void projectPoints_1(long objectPoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long imagePoints_mat_nativeObj); + + // C++: void reprojectImageTo3D(Mat disparity, Mat& _3dImage, Mat Q, bool handleMissingValues = false, int ddepth = -1) + private static native void reprojectImageTo3D_0(long disparity_nativeObj, long _3dImage_nativeObj, long Q_nativeObj, boolean handleMissingValues, int ddepth); + private static native void reprojectImageTo3D_1(long disparity_nativeObj, long _3dImage_nativeObj, long Q_nativeObj, boolean handleMissingValues); + private static native void reprojectImageTo3D_2(long disparity_nativeObj, long _3dImage_nativeObj, long Q_nativeObj); + + // C++: void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags = CALIB_ZERO_DISPARITY, double alpha = -1, Size newImageSize = Size(), Rect* validPixROI1 = 0, Rect* validPixROI2 = 0) + private static native void stereoRectify_0(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double alpha, double newImageSize_width, double newImageSize_height, double[] validPixROI1_out, double[] validPixROI2_out); + private static native void stereoRectify_1(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj); + + // C++: void triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat& points4D) + private static native void triangulatePoints_0(long projMatr1_nativeObj, long projMatr2_nativeObj, long projPoints1_nativeObj, long projPoints2_nativeObj, long points4D_nativeObj); + + // C++: void validateDisparity(Mat& disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1) + private static native void validateDisparity_0(long disparity_nativeObj, long cost_nativeObj, int minDisparity, int numberOfDisparities, int disp12MaxDisp); + private static native void validateDisparity_1(long disparity_nativeObj, long cost_nativeObj, int minDisparity, int numberOfDisparities); + + // C++: void distortPoints(Mat undistorted, Mat& distorted, Mat K, Mat D, double alpha = 0) + private static native void distortPoints_0(long undistorted_nativeObj, long distorted_nativeObj, long K_nativeObj, long D_nativeObj, double alpha); + private static native void distortPoints_1(long undistorted_nativeObj, long distorted_nativeObj, long K_nativeObj, long D_nativeObj); + + // C++: void estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat& P, double balance = 0.0, Size new_size = Size(), double fov_scale = 1.0) + private static native void estimateNewCameraMatrixForUndistortRectify_0(long K_nativeObj, long D_nativeObj, double image_size_width, double image_size_height, long R_nativeObj, long P_nativeObj, double balance, double new_size_width, double new_size_height, double fov_scale); + private static native void estimateNewCameraMatrixForUndistortRectify_1(long K_nativeObj, long D_nativeObj, double image_size_width, double image_size_height, long R_nativeObj, long P_nativeObj); + + // C++: void initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat& map1, Mat& map2) + private static native void initUndistortRectifyMap_0(long K_nativeObj, long D_nativeObj, long R_nativeObj, long P_nativeObj, double size_width, double size_height, int m1type, long map1_nativeObj, long map2_nativeObj); + + // C++: void projectPoints(vector_Point3f objectPoints, vector_Point2f& imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha = 0, Mat& jacobian = Mat()) + private static native void projectPoints_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long K_nativeObj, long D_nativeObj, double alpha, long jacobian_nativeObj); + private static native void projectPoints_3(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long K_nativeObj, long D_nativeObj); + + // C++: void stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags, Size newImageSize = Size(), double balance = 0.0, double fov_scale = 1.0) + private static native void stereoRectify_2(long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long tvec_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double newImageSize_width, double newImageSize_height, double balance, double fov_scale); + private static native void stereoRectify_3(long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long tvec_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags); + + // C++: void undistortImage(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat Knew = cv::Mat(), Size new_size = Size()) + private static native void undistortImage_0(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj, long Knew_nativeObj, double new_size_width, double new_size_height); + private static native void undistortImage_1(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj); + + // C++: void undistortPoints(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat R = Mat(), Mat P = Mat()) + private static native void undistortPoints_0(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj, long R_nativeObj, long P_nativeObj); + private static native void undistortPoints_1(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoBM.java b/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoBM.java new file mode 100644 index 00000000000..18aba05c01d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoBM.java @@ -0,0 +1,330 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.calib3d; + +import org.opencv.core.Rect; + +// C++: class StereoBM +//javadoc: StereoBM +public class StereoBM extends StereoMatcher { + + protected StereoBM(long addr) { super(addr); } + + + public static final int + PREFILTER_NORMALIZED_RESPONSE = 0, + PREFILTER_XSOBEL = 1; + + + // + // C++: static Ptr_StereoBM create(int numDisparities = 0, int blockSize = 21) + // + + //javadoc: StereoBM::create(numDisparities, blockSize) + public static StereoBM create(int numDisparities, int blockSize) + { + + StereoBM retVal = new StereoBM(create_0(numDisparities, blockSize)); + + return retVal; + } + + //javadoc: StereoBM::create() + public static StereoBM create() + { + + StereoBM retVal = new StereoBM(create_1()); + + return retVal; + } + + + // + // C++: Rect getROI1() + // + + //javadoc: StereoBM::getROI1() + public Rect getROI1() + { + + Rect retVal = new Rect(getROI1_0(nativeObj)); + + return retVal; + } + + + // + // C++: Rect getROI2() + // + + //javadoc: StereoBM::getROI2() + public Rect getROI2() + { + + Rect retVal = new Rect(getROI2_0(nativeObj)); + + return retVal; + } + + + // + // C++: int getPreFilterCap() + // + + //javadoc: StereoBM::getPreFilterCap() + public int getPreFilterCap() + { + + int retVal = getPreFilterCap_0(nativeObj); + + return retVal; + } + + + // + // C++: int getPreFilterSize() + // + + //javadoc: StereoBM::getPreFilterSize() + public int getPreFilterSize() + { + + int retVal = getPreFilterSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getPreFilterType() + // + + //javadoc: StereoBM::getPreFilterType() + public int getPreFilterType() + { + + int retVal = getPreFilterType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getSmallerBlockSize() + // + + //javadoc: StereoBM::getSmallerBlockSize() + public int getSmallerBlockSize() + { + + int retVal = getSmallerBlockSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getTextureThreshold() + // + + //javadoc: StereoBM::getTextureThreshold() + public int getTextureThreshold() + { + + int retVal = getTextureThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getUniquenessRatio() + // + + //javadoc: StereoBM::getUniquenessRatio() + public int getUniquenessRatio() + { + + int retVal = getUniquenessRatio_0(nativeObj); + + return retVal; + } + + + // + // C++: void setPreFilterCap(int preFilterCap) + // + + //javadoc: StereoBM::setPreFilterCap(preFilterCap) + public void setPreFilterCap(int preFilterCap) + { + + setPreFilterCap_0(nativeObj, preFilterCap); + + return; + } + + + // + // C++: void setPreFilterSize(int preFilterSize) + // + + //javadoc: StereoBM::setPreFilterSize(preFilterSize) + public void setPreFilterSize(int preFilterSize) + { + + setPreFilterSize_0(nativeObj, preFilterSize); + + return; + } + + + // + // C++: void setPreFilterType(int preFilterType) + // + + //javadoc: StereoBM::setPreFilterType(preFilterType) + public void setPreFilterType(int preFilterType) + { + + setPreFilterType_0(nativeObj, preFilterType); + + return; + } + + + // + // C++: void setROI1(Rect roi1) + // + + //javadoc: StereoBM::setROI1(roi1) + public void setROI1(Rect roi1) + { + + setROI1_0(nativeObj, roi1.x, roi1.y, roi1.width, roi1.height); + + return; + } + + + // + // C++: void setROI2(Rect roi2) + // + + //javadoc: StereoBM::setROI2(roi2) + public void setROI2(Rect roi2) + { + + setROI2_0(nativeObj, roi2.x, roi2.y, roi2.width, roi2.height); + + return; + } + + + // + // C++: void setSmallerBlockSize(int blockSize) + // + + //javadoc: StereoBM::setSmallerBlockSize(blockSize) + public void setSmallerBlockSize(int blockSize) + { + + setSmallerBlockSize_0(nativeObj, blockSize); + + return; + } + + + // + // C++: void setTextureThreshold(int textureThreshold) + // + + //javadoc: StereoBM::setTextureThreshold(textureThreshold) + public void setTextureThreshold(int textureThreshold) + { + + setTextureThreshold_0(nativeObj, textureThreshold); + + return; + } + + + // + // C++: void setUniquenessRatio(int uniquenessRatio) + // + + //javadoc: StereoBM::setUniquenessRatio(uniquenessRatio) + public void setUniquenessRatio(int uniquenessRatio) + { + + setUniquenessRatio_0(nativeObj, uniquenessRatio); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_StereoBM create(int numDisparities = 0, int blockSize = 21) + private static native long create_0(int numDisparities, int blockSize); + private static native long create_1(); + + // C++: Rect getROI1() + private static native double[] getROI1_0(long nativeObj); + + // C++: Rect getROI2() + private static native double[] getROI2_0(long nativeObj); + + // C++: int getPreFilterCap() + private static native int getPreFilterCap_0(long nativeObj); + + // C++: int getPreFilterSize() + private static native int getPreFilterSize_0(long nativeObj); + + // C++: int getPreFilterType() + private static native int getPreFilterType_0(long nativeObj); + + // C++: int getSmallerBlockSize() + private static native int getSmallerBlockSize_0(long nativeObj); + + // C++: int getTextureThreshold() + private static native int getTextureThreshold_0(long nativeObj); + + // C++: int getUniquenessRatio() + private static native int getUniquenessRatio_0(long nativeObj); + + // C++: void setPreFilterCap(int preFilterCap) + private static native void setPreFilterCap_0(long nativeObj, int preFilterCap); + + // C++: void setPreFilterSize(int preFilterSize) + private static native void setPreFilterSize_0(long nativeObj, int preFilterSize); + + // C++: void setPreFilterType(int preFilterType) + private static native void setPreFilterType_0(long nativeObj, int preFilterType); + + // C++: void setROI1(Rect roi1) + private static native void setROI1_0(long nativeObj, int roi1_x, int roi1_y, int roi1_width, int roi1_height); + + // C++: void setROI2(Rect roi2) + private static native void setROI2_0(long nativeObj, int roi2_x, int roi2_y, int roi2_width, int roi2_height); + + // C++: void setSmallerBlockSize(int blockSize) + private static native void setSmallerBlockSize_0(long nativeObj, int blockSize); + + // C++: void setTextureThreshold(int textureThreshold) + private static native void setTextureThreshold_0(long nativeObj, int textureThreshold); + + // C++: void setUniquenessRatio(int uniquenessRatio) + private static native void setUniquenessRatio_0(long nativeObj, int uniquenessRatio); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoMatcher.java b/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoMatcher.java new file mode 100644 index 00000000000..6b3c4f63fd0 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoMatcher.java @@ -0,0 +1,253 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.calib3d; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; + +// C++: class StereoMatcher +//javadoc: StereoMatcher +public class StereoMatcher extends Algorithm { + + protected StereoMatcher(long addr) { super(addr); } + + + public static final int + DISP_SHIFT = 4, + DISP_SCALE = (1 << DISP_SHIFT); + + + // + // C++: int getBlockSize() + // + + //javadoc: StereoMatcher::getBlockSize() + public int getBlockSize() + { + + int retVal = getBlockSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDisp12MaxDiff() + // + + //javadoc: StereoMatcher::getDisp12MaxDiff() + public int getDisp12MaxDiff() + { + + int retVal = getDisp12MaxDiff_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMinDisparity() + // + + //javadoc: StereoMatcher::getMinDisparity() + public int getMinDisparity() + { + + int retVal = getMinDisparity_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNumDisparities() + // + + //javadoc: StereoMatcher::getNumDisparities() + public int getNumDisparities() + { + + int retVal = getNumDisparities_0(nativeObj); + + return retVal; + } + + + // + // C++: int getSpeckleRange() + // + + //javadoc: StereoMatcher::getSpeckleRange() + public int getSpeckleRange() + { + + int retVal = getSpeckleRange_0(nativeObj); + + return retVal; + } + + + // + // C++: int getSpeckleWindowSize() + // + + //javadoc: StereoMatcher::getSpeckleWindowSize() + public int getSpeckleWindowSize() + { + + int retVal = getSpeckleWindowSize_0(nativeObj); + + return retVal; + } + + + // + // C++: void compute(Mat left, Mat right, Mat& disparity) + // + + //javadoc: StereoMatcher::compute(left, right, disparity) + public void compute(Mat left, Mat right, Mat disparity) + { + + compute_0(nativeObj, left.nativeObj, right.nativeObj, disparity.nativeObj); + + return; + } + + + // + // C++: void setBlockSize(int blockSize) + // + + //javadoc: StereoMatcher::setBlockSize(blockSize) + public void setBlockSize(int blockSize) + { + + setBlockSize_0(nativeObj, blockSize); + + return; + } + + + // + // C++: void setDisp12MaxDiff(int disp12MaxDiff) + // + + //javadoc: StereoMatcher::setDisp12MaxDiff(disp12MaxDiff) + public void setDisp12MaxDiff(int disp12MaxDiff) + { + + setDisp12MaxDiff_0(nativeObj, disp12MaxDiff); + + return; + } + + + // + // C++: void setMinDisparity(int minDisparity) + // + + //javadoc: StereoMatcher::setMinDisparity(minDisparity) + public void setMinDisparity(int minDisparity) + { + + setMinDisparity_0(nativeObj, minDisparity); + + return; + } + + + // + // C++: void setNumDisparities(int numDisparities) + // + + //javadoc: StereoMatcher::setNumDisparities(numDisparities) + public void setNumDisparities(int numDisparities) + { + + setNumDisparities_0(nativeObj, numDisparities); + + return; + } + + + // + // C++: void setSpeckleRange(int speckleRange) + // + + //javadoc: StereoMatcher::setSpeckleRange(speckleRange) + public void setSpeckleRange(int speckleRange) + { + + setSpeckleRange_0(nativeObj, speckleRange); + + return; + } + + + // + // C++: void setSpeckleWindowSize(int speckleWindowSize) + // + + //javadoc: StereoMatcher::setSpeckleWindowSize(speckleWindowSize) + public void setSpeckleWindowSize(int speckleWindowSize) + { + + setSpeckleWindowSize_0(nativeObj, speckleWindowSize); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: int getBlockSize() + private static native int getBlockSize_0(long nativeObj); + + // C++: int getDisp12MaxDiff() + private static native int getDisp12MaxDiff_0(long nativeObj); + + // C++: int getMinDisparity() + private static native int getMinDisparity_0(long nativeObj); + + // C++: int getNumDisparities() + private static native int getNumDisparities_0(long nativeObj); + + // C++: int getSpeckleRange() + private static native int getSpeckleRange_0(long nativeObj); + + // C++: int getSpeckleWindowSize() + private static native int getSpeckleWindowSize_0(long nativeObj); + + // C++: void compute(Mat left, Mat right, Mat& disparity) + private static native void compute_0(long nativeObj, long left_nativeObj, long right_nativeObj, long disparity_nativeObj); + + // C++: void setBlockSize(int blockSize) + private static native void setBlockSize_0(long nativeObj, int blockSize); + + // C++: void setDisp12MaxDiff(int disp12MaxDiff) + private static native void setDisp12MaxDiff_0(long nativeObj, int disp12MaxDiff); + + // C++: void setMinDisparity(int minDisparity) + private static native void setMinDisparity_0(long nativeObj, int minDisparity); + + // C++: void setNumDisparities(int numDisparities) + private static native void setNumDisparities_0(long nativeObj, int numDisparities); + + // C++: void setSpeckleRange(int speckleRange) + private static native void setSpeckleRange_0(long nativeObj, int speckleRange); + + // C++: void setSpeckleWindowSize(int speckleWindowSize) + private static native void setSpeckleWindowSize_0(long nativeObj, int speckleWindowSize); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoSGBM.java b/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoSGBM.java new file mode 100644 index 00000000000..d1d7b598b36 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/calib3d/StereoSGBM.java @@ -0,0 +1,230 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.calib3d; + + + +// C++: class StereoSGBM +//javadoc: StereoSGBM +public class StereoSGBM extends StereoMatcher { + + protected StereoSGBM(long addr) { super(addr); } + + + public static final int + MODE_SGBM = 0, + MODE_HH = 1, + MODE_SGBM_3WAY = 2, + MODE_HH4 = 3; + + + // + // C++: static Ptr_StereoSGBM create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3, int P1 = 0, int P2 = 0, int disp12MaxDiff = 0, int preFilterCap = 0, int uniquenessRatio = 0, int speckleWindowSize = 0, int speckleRange = 0, int mode = StereoSGBM::MODE_SGBM) + // + + //javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode) + public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, int mode) + { + + StereoSGBM retVal = new StereoSGBM(create_0(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode)); + + return retVal; + } + + //javadoc: StereoSGBM::create() + public static StereoSGBM create() + { + + StereoSGBM retVal = new StereoSGBM(create_1()); + + return retVal; + } + + + // + // C++: int getMode() + // + + //javadoc: StereoSGBM::getMode() + public int getMode() + { + + int retVal = getMode_0(nativeObj); + + return retVal; + } + + + // + // C++: int getP1() + // + + //javadoc: StereoSGBM::getP1() + public int getP1() + { + + int retVal = getP1_0(nativeObj); + + return retVal; + } + + + // + // C++: int getP2() + // + + //javadoc: StereoSGBM::getP2() + public int getP2() + { + + int retVal = getP2_0(nativeObj); + + return retVal; + } + + + // + // C++: int getPreFilterCap() + // + + //javadoc: StereoSGBM::getPreFilterCap() + public int getPreFilterCap() + { + + int retVal = getPreFilterCap_0(nativeObj); + + return retVal; + } + + + // + // C++: int getUniquenessRatio() + // + + //javadoc: StereoSGBM::getUniquenessRatio() + public int getUniquenessRatio() + { + + int retVal = getUniquenessRatio_0(nativeObj); + + return retVal; + } + + + // + // C++: void setMode(int mode) + // + + //javadoc: StereoSGBM::setMode(mode) + public void setMode(int mode) + { + + setMode_0(nativeObj, mode); + + return; + } + + + // + // C++: void setP1(int P1) + // + + //javadoc: StereoSGBM::setP1(P1) + public void setP1(int P1) + { + + setP1_0(nativeObj, P1); + + return; + } + + + // + // C++: void setP2(int P2) + // + + //javadoc: StereoSGBM::setP2(P2) + public void setP2(int P2) + { + + setP2_0(nativeObj, P2); + + return; + } + + + // + // C++: void setPreFilterCap(int preFilterCap) + // + + //javadoc: StereoSGBM::setPreFilterCap(preFilterCap) + public void setPreFilterCap(int preFilterCap) + { + + setPreFilterCap_0(nativeObj, preFilterCap); + + return; + } + + + // + // C++: void setUniquenessRatio(int uniquenessRatio) + // + + //javadoc: StereoSGBM::setUniquenessRatio(uniquenessRatio) + public void setUniquenessRatio(int uniquenessRatio) + { + + setUniquenessRatio_0(nativeObj, uniquenessRatio); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_StereoSGBM create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3, int P1 = 0, int P2 = 0, int disp12MaxDiff = 0, int preFilterCap = 0, int uniquenessRatio = 0, int speckleWindowSize = 0, int speckleRange = 0, int mode = StereoSGBM::MODE_SGBM) + private static native long create_0(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, int mode); + private static native long create_1(); + + // C++: int getMode() + private static native int getMode_0(long nativeObj); + + // C++: int getP1() + private static native int getP1_0(long nativeObj); + + // C++: int getP2() + private static native int getP2_0(long nativeObj); + + // C++: int getPreFilterCap() + private static native int getPreFilterCap_0(long nativeObj); + + // C++: int getUniquenessRatio() + private static native int getUniquenessRatio_0(long nativeObj); + + // C++: void setMode(int mode) + private static native void setMode_0(long nativeObj, int mode); + + // C++: void setP1(int P1) + private static native void setP1_0(long nativeObj, int P1); + + // C++: void setP2(int P2) + private static native void setP2_0(long nativeObj, int P2); + + // C++: void setPreFilterCap(int preFilterCap) + private static native void setPreFilterCap_0(long nativeObj, int preFilterCap); + + // C++: void setUniquenessRatio(int uniquenessRatio) + private static native void setUniquenessRatio_0(long nativeObj, int uniquenessRatio); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Algorithm.java b/openCVLibrary330/src/main/java/org/opencv/core/Algorithm.java new file mode 100644 index 00000000000..8437104c3b5 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Algorithm.java @@ -0,0 +1,79 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.core; + +import java.lang.String; + +// C++: class Algorithm +//javadoc: Algorithm +public class Algorithm { + + protected final long nativeObj; + protected Algorithm(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: String getDefaultName() + // + + //javadoc: Algorithm::getDefaultName() + public String getDefaultName() + { + + String retVal = getDefaultName_0(nativeObj); + + return retVal; + } + + + // + // C++: void clear() + // + + //javadoc: Algorithm::clear() + public void clear() + { + + clear_0(nativeObj); + + return; + } + + + // + // C++: void save(String filename) + // + + //javadoc: Algorithm::save(filename) + public void save(String filename) + { + + save_0(nativeObj, filename); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: String getDefaultName() + private static native String getDefaultName_0(long nativeObj); + + // C++: void clear() + private static native void clear_0(long nativeObj); + + // C++: void save(String filename) + private static native void save_0(long nativeObj, String filename); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Core.java b/openCVLibrary330/src/main/java/org/opencv/core/Core.java new file mode 100644 index 00000000000..6f89b134ce1 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Core.java @@ -0,0 +1,2674 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.core; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfDouble; +import org.opencv.core.MatOfInt; +import org.opencv.core.Scalar; +import org.opencv.core.TermCriteria; +import org.opencv.utils.Converters; + +public class Core { + + // these constants are wrapped inside functions to prevent inlining + private static String getVersion() { return "3.3.0"; } + private static String getNativeLibraryName() { return "opencv_java330"; } + private static int getVersionMajor() { return 3; } + private static int getVersionMinor() { return 3; } + private static int getVersionRevision() { return 0; } + private static String getVersionStatus() { return ""; } + + public static final String VERSION = getVersion(); + public static final String NATIVE_LIBRARY_NAME = getNativeLibraryName(); + public static final int VERSION_MAJOR = getVersionMajor(); + public static final int VERSION_MINOR = getVersionMinor(); + public static final int VERSION_REVISION = getVersionRevision(); + public static final String VERSION_STATUS = getVersionStatus(); + + private static final int + CV_8U = 0, + CV_8S = 1, + CV_16U = 2, + CV_16S = 3, + CV_32S = 4, + CV_32F = 5, + CV_64F = 6, + CV_USRTYPE1 = 7; + + + public static final int + SVD_MODIFY_A = 1, + SVD_NO_UV = 2, + SVD_FULL_UV = 4, + FILLED = -1, + REDUCE_SUM = 0, + REDUCE_AVG = 1, + REDUCE_MAX = 2, + REDUCE_MIN = 3, + StsOk = 0, + StsBackTrace = -1, + StsError = -2, + StsInternal = -3, + StsNoMem = -4, + StsBadArg = -5, + StsBadFunc = -6, + StsNoConv = -7, + StsAutoTrace = -8, + HeaderIsNull = -9, + BadImageSize = -10, + BadOffset = -11, + BadDataPtr = -12, + BadStep = -13, + BadModelOrChSeq = -14, + BadNumChannels = -15, + BadNumChannel1U = -16, + BadDepth = -17, + BadAlphaChannel = -18, + BadOrder = -19, + BadOrigin = -20, + BadAlign = -21, + BadCallBack = -22, + BadTileSize = -23, + BadCOI = -24, + BadROISize = -25, + MaskIsTiled = -26, + StsNullPtr = -27, + StsVecLengthErr = -28, + StsFilterStructContentErr = -29, + StsKernelStructContentErr = -30, + StsFilterOffsetErr = -31, + StsBadSize = -201, + StsDivByZero = -202, + StsInplaceNotSupported = -203, + StsObjectNotFound = -204, + StsUnmatchedFormats = -205, + StsBadFlag = -206, + StsBadPoint = -207, + StsBadMask = -208, + StsUnmatchedSizes = -209, + StsUnsupportedFormat = -210, + StsOutOfRange = -211, + StsParseError = -212, + StsNotImplemented = -213, + StsBadMemBlock = -214, + StsAssert = -215, + GpuNotSupported = -216, + GpuApiCallError = -217, + OpenGlNotSupported = -218, + OpenGlApiCallError = -219, + OpenCLApiCallError = -220, + OpenCLDoubleNotSupported = -221, + OpenCLInitError = -222, + OpenCLNoAMDBlasFft = -223, + DECOMP_LU = 0, + DECOMP_SVD = 1, + DECOMP_EIG = 2, + DECOMP_CHOLESKY = 3, + DECOMP_QR = 4, + DECOMP_NORMAL = 16, + NORM_INF = 1, + NORM_L1 = 2, + NORM_L2 = 4, + NORM_L2SQR = 5, + NORM_HAMMING = 6, + NORM_HAMMING2 = 7, + NORM_TYPE_MASK = 7, + NORM_RELATIVE = 8, + NORM_MINMAX = 32, + CMP_EQ = 0, + CMP_GT = 1, + CMP_GE = 2, + CMP_LT = 3, + CMP_LE = 4, + CMP_NE = 5, + GEMM_1_T = 1, + GEMM_2_T = 2, + GEMM_3_T = 4, + DFT_INVERSE = 1, + DFT_SCALE = 2, + DFT_ROWS = 4, + DFT_COMPLEX_OUTPUT = 16, + DFT_REAL_OUTPUT = 32, + DFT_COMPLEX_INPUT = 64, + DCT_INVERSE = DFT_INVERSE, + DCT_ROWS = DFT_ROWS, + BORDER_CONSTANT = 0, + BORDER_REPLICATE = 1, + BORDER_REFLECT = 2, + BORDER_WRAP = 3, + BORDER_REFLECT_101 = 4, + BORDER_TRANSPARENT = 5, + BORDER_REFLECT101 = BORDER_REFLECT_101, + BORDER_DEFAULT = BORDER_REFLECT_101, + BORDER_ISOLATED = 16, + SORT_EVERY_ROW = 0, + SORT_EVERY_COLUMN = 1, + SORT_ASCENDING = 0, + SORT_DESCENDING = 16, + COVAR_SCRAMBLED = 0, + COVAR_NORMAL = 1, + COVAR_USE_AVG = 2, + COVAR_SCALE = 4, + COVAR_ROWS = 8, + COVAR_COLS = 16, + KMEANS_RANDOM_CENTERS = 0, + KMEANS_PP_CENTERS = 2, + KMEANS_USE_INITIAL_LABELS = 1, + LINE_4 = 4, + LINE_8 = 8, + LINE_AA = 16, + FONT_HERSHEY_SIMPLEX = 0, + FONT_HERSHEY_PLAIN = 1, + FONT_HERSHEY_DUPLEX = 2, + FONT_HERSHEY_COMPLEX = 3, + FONT_HERSHEY_TRIPLEX = 4, + FONT_HERSHEY_COMPLEX_SMALL = 5, + FONT_HERSHEY_SCRIPT_SIMPLEX = 6, + FONT_HERSHEY_SCRIPT_COMPLEX = 7, + FONT_ITALIC = 16, + ROTATE_90_CLOCKWISE = 0, + ROTATE_180 = 1, + ROTATE_90_COUNTERCLOCKWISE = 2, + TYPE_GENERAL = 0, + TYPE_MARKER = 0+1, + TYPE_WRAPPER = 0+2, + TYPE_FUN = 0+3, + IMPL_PLAIN = 0, + IMPL_IPP = 0+1, + IMPL_OPENCL = 0+2, + FLAGS_NONE = 0, + FLAGS_MAPPING = 0x01, + FLAGS_EXPAND_SAME_NAMES = 0x02; + + + // + // C++: Scalar mean(Mat src, Mat mask = Mat()) + // + + //javadoc: mean(src, mask) + public static Scalar mean(Mat src, Mat mask) + { + + Scalar retVal = new Scalar(mean_0(src.nativeObj, mask.nativeObj)); + + return retVal; + } + + //javadoc: mean(src) + public static Scalar mean(Mat src) + { + + Scalar retVal = new Scalar(mean_1(src.nativeObj)); + + return retVal; + } + + + // + // C++: Scalar sum(Mat src) + // + + //javadoc: sum(src) + public static Scalar sumElems(Mat src) + { + + Scalar retVal = new Scalar(sumElems_0(src.nativeObj)); + + return retVal; + } + + + // + // C++: Scalar trace(Mat mtx) + // + + //javadoc: trace(mtx) + public static Scalar trace(Mat mtx) + { + + Scalar retVal = new Scalar(trace_0(mtx.nativeObj)); + + return retVal; + } + + + // + // C++: String getBuildInformation() + // + + //javadoc: getBuildInformation() + public static String getBuildInformation() + { + + String retVal = getBuildInformation_0(); + + return retVal; + } + + + // + // C++: bool checkRange(Mat a, bool quiet = true, _hidden_ * pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX) + // + + //javadoc: checkRange(a, quiet, minVal, maxVal) + public static boolean checkRange(Mat a, boolean quiet, double minVal, double maxVal) + { + + boolean retVal = checkRange_0(a.nativeObj, quiet, minVal, maxVal); + + return retVal; + } + + //javadoc: checkRange(a) + public static boolean checkRange(Mat a) + { + + boolean retVal = checkRange_1(a.nativeObj); + + return retVal; + } + + + // + // C++: bool eigen(Mat src, Mat& eigenvalues, Mat& eigenvectors = Mat()) + // + + //javadoc: eigen(src, eigenvalues, eigenvectors) + public static boolean eigen(Mat src, Mat eigenvalues, Mat eigenvectors) + { + + boolean retVal = eigen_0(src.nativeObj, eigenvalues.nativeObj, eigenvectors.nativeObj); + + return retVal; + } + + //javadoc: eigen(src, eigenvalues) + public static boolean eigen(Mat src, Mat eigenvalues) + { + + boolean retVal = eigen_1(src.nativeObj, eigenvalues.nativeObj); + + return retVal; + } + + + // + // C++: bool solve(Mat src1, Mat src2, Mat& dst, int flags = DECOMP_LU) + // + + //javadoc: solve(src1, src2, dst, flags) + public static boolean solve(Mat src1, Mat src2, Mat dst, int flags) + { + + boolean retVal = solve_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, flags); + + return retVal; + } + + //javadoc: solve(src1, src2, dst) + public static boolean solve(Mat src1, Mat src2, Mat dst) + { + + boolean retVal = solve_1(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return retVal; + } + + + // + // C++: bool useIPP() + // + + //javadoc: useIPP() + public static boolean useIPP() + { + + boolean retVal = useIPP_0(); + + return retVal; + } + + + // + // C++: double Mahalanobis(Mat v1, Mat v2, Mat icovar) + // + + //javadoc: Mahalanobis(v1, v2, icovar) + public static double Mahalanobis(Mat v1, Mat v2, Mat icovar) + { + + double retVal = Mahalanobis_0(v1.nativeObj, v2.nativeObj, icovar.nativeObj); + + return retVal; + } + + + // + // C++: double PSNR(Mat src1, Mat src2) + // + + //javadoc: PSNR(src1, src2) + public static double PSNR(Mat src1, Mat src2) + { + + double retVal = PSNR_0(src1.nativeObj, src2.nativeObj); + + return retVal; + } + + + // + // C++: double determinant(Mat mtx) + // + + //javadoc: determinant(mtx) + public static double determinant(Mat mtx) + { + + double retVal = determinant_0(mtx.nativeObj); + + return retVal; + } + + + // + // C++: double getTickFrequency() + // + + //javadoc: getTickFrequency() + public static double getTickFrequency() + { + + double retVal = getTickFrequency_0(); + + return retVal; + } + + + // + // C++: double invert(Mat src, Mat& dst, int flags = DECOMP_LU) + // + + //javadoc: invert(src, dst, flags) + public static double invert(Mat src, Mat dst, int flags) + { + + double retVal = invert_0(src.nativeObj, dst.nativeObj, flags); + + return retVal; + } + + //javadoc: invert(src, dst) + public static double invert(Mat src, Mat dst) + { + + double retVal = invert_1(src.nativeObj, dst.nativeObj); + + return retVal; + } + + + // + // C++: double kmeans(Mat data, int K, Mat& bestLabels, TermCriteria criteria, int attempts, int flags, Mat& centers = Mat()) + // + + //javadoc: kmeans(data, K, bestLabels, criteria, attempts, flags, centers) + public static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers) + { + + double retVal = kmeans_0(data.nativeObj, K, bestLabels.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, attempts, flags, centers.nativeObj); + + return retVal; + } + + //javadoc: kmeans(data, K, bestLabels, criteria, attempts, flags) + public static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags) + { + + double retVal = kmeans_1(data.nativeObj, K, bestLabels.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, attempts, flags); + + return retVal; + } + + + // + // C++: double norm(Mat src1, Mat src2, int normType = NORM_L2, Mat mask = Mat()) + // + + //javadoc: norm(src1, src2, normType, mask) + public static double norm(Mat src1, Mat src2, int normType, Mat mask) + { + + double retVal = norm_0(src1.nativeObj, src2.nativeObj, normType, mask.nativeObj); + + return retVal; + } + + //javadoc: norm(src1, src2, normType) + public static double norm(Mat src1, Mat src2, int normType) + { + + double retVal = norm_1(src1.nativeObj, src2.nativeObj, normType); + + return retVal; + } + + //javadoc: norm(src1, src2) + public static double norm(Mat src1, Mat src2) + { + + double retVal = norm_2(src1.nativeObj, src2.nativeObj); + + return retVal; + } + + + // + // C++: double norm(Mat src1, int normType = NORM_L2, Mat mask = Mat()) + // + + //javadoc: norm(src1, normType, mask) + public static double norm(Mat src1, int normType, Mat mask) + { + + double retVal = norm_3(src1.nativeObj, normType, mask.nativeObj); + + return retVal; + } + + //javadoc: norm(src1, normType) + public static double norm(Mat src1, int normType) + { + + double retVal = norm_4(src1.nativeObj, normType); + + return retVal; + } + + //javadoc: norm(src1) + public static double norm(Mat src1) + { + + double retVal = norm_5(src1.nativeObj); + + return retVal; + } + + + // + // C++: double solvePoly(Mat coeffs, Mat& roots, int maxIters = 300) + // + + //javadoc: solvePoly(coeffs, roots, maxIters) + public static double solvePoly(Mat coeffs, Mat roots, int maxIters) + { + + double retVal = solvePoly_0(coeffs.nativeObj, roots.nativeObj, maxIters); + + return retVal; + } + + //javadoc: solvePoly(coeffs, roots) + public static double solvePoly(Mat coeffs, Mat roots) + { + + double retVal = solvePoly_1(coeffs.nativeObj, roots.nativeObj); + + return retVal; + } + + + // + // C++: float cubeRoot(float val) + // + + //javadoc: cubeRoot(val) + public static float cubeRoot(float val) + { + + float retVal = cubeRoot_0(val); + + return retVal; + } + + + // + // C++: float fastAtan2(float y, float x) + // + + //javadoc: fastAtan2(y, x) + public static float fastAtan2(float y, float x) + { + + float retVal = fastAtan2_0(y, x); + + return retVal; + } + + + // + // C++: int borderInterpolate(int p, int len, int borderType) + // + + //javadoc: borderInterpolate(p, len, borderType) + public static int borderInterpolate(int p, int len, int borderType) + { + + int retVal = borderInterpolate_0(p, len, borderType); + + return retVal; + } + + + // + // C++: int countNonZero(Mat src) + // + + //javadoc: countNonZero(src) + public static int countNonZero(Mat src) + { + + int retVal = countNonZero_0(src.nativeObj); + + return retVal; + } + + + // + // C++: int getNumThreads() + // + + //javadoc: getNumThreads() + public static int getNumThreads() + { + + int retVal = getNumThreads_0(); + + return retVal; + } + + + // + // C++: int getNumberOfCPUs() + // + + //javadoc: getNumberOfCPUs() + public static int getNumberOfCPUs() + { + + int retVal = getNumberOfCPUs_0(); + + return retVal; + } + + + // + // C++: int getOptimalDFTSize(int vecsize) + // + + //javadoc: getOptimalDFTSize(vecsize) + public static int getOptimalDFTSize(int vecsize) + { + + int retVal = getOptimalDFTSize_0(vecsize); + + return retVal; + } + + + // + // C++: int getThreadNum() + // + + //javadoc: getThreadNum() + public static int getThreadNum() + { + + int retVal = getThreadNum_0(); + + return retVal; + } + + + // + // C++: int solveCubic(Mat coeffs, Mat& roots) + // + + //javadoc: solveCubic(coeffs, roots) + public static int solveCubic(Mat coeffs, Mat roots) + { + + int retVal = solveCubic_0(coeffs.nativeObj, roots.nativeObj); + + return retVal; + } + + + // + // C++: int64 getCPUTickCount() + // + + //javadoc: getCPUTickCount() + public static long getCPUTickCount() + { + + long retVal = getCPUTickCount_0(); + + return retVal; + } + + + // + // C++: int64 getTickCount() + // + + //javadoc: getTickCount() + public static long getTickCount() + { + + long retVal = getTickCount_0(); + + return retVal; + } + + + // + // C++: void LUT(Mat src, Mat lut, Mat& dst) + // + + //javadoc: LUT(src, lut, dst) + public static void LUT(Mat src, Mat lut, Mat dst) + { + + LUT_0(src.nativeObj, lut.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat& result) + // + + //javadoc: PCABackProject(data, mean, eigenvectors, result) + public static void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result) + { + + PCABackProject_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, result.nativeObj); + + return; + } + + + // + // C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, double retainedVariance) + // + + //javadoc: PCACompute(data, mean, eigenvectors, retainedVariance) + public static void PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance) + { + + PCACompute_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, retainedVariance); + + return; + } + + + // + // C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, int maxComponents = 0) + // + + //javadoc: PCACompute(data, mean, eigenvectors, maxComponents) + public static void PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents) + { + + PCACompute_1(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, maxComponents); + + return; + } + + //javadoc: PCACompute(data, mean, eigenvectors) + public static void PCACompute(Mat data, Mat mean, Mat eigenvectors) + { + + PCACompute_2(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj); + + return; + } + + + // + // C++: void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat& result) + // + + //javadoc: PCAProject(data, mean, eigenvectors, result) + public static void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result) + { + + PCAProject_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, result.nativeObj); + + return; + } + + + // + // C++: void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat& dst) + // + + //javadoc: SVBackSubst(w, u, vt, rhs, dst) + public static void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst) + { + + SVBackSubst_0(w.nativeObj, u.nativeObj, vt.nativeObj, rhs.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void SVDecomp(Mat src, Mat& w, Mat& u, Mat& vt, int flags = 0) + // + + //javadoc: SVDecomp(src, w, u, vt, flags) + public static void SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags) + { + + SVDecomp_0(src.nativeObj, w.nativeObj, u.nativeObj, vt.nativeObj, flags); + + return; + } + + //javadoc: SVDecomp(src, w, u, vt) + public static void SVDecomp(Mat src, Mat w, Mat u, Mat vt) + { + + SVDecomp_1(src.nativeObj, w.nativeObj, u.nativeObj, vt.nativeObj); + + return; + } + + + // + // C++: void absdiff(Mat src1, Mat src2, Mat& dst) + // + + //javadoc: absdiff(src1, src2, dst) + public static void absdiff(Mat src1, Mat src2, Mat dst) + { + + absdiff_0(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void absdiff(Mat src1, Scalar src2, Mat& dst) + // + + //javadoc: absdiff(src1, src2, dst) + public static void absdiff(Mat src1, Scalar src2, Mat dst) + { + + absdiff_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void add(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + // + + //javadoc: add(src1, src2, dst, mask, dtype) + public static void add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype) + { + + add_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype); + + return; + } + + //javadoc: add(src1, src2, dst, mask) + public static void add(Mat src1, Mat src2, Mat dst, Mat mask) + { + + add_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: add(src1, src2, dst) + public static void add(Mat src1, Mat src2, Mat dst) + { + + add_2(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void add(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + // + + //javadoc: add(src1, src2, dst, mask, dtype) + public static void add(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype) + { + + add_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj, dtype); + + return; + } + + //javadoc: add(src1, src2, dst, mask) + public static void add(Mat src1, Scalar src2, Mat dst, Mat mask) + { + + add_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: add(src1, src2, dst) + public static void add(Mat src1, Scalar src2, Mat dst) + { + + add_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat& dst, int dtype = -1) + // + + //javadoc: addWeighted(src1, alpha, src2, beta, gamma, dst, dtype) + public static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype) + { + + addWeighted_0(src1.nativeObj, alpha, src2.nativeObj, beta, gamma, dst.nativeObj, dtype); + + return; + } + + //javadoc: addWeighted(src1, alpha, src2, beta, gamma, dst) + public static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst) + { + + addWeighted_1(src1.nativeObj, alpha, src2.nativeObj, beta, gamma, dst.nativeObj); + + return; + } + + + // + // C++: void batchDistance(Mat src1, Mat src2, Mat& dist, int dtype, Mat& nidx, int normType = NORM_L2, int K = 0, Mat mask = Mat(), int update = 0, bool crosscheck = false) + // + + //javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K, mask, update, crosscheck) + public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck) + { + + batchDistance_0(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K, mask.nativeObj, update, crosscheck); + + return; + } + + //javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K) + public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K) + { + + batchDistance_1(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K); + + return; + } + + //javadoc: batchDistance(src1, src2, dist, dtype, nidx) + public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx) + { + + batchDistance_2(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj); + + return; + } + + + // + // C++: void bitwise_and(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + // + + //javadoc: bitwise_and(src1, src2, dst, mask) + public static void bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask) + { + + bitwise_and_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: bitwise_and(src1, src2, dst) + public static void bitwise_and(Mat src1, Mat src2, Mat dst) + { + + bitwise_and_1(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void bitwise_not(Mat src, Mat& dst, Mat mask = Mat()) + // + + //javadoc: bitwise_not(src, dst, mask) + public static void bitwise_not(Mat src, Mat dst, Mat mask) + { + + bitwise_not_0(src.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: bitwise_not(src, dst) + public static void bitwise_not(Mat src, Mat dst) + { + + bitwise_not_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void bitwise_or(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + // + + //javadoc: bitwise_or(src1, src2, dst, mask) + public static void bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask) + { + + bitwise_or_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: bitwise_or(src1, src2, dst) + public static void bitwise_or(Mat src1, Mat src2, Mat dst) + { + + bitwise_or_1(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void bitwise_xor(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + // + + //javadoc: bitwise_xor(src1, src2, dst, mask) + public static void bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask) + { + + bitwise_xor_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: bitwise_xor(src1, src2, dst) + public static void bitwise_xor(Mat src1, Mat src2, Mat dst) + { + + bitwise_xor_1(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void calcCovarMatrix(Mat samples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F) + // + + //javadoc: calcCovarMatrix(samples, covar, mean, flags, ctype) + public static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype) + { + + calcCovarMatrix_0(samples.nativeObj, covar.nativeObj, mean.nativeObj, flags, ctype); + + return; + } + + //javadoc: calcCovarMatrix(samples, covar, mean, flags) + public static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags) + { + + calcCovarMatrix_1(samples.nativeObj, covar.nativeObj, mean.nativeObj, flags); + + return; + } + + + // + // C++: void cartToPolar(Mat x, Mat y, Mat& magnitude, Mat& angle, bool angleInDegrees = false) + // + + //javadoc: cartToPolar(x, y, magnitude, angle, angleInDegrees) + public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees) + { + + cartToPolar_0(x.nativeObj, y.nativeObj, magnitude.nativeObj, angle.nativeObj, angleInDegrees); + + return; + } + + //javadoc: cartToPolar(x, y, magnitude, angle) + public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle) + { + + cartToPolar_1(x.nativeObj, y.nativeObj, magnitude.nativeObj, angle.nativeObj); + + return; + } + + + // + // C++: void compare(Mat src1, Mat src2, Mat& dst, int cmpop) + // + + //javadoc: compare(src1, src2, dst, cmpop) + public static void compare(Mat src1, Mat src2, Mat dst, int cmpop) + { + + compare_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, cmpop); + + return; + } + + + // + // C++: void compare(Mat src1, Scalar src2, Mat& dst, int cmpop) + // + + //javadoc: compare(src1, src2, dst, cmpop) + public static void compare(Mat src1, Scalar src2, Mat dst, int cmpop) + { + + compare_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, cmpop); + + return; + } + + + // + // C++: void completeSymm(Mat& mtx, bool lowerToUpper = false) + // + + //javadoc: completeSymm(mtx, lowerToUpper) + public static void completeSymm(Mat mtx, boolean lowerToUpper) + { + + completeSymm_0(mtx.nativeObj, lowerToUpper); + + return; + } + + //javadoc: completeSymm(mtx) + public static void completeSymm(Mat mtx) + { + + completeSymm_1(mtx.nativeObj); + + return; + } + + + // + // C++: void convertFp16(Mat src, Mat& dst) + // + + //javadoc: convertFp16(src, dst) + public static void convertFp16(Mat src, Mat dst) + { + + convertFp16_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void convertScaleAbs(Mat src, Mat& dst, double alpha = 1, double beta = 0) + // + + //javadoc: convertScaleAbs(src, dst, alpha, beta) + public static void convertScaleAbs(Mat src, Mat dst, double alpha, double beta) + { + + convertScaleAbs_0(src.nativeObj, dst.nativeObj, alpha, beta); + + return; + } + + //javadoc: convertScaleAbs(src, dst) + public static void convertScaleAbs(Mat src, Mat dst) + { + + convertScaleAbs_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void copyMakeBorder(Mat src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar value = Scalar()) + // + + //javadoc: copyMakeBorder(src, dst, top, bottom, left, right, borderType, value) + public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value) + { + + copyMakeBorder_0(src.nativeObj, dst.nativeObj, top, bottom, left, right, borderType, value.val[0], value.val[1], value.val[2], value.val[3]); + + return; + } + + //javadoc: copyMakeBorder(src, dst, top, bottom, left, right, borderType) + public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType) + { + + copyMakeBorder_1(src.nativeObj, dst.nativeObj, top, bottom, left, right, borderType); + + return; + } + + + // + // C++: void dct(Mat src, Mat& dst, int flags = 0) + // + + //javadoc: dct(src, dst, flags) + public static void dct(Mat src, Mat dst, int flags) + { + + dct_0(src.nativeObj, dst.nativeObj, flags); + + return; + } + + //javadoc: dct(src, dst) + public static void dct(Mat src, Mat dst) + { + + dct_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void dft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0) + // + + //javadoc: dft(src, dst, flags, nonzeroRows) + public static void dft(Mat src, Mat dst, int flags, int nonzeroRows) + { + + dft_0(src.nativeObj, dst.nativeObj, flags, nonzeroRows); + + return; + } + + //javadoc: dft(src, dst) + public static void dft(Mat src, Mat dst) + { + + dft_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void divide(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1) + // + + //javadoc: divide(src1, src2, dst, scale, dtype) + public static void divide(Mat src1, Mat src2, Mat dst, double scale, int dtype) + { + + divide_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale, dtype); + + return; + } + + //javadoc: divide(src1, src2, dst, scale) + public static void divide(Mat src1, Mat src2, Mat dst, double scale) + { + + divide_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale); + + return; + } + + //javadoc: divide(src1, src2, dst) + public static void divide(Mat src1, Mat src2, Mat dst) + { + + divide_2(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void divide(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1) + // + + //javadoc: divide(src1, src2, dst, scale, dtype) + public static void divide(Mat src1, Scalar src2, Mat dst, double scale, int dtype) + { + + divide_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale, dtype); + + return; + } + + //javadoc: divide(src1, src2, dst, scale) + public static void divide(Mat src1, Scalar src2, Mat dst, double scale) + { + + divide_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale); + + return; + } + + //javadoc: divide(src1, src2, dst) + public static void divide(Mat src1, Scalar src2, Mat dst) + { + + divide_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void divide(double scale, Mat src2, Mat& dst, int dtype = -1) + // + + //javadoc: divide(scale, src2, dst, dtype) + public static void divide(double scale, Mat src2, Mat dst, int dtype) + { + + divide_6(scale, src2.nativeObj, dst.nativeObj, dtype); + + return; + } + + //javadoc: divide(scale, src2, dst) + public static void divide(double scale, Mat src2, Mat dst) + { + + divide_7(scale, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void exp(Mat src, Mat& dst) + // + + //javadoc: exp(src, dst) + public static void exp(Mat src, Mat dst) + { + + exp_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void extractChannel(Mat src, Mat& dst, int coi) + // + + //javadoc: extractChannel(src, dst, coi) + public static void extractChannel(Mat src, Mat dst, int coi) + { + + extractChannel_0(src.nativeObj, dst.nativeObj, coi); + + return; + } + + + // + // C++: void findNonZero(Mat src, Mat& idx) + // + + //javadoc: findNonZero(src, idx) + public static void findNonZero(Mat src, Mat idx) + { + + findNonZero_0(src.nativeObj, idx.nativeObj); + + return; + } + + + // + // C++: void flip(Mat src, Mat& dst, int flipCode) + // + + //javadoc: flip(src, dst, flipCode) + public static void flip(Mat src, Mat dst, int flipCode) + { + + flip_0(src.nativeObj, dst.nativeObj, flipCode); + + return; + } + + + // + // C++: void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat& dst, int flags = 0) + // + + //javadoc: gemm(src1, src2, alpha, src3, beta, dst, flags) + public static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags) + { + + gemm_0(src1.nativeObj, src2.nativeObj, alpha, src3.nativeObj, beta, dst.nativeObj, flags); + + return; + } + + //javadoc: gemm(src1, src2, alpha, src3, beta, dst) + public static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst) + { + + gemm_1(src1.nativeObj, src2.nativeObj, alpha, src3.nativeObj, beta, dst.nativeObj); + + return; + } + + + // + // C++: void hconcat(vector_Mat src, Mat& dst) + // + + //javadoc: hconcat(src, dst) + public static void hconcat(List src, Mat dst) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + hconcat_0(src_mat.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void idct(Mat src, Mat& dst, int flags = 0) + // + + //javadoc: idct(src, dst, flags) + public static void idct(Mat src, Mat dst, int flags) + { + + idct_0(src.nativeObj, dst.nativeObj, flags); + + return; + } + + //javadoc: idct(src, dst) + public static void idct(Mat src, Mat dst) + { + + idct_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void idft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0) + // + + //javadoc: idft(src, dst, flags, nonzeroRows) + public static void idft(Mat src, Mat dst, int flags, int nonzeroRows) + { + + idft_0(src.nativeObj, dst.nativeObj, flags, nonzeroRows); + + return; + } + + //javadoc: idft(src, dst) + public static void idft(Mat src, Mat dst) + { + + idft_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat& dst) + // + + //javadoc: inRange(src, lowerb, upperb, dst) + public static void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst) + { + + inRange_0(src.nativeObj, lowerb.val[0], lowerb.val[1], lowerb.val[2], lowerb.val[3], upperb.val[0], upperb.val[1], upperb.val[2], upperb.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void insertChannel(Mat src, Mat& dst, int coi) + // + + //javadoc: insertChannel(src, dst, coi) + public static void insertChannel(Mat src, Mat dst, int coi) + { + + insertChannel_0(src.nativeObj, dst.nativeObj, coi); + + return; + } + + + // + // C++: void log(Mat src, Mat& dst) + // + + //javadoc: log(src, dst) + public static void log(Mat src, Mat dst) + { + + log_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void magnitude(Mat x, Mat y, Mat& magnitude) + // + + //javadoc: magnitude(x, y, magnitude) + public static void magnitude(Mat x, Mat y, Mat magnitude) + { + + magnitude_0(x.nativeObj, y.nativeObj, magnitude.nativeObj); + + return; + } + + + // + // C++: void max(Mat src1, Mat src2, Mat& dst) + // + + //javadoc: max(src1, src2, dst) + public static void max(Mat src1, Mat src2, Mat dst) + { + + max_0(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void max(Mat src1, Scalar src2, Mat& dst) + // + + //javadoc: max(src1, src2, dst) + public static void max(Mat src1, Scalar src2, Mat dst) + { + + max_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void meanStdDev(Mat src, vector_double& mean, vector_double& stddev, Mat mask = Mat()) + // + + //javadoc: meanStdDev(src, mean, stddev, mask) + public static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev, Mat mask) + { + Mat mean_mat = mean; + Mat stddev_mat = stddev; + meanStdDev_0(src.nativeObj, mean_mat.nativeObj, stddev_mat.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: meanStdDev(src, mean, stddev) + public static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev) + { + Mat mean_mat = mean; + Mat stddev_mat = stddev; + meanStdDev_1(src.nativeObj, mean_mat.nativeObj, stddev_mat.nativeObj); + + return; + } + + + // + // C++: void merge(vector_Mat mv, Mat& dst) + // + + //javadoc: merge(mv, dst) + public static void merge(List mv, Mat dst) + { + Mat mv_mat = Converters.vector_Mat_to_Mat(mv); + merge_0(mv_mat.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void min(Mat src1, Mat src2, Mat& dst) + // + + //javadoc: min(src1, src2, dst) + public static void min(Mat src1, Mat src2, Mat dst) + { + + min_0(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void min(Mat src1, Scalar src2, Mat& dst) + // + + //javadoc: min(src1, src2, dst) + public static void min(Mat src1, Scalar src2, Mat dst) + { + + min_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void mixChannels(vector_Mat src, vector_Mat dst, vector_int fromTo) + // + + //javadoc: mixChannels(src, dst, fromTo) + public static void mixChannels(List src, List dst, MatOfInt fromTo) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + Mat dst_mat = Converters.vector_Mat_to_Mat(dst); + Mat fromTo_mat = fromTo; + mixChannels_0(src_mat.nativeObj, dst_mat.nativeObj, fromTo_mat.nativeObj); + + return; + } + + + // + // C++: void mulSpectrums(Mat a, Mat b, Mat& c, int flags, bool conjB = false) + // + + //javadoc: mulSpectrums(a, b, c, flags, conjB) + public static void mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB) + { + + mulSpectrums_0(a.nativeObj, b.nativeObj, c.nativeObj, flags, conjB); + + return; + } + + //javadoc: mulSpectrums(a, b, c, flags) + public static void mulSpectrums(Mat a, Mat b, Mat c, int flags) + { + + mulSpectrums_1(a.nativeObj, b.nativeObj, c.nativeObj, flags); + + return; + } + + + // + // C++: void mulTransposed(Mat src, Mat& dst, bool aTa, Mat delta = Mat(), double scale = 1, int dtype = -1) + // + + //javadoc: mulTransposed(src, dst, aTa, delta, scale, dtype) + public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype) + { + + mulTransposed_0(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj, scale, dtype); + + return; + } + + //javadoc: mulTransposed(src, dst, aTa, delta, scale) + public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale) + { + + mulTransposed_1(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj, scale); + + return; + } + + //javadoc: mulTransposed(src, dst, aTa) + public static void mulTransposed(Mat src, Mat dst, boolean aTa) + { + + mulTransposed_2(src.nativeObj, dst.nativeObj, aTa); + + return; + } + + + // + // C++: void multiply(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1) + // + + //javadoc: multiply(src1, src2, dst, scale, dtype) + public static void multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype) + { + + multiply_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale, dtype); + + return; + } + + //javadoc: multiply(src1, src2, dst, scale) + public static void multiply(Mat src1, Mat src2, Mat dst, double scale) + { + + multiply_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale); + + return; + } + + //javadoc: multiply(src1, src2, dst) + public static void multiply(Mat src1, Mat src2, Mat dst) + { + + multiply_2(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void multiply(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1) + // + + //javadoc: multiply(src1, src2, dst, scale, dtype) + public static void multiply(Mat src1, Scalar src2, Mat dst, double scale, int dtype) + { + + multiply_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale, dtype); + + return; + } + + //javadoc: multiply(src1, src2, dst, scale) + public static void multiply(Mat src1, Scalar src2, Mat dst, double scale) + { + + multiply_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale); + + return; + } + + //javadoc: multiply(src1, src2, dst) + public static void multiply(Mat src1, Scalar src2, Mat dst) + { + + multiply_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void normalize(Mat src, Mat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, Mat mask = Mat()) + // + + //javadoc: normalize(src, dst, alpha, beta, norm_type, dtype, mask) + public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask) + { + + normalize_0(src.nativeObj, dst.nativeObj, alpha, beta, norm_type, dtype, mask.nativeObj); + + return; + } + + //javadoc: normalize(src, dst, alpha, beta, norm_type, dtype) + public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype) + { + + normalize_1(src.nativeObj, dst.nativeObj, alpha, beta, norm_type, dtype); + + return; + } + + //javadoc: normalize(src, dst, alpha, beta, norm_type) + public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type) + { + + normalize_2(src.nativeObj, dst.nativeObj, alpha, beta, norm_type); + + return; + } + + //javadoc: normalize(src, dst) + public static void normalize(Mat src, Mat dst) + { + + normalize_3(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void patchNaNs(Mat& a, double val = 0) + // + + //javadoc: patchNaNs(a, val) + public static void patchNaNs(Mat a, double val) + { + + patchNaNs_0(a.nativeObj, val); + + return; + } + + //javadoc: patchNaNs(a) + public static void patchNaNs(Mat a) + { + + patchNaNs_1(a.nativeObj); + + return; + } + + + // + // C++: void perspectiveTransform(Mat src, Mat& dst, Mat m) + // + + //javadoc: perspectiveTransform(src, dst, m) + public static void perspectiveTransform(Mat src, Mat dst, Mat m) + { + + perspectiveTransform_0(src.nativeObj, dst.nativeObj, m.nativeObj); + + return; + } + + + // + // C++: void phase(Mat x, Mat y, Mat& angle, bool angleInDegrees = false) + // + + //javadoc: phase(x, y, angle, angleInDegrees) + public static void phase(Mat x, Mat y, Mat angle, boolean angleInDegrees) + { + + phase_0(x.nativeObj, y.nativeObj, angle.nativeObj, angleInDegrees); + + return; + } + + //javadoc: phase(x, y, angle) + public static void phase(Mat x, Mat y, Mat angle) + { + + phase_1(x.nativeObj, y.nativeObj, angle.nativeObj); + + return; + } + + + // + // C++: void polarToCart(Mat magnitude, Mat angle, Mat& x, Mat& y, bool angleInDegrees = false) + // + + //javadoc: polarToCart(magnitude, angle, x, y, angleInDegrees) + public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees) + { + + polarToCart_0(magnitude.nativeObj, angle.nativeObj, x.nativeObj, y.nativeObj, angleInDegrees); + + return; + } + + //javadoc: polarToCart(magnitude, angle, x, y) + public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y) + { + + polarToCart_1(magnitude.nativeObj, angle.nativeObj, x.nativeObj, y.nativeObj); + + return; + } + + + // + // C++: void pow(Mat src, double power, Mat& dst) + // + + //javadoc: pow(src, power, dst) + public static void pow(Mat src, double power, Mat dst) + { + + pow_0(src.nativeObj, power, dst.nativeObj); + + return; + } + + + // + // C++: void randShuffle(Mat& dst, double iterFactor = 1., RNG* rng = 0) + // + + //javadoc: randShuffle(dst, iterFactor) + public static void randShuffle(Mat dst, double iterFactor) + { + + randShuffle_0(dst.nativeObj, iterFactor); + + return; + } + + //javadoc: randShuffle(dst) + public static void randShuffle(Mat dst) + { + + randShuffle_1(dst.nativeObj); + + return; + } + + + // + // C++: void randn(Mat& dst, double mean, double stddev) + // + + //javadoc: randn(dst, mean, stddev) + public static void randn(Mat dst, double mean, double stddev) + { + + randn_0(dst.nativeObj, mean, stddev); + + return; + } + + + // + // C++: void randu(Mat& dst, double low, double high) + // + + //javadoc: randu(dst, low, high) + public static void randu(Mat dst, double low, double high) + { + + randu_0(dst.nativeObj, low, high); + + return; + } + + + // + // C++: void reduce(Mat src, Mat& dst, int dim, int rtype, int dtype = -1) + // + + //javadoc: reduce(src, dst, dim, rtype, dtype) + public static void reduce(Mat src, Mat dst, int dim, int rtype, int dtype) + { + + reduce_0(src.nativeObj, dst.nativeObj, dim, rtype, dtype); + + return; + } + + //javadoc: reduce(src, dst, dim, rtype) + public static void reduce(Mat src, Mat dst, int dim, int rtype) + { + + reduce_1(src.nativeObj, dst.nativeObj, dim, rtype); + + return; + } + + + // + // C++: void repeat(Mat src, int ny, int nx, Mat& dst) + // + + //javadoc: repeat(src, ny, nx, dst) + public static void repeat(Mat src, int ny, int nx, Mat dst) + { + + repeat_0(src.nativeObj, ny, nx, dst.nativeObj); + + return; + } + + + // + // C++: void rotate(Mat src, Mat& dst, int rotateCode) + // + + //javadoc: rotate(src, dst, rotateCode) + public static void rotate(Mat src, Mat dst, int rotateCode) + { + + rotate_0(src.nativeObj, dst.nativeObj, rotateCode); + + return; + } + + + // + // C++: void scaleAdd(Mat src1, double alpha, Mat src2, Mat& dst) + // + + //javadoc: scaleAdd(src1, alpha, src2, dst) + public static void scaleAdd(Mat src1, double alpha, Mat src2, Mat dst) + { + + scaleAdd_0(src1.nativeObj, alpha, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void setErrorVerbosity(bool verbose) + // + + //javadoc: setErrorVerbosity(verbose) + public static void setErrorVerbosity(boolean verbose) + { + + setErrorVerbosity_0(verbose); + + return; + } + + + // + // C++: void setIdentity(Mat& mtx, Scalar s = Scalar(1)) + // + + //javadoc: setIdentity(mtx, s) + public static void setIdentity(Mat mtx, Scalar s) + { + + setIdentity_0(mtx.nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]); + + return; + } + + //javadoc: setIdentity(mtx) + public static void setIdentity(Mat mtx) + { + + setIdentity_1(mtx.nativeObj); + + return; + } + + + // + // C++: void setNumThreads(int nthreads) + // + + //javadoc: setNumThreads(nthreads) + public static void setNumThreads(int nthreads) + { + + setNumThreads_0(nthreads); + + return; + } + + + // + // C++: void setRNGSeed(int seed) + // + + //javadoc: setRNGSeed(seed) + public static void setRNGSeed(int seed) + { + + setRNGSeed_0(seed); + + return; + } + + + // + // C++: void sort(Mat src, Mat& dst, int flags) + // + + //javadoc: sort(src, dst, flags) + public static void sort(Mat src, Mat dst, int flags) + { + + sort_0(src.nativeObj, dst.nativeObj, flags); + + return; + } + + + // + // C++: void sortIdx(Mat src, Mat& dst, int flags) + // + + //javadoc: sortIdx(src, dst, flags) + public static void sortIdx(Mat src, Mat dst, int flags) + { + + sortIdx_0(src.nativeObj, dst.nativeObj, flags); + + return; + } + + + // + // C++: void split(Mat m, vector_Mat& mv) + // + + //javadoc: split(m, mv) + public static void split(Mat m, List mv) + { + Mat mv_mat = new Mat(); + split_0(m.nativeObj, mv_mat.nativeObj); + Converters.Mat_to_vector_Mat(mv_mat, mv); + mv_mat.release(); + return; + } + + + // + // C++: void sqrt(Mat src, Mat& dst) + // + + //javadoc: sqrt(src, dst) + public static void sqrt(Mat src, Mat dst) + { + + sqrt_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void subtract(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + // + + //javadoc: subtract(src1, src2, dst, mask, dtype) + public static void subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype) + { + + subtract_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype); + + return; + } + + //javadoc: subtract(src1, src2, dst, mask) + public static void subtract(Mat src1, Mat src2, Mat dst, Mat mask) + { + + subtract_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: subtract(src1, src2, dst) + public static void subtract(Mat src1, Mat src2, Mat dst) + { + + subtract_2(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void subtract(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + // + + //javadoc: subtract(src1, src2, dst, mask, dtype) + public static void subtract(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype) + { + + subtract_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj, dtype); + + return; + } + + //javadoc: subtract(src1, src2, dst, mask) + public static void subtract(Mat src1, Scalar src2, Mat dst, Mat mask) + { + + subtract_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: subtract(src1, src2, dst) + public static void subtract(Mat src1, Scalar src2, Mat dst) + { + + subtract_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj); + + return; + } + + + // + // C++: void transform(Mat src, Mat& dst, Mat m) + // + + //javadoc: transform(src, dst, m) + public static void transform(Mat src, Mat dst, Mat m) + { + + transform_0(src.nativeObj, dst.nativeObj, m.nativeObj); + + return; + } + + + // + // C++: void transpose(Mat src, Mat& dst) + // + + //javadoc: transpose(src, dst) + public static void transpose(Mat src, Mat dst) + { + + transpose_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void vconcat(vector_Mat src, Mat& dst) + // + + //javadoc: vconcat(src, dst) + public static void vconcat(List src, Mat dst) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + vconcat_0(src_mat.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void setUseIPP(bool flag) + // + + //javadoc: setUseIPP(flag) + public static void setUseIPP(boolean flag) + { + + setUseIPP_0(flag); + + return; + } + +// manual port +public static class MinMaxLocResult { + public double minVal; + public double maxVal; + public Point minLoc; + public Point maxLoc; + + + public MinMaxLocResult() { + minVal=0; maxVal=0; + minLoc=new Point(); + maxLoc=new Point(); + } +} + + +// C++: minMaxLoc(Mat src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray()) + + +//javadoc: minMaxLoc(src, mask) +public static MinMaxLocResult minMaxLoc(Mat src, Mat mask) { + MinMaxLocResult res = new MinMaxLocResult(); + long maskNativeObj=0; + if (mask != null) { + maskNativeObj=mask.nativeObj; + } + double resarr[] = n_minMaxLocManual(src.nativeObj, maskNativeObj); + res.minVal=resarr[0]; + res.maxVal=resarr[1]; + res.minLoc.x=resarr[2]; + res.minLoc.y=resarr[3]; + res.maxLoc.x=resarr[4]; + res.maxLoc.y=resarr[5]; + return res; +} + + +//javadoc: minMaxLoc(src) +public static MinMaxLocResult minMaxLoc(Mat src) { + return minMaxLoc(src, null); +} + + + // C++: Scalar mean(Mat src, Mat mask = Mat()) + private static native double[] mean_0(long src_nativeObj, long mask_nativeObj); + private static native double[] mean_1(long src_nativeObj); + + // C++: Scalar sum(Mat src) + private static native double[] sumElems_0(long src_nativeObj); + + // C++: Scalar trace(Mat mtx) + private static native double[] trace_0(long mtx_nativeObj); + + // C++: String getBuildInformation() + private static native String getBuildInformation_0(); + + // C++: bool checkRange(Mat a, bool quiet = true, _hidden_ * pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX) + private static native boolean checkRange_0(long a_nativeObj, boolean quiet, double minVal, double maxVal); + private static native boolean checkRange_1(long a_nativeObj); + + // C++: bool eigen(Mat src, Mat& eigenvalues, Mat& eigenvectors = Mat()) + private static native boolean eigen_0(long src_nativeObj, long eigenvalues_nativeObj, long eigenvectors_nativeObj); + private static native boolean eigen_1(long src_nativeObj, long eigenvalues_nativeObj); + + // C++: bool solve(Mat src1, Mat src2, Mat& dst, int flags = DECOMP_LU) + private static native boolean solve_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, int flags); + private static native boolean solve_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: bool useIPP() + private static native boolean useIPP_0(); + + // C++: double Mahalanobis(Mat v1, Mat v2, Mat icovar) + private static native double Mahalanobis_0(long v1_nativeObj, long v2_nativeObj, long icovar_nativeObj); + + // C++: double PSNR(Mat src1, Mat src2) + private static native double PSNR_0(long src1_nativeObj, long src2_nativeObj); + + // C++: double determinant(Mat mtx) + private static native double determinant_0(long mtx_nativeObj); + + // C++: double getTickFrequency() + private static native double getTickFrequency_0(); + + // C++: double invert(Mat src, Mat& dst, int flags = DECOMP_LU) + private static native double invert_0(long src_nativeObj, long dst_nativeObj, int flags); + private static native double invert_1(long src_nativeObj, long dst_nativeObj); + + // C++: double kmeans(Mat data, int K, Mat& bestLabels, TermCriteria criteria, int attempts, int flags, Mat& centers = Mat()) + private static native double kmeans_0(long data_nativeObj, int K, long bestLabels_nativeObj, int criteria_type, int criteria_maxCount, double criteria_epsilon, int attempts, int flags, long centers_nativeObj); + private static native double kmeans_1(long data_nativeObj, int K, long bestLabels_nativeObj, int criteria_type, int criteria_maxCount, double criteria_epsilon, int attempts, int flags); + + // C++: double norm(Mat src1, Mat src2, int normType = NORM_L2, Mat mask = Mat()) + private static native double norm_0(long src1_nativeObj, long src2_nativeObj, int normType, long mask_nativeObj); + private static native double norm_1(long src1_nativeObj, long src2_nativeObj, int normType); + private static native double norm_2(long src1_nativeObj, long src2_nativeObj); + + // C++: double norm(Mat src1, int normType = NORM_L2, Mat mask = Mat()) + private static native double norm_3(long src1_nativeObj, int normType, long mask_nativeObj); + private static native double norm_4(long src1_nativeObj, int normType); + private static native double norm_5(long src1_nativeObj); + + // C++: double solvePoly(Mat coeffs, Mat& roots, int maxIters = 300) + private static native double solvePoly_0(long coeffs_nativeObj, long roots_nativeObj, int maxIters); + private static native double solvePoly_1(long coeffs_nativeObj, long roots_nativeObj); + + // C++: float cubeRoot(float val) + private static native float cubeRoot_0(float val); + + // C++: float fastAtan2(float y, float x) + private static native float fastAtan2_0(float y, float x); + + // C++: int borderInterpolate(int p, int len, int borderType) + private static native int borderInterpolate_0(int p, int len, int borderType); + + // C++: int countNonZero(Mat src) + private static native int countNonZero_0(long src_nativeObj); + + // C++: int getNumThreads() + private static native int getNumThreads_0(); + + // C++: int getNumberOfCPUs() + private static native int getNumberOfCPUs_0(); + + // C++: int getOptimalDFTSize(int vecsize) + private static native int getOptimalDFTSize_0(int vecsize); + + // C++: int getThreadNum() + private static native int getThreadNum_0(); + + // C++: int solveCubic(Mat coeffs, Mat& roots) + private static native int solveCubic_0(long coeffs_nativeObj, long roots_nativeObj); + + // C++: int64 getCPUTickCount() + private static native long getCPUTickCount_0(); + + // C++: int64 getTickCount() + private static native long getTickCount_0(); + + // C++: void LUT(Mat src, Mat lut, Mat& dst) + private static native void LUT_0(long src_nativeObj, long lut_nativeObj, long dst_nativeObj); + + // C++: void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat& result) + private static native void PCABackProject_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long result_nativeObj); + + // C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, double retainedVariance) + private static native void PCACompute_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, double retainedVariance); + + // C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, int maxComponents = 0) + private static native void PCACompute_1(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, int maxComponents); + private static native void PCACompute_2(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj); + + // C++: void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat& result) + private static native void PCAProject_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long result_nativeObj); + + // C++: void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat& dst) + private static native void SVBackSubst_0(long w_nativeObj, long u_nativeObj, long vt_nativeObj, long rhs_nativeObj, long dst_nativeObj); + + // C++: void SVDecomp(Mat src, Mat& w, Mat& u, Mat& vt, int flags = 0) + private static native void SVDecomp_0(long src_nativeObj, long w_nativeObj, long u_nativeObj, long vt_nativeObj, int flags); + private static native void SVDecomp_1(long src_nativeObj, long w_nativeObj, long u_nativeObj, long vt_nativeObj); + + // C++: void absdiff(Mat src1, Mat src2, Mat& dst) + private static native void absdiff_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void absdiff(Mat src1, Scalar src2, Mat& dst) + private static native void absdiff_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void add(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + private static native void add_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj, int dtype); + private static native void add_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void add_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void add(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + private static native void add_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj, int dtype); + private static native void add_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj); + private static native void add_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat& dst, int dtype = -1) + private static native void addWeighted_0(long src1_nativeObj, double alpha, long src2_nativeObj, double beta, double gamma, long dst_nativeObj, int dtype); + private static native void addWeighted_1(long src1_nativeObj, double alpha, long src2_nativeObj, double beta, double gamma, long dst_nativeObj); + + // C++: void batchDistance(Mat src1, Mat src2, Mat& dist, int dtype, Mat& nidx, int normType = NORM_L2, int K = 0, Mat mask = Mat(), int update = 0, bool crosscheck = false) + private static native void batchDistance_0(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K, long mask_nativeObj, int update, boolean crosscheck); + private static native void batchDistance_1(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K); + private static native void batchDistance_2(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj); + + // C++: void bitwise_and(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + private static native void bitwise_and_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void bitwise_and_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void bitwise_not(Mat src, Mat& dst, Mat mask = Mat()) + private static native void bitwise_not_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void bitwise_not_1(long src_nativeObj, long dst_nativeObj); + + // C++: void bitwise_or(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + private static native void bitwise_or_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void bitwise_or_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void bitwise_xor(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + private static native void bitwise_xor_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void bitwise_xor_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void calcCovarMatrix(Mat samples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F) + private static native void calcCovarMatrix_0(long samples_nativeObj, long covar_nativeObj, long mean_nativeObj, int flags, int ctype); + private static native void calcCovarMatrix_1(long samples_nativeObj, long covar_nativeObj, long mean_nativeObj, int flags); + + // C++: void cartToPolar(Mat x, Mat y, Mat& magnitude, Mat& angle, bool angleInDegrees = false) + private static native void cartToPolar_0(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj, long angle_nativeObj, boolean angleInDegrees); + private static native void cartToPolar_1(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj, long angle_nativeObj); + + // C++: void compare(Mat src1, Mat src2, Mat& dst, int cmpop) + private static native void compare_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, int cmpop); + + // C++: void compare(Mat src1, Scalar src2, Mat& dst, int cmpop) + private static native void compare_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, int cmpop); + + // C++: void completeSymm(Mat& mtx, bool lowerToUpper = false) + private static native void completeSymm_0(long mtx_nativeObj, boolean lowerToUpper); + private static native void completeSymm_1(long mtx_nativeObj); + + // C++: void convertFp16(Mat src, Mat& dst) + private static native void convertFp16_0(long src_nativeObj, long dst_nativeObj); + + // C++: void convertScaleAbs(Mat src, Mat& dst, double alpha = 1, double beta = 0) + private static native void convertScaleAbs_0(long src_nativeObj, long dst_nativeObj, double alpha, double beta); + private static native void convertScaleAbs_1(long src_nativeObj, long dst_nativeObj); + + // C++: void copyMakeBorder(Mat src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar value = Scalar()) + private static native void copyMakeBorder_0(long src_nativeObj, long dst_nativeObj, int top, int bottom, int left, int right, int borderType, double value_val0, double value_val1, double value_val2, double value_val3); + private static native void copyMakeBorder_1(long src_nativeObj, long dst_nativeObj, int top, int bottom, int left, int right, int borderType); + + // C++: void dct(Mat src, Mat& dst, int flags = 0) + private static native void dct_0(long src_nativeObj, long dst_nativeObj, int flags); + private static native void dct_1(long src_nativeObj, long dst_nativeObj); + + // C++: void dft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0) + private static native void dft_0(long src_nativeObj, long dst_nativeObj, int flags, int nonzeroRows); + private static native void dft_1(long src_nativeObj, long dst_nativeObj); + + // C++: void divide(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1) + private static native void divide_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale, int dtype); + private static native void divide_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale); + private static native void divide_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void divide(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1) + private static native void divide_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale, int dtype); + private static native void divide_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale); + private static native void divide_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void divide(double scale, Mat src2, Mat& dst, int dtype = -1) + private static native void divide_6(double scale, long src2_nativeObj, long dst_nativeObj, int dtype); + private static native void divide_7(double scale, long src2_nativeObj, long dst_nativeObj); + + // C++: void exp(Mat src, Mat& dst) + private static native void exp_0(long src_nativeObj, long dst_nativeObj); + + // C++: void extractChannel(Mat src, Mat& dst, int coi) + private static native void extractChannel_0(long src_nativeObj, long dst_nativeObj, int coi); + + // C++: void findNonZero(Mat src, Mat& idx) + private static native void findNonZero_0(long src_nativeObj, long idx_nativeObj); + + // C++: void flip(Mat src, Mat& dst, int flipCode) + private static native void flip_0(long src_nativeObj, long dst_nativeObj, int flipCode); + + // C++: void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat& dst, int flags = 0) + private static native void gemm_0(long src1_nativeObj, long src2_nativeObj, double alpha, long src3_nativeObj, double beta, long dst_nativeObj, int flags); + private static native void gemm_1(long src1_nativeObj, long src2_nativeObj, double alpha, long src3_nativeObj, double beta, long dst_nativeObj); + + // C++: void hconcat(vector_Mat src, Mat& dst) + private static native void hconcat_0(long src_mat_nativeObj, long dst_nativeObj); + + // C++: void idct(Mat src, Mat& dst, int flags = 0) + private static native void idct_0(long src_nativeObj, long dst_nativeObj, int flags); + private static native void idct_1(long src_nativeObj, long dst_nativeObj); + + // C++: void idft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0) + private static native void idft_0(long src_nativeObj, long dst_nativeObj, int flags, int nonzeroRows); + private static native void idft_1(long src_nativeObj, long dst_nativeObj); + + // C++: void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat& dst) + private static native void inRange_0(long src_nativeObj, double lowerb_val0, double lowerb_val1, double lowerb_val2, double lowerb_val3, double upperb_val0, double upperb_val1, double upperb_val2, double upperb_val3, long dst_nativeObj); + + // C++: void insertChannel(Mat src, Mat& dst, int coi) + private static native void insertChannel_0(long src_nativeObj, long dst_nativeObj, int coi); + + // C++: void log(Mat src, Mat& dst) + private static native void log_0(long src_nativeObj, long dst_nativeObj); + + // C++: void magnitude(Mat x, Mat y, Mat& magnitude) + private static native void magnitude_0(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj); + + // C++: void max(Mat src1, Mat src2, Mat& dst) + private static native void max_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void max(Mat src1, Scalar src2, Mat& dst) + private static native void max_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void meanStdDev(Mat src, vector_double& mean, vector_double& stddev, Mat mask = Mat()) + private static native void meanStdDev_0(long src_nativeObj, long mean_mat_nativeObj, long stddev_mat_nativeObj, long mask_nativeObj); + private static native void meanStdDev_1(long src_nativeObj, long mean_mat_nativeObj, long stddev_mat_nativeObj); + + // C++: void merge(vector_Mat mv, Mat& dst) + private static native void merge_0(long mv_mat_nativeObj, long dst_nativeObj); + + // C++: void min(Mat src1, Mat src2, Mat& dst) + private static native void min_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void min(Mat src1, Scalar src2, Mat& dst) + private static native void min_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void mixChannels(vector_Mat src, vector_Mat dst, vector_int fromTo) + private static native void mixChannels_0(long src_mat_nativeObj, long dst_mat_nativeObj, long fromTo_mat_nativeObj); + + // C++: void mulSpectrums(Mat a, Mat b, Mat& c, int flags, bool conjB = false) + private static native void mulSpectrums_0(long a_nativeObj, long b_nativeObj, long c_nativeObj, int flags, boolean conjB); + private static native void mulSpectrums_1(long a_nativeObj, long b_nativeObj, long c_nativeObj, int flags); + + // C++: void mulTransposed(Mat src, Mat& dst, bool aTa, Mat delta = Mat(), double scale = 1, int dtype = -1) + private static native void mulTransposed_0(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj, double scale, int dtype); + private static native void mulTransposed_1(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj, double scale); + private static native void mulTransposed_2(long src_nativeObj, long dst_nativeObj, boolean aTa); + + // C++: void multiply(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1) + private static native void multiply_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale, int dtype); + private static native void multiply_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale); + private static native void multiply_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void multiply(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1) + private static native void multiply_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale, int dtype); + private static native void multiply_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale); + private static native void multiply_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void normalize(Mat src, Mat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, Mat mask = Mat()) + private static native void normalize_0(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type, int dtype, long mask_nativeObj); + private static native void normalize_1(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type, int dtype); + private static native void normalize_2(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type); + private static native void normalize_3(long src_nativeObj, long dst_nativeObj); + + // C++: void patchNaNs(Mat& a, double val = 0) + private static native void patchNaNs_0(long a_nativeObj, double val); + private static native void patchNaNs_1(long a_nativeObj); + + // C++: void perspectiveTransform(Mat src, Mat& dst, Mat m) + private static native void perspectiveTransform_0(long src_nativeObj, long dst_nativeObj, long m_nativeObj); + + // C++: void phase(Mat x, Mat y, Mat& angle, bool angleInDegrees = false) + private static native void phase_0(long x_nativeObj, long y_nativeObj, long angle_nativeObj, boolean angleInDegrees); + private static native void phase_1(long x_nativeObj, long y_nativeObj, long angle_nativeObj); + + // C++: void polarToCart(Mat magnitude, Mat angle, Mat& x, Mat& y, bool angleInDegrees = false) + private static native void polarToCart_0(long magnitude_nativeObj, long angle_nativeObj, long x_nativeObj, long y_nativeObj, boolean angleInDegrees); + private static native void polarToCart_1(long magnitude_nativeObj, long angle_nativeObj, long x_nativeObj, long y_nativeObj); + + // C++: void pow(Mat src, double power, Mat& dst) + private static native void pow_0(long src_nativeObj, double power, long dst_nativeObj); + + // C++: void randShuffle(Mat& dst, double iterFactor = 1., RNG* rng = 0) + private static native void randShuffle_0(long dst_nativeObj, double iterFactor); + private static native void randShuffle_1(long dst_nativeObj); + + // C++: void randn(Mat& dst, double mean, double stddev) + private static native void randn_0(long dst_nativeObj, double mean, double stddev); + + // C++: void randu(Mat& dst, double low, double high) + private static native void randu_0(long dst_nativeObj, double low, double high); + + // C++: void reduce(Mat src, Mat& dst, int dim, int rtype, int dtype = -1) + private static native void reduce_0(long src_nativeObj, long dst_nativeObj, int dim, int rtype, int dtype); + private static native void reduce_1(long src_nativeObj, long dst_nativeObj, int dim, int rtype); + + // C++: void repeat(Mat src, int ny, int nx, Mat& dst) + private static native void repeat_0(long src_nativeObj, int ny, int nx, long dst_nativeObj); + + // C++: void rotate(Mat src, Mat& dst, int rotateCode) + private static native void rotate_0(long src_nativeObj, long dst_nativeObj, int rotateCode); + + // C++: void scaleAdd(Mat src1, double alpha, Mat src2, Mat& dst) + private static native void scaleAdd_0(long src1_nativeObj, double alpha, long src2_nativeObj, long dst_nativeObj); + + // C++: void setErrorVerbosity(bool verbose) + private static native void setErrorVerbosity_0(boolean verbose); + + // C++: void setIdentity(Mat& mtx, Scalar s = Scalar(1)) + private static native void setIdentity_0(long mtx_nativeObj, double s_val0, double s_val1, double s_val2, double s_val3); + private static native void setIdentity_1(long mtx_nativeObj); + + // C++: void setNumThreads(int nthreads) + private static native void setNumThreads_0(int nthreads); + + // C++: void setRNGSeed(int seed) + private static native void setRNGSeed_0(int seed); + + // C++: void sort(Mat src, Mat& dst, int flags) + private static native void sort_0(long src_nativeObj, long dst_nativeObj, int flags); + + // C++: void sortIdx(Mat src, Mat& dst, int flags) + private static native void sortIdx_0(long src_nativeObj, long dst_nativeObj, int flags); + + // C++: void split(Mat m, vector_Mat& mv) + private static native void split_0(long m_nativeObj, long mv_mat_nativeObj); + + // C++: void sqrt(Mat src, Mat& dst) + private static native void sqrt_0(long src_nativeObj, long dst_nativeObj); + + // C++: void subtract(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + private static native void subtract_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj, int dtype); + private static native void subtract_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void subtract_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void subtract(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1) + private static native void subtract_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj, int dtype); + private static native void subtract_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj); + private static native void subtract_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj); + + // C++: void transform(Mat src, Mat& dst, Mat m) + private static native void transform_0(long src_nativeObj, long dst_nativeObj, long m_nativeObj); + + // C++: void transpose(Mat src, Mat& dst) + private static native void transpose_0(long src_nativeObj, long dst_nativeObj); + + // C++: void vconcat(vector_Mat src, Mat& dst) + private static native void vconcat_0(long src_mat_nativeObj, long dst_nativeObj); + + // C++: void setUseIPP(bool flag) + private static native void setUseIPP_0(boolean flag); +private static native double[] n_minMaxLocManual(long src_nativeObj, long mask_nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/CvException.java b/openCVLibrary330/src/main/java/org/opencv/core/CvException.java new file mode 100644 index 00000000000..e9241e68860 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/CvException.java @@ -0,0 +1,15 @@ +package org.opencv.core; + +public class CvException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public CvException(String msg) { + super(msg); + } + + @Override + public String toString() { + return "CvException [" + super.toString() + "]"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/CvType.java b/openCVLibrary330/src/main/java/org/opencv/core/CvType.java new file mode 100644 index 00000000000..748c1cd75c2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/CvType.java @@ -0,0 +1,136 @@ +package org.opencv.core; + +public final class CvType { + + // type depth constants + public static final int + CV_8U = 0, CV_8S = 1, + CV_16U = 2, CV_16S = 3, + CV_32S = 4, + CV_32F = 5, + CV_64F = 6, + CV_USRTYPE1 = 7; + + // predefined type constants + public static final int + CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4), + CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4), + CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4), + CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4), + CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4), + CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4), + CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4); + + private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT); + + public static final int makeType(int depth, int channels) { + if (channels <= 0 || channels >= CV_CN_MAX) { + throw new java.lang.UnsupportedOperationException( + "Channels count should be 1.." + (CV_CN_MAX - 1)); + } + if (depth < 0 || depth >= CV_DEPTH_MAX) { + throw new java.lang.UnsupportedOperationException( + "Data type depth should be 0.." + (CV_DEPTH_MAX - 1)); + } + return (depth & (CV_DEPTH_MAX - 1)) + ((channels - 1) << CV_CN_SHIFT); + } + + public static final int CV_8UC(int ch) { + return makeType(CV_8U, ch); + } + + public static final int CV_8SC(int ch) { + return makeType(CV_8S, ch); + } + + public static final int CV_16UC(int ch) { + return makeType(CV_16U, ch); + } + + public static final int CV_16SC(int ch) { + return makeType(CV_16S, ch); + } + + public static final int CV_32SC(int ch) { + return makeType(CV_32S, ch); + } + + public static final int CV_32FC(int ch) { + return makeType(CV_32F, ch); + } + + public static final int CV_64FC(int ch) { + return makeType(CV_64F, ch); + } + + public static final int channels(int type) { + return (type >> CV_CN_SHIFT) + 1; + } + + public static final int depth(int type) { + return type & (CV_DEPTH_MAX - 1); + } + + public static final boolean isInteger(int type) { + return depth(type) < CV_32F; + } + + public static final int ELEM_SIZE(int type) { + switch (depth(type)) { + case CV_8U: + case CV_8S: + return channels(type); + case CV_16U: + case CV_16S: + return 2 * channels(type); + case CV_32S: + case CV_32F: + return 4 * channels(type); + case CV_64F: + return 8 * channels(type); + default: + throw new java.lang.UnsupportedOperationException( + "Unsupported CvType value: " + type); + } + } + + public static final String typeToString(int type) { + String s; + switch (depth(type)) { + case CV_8U: + s = "CV_8U"; + break; + case CV_8S: + s = "CV_8S"; + break; + case CV_16U: + s = "CV_16U"; + break; + case CV_16S: + s = "CV_16S"; + break; + case CV_32S: + s = "CV_32S"; + break; + case CV_32F: + s = "CV_32F"; + break; + case CV_64F: + s = "CV_64F"; + break; + case CV_USRTYPE1: + s = "CV_USRTYPE1"; + break; + default: + throw new java.lang.UnsupportedOperationException( + "Unsupported CvType value: " + type); + } + + int ch = channels(type); + if (ch <= 4) + return s + "C" + ch; + else + return s + "C(" + ch + ")"; + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/DMatch.java b/openCVLibrary330/src/main/java/org/opencv/core/DMatch.java new file mode 100644 index 00000000000..db44d9a0a68 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/DMatch.java @@ -0,0 +1,58 @@ +package org.opencv.core; + +//C++: class DMatch + +/** + * Structure for matching: query descriptor index, train descriptor index, train + * image index and distance between descriptors. + */ +public class DMatch { + + /** + * Query descriptor index. + */ + public int queryIdx; + /** + * Train descriptor index. + */ + public int trainIdx; + /** + * Train image index. + */ + public int imgIdx; + + // javadoc: DMatch::distance + public float distance; + + // javadoc: DMatch::DMatch() + public DMatch() { + this(-1, -1, Float.MAX_VALUE); + } + + // javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _distance) + public DMatch(int _queryIdx, int _trainIdx, float _distance) { + queryIdx = _queryIdx; + trainIdx = _trainIdx; + imgIdx = -1; + distance = _distance; + } + + // javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance) + public DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) { + queryIdx = _queryIdx; + trainIdx = _trainIdx; + imgIdx = _imgIdx; + distance = _distance; + } + + public boolean lessThan(DMatch it) { + return distance < it.distance; + } + + @Override + public String toString() { + return "DMatch [queryIdx=" + queryIdx + ", trainIdx=" + trainIdx + + ", imgIdx=" + imgIdx + ", distance=" + distance + "]"; + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/KeyPoint.java b/openCVLibrary330/src/main/java/org/opencv/core/KeyPoint.java new file mode 100644 index 00000000000..de5b2151ff7 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/KeyPoint.java @@ -0,0 +1,83 @@ +package org.opencv.core; + +import org.opencv.core.Point; + +//javadoc: KeyPoint +public class KeyPoint { + + /** + * Coordinates of the keypoint. + */ + public Point pt; + /** + * Diameter of the useful keypoint adjacent area. + */ + public float size; + /** + * Computed orientation of the keypoint (-1 if not applicable). + */ + public float angle; + /** + * The response, by which the strongest keypoints have been selected. Can + * be used for further sorting or subsampling. + */ + public float response; + /** + * Octave (pyramid layer), from which the keypoint has been extracted. + */ + public int octave; + /** + * Object ID, that can be used to cluster keypoints by an object they + * belong to. + */ + public int class_id; + + // javadoc:KeyPoint::KeyPoint(x,y,_size,_angle,_response,_octave,_class_id) + public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id) + { + pt = new Point(x, y); + size = _size; + angle = _angle; + response = _response; + octave = _octave; + class_id = _class_id; + } + + // javadoc: KeyPoint::KeyPoint() + public KeyPoint() + { + this(0, 0, 0, -1, 0, 0, -1); + } + + // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave) + public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave) + { + this(x, y, _size, _angle, _response, _octave, -1); + } + + // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response) + public KeyPoint(float x, float y, float _size, float _angle, float _response) + { + this(x, y, _size, _angle, _response, 0, -1); + } + + // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle) + public KeyPoint(float x, float y, float _size, float _angle) + { + this(x, y, _size, _angle, 0, 0, -1); + } + + // javadoc: KeyPoint::KeyPoint(x, y, _size) + public KeyPoint(float x, float y, float _size) + { + this(x, y, _size, -1, 0, 0, -1); + } + + @Override + public String toString() { + return "KeyPoint [pt=" + pt + ", size=" + size + ", angle=" + angle + + ", response=" + response + ", octave=" + octave + + ", class_id=" + class_id + "]"; + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Mat.java b/openCVLibrary330/src/main/java/org/opencv/core/Mat.java new file mode 100644 index 00000000000..6db255417cc --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Mat.java @@ -0,0 +1,1316 @@ +package org.opencv.core; + +// C++: class Mat +//javadoc: Mat +public class Mat { + + public final long nativeObj; + + public Mat(long addr) + { + if (addr == 0) + throw new java.lang.UnsupportedOperationException("Native object address is NULL"); + nativeObj = addr; + } + + // + // C++: Mat::Mat() + // + + // javadoc: Mat::Mat() + public Mat() + { + + nativeObj = n_Mat(); + + return; + } + + // + // C++: Mat::Mat(int rows, int cols, int type) + // + + // javadoc: Mat::Mat(rows, cols, type) + public Mat(int rows, int cols, int type) + { + + nativeObj = n_Mat(rows, cols, type); + + return; + } + + // + // C++: Mat::Mat(Size size, int type) + // + + // javadoc: Mat::Mat(size, type) + public Mat(Size size, int type) + { + + nativeObj = n_Mat(size.width, size.height, type); + + return; + } + + // + // C++: Mat::Mat(int rows, int cols, int type, Scalar s) + // + + // javadoc: Mat::Mat(rows, cols, type, s) + public Mat(int rows, int cols, int type, Scalar s) + { + + nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]); + + return; + } + + // + // C++: Mat::Mat(Size size, int type, Scalar s) + // + + // javadoc: Mat::Mat(size, type, s) + public Mat(Size size, int type, Scalar s) + { + + nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]); + + return; + } + + // + // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all()) + // + + // javadoc: Mat::Mat(m, rowRange, colRange) + public Mat(Mat m, Range rowRange, Range colRange) + { + + nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end); + + return; + } + + // javadoc: Mat::Mat(m, rowRange) + public Mat(Mat m, Range rowRange) + { + + nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end); + + return; + } + + // + // C++: Mat::Mat(Mat m, Rect roi) + // + + // javadoc: Mat::Mat(m, roi) + public Mat(Mat m, Rect roi) + { + + nativeObj = n_Mat(m.nativeObj, roi.y, roi.y + roi.height, roi.x, roi.x + roi.width); + + return; + } + + // + // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright) + // + + // javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright) + public Mat adjustROI(int dtop, int dbottom, int dleft, int dright) + { + + Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright)); + + return retVal; + } + + // + // C++: void Mat::assignTo(Mat m, int type = -1) + // + + // javadoc: Mat::assignTo(m, type) + public void assignTo(Mat m, int type) + { + + n_assignTo(nativeObj, m.nativeObj, type); + + return; + } + + // javadoc: Mat::assignTo(m) + public void assignTo(Mat m) + { + + n_assignTo(nativeObj, m.nativeObj); + + return; + } + + // + // C++: int Mat::channels() + // + + // javadoc: Mat::channels() + public int channels() + { + + int retVal = n_channels(nativeObj); + + return retVal; + } + + // + // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool + // requireContinuous = true) + // + + // javadoc: Mat::checkVector(elemChannels, depth, requireContinuous) + public int checkVector(int elemChannels, int depth, boolean requireContinuous) + { + + int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous); + + return retVal; + } + + // javadoc: Mat::checkVector(elemChannels, depth) + public int checkVector(int elemChannels, int depth) + { + + int retVal = n_checkVector(nativeObj, elemChannels, depth); + + return retVal; + } + + // javadoc: Mat::checkVector(elemChannels) + public int checkVector(int elemChannels) + { + + int retVal = n_checkVector(nativeObj, elemChannels); + + return retVal; + } + + // + // C++: Mat Mat::clone() + // + + // javadoc: Mat::clone() + public Mat clone() + { + + Mat retVal = new Mat(n_clone(nativeObj)); + + return retVal; + } + + // + // C++: Mat Mat::col(int x) + // + + // javadoc: Mat::col(x) + public Mat col(int x) + { + + Mat retVal = new Mat(n_col(nativeObj, x)); + + return retVal; + } + + // + // C++: Mat Mat::colRange(int startcol, int endcol) + // + + // javadoc: Mat::colRange(startcol, endcol) + public Mat colRange(int startcol, int endcol) + { + + Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol)); + + return retVal; + } + + // + // C++: Mat Mat::colRange(Range r) + // + + // javadoc: Mat::colRange(r) + public Mat colRange(Range r) + { + + Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end)); + + return retVal; + } + + // + // C++: int Mat::dims() + // + + // javadoc: Mat::dims() + public int dims() + { + + int retVal = n_dims(nativeObj); + + return retVal; + } + + // + // C++: int Mat::cols() + // + + // javadoc: Mat::cols() + public int cols() + { + + int retVal = n_cols(nativeObj); + + return retVal; + } + + // + // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta + // = 0) + // + + // javadoc: Mat::convertTo(m, rtype, alpha, beta) + public void convertTo(Mat m, int rtype, double alpha, double beta) + { + + n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta); + + return; + } + + // javadoc: Mat::convertTo(m, rtype, alpha) + public void convertTo(Mat m, int rtype, double alpha) + { + + n_convertTo(nativeObj, m.nativeObj, rtype, alpha); + + return; + } + + // javadoc: Mat::convertTo(m, rtype) + public void convertTo(Mat m, int rtype) + { + + n_convertTo(nativeObj, m.nativeObj, rtype); + + return; + } + + // + // C++: void Mat::copyTo(Mat& m) + // + + // javadoc: Mat::copyTo(m) + public void copyTo(Mat m) + { + + n_copyTo(nativeObj, m.nativeObj); + + return; + } + + // + // C++: void Mat::copyTo(Mat& m, Mat mask) + // + + // javadoc: Mat::copyTo(m, mask) + public void copyTo(Mat m, Mat mask) + { + + n_copyTo(nativeObj, m.nativeObj, mask.nativeObj); + + return; + } + + // + // C++: void Mat::create(int rows, int cols, int type) + // + + // javadoc: Mat::create(rows, cols, type) + public void create(int rows, int cols, int type) + { + + n_create(nativeObj, rows, cols, type); + + return; + } + + // + // C++: void Mat::create(Size size, int type) + // + + // javadoc: Mat::create(size, type) + public void create(Size size, int type) + { + + n_create(nativeObj, size.width, size.height, type); + + return; + } + + // + // C++: Mat Mat::cross(Mat m) + // + + // javadoc: Mat::cross(m) + public Mat cross(Mat m) + { + + Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj)); + + return retVal; + } + + // + // C++: long Mat::dataAddr() + // + + // javadoc: Mat::dataAddr() + public long dataAddr() + { + + long retVal = n_dataAddr(nativeObj); + + return retVal; + } + + // + // C++: int Mat::depth() + // + + // javadoc: Mat::depth() + public int depth() + { + + int retVal = n_depth(nativeObj); + + return retVal; + } + + // + // C++: Mat Mat::diag(int d = 0) + // + + // javadoc: Mat::diag(d) + public Mat diag(int d) + { + + Mat retVal = new Mat(n_diag(nativeObj, d)); + + return retVal; + } + + // javadoc: Mat::diag() + public Mat diag() + { + + Mat retVal = new Mat(n_diag(nativeObj, 0)); + + return retVal; + } + + // + // C++: static Mat Mat::diag(Mat d) + // + + // javadoc: Mat::diag(d) + public static Mat diag(Mat d) + { + + Mat retVal = new Mat(n_diag(d.nativeObj)); + + return retVal; + } + + // + // C++: double Mat::dot(Mat m) + // + + // javadoc: Mat::dot(m) + public double dot(Mat m) + { + + double retVal = n_dot(nativeObj, m.nativeObj); + + return retVal; + } + + // + // C++: size_t Mat::elemSize() + // + + // javadoc: Mat::elemSize() + public long elemSize() + { + + long retVal = n_elemSize(nativeObj); + + return retVal; + } + + // + // C++: size_t Mat::elemSize1() + // + + // javadoc: Mat::elemSize1() + public long elemSize1() + { + + long retVal = n_elemSize1(nativeObj); + + return retVal; + } + + // + // C++: bool Mat::empty() + // + + // javadoc: Mat::empty() + public boolean empty() + { + + boolean retVal = n_empty(nativeObj); + + return retVal; + } + + // + // C++: static Mat Mat::eye(int rows, int cols, int type) + // + + // javadoc: Mat::eye(rows, cols, type) + public static Mat eye(int rows, int cols, int type) + { + + Mat retVal = new Mat(n_eye(rows, cols, type)); + + return retVal; + } + + // + // C++: static Mat Mat::eye(Size size, int type) + // + + // javadoc: Mat::eye(size, type) + public static Mat eye(Size size, int type) + { + + Mat retVal = new Mat(n_eye(size.width, size.height, type)); + + return retVal; + } + + // + // C++: Mat Mat::inv(int method = DECOMP_LU) + // + + // javadoc: Mat::inv(method) + public Mat inv(int method) + { + + Mat retVal = new Mat(n_inv(nativeObj, method)); + + return retVal; + } + + // javadoc: Mat::inv() + public Mat inv() + { + + Mat retVal = new Mat(n_inv(nativeObj)); + + return retVal; + } + + // + // C++: bool Mat::isContinuous() + // + + // javadoc: Mat::isContinuous() + public boolean isContinuous() + { + + boolean retVal = n_isContinuous(nativeObj); + + return retVal; + } + + // + // C++: bool Mat::isSubmatrix() + // + + // javadoc: Mat::isSubmatrix() + public boolean isSubmatrix() + { + + boolean retVal = n_isSubmatrix(nativeObj); + + return retVal; + } + + // + // C++: void Mat::locateROI(Size wholeSize, Point ofs) + // + + // javadoc: Mat::locateROI(wholeSize, ofs) + public void locateROI(Size wholeSize, Point ofs) + { + double[] wholeSize_out = new double[2]; + double[] ofs_out = new double[2]; + locateROI_0(nativeObj, wholeSize_out, ofs_out); + if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; } + if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; } + return; + } + + // + // C++: Mat Mat::mul(Mat m, double scale = 1) + // + + // javadoc: Mat::mul(m, scale) + public Mat mul(Mat m, double scale) + { + + Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale)); + + return retVal; + } + + // javadoc: Mat::mul(m) + public Mat mul(Mat m) + { + + Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj)); + + return retVal; + } + + // + // C++: static Mat Mat::ones(int rows, int cols, int type) + // + + // javadoc: Mat::ones(rows, cols, type) + public static Mat ones(int rows, int cols, int type) + { + + Mat retVal = new Mat(n_ones(rows, cols, type)); + + return retVal; + } + + // + // C++: static Mat Mat::ones(Size size, int type) + // + + // javadoc: Mat::ones(size, type) + public static Mat ones(Size size, int type) + { + + Mat retVal = new Mat(n_ones(size.width, size.height, type)); + + return retVal; + } + + // + // C++: void Mat::push_back(Mat m) + // + + // javadoc: Mat::push_back(m) + public void push_back(Mat m) + { + + n_push_back(nativeObj, m.nativeObj); + + return; + } + + // + // C++: void Mat::release() + // + + // javadoc: Mat::release() + public void release() + { + + n_release(nativeObj); + + return; + } + + // + // C++: Mat Mat::reshape(int cn, int rows = 0) + // + + // javadoc: Mat::reshape(cn, rows) + public Mat reshape(int cn, int rows) + { + + Mat retVal = new Mat(n_reshape(nativeObj, cn, rows)); + + return retVal; + } + + // javadoc: Mat::reshape(cn) + public Mat reshape(int cn) + { + + Mat retVal = new Mat(n_reshape(nativeObj, cn)); + + return retVal; + } + + // + // C++: Mat Mat::row(int y) + // + + // javadoc: Mat::row(y) + public Mat row(int y) + { + + Mat retVal = new Mat(n_row(nativeObj, y)); + + return retVal; + } + + // + // C++: Mat Mat::rowRange(int startrow, int endrow) + // + + // javadoc: Mat::rowRange(startrow, endrow) + public Mat rowRange(int startrow, int endrow) + { + + Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow)); + + return retVal; + } + + // + // C++: Mat Mat::rowRange(Range r) + // + + // javadoc: Mat::rowRange(r) + public Mat rowRange(Range r) + { + + Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end)); + + return retVal; + } + + // + // C++: int Mat::rows() + // + + // javadoc: Mat::rows() + public int rows() + { + + int retVal = n_rows(nativeObj); + + return retVal; + } + + // + // C++: Mat Mat::operator =(Scalar s) + // + + // javadoc: Mat::operator =(s) + public Mat setTo(Scalar s) + { + + Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3])); + + return retVal; + } + + // + // C++: Mat Mat::setTo(Scalar value, Mat mask = Mat()) + // + + // javadoc: Mat::setTo(value, mask) + public Mat setTo(Scalar value, Mat mask) + { + + Mat retVal = new Mat(n_setTo(nativeObj, value.val[0], value.val[1], value.val[2], value.val[3], mask.nativeObj)); + + return retVal; + } + + // + // C++: Mat Mat::setTo(Mat value, Mat mask = Mat()) + // + + // javadoc: Mat::setTo(value, mask) + public Mat setTo(Mat value, Mat mask) + { + + Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj)); + + return retVal; + } + + // javadoc: Mat::setTo(value) + public Mat setTo(Mat value) + { + + Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj)); + + return retVal; + } + + // + // C++: Size Mat::size() + // + + // javadoc: Mat::size() + public Size size() + { + + Size retVal = new Size(n_size(nativeObj)); + + return retVal; + } + + // + // C++: size_t Mat::step1(int i = 0) + // + + // javadoc: Mat::step1(i) + public long step1(int i) + { + + long retVal = n_step1(nativeObj, i); + + return retVal; + } + + // javadoc: Mat::step1() + public long step1() + { + + long retVal = n_step1(nativeObj); + + return retVal; + } + + // + // C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int + // colEnd) + // + + // javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd) + public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd) + { + + Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd)); + + return retVal; + } + + // + // C++: Mat Mat::operator()(Range rowRange, Range colRange) + // + + // javadoc: Mat::operator()(rowRange, colRange) + public Mat submat(Range rowRange, Range colRange) + { + + Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end)); + + return retVal; + } + + // + // C++: Mat Mat::operator()(Rect roi) + // + + // javadoc: Mat::operator()(roi) + public Mat submat(Rect roi) + { + + Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height)); + + return retVal; + } + + // + // C++: Mat Mat::t() + // + + // javadoc: Mat::t() + public Mat t() + { + + Mat retVal = new Mat(n_t(nativeObj)); + + return retVal; + } + + // + // C++: size_t Mat::total() + // + + // javadoc: Mat::total() + public long total() + { + + long retVal = n_total(nativeObj); + + return retVal; + } + + // + // C++: int Mat::type() + // + + // javadoc: Mat::type() + public int type() + { + + int retVal = n_type(nativeObj); + + return retVal; + } + + // + // C++: static Mat Mat::zeros(int rows, int cols, int type) + // + + // javadoc: Mat::zeros(rows, cols, type) + public static Mat zeros(int rows, int cols, int type) + { + + Mat retVal = new Mat(n_zeros(rows, cols, type)); + + return retVal; + } + + // + // C++: static Mat Mat::zeros(Size size, int type) + // + + // javadoc: Mat::zeros(size, type) + public static Mat zeros(Size size, int type) + { + + Mat retVal = new Mat(n_zeros(size.width, size.height, type)); + + return retVal; + } + + @Override + protected void finalize() throws Throwable { + n_delete(nativeObj); + super.finalize(); + } + + // javadoc:Mat::toString() + @Override + public String toString() { + return "Mat [ " + + rows() + "*" + cols() + "*" + CvType.typeToString(type()) + + ", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() + + ", nativeObj=0x" + Long.toHexString(nativeObj) + + ", dataAddr=0x" + Long.toHexString(dataAddr()) + + " ]"; + } + + // javadoc:Mat::dump() + public String dump() { + return nDump(nativeObj); + } + + // javadoc:Mat::put(row,col,data) + public int put(int row, int col, double... data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + return nPutD(nativeObj, row, col, data.length, data); + } + + // javadoc:Mat::put(row,col,data) + public int put(int row, int col, float[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_32F) { + return nPutF(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::put(row,col,data) + public int put(int row, int col, int[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_32S) { + return nPutI(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::put(row,col,data) + public int put(int row, int col, short[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) { + return nPutS(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::put(row,col,data) + public int put(int row, int col, byte[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) { + return nPutB(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::get(row,col,data) + public int get(int row, int col, byte[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) { + return nGetB(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::get(row,col,data) + public int get(int row, int col, short[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) { + return nGetS(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::get(row,col,data) + public int get(int row, int col, int[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_32S) { + return nGetI(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::get(row,col,data) + public int get(int row, int col, float[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_32F) { + return nGetF(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::get(row,col,data) + public int get(int row, int col, double[] data) { + int t = type(); + if (data == null || data.length % CvType.channels(t) != 0) + throw new java.lang.UnsupportedOperationException( + "Provided data element number (" + + (data == null ? 0 : data.length) + + ") should be multiple of the Mat channels count (" + + CvType.channels(t) + ")"); + if (CvType.depth(t) == CvType.CV_64F) { + return nGetD(nativeObj, row, col, data.length, data); + } + throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); + } + + // javadoc:Mat::get(row,col) + public double[] get(int row, int col) { + return nGet(nativeObj, row, col); + } + + // javadoc:Mat::height() + public int height() { + return rows(); + } + + // javadoc:Mat::width() + public int width() { + return cols(); + } + + // javadoc:Mat::getNativeObjAddr() + public long getNativeObjAddr() { + return nativeObj; + } + + // C++: Mat::Mat() + private static native long n_Mat(); + + // C++: Mat::Mat(int rows, int cols, int type) + private static native long n_Mat(int rows, int cols, int type); + + // C++: Mat::Mat(Size size, int type) + private static native long n_Mat(double size_width, double size_height, int type); + + // C++: Mat::Mat(int rows, int cols, int type, Scalar s) + private static native long n_Mat(int rows, int cols, int type, double s_val0, double s_val1, double s_val2, double s_val3); + + // C++: Mat::Mat(Size size, int type, Scalar s) + private static native long n_Mat(double size_width, double size_height, int type, double s_val0, double s_val1, double s_val2, double s_val3); + + // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all()) + private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end); + + private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end); + + // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright) + private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright); + + // C++: void Mat::assignTo(Mat m, int type = -1) + private static native void n_assignTo(long nativeObj, long m_nativeObj, int type); + + private static native void n_assignTo(long nativeObj, long m_nativeObj); + + // C++: int Mat::channels() + private static native int n_channels(long nativeObj); + + // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool + // requireContinuous = true) + private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous); + + private static native int n_checkVector(long nativeObj, int elemChannels, int depth); + + private static native int n_checkVector(long nativeObj, int elemChannels); + + // C++: Mat Mat::clone() + private static native long n_clone(long nativeObj); + + // C++: Mat Mat::col(int x) + private static native long n_col(long nativeObj, int x); + + // C++: Mat Mat::colRange(int startcol, int endcol) + private static native long n_colRange(long nativeObj, int startcol, int endcol); + + // C++: int Mat::dims() + private static native int n_dims(long nativeObj); + + // C++: int Mat::cols() + private static native int n_cols(long nativeObj); + + // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta + // = 0) + private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta); + + private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha); + + private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype); + + // C++: void Mat::copyTo(Mat& m) + private static native void n_copyTo(long nativeObj, long m_nativeObj); + + // C++: void Mat::copyTo(Mat& m, Mat mask) + private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj); + + // C++: void Mat::create(int rows, int cols, int type) + private static native void n_create(long nativeObj, int rows, int cols, int type); + + // C++: void Mat::create(Size size, int type) + private static native void n_create(long nativeObj, double size_width, double size_height, int type); + + // C++: Mat Mat::cross(Mat m) + private static native long n_cross(long nativeObj, long m_nativeObj); + + // C++: long Mat::dataAddr() + private static native long n_dataAddr(long nativeObj); + + // C++: int Mat::depth() + private static native int n_depth(long nativeObj); + + // C++: Mat Mat::diag(int d = 0) + private static native long n_diag(long nativeObj, int d); + + // C++: static Mat Mat::diag(Mat d) + private static native long n_diag(long d_nativeObj); + + // C++: double Mat::dot(Mat m) + private static native double n_dot(long nativeObj, long m_nativeObj); + + // C++: size_t Mat::elemSize() + private static native long n_elemSize(long nativeObj); + + // C++: size_t Mat::elemSize1() + private static native long n_elemSize1(long nativeObj); + + // C++: bool Mat::empty() + private static native boolean n_empty(long nativeObj); + + // C++: static Mat Mat::eye(int rows, int cols, int type) + private static native long n_eye(int rows, int cols, int type); + + // C++: static Mat Mat::eye(Size size, int type) + private static native long n_eye(double size_width, double size_height, int type); + + // C++: Mat Mat::inv(int method = DECOMP_LU) + private static native long n_inv(long nativeObj, int method); + + private static native long n_inv(long nativeObj); + + // C++: bool Mat::isContinuous() + private static native boolean n_isContinuous(long nativeObj); + + // C++: bool Mat::isSubmatrix() + private static native boolean n_isSubmatrix(long nativeObj); + + // C++: void Mat::locateROI(Size wholeSize, Point ofs) + private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out); + + // C++: Mat Mat::mul(Mat m, double scale = 1) + private static native long n_mul(long nativeObj, long m_nativeObj, double scale); + + private static native long n_mul(long nativeObj, long m_nativeObj); + + // C++: static Mat Mat::ones(int rows, int cols, int type) + private static native long n_ones(int rows, int cols, int type); + + // C++: static Mat Mat::ones(Size size, int type) + private static native long n_ones(double size_width, double size_height, int type); + + // C++: void Mat::push_back(Mat m) + private static native void n_push_back(long nativeObj, long m_nativeObj); + + // C++: void Mat::release() + private static native void n_release(long nativeObj); + + // C++: Mat Mat::reshape(int cn, int rows = 0) + private static native long n_reshape(long nativeObj, int cn, int rows); + + private static native long n_reshape(long nativeObj, int cn); + + // C++: Mat Mat::row(int y) + private static native long n_row(long nativeObj, int y); + + // C++: Mat Mat::rowRange(int startrow, int endrow) + private static native long n_rowRange(long nativeObj, int startrow, int endrow); + + // C++: int Mat::rows() + private static native int n_rows(long nativeObj); + + // C++: Mat Mat::operator =(Scalar s) + private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3); + + // C++: Mat Mat::setTo(Scalar value, Mat mask = Mat()) + private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3, long mask_nativeObj); + + // C++: Mat Mat::setTo(Mat value, Mat mask = Mat()) + private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj); + + private static native long n_setTo(long nativeObj, long value_nativeObj); + + // C++: Size Mat::size() + private static native double[] n_size(long nativeObj); + + // C++: size_t Mat::step1(int i = 0) + private static native long n_step1(long nativeObj, int i); + + private static native long n_step1(long nativeObj); + + // C++: Mat Mat::operator()(Range rowRange, Range colRange) + private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end); + + // C++: Mat Mat::operator()(Rect roi) + private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height); + + // C++: Mat Mat::t() + private static native long n_t(long nativeObj); + + // C++: size_t Mat::total() + private static native long n_total(long nativeObj); + + // C++: int Mat::type() + private static native int n_type(long nativeObj); + + // C++: static Mat Mat::zeros(int rows, int cols, int type) + private static native long n_zeros(int rows, int cols, int type); + + // C++: static Mat Mat::zeros(Size size, int type) + private static native long n_zeros(double size_width, double size_height, int type); + + // native support for java finalize() + private static native void n_delete(long nativeObj); + + private static native int nPutD(long self, int row, int col, int count, double[] data); + + private static native int nPutF(long self, int row, int col, int count, float[] data); + + private static native int nPutI(long self, int row, int col, int count, int[] data); + + private static native int nPutS(long self, int row, int col, int count, short[] data); + + private static native int nPutB(long self, int row, int col, int count, byte[] data); + + private static native int nGetB(long self, int row, int col, int count, byte[] vals); + + private static native int nGetS(long self, int row, int col, int count, short[] vals); + + private static native int nGetI(long self, int row, int col, int count, int[] vals); + + private static native int nGetF(long self, int row, int col, int count, float[] vals); + + private static native int nGetD(long self, int row, int col, int count, double[] vals); + + private static native double[] nGet(long self, int row, int col); + + private static native String nDump(long self); +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfByte.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfByte.java new file mode 100644 index 00000000000..7756eb94f95 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfByte.java @@ -0,0 +1,79 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + +public class MatOfByte extends Mat { + // 8UC(x) + private static final int _depth = CvType.CV_8U; + private static final int _channels = 1; + + public MatOfByte() { + super(); + } + + protected MatOfByte(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfByte fromNativeAddr(long addr) { + return new MatOfByte(addr); + } + + public MatOfByte(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfByte(byte...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(byte...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public byte[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + byte[] a = new byte[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Byte ab[] = lb.toArray(new Byte[0]); + byte a[] = new byte[ab.length]; + for(int i=0; i toList() { + byte[] a = toArray(); + Byte ab[] = new Byte[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + + public void fromArray(DMatch...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + float buff[] = new float[num * _channels]; + for(int i=0; i ldm) { + DMatch adm[] = ldm.toArray(new DMatch[0]); + fromArray(adm); + } + + public List toList() { + DMatch[] adm = toArray(); + return Arrays.asList(adm); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfDouble.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfDouble.java new file mode 100644 index 00000000000..1a8e23ca30f --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfDouble.java @@ -0,0 +1,79 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + +public class MatOfDouble extends Mat { + // 64FC(x) + private static final int _depth = CvType.CV_64F; + private static final int _channels = 1; + + public MatOfDouble() { + super(); + } + + protected MatOfDouble(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfDouble fromNativeAddr(long addr) { + return new MatOfDouble(addr); + } + + public MatOfDouble(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfDouble(double...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(double...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public double[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + double[] a = new double[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Double ab[] = lb.toArray(new Double[0]); + double a[] = new double[ab.length]; + for(int i=0; i toList() { + double[] a = toArray(); + Double ab[] = new Double[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(float...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public float[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + float[] a = new float[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Float ab[] = lb.toArray(new Float[0]); + float a[] = new float[ab.length]; + for(int i=0; i toList() { + float[] a = toArray(); + Float ab[] = new Float[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(float...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public float[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + float[] a = new float[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Float ab[] = lb.toArray(new Float[0]); + float a[] = new float[ab.length]; + for(int i=0; i toList() { + float[] a = toArray(); + Float ab[] = new Float[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(float...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public float[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + float[] a = new float[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Float ab[] = lb.toArray(new Float[0]); + float a[] = new float[ab.length]; + for(int i=0; i toList() { + float[] a = toArray(); + Float ab[] = new Float[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(int...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public int[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + int[] a = new int[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Integer ab[] = lb.toArray(new Integer[0]); + int a[] = new int[ab.length]; + for(int i=0; i toList() { + int[] a = toArray(); + Integer ab[] = new Integer[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(int...a) { + if(a==null || a.length==0) + return; + int num = a.length / _channels; + alloc(num); + put(0, 0, a); //TODO: check ret val! + } + + public int[] toArray() { + int num = checkVector(_channels, _depth); + if(num < 0) + throw new RuntimeException("Native Mat has unexpected type or size: " + toString()); + int[] a = new int[num * _channels]; + if(num == 0) + return a; + get(0, 0, a); //TODO: check ret val! + return a; + } + + public void fromList(List lb) { + if(lb==null || lb.size()==0) + return; + Integer ab[] = lb.toArray(new Integer[0]); + int a[] = new int[ab.length]; + for(int i=0; i toList() { + int[] a = toArray(); + Integer ab[] = new Integer[a.length]; + for(int i=0; i0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(KeyPoint...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + float buff[] = new float[num * _channels]; + for(int i=0; i lkp) { + KeyPoint akp[] = lkp.toArray(new KeyPoint[0]); + fromArray(akp); + } + + public List toList() { + KeyPoint[] akp = toArray(); + return Arrays.asList(akp); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint.java new file mode 100644 index 00000000000..f4d573bb734 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint.java @@ -0,0 +1,78 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + +public class MatOfPoint extends Mat { + // 32SC2 + private static final int _depth = CvType.CV_32S; + private static final int _channels = 2; + + public MatOfPoint() { + super(); + } + + protected MatOfPoint(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfPoint fromNativeAddr(long addr) { + return new MatOfPoint(addr); + } + + public MatOfPoint(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfPoint(Point...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(Point...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + int buff[] = new int[num * _channels]; + for(int i=0; i lp) { + Point ap[] = lp.toArray(new Point[0]); + fromArray(ap); + } + + public List toList() { + Point[] ap = toArray(); + return Arrays.asList(ap); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint2f.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint2f.java new file mode 100644 index 00000000000..4b8c926fffa --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint2f.java @@ -0,0 +1,78 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + +public class MatOfPoint2f extends Mat { + // 32FC2 + private static final int _depth = CvType.CV_32F; + private static final int _channels = 2; + + public MatOfPoint2f() { + super(); + } + + protected MatOfPoint2f(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfPoint2f fromNativeAddr(long addr) { + return new MatOfPoint2f(addr); + } + + public MatOfPoint2f(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfPoint2f(Point...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(Point...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + float buff[] = new float[num * _channels]; + for(int i=0; i lp) { + Point ap[] = lp.toArray(new Point[0]); + fromArray(ap); + } + + public List toList() { + Point[] ap = toArray(); + return Arrays.asList(ap); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint3.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint3.java new file mode 100644 index 00000000000..3b50561e914 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint3.java @@ -0,0 +1,79 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + +public class MatOfPoint3 extends Mat { + // 32SC3 + private static final int _depth = CvType.CV_32S; + private static final int _channels = 3; + + public MatOfPoint3() { + super(); + } + + protected MatOfPoint3(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfPoint3 fromNativeAddr(long addr) { + return new MatOfPoint3(addr); + } + + public MatOfPoint3(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfPoint3(Point3...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(Point3...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + int buff[] = new int[num * _channels]; + for(int i=0; i lp) { + Point3 ap[] = lp.toArray(new Point3[0]); + fromArray(ap); + } + + public List toList() { + Point3[] ap = toArray(); + return Arrays.asList(ap); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint3f.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint3f.java new file mode 100644 index 00000000000..fc5fee436d7 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfPoint3f.java @@ -0,0 +1,79 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + +public class MatOfPoint3f extends Mat { + // 32FC3 + private static final int _depth = CvType.CV_32F; + private static final int _channels = 3; + + public MatOfPoint3f() { + super(); + } + + protected MatOfPoint3f(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfPoint3f fromNativeAddr(long addr) { + return new MatOfPoint3f(addr); + } + + public MatOfPoint3f(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfPoint3f(Point3...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(Point3...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + float buff[] = new float[num * _channels]; + for(int i=0; i lp) { + Point3 ap[] = lp.toArray(new Point3[0]); + fromArray(ap); + } + + public List toList() { + Point3[] ap = toArray(); + return Arrays.asList(ap); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfRect.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfRect.java new file mode 100644 index 00000000000..ec0fb01e4ac --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfRect.java @@ -0,0 +1,81 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + + +public class MatOfRect extends Mat { + // 32SC4 + private static final int _depth = CvType.CV_32S; + private static final int _channels = 4; + + public MatOfRect() { + super(); + } + + protected MatOfRect(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfRect fromNativeAddr(long addr) { + return new MatOfRect(addr); + } + + public MatOfRect(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfRect(Rect...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(Rect...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + int buff[] = new int[num * _channels]; + for(int i=0; i lr) { + Rect ap[] = lr.toArray(new Rect[0]); + fromArray(ap); + } + + public List toList() { + Rect[] ar = toArray(); + return Arrays.asList(ar); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/MatOfRect2d.java b/openCVLibrary330/src/main/java/org/opencv/core/MatOfRect2d.java new file mode 100644 index 00000000000..71c4b1aef61 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/MatOfRect2d.java @@ -0,0 +1,81 @@ +package org.opencv.core; + +import java.util.Arrays; +import java.util.List; + + +public class MatOfRect2d extends Mat { + // 64FC4 + private static final int _depth = CvType.CV_64F; + private static final int _channels = 4; + + public MatOfRect2d() { + super(); + } + + protected MatOfRect2d(long addr) { + super(addr); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public static MatOfRect2d fromNativeAddr(long addr) { + return new MatOfRect2d(addr); + } + + public MatOfRect2d(Mat m) { + super(m, Range.all()); + if( !empty() && checkVector(_channels, _depth) < 0 ) + throw new IllegalArgumentException("Incompatible Mat"); + //FIXME: do we need release() here? + } + + public MatOfRect2d(Rect2d...a) { + super(); + fromArray(a); + } + + public void alloc(int elemNumber) { + if(elemNumber>0) + super.create(elemNumber, 1, CvType.makeType(_depth, _channels)); + } + + public void fromArray(Rect2d...a) { + if(a==null || a.length==0) + return; + int num = a.length; + alloc(num); + double buff[] = new double[num * _channels]; + for(int i=0; i lr) { + Rect2d ap[] = lr.toArray(new Rect2d[0]); + fromArray(ap); + } + + public List toList() { + Rect2d[] ar = toArray(); + return Arrays.asList(ar); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Point.java b/openCVLibrary330/src/main/java/org/opencv/core/Point.java new file mode 100644 index 00000000000..ce493d7400f --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Point.java @@ -0,0 +1,68 @@ +package org.opencv.core; + +//javadoc:Point_ +public class Point { + + public double x, y; + + public Point(double x, double y) { + this.x = x; + this.y = y; + } + + public Point() { + this(0, 0); + } + + public Point(double[] vals) { + this(); + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + x = vals.length > 0 ? vals[0] : 0; + y = vals.length > 1 ? vals[1] : 0; + } else { + x = 0; + y = 0; + } + } + + public Point clone() { + return new Point(x, y); + } + + public double dot(Point p) { + return x * p.x + y * p.y; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(x); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(y); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Point)) return false; + Point it = (Point) obj; + return x == it.x && y == it.y; + } + + public boolean inside(Rect r) { + return r.contains(this); + } + + @Override + public String toString() { + return "{" + x + ", " + y + "}"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Point3.java b/openCVLibrary330/src/main/java/org/opencv/core/Point3.java new file mode 100644 index 00000000000..14b91c6b218 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Point3.java @@ -0,0 +1,79 @@ +package org.opencv.core; + +//javadoc:Point3_ +public class Point3 { + + public double x, y, z; + + public Point3(double x, double y, double z) { + this.x = x; + this.y = y; + this.z = z; + } + + public Point3() { + this(0, 0, 0); + } + + public Point3(Point p) { + x = p.x; + y = p.y; + z = 0; + } + + public Point3(double[] vals) { + this(); + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + x = vals.length > 0 ? vals[0] : 0; + y = vals.length > 1 ? vals[1] : 0; + z = vals.length > 2 ? vals[2] : 0; + } else { + x = 0; + y = 0; + z = 0; + } + } + + public Point3 clone() { + return new Point3(x, y, z); + } + + public double dot(Point3 p) { + return x * p.x + y * p.y + z * p.z; + } + + public Point3 cross(Point3 p) { + return new Point3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(x); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(y); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(z); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Point3)) return false; + Point3 it = (Point3) obj; + return x == it.x && y == it.y && z == it.z; + } + + @Override + public String toString() { + return "{" + x + ", " + y + ", " + z + "}"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Range.java b/openCVLibrary330/src/main/java/org/opencv/core/Range.java new file mode 100644 index 00000000000..f7eee4ddc3f --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Range.java @@ -0,0 +1,82 @@ +package org.opencv.core; + +//javadoc:Range +public class Range { + + public int start, end; + + public Range(int s, int e) { + this.start = s; + this.end = e; + } + + public Range() { + this(0, 0); + } + + public Range(double[] vals) { + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + start = vals.length > 0 ? (int) vals[0] : 0; + end = vals.length > 1 ? (int) vals[1] : 0; + } else { + start = 0; + end = 0; + } + + } + + public int size() { + return empty() ? 0 : end - start; + } + + public boolean empty() { + return end <= start; + } + + public static Range all() { + return new Range(Integer.MIN_VALUE, Integer.MAX_VALUE); + } + + public Range intersection(Range r1) { + Range r = new Range(Math.max(r1.start, this.start), Math.min(r1.end, this.end)); + r.end = Math.max(r.end, r.start); + return r; + } + + public Range shift(int delta) { + return new Range(start + delta, end + delta); + } + + public Range clone() { + return new Range(start, end); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(start); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(end); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Range)) return false; + Range it = (Range) obj; + return start == it.start && end == it.end; + } + + @Override + public String toString() { + return "[" + start + ", " + end + ")"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Rect.java b/openCVLibrary330/src/main/java/org/opencv/core/Rect.java new file mode 100644 index 00000000000..c68e818ea42 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Rect.java @@ -0,0 +1,104 @@ +package org.opencv.core; + +//javadoc:Rect_ +public class Rect { + + public int x, y, width, height; + + public Rect(int x, int y, int width, int height) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + public Rect() { + this(0, 0, 0, 0); + } + + public Rect(Point p1, Point p2) { + x = (int) (p1.x < p2.x ? p1.x : p2.x); + y = (int) (p1.y < p2.y ? p1.y : p2.y); + width = (int) (p1.x > p2.x ? p1.x : p2.x) - x; + height = (int) (p1.y > p2.y ? p1.y : p2.y) - y; + } + + public Rect(Point p, Size s) { + this((int) p.x, (int) p.y, (int) s.width, (int) s.height); + } + + public Rect(double[] vals) { + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + x = vals.length > 0 ? (int) vals[0] : 0; + y = vals.length > 1 ? (int) vals[1] : 0; + width = vals.length > 2 ? (int) vals[2] : 0; + height = vals.length > 3 ? (int) vals[3] : 0; + } else { + x = 0; + y = 0; + width = 0; + height = 0; + } + } + + public Rect clone() { + return new Rect(x, y, width, height); + } + + public Point tl() { + return new Point(x, y); + } + + public Point br() { + return new Point(x + width, y + height); + } + + public Size size() { + return new Size(width, height); + } + + public double area() { + return width * height; + } + + public boolean empty() { + return width <= 0 || height <= 0; + } + + public boolean contains(Point p) { + return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(height); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(width); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(x); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(y); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Rect)) return false; + Rect it = (Rect) obj; + return x == it.x && y == it.y && width == it.width && height == it.height; + } + + @Override + public String toString() { + return "{" + x + ", " + y + ", " + width + "x" + height + "}"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Rect2d.java b/openCVLibrary330/src/main/java/org/opencv/core/Rect2d.java new file mode 100644 index 00000000000..4c278696350 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Rect2d.java @@ -0,0 +1,104 @@ +package org.opencv.core; + +//javadoc:Rect2d_ +public class Rect2d { + + public double x, y, width, height; + + public Rect2d(double x, double y, double width, double height) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + public Rect2d() { + this(0, 0, 0, 0); + } + + public Rect2d(Point p1, Point p2) { + x = (double) (p1.x < p2.x ? p1.x : p2.x); + y = (double) (p1.y < p2.y ? p1.y : p2.y); + width = (double) (p1.x > p2.x ? p1.x : p2.x) - x; + height = (double) (p1.y > p2.y ? p1.y : p2.y) - y; + } + + public Rect2d(Point p, Size s) { + this((double) p.x, (double) p.y, (double) s.width, (double) s.height); + } + + public Rect2d(double[] vals) { + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + x = vals.length > 0 ? (double) vals[0] : 0; + y = vals.length > 1 ? (double) vals[1] : 0; + width = vals.length > 2 ? (double) vals[2] : 0; + height = vals.length > 3 ? (double) vals[3] : 0; + } else { + x = 0; + y = 0; + width = 0; + height = 0; + } + } + + public Rect2d clone() { + return new Rect2d(x, y, width, height); + } + + public Point tl() { + return new Point(x, y); + } + + public Point br() { + return new Point(x + width, y + height); + } + + public Size size() { + return new Size(width, height); + } + + public double area() { + return width * height; + } + + public boolean empty() { + return width <= 0 || height <= 0; + } + + public boolean contains(Point p) { + return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(height); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(width); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(x); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(y); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Rect2d)) return false; + Rect2d it = (Rect2d) obj; + return x == it.x && y == it.y && width == it.width && height == it.height; + } + + @Override + public String toString() { + return "{" + x + ", " + y + ", " + width + "x" + height + "}"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/RotatedRect.java b/openCVLibrary330/src/main/java/org/opencv/core/RotatedRect.java new file mode 100644 index 00000000000..f6d1163e02b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/RotatedRect.java @@ -0,0 +1,113 @@ +package org.opencv.core; + +//javadoc:RotatedRect_ +public class RotatedRect { + + public Point center; + public Size size; + public double angle; + + public RotatedRect() { + this.center = new Point(); + this.size = new Size(); + this.angle = 0; + } + + public RotatedRect(Point c, Size s, double a) { + this.center = c.clone(); + this.size = s.clone(); + this.angle = a; + } + + public RotatedRect(double[] vals) { + this(); + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + center.x = vals.length > 0 ? (double) vals[0] : 0; + center.y = vals.length > 1 ? (double) vals[1] : 0; + size.width = vals.length > 2 ? (double) vals[2] : 0; + size.height = vals.length > 3 ? (double) vals[3] : 0; + angle = vals.length > 4 ? (double) vals[4] : 0; + } else { + center.x = 0; + center.x = 0; + size.width = 0; + size.height = 0; + angle = 0; + } + } + + public void points(Point pt[]) + { + double _angle = angle * Math.PI / 180.0; + double b = (double) Math.cos(_angle) * 0.5f; + double a = (double) Math.sin(_angle) * 0.5f; + + pt[0] = new Point( + center.x - a * size.height - b * size.width, + center.y + b * size.height - a * size.width); + + pt[1] = new Point( + center.x + a * size.height - b * size.width, + center.y - b * size.height - a * size.width); + + pt[2] = new Point( + 2 * center.x - pt[0].x, + 2 * center.y - pt[0].y); + + pt[3] = new Point( + 2 * center.x - pt[1].x, + 2 * center.y - pt[1].y); + } + + public Rect boundingRect() + { + Point pt[] = new Point[4]; + points(pt); + Rect r = new Rect((int) Math.floor(Math.min(Math.min(Math.min(pt[0].x, pt[1].x), pt[2].x), pt[3].x)), + (int) Math.floor(Math.min(Math.min(Math.min(pt[0].y, pt[1].y), pt[2].y), pt[3].y)), + (int) Math.ceil(Math.max(Math.max(Math.max(pt[0].x, pt[1].x), pt[2].x), pt[3].x)), + (int) Math.ceil(Math.max(Math.max(Math.max(pt[0].y, pt[1].y), pt[2].y), pt[3].y))); + r.width -= r.x - 1; + r.height -= r.y - 1; + return r; + } + + public RotatedRect clone() { + return new RotatedRect(center, size, angle); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(center.x); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(center.y); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(size.width); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(size.height); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(angle); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof RotatedRect)) return false; + RotatedRect it = (RotatedRect) obj; + return center.equals(it.center) && size.equals(it.size) && angle == it.angle; + } + + @Override + public String toString() { + return "{ " + center + " " + size + " * " + angle + " }"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Scalar.java b/openCVLibrary330/src/main/java/org/opencv/core/Scalar.java new file mode 100644 index 00000000000..01676e4cb5b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Scalar.java @@ -0,0 +1,90 @@ +package org.opencv.core; + +//javadoc:Scalar_ +public class Scalar { + + public double val[]; + + public Scalar(double v0, double v1, double v2, double v3) { + val = new double[] { v0, v1, v2, v3 }; + } + + public Scalar(double v0, double v1, double v2) { + val = new double[] { v0, v1, v2, 0 }; + } + + public Scalar(double v0, double v1) { + val = new double[] { v0, v1, 0, 0 }; + } + + public Scalar(double v0) { + val = new double[] { v0, 0, 0, 0 }; + } + + public Scalar(double[] vals) { + if (vals != null && vals.length == 4) + val = vals.clone(); + else { + val = new double[4]; + set(vals); + } + } + + public void set(double[] vals) { + if (vals != null) { + val[0] = vals.length > 0 ? vals[0] : 0; + val[1] = vals.length > 1 ? vals[1] : 0; + val[2] = vals.length > 2 ? vals[2] : 0; + val[3] = vals.length > 3 ? vals[3] : 0; + } else + val[0] = val[1] = val[2] = val[3] = 0; + } + + public static Scalar all(double v) { + return new Scalar(v, v, v, v); + } + + public Scalar clone() { + return new Scalar(val); + } + + public Scalar mul(Scalar it, double scale) { + return new Scalar(val[0] * it.val[0] * scale, val[1] * it.val[1] * scale, + val[2] * it.val[2] * scale, val[3] * it.val[3] * scale); + } + + public Scalar mul(Scalar it) { + return mul(it, 1); + } + + public Scalar conj() { + return new Scalar(val[0], -val[1], -val[2], -val[3]); + } + + public boolean isReal() { + return val[1] == 0 && val[2] == 0 && val[3] == 0; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + java.util.Arrays.hashCode(val); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Scalar)) return false; + Scalar it = (Scalar) obj; + if (!java.util.Arrays.equals(val, it.val)) return false; + return true; + } + + @Override + public String toString() { + return "[" + val[0] + ", " + val[1] + ", " + val[2] + ", " + val[3] + "]"; + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/Size.java b/openCVLibrary330/src/main/java/org/opencv/core/Size.java new file mode 100644 index 00000000000..f7d69f37cd4 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/Size.java @@ -0,0 +1,73 @@ +package org.opencv.core; + +//javadoc:Size_ +public class Size { + + public double width, height; + + public Size(double width, double height) { + this.width = width; + this.height = height; + } + + public Size() { + this(0, 0); + } + + public Size(Point p) { + width = p.x; + height = p.y; + } + + public Size(double[] vals) { + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + width = vals.length > 0 ? vals[0] : 0; + height = vals.length > 1 ? vals[1] : 0; + } else { + width = 0; + height = 0; + } + } + + public double area() { + return width * height; + } + + public boolean empty() { + return width <= 0 || height <= 0; + } + + public Size clone() { + return new Size(width, height); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(height); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(width); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Size)) return false; + Size it = (Size) obj; + return width == it.width && height == it.height; + } + + @Override + public String toString() { + return (int)width + "x" + (int)height; + } + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/TermCriteria.java b/openCVLibrary330/src/main/java/org/opencv/core/TermCriteria.java new file mode 100644 index 00000000000..c67e51ea8dc --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/TermCriteria.java @@ -0,0 +1,92 @@ +package org.opencv.core; + +//javadoc:TermCriteria +public class TermCriteria { + + /** + * The maximum number of iterations or elements to compute + */ + public static final int COUNT = 1; + /** + * The maximum number of iterations or elements to compute + */ + public static final int MAX_ITER = COUNT; + /** + * The desired accuracy threshold or change in parameters at which the iterative algorithm is terminated. + */ + public static final int EPS = 2; + + public int type; + public int maxCount; + public double epsilon; + + /** + * Termination criteria for iterative algorithms. + * + * @param type + * the type of termination criteria: COUNT, EPS or COUNT + EPS. + * @param maxCount + * the maximum number of iterations/elements. + * @param epsilon + * the desired accuracy. + */ + public TermCriteria(int type, int maxCount, double epsilon) { + this.type = type; + this.maxCount = maxCount; + this.epsilon = epsilon; + } + + /** + * Termination criteria for iterative algorithms. + */ + public TermCriteria() { + this(0, 0, 0.0); + } + + public TermCriteria(double[] vals) { + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + type = vals.length > 0 ? (int) vals[0] : 0; + maxCount = vals.length > 1 ? (int) vals[1] : 0; + epsilon = vals.length > 2 ? (double) vals[2] : 0; + } else { + type = 0; + maxCount = 0; + epsilon = 0; + } + } + + public TermCriteria clone() { + return new TermCriteria(type, maxCount, epsilon); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + long temp; + temp = Double.doubleToLongBits(type); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(maxCount); + result = prime * result + (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(epsilon); + result = prime * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof TermCriteria)) return false; + TermCriteria it = (TermCriteria) obj; + return type == it.type && maxCount == it.maxCount && epsilon == it.epsilon; + } + + @Override + public String toString() { + return "{ type: " + type + ", maxCount: " + maxCount + ", epsilon: " + epsilon + "}"; + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/core/TickMeter.java b/openCVLibrary330/src/main/java/org/opencv/core/TickMeter.java new file mode 100644 index 00000000000..1ab5a563a4a --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/core/TickMeter.java @@ -0,0 +1,181 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.core; + + + +// C++: class TickMeter +//javadoc: TickMeter +public class TickMeter { + + protected final long nativeObj; + protected TickMeter(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: TickMeter() + // + + //javadoc: TickMeter::TickMeter() + public TickMeter() + { + + nativeObj = TickMeter_0(); + + return; + } + + + // + // C++: double getTimeMicro() + // + + //javadoc: TickMeter::getTimeMicro() + public double getTimeMicro() + { + + double retVal = getTimeMicro_0(nativeObj); + + return retVal; + } + + + // + // C++: double getTimeMilli() + // + + //javadoc: TickMeter::getTimeMilli() + public double getTimeMilli() + { + + double retVal = getTimeMilli_0(nativeObj); + + return retVal; + } + + + // + // C++: double getTimeSec() + // + + //javadoc: TickMeter::getTimeSec() + public double getTimeSec() + { + + double retVal = getTimeSec_0(nativeObj); + + return retVal; + } + + + // + // C++: int64 getCounter() + // + + //javadoc: TickMeter::getCounter() + public long getCounter() + { + + long retVal = getCounter_0(nativeObj); + + return retVal; + } + + + // + // C++: int64 getTimeTicks() + // + + //javadoc: TickMeter::getTimeTicks() + public long getTimeTicks() + { + + long retVal = getTimeTicks_0(nativeObj); + + return retVal; + } + + + // + // C++: void reset() + // + + //javadoc: TickMeter::reset() + public void reset() + { + + reset_0(nativeObj); + + return; + } + + + // + // C++: void start() + // + + //javadoc: TickMeter::start() + public void start() + { + + start_0(nativeObj); + + return; + } + + + // + // C++: void stop() + // + + //javadoc: TickMeter::stop() + public void stop() + { + + stop_0(nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: TickMeter() + private static native long TickMeter_0(); + + // C++: double getTimeMicro() + private static native double getTimeMicro_0(long nativeObj); + + // C++: double getTimeMilli() + private static native double getTimeMilli_0(long nativeObj); + + // C++: double getTimeSec() + private static native double getTimeSec_0(long nativeObj); + + // C++: int64 getCounter() + private static native long getCounter_0(long nativeObj); + + // C++: int64 getTimeTicks() + private static native long getTimeTicks_0(long nativeObj); + + // C++: void reset() + private static native void reset_0(long nativeObj); + + // C++: void start() + private static native void start_0(long nativeObj); + + // C++: void stop() + private static native void stop_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/dnn/DictValue.java b/openCVLibrary330/src/main/java/org/opencv/dnn/DictValue.java new file mode 100644 index 00000000000..87c76a23da8 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/dnn/DictValue.java @@ -0,0 +1,211 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.dnn; + +import java.lang.String; + +// C++: class DictValue +//javadoc: DictValue +public class DictValue { + + protected final long nativeObj; + protected DictValue(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: DictValue(String s) + // + + //javadoc: DictValue::DictValue(s) + public DictValue(String s) + { + + nativeObj = DictValue_0(s); + + return; + } + + + // + // C++: DictValue(double p) + // + + //javadoc: DictValue::DictValue(p) + public DictValue(double p) + { + + nativeObj = DictValue_1(p); + + return; + } + + + // + // C++: DictValue(int i) + // + + //javadoc: DictValue::DictValue(i) + public DictValue(int i) + { + + nativeObj = DictValue_2(i); + + return; + } + + + // + // C++: String getStringValue(int idx = -1) + // + + //javadoc: DictValue::getStringValue(idx) + public String getStringValue(int idx) + { + + String retVal = getStringValue_0(nativeObj, idx); + + return retVal; + } + + //javadoc: DictValue::getStringValue() + public String getStringValue() + { + + String retVal = getStringValue_1(nativeObj); + + return retVal; + } + + + // + // C++: bool isInt() + // + + //javadoc: DictValue::isInt() + public boolean isInt() + { + + boolean retVal = isInt_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isReal() + // + + //javadoc: DictValue::isReal() + public boolean isReal() + { + + boolean retVal = isReal_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isString() + // + + //javadoc: DictValue::isString() + public boolean isString() + { + + boolean retVal = isString_0(nativeObj); + + return retVal; + } + + + // + // C++: double getRealValue(int idx = -1) + // + + //javadoc: DictValue::getRealValue(idx) + public double getRealValue(int idx) + { + + double retVal = getRealValue_0(nativeObj, idx); + + return retVal; + } + + //javadoc: DictValue::getRealValue() + public double getRealValue() + { + + double retVal = getRealValue_1(nativeObj); + + return retVal; + } + + + // + // C++: int getIntValue(int idx = -1) + // + + //javadoc: DictValue::getIntValue(idx) + public int getIntValue(int idx) + { + + int retVal = getIntValue_0(nativeObj, idx); + + return retVal; + } + + //javadoc: DictValue::getIntValue() + public int getIntValue() + { + + int retVal = getIntValue_1(nativeObj); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: DictValue(String s) + private static native long DictValue_0(String s); + + // C++: DictValue(double p) + private static native long DictValue_1(double p); + + // C++: DictValue(int i) + private static native long DictValue_2(int i); + + // C++: String getStringValue(int idx = -1) + private static native String getStringValue_0(long nativeObj, int idx); + private static native String getStringValue_1(long nativeObj); + + // C++: bool isInt() + private static native boolean isInt_0(long nativeObj); + + // C++: bool isReal() + private static native boolean isReal_0(long nativeObj); + + // C++: bool isString() + private static native boolean isString_0(long nativeObj); + + // C++: double getRealValue(int idx = -1) + private static native double getRealValue_0(long nativeObj, int idx); + private static native double getRealValue_1(long nativeObj); + + // C++: int getIntValue(int idx = -1) + private static native int getIntValue_0(long nativeObj, int idx); + private static native int getIntValue_1(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/dnn/Dnn.java b/openCVLibrary330/src/main/java/org/opencv/dnn/Dnn.java new file mode 100644 index 00000000000..1e92e75f047 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/dnn/Dnn.java @@ -0,0 +1,249 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.dnn; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.utils.Converters; + +public class Dnn { + + public static final int + DNN_BACKEND_DEFAULT = 0, + DNN_BACKEND_HALIDE = 1, + DNN_TARGET_CPU = 0, + DNN_TARGET_OPENCL = 1; + + + // + // C++: Mat blobFromImage(Mat image, double scalefactor = 1.0, Size size = Size(), Scalar mean = Scalar(), bool swapRB = true) + // + + //javadoc: blobFromImage(image, scalefactor, size, mean, swapRB) + public static Mat blobFromImage(Mat image, double scalefactor, Size size, Scalar mean, boolean swapRB) + { + + Mat retVal = new Mat(blobFromImage_0(image.nativeObj, scalefactor, size.width, size.height, mean.val[0], mean.val[1], mean.val[2], mean.val[3], swapRB)); + + return retVal; + } + + //javadoc: blobFromImage(image) + public static Mat blobFromImage(Mat image) + { + + Mat retVal = new Mat(blobFromImage_1(image.nativeObj)); + + return retVal; + } + + + // + // C++: Mat blobFromImages(vector_Mat images, double scalefactor = 1.0, Size size = Size(), Scalar mean = Scalar(), bool swapRB = true) + // + + //javadoc: blobFromImages(images, scalefactor, size, mean, swapRB) + public static Mat blobFromImages(List images, double scalefactor, Size size, Scalar mean, boolean swapRB) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat retVal = new Mat(blobFromImages_0(images_mat.nativeObj, scalefactor, size.width, size.height, mean.val[0], mean.val[1], mean.val[2], mean.val[3], swapRB)); + + return retVal; + } + + //javadoc: blobFromImages(images) + public static Mat blobFromImages(List images) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat retVal = new Mat(blobFromImages_1(images_mat.nativeObj)); + + return retVal; + } + + + // + // C++: Mat readTorchBlob(String filename, bool isBinary = true) + // + + //javadoc: readTorchBlob(filename, isBinary) + public static Mat readTorchBlob(String filename, boolean isBinary) + { + + Mat retVal = new Mat(readTorchBlob_0(filename, isBinary)); + + return retVal; + } + + //javadoc: readTorchBlob(filename) + public static Mat readTorchBlob(String filename) + { + + Mat retVal = new Mat(readTorchBlob_1(filename)); + + return retVal; + } + + + // + // C++: Net readNetFromCaffe(String prototxt, String caffeModel = String()) + // + + //javadoc: readNetFromCaffe(prototxt, caffeModel) + public static Net readNetFromCaffe(String prototxt, String caffeModel) + { + + Net retVal = new Net(readNetFromCaffe_0(prototxt, caffeModel)); + + return retVal; + } + + //javadoc: readNetFromCaffe(prototxt) + public static Net readNetFromCaffe(String prototxt) + { + + Net retVal = new Net(readNetFromCaffe_1(prototxt)); + + return retVal; + } + + + // + // C++: Net readNetFromTensorflow(String model) + // + + //javadoc: readNetFromTensorflow(model) + public static Net readNetFromTensorflow(String model) + { + + Net retVal = new Net(readNetFromTensorflow_0(model)); + + return retVal; + } + + + // + // C++: Net readNetFromTorch(String model, bool isBinary = true) + // + + //javadoc: readNetFromTorch(model, isBinary) + public static Net readNetFromTorch(String model, boolean isBinary) + { + + Net retVal = new Net(readNetFromTorch_0(model, isBinary)); + + return retVal; + } + + //javadoc: readNetFromTorch(model) + public static Net readNetFromTorch(String model) + { + + Net retVal = new Net(readNetFromTorch_1(model)); + + return retVal; + } + + + // + // C++: Ptr_Importer createCaffeImporter(String prototxt, String caffeModel = String()) + // + + //javadoc: createCaffeImporter(prototxt, caffeModel) + public static Importer createCaffeImporter(String prototxt, String caffeModel) + { + + Importer retVal = new Importer(createCaffeImporter_0(prototxt, caffeModel)); + + return retVal; + } + + //javadoc: createCaffeImporter(prototxt) + public static Importer createCaffeImporter(String prototxt) + { + + Importer retVal = new Importer(createCaffeImporter_1(prototxt)); + + return retVal; + } + + + // + // C++: Ptr_Importer createTensorflowImporter(String model) + // + + //javadoc: createTensorflowImporter(model) + public static Importer createTensorflowImporter(String model) + { + + Importer retVal = new Importer(createTensorflowImporter_0(model)); + + return retVal; + } + + + // + // C++: Ptr_Importer createTorchImporter(String filename, bool isBinary = true) + // + + //javadoc: createTorchImporter(filename, isBinary) + public static Importer createTorchImporter(String filename, boolean isBinary) + { + + Importer retVal = new Importer(createTorchImporter_0(filename, isBinary)); + + return retVal; + } + + //javadoc: createTorchImporter(filename) + public static Importer createTorchImporter(String filename) + { + + Importer retVal = new Importer(createTorchImporter_1(filename)); + + return retVal; + } + + + + + // C++: Mat blobFromImage(Mat image, double scalefactor = 1.0, Size size = Size(), Scalar mean = Scalar(), bool swapRB = true) + private static native long blobFromImage_0(long image_nativeObj, double scalefactor, double size_width, double size_height, double mean_val0, double mean_val1, double mean_val2, double mean_val3, boolean swapRB); + private static native long blobFromImage_1(long image_nativeObj); + + // C++: Mat blobFromImages(vector_Mat images, double scalefactor = 1.0, Size size = Size(), Scalar mean = Scalar(), bool swapRB = true) + private static native long blobFromImages_0(long images_mat_nativeObj, double scalefactor, double size_width, double size_height, double mean_val0, double mean_val1, double mean_val2, double mean_val3, boolean swapRB); + private static native long blobFromImages_1(long images_mat_nativeObj); + + // C++: Mat readTorchBlob(String filename, bool isBinary = true) + private static native long readTorchBlob_0(String filename, boolean isBinary); + private static native long readTorchBlob_1(String filename); + + // C++: Net readNetFromCaffe(String prototxt, String caffeModel = String()) + private static native long readNetFromCaffe_0(String prototxt, String caffeModel); + private static native long readNetFromCaffe_1(String prototxt); + + // C++: Net readNetFromTensorflow(String model) + private static native long readNetFromTensorflow_0(String model); + + // C++: Net readNetFromTorch(String model, bool isBinary = true) + private static native long readNetFromTorch_0(String model, boolean isBinary); + private static native long readNetFromTorch_1(String model); + + // C++: Ptr_Importer createCaffeImporter(String prototxt, String caffeModel = String()) + private static native long createCaffeImporter_0(String prototxt, String caffeModel); + private static native long createCaffeImporter_1(String prototxt); + + // C++: Ptr_Importer createTensorflowImporter(String model) + private static native long createTensorflowImporter_0(String model); + + // C++: Ptr_Importer createTorchImporter(String filename, bool isBinary = true) + private static native long createTorchImporter_0(String filename, boolean isBinary); + private static native long createTorchImporter_1(String filename); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/dnn/Importer.java b/openCVLibrary330/src/main/java/org/opencv/dnn/Importer.java new file mode 100644 index 00000000000..8aca7c4a7d1 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/dnn/Importer.java @@ -0,0 +1,43 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.dnn; + +import org.opencv.core.Algorithm; + +// C++: class Importer +//javadoc: Importer +public class Importer extends Algorithm { + + protected Importer(long addr) { super(addr); } + + + // + // C++: void populateNet(Net net) + // + + //javadoc: Importer::populateNet(net) + public void populateNet(Net net) + { + + populateNet_0(nativeObj, net.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void populateNet(Net net) + private static native void populateNet_0(long nativeObj, long net_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/dnn/Layer.java b/openCVLibrary330/src/main/java/org/opencv/dnn/Layer.java new file mode 100644 index 00000000000..f30b01cf415 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/dnn/Layer.java @@ -0,0 +1,180 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.dnn; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class Layer +//javadoc: Layer +public class Layer extends Algorithm { + + protected Layer(long addr) { super(addr); } + + + // + // C++: vector_Mat finalize(vector_Mat inputs) + // + + //javadoc: Layer::finalize(inputs) + public List finalize(List inputs) + { + Mat inputs_mat = Converters.vector_Mat_to_Mat(inputs); + List retVal = new ArrayList(); + Mat retValMat = new Mat(finalize_0(nativeObj, inputs_mat.nativeObj)); + Converters.Mat_to_vector_Mat(retValMat, retVal); + return retVal; + } + + + // + // C++: void finalize(vector_Mat inputs, vector_Mat& outputs) + // + + //javadoc: Layer::finalize(inputs, outputs) + public void finalize(List inputs, List outputs) + { + Mat inputs_mat = Converters.vector_Mat_to_Mat(inputs); + Mat outputs_mat = new Mat(); + finalize_1(nativeObj, inputs_mat.nativeObj, outputs_mat.nativeObj); + Converters.Mat_to_vector_Mat(outputs_mat, outputs); + outputs_mat.release(); + return; + } + + + // + // C++: void forward(vector_Mat inputs, vector_Mat& outputs, vector_Mat& internals) + // + + //javadoc: Layer::forward(inputs, outputs, internals) + public void forward(List inputs, List outputs, List internals) + { + Mat inputs_mat = Converters.vector_Mat_to_Mat(inputs); + Mat outputs_mat = Converters.vector_Mat_to_Mat(outputs); + Mat internals_mat = Converters.vector_Mat_to_Mat(internals); + forward_0(nativeObj, inputs_mat.nativeObj, outputs_mat.nativeObj, internals_mat.nativeObj); + Converters.Mat_to_vector_Mat(outputs_mat, outputs); + outputs_mat.release(); + Converters.Mat_to_vector_Mat(internals_mat, internals); + internals_mat.release(); + return; + } + + + // + // C++: void run(vector_Mat inputs, vector_Mat& outputs, vector_Mat& internals) + // + + //javadoc: Layer::run(inputs, outputs, internals) + public void run(List inputs, List outputs, List internals) + { + Mat inputs_mat = Converters.vector_Mat_to_Mat(inputs); + Mat outputs_mat = new Mat(); + Mat internals_mat = Converters.vector_Mat_to_Mat(internals); + run_0(nativeObj, inputs_mat.nativeObj, outputs_mat.nativeObj, internals_mat.nativeObj); + Converters.Mat_to_vector_Mat(outputs_mat, outputs); + outputs_mat.release(); + Converters.Mat_to_vector_Mat(internals_mat, internals); + internals_mat.release(); + return; + } + + + // + // C++: vector_Mat Layer::blobs + // + + //javadoc: Layer::get_blobs() + public List get_blobs() + { + List retVal = new ArrayList(); + Mat retValMat = new Mat(get_blobs_0(nativeObj)); + Converters.Mat_to_vector_Mat(retValMat, retVal); + return retVal; + } + + + // + // C++: void Layer::blobs + // + + //javadoc: Layer::set_blobs(blobs) + public void set_blobs(List blobs) + { + Mat blobs_mat = Converters.vector_Mat_to_Mat(blobs); + set_blobs_0(nativeObj, blobs_mat.nativeObj); + + return; + } + + + // + // C++: String Layer::name + // + + //javadoc: Layer::get_name() + public String get_name() + { + + String retVal = get_name_0(nativeObj); + + return retVal; + } + + + // + // C++: String Layer::type + // + + //javadoc: Layer::get_type() + public String get_type() + { + + String retVal = get_type_0(nativeObj); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: vector_Mat finalize(vector_Mat inputs) + private static native long finalize_0(long nativeObj, long inputs_mat_nativeObj); + + // C++: void finalize(vector_Mat inputs, vector_Mat& outputs) + private static native void finalize_1(long nativeObj, long inputs_mat_nativeObj, long outputs_mat_nativeObj); + + // C++: void forward(vector_Mat inputs, vector_Mat& outputs, vector_Mat& internals) + private static native void forward_0(long nativeObj, long inputs_mat_nativeObj, long outputs_mat_nativeObj, long internals_mat_nativeObj); + + // C++: void run(vector_Mat inputs, vector_Mat& outputs, vector_Mat& internals) + private static native void run_0(long nativeObj, long inputs_mat_nativeObj, long outputs_mat_nativeObj, long internals_mat_nativeObj); + + // C++: vector_Mat Layer::blobs + private static native long get_blobs_0(long nativeObj); + + // C++: void Layer::blobs + private static native void set_blobs_0(long nativeObj, long blobs_mat_nativeObj); + + // C++: String Layer::name + private static native String get_name_0(long nativeObj); + + // C++: String Layer::type + private static native String get_type_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/dnn/Net.java b/openCVLibrary330/src/main/java/org/opencv/dnn/Net.java new file mode 100644 index 00000000000..d2f269a7280 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/dnn/Net.java @@ -0,0 +1,639 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.dnn; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfDouble; +import org.opencv.core.MatOfInt; +import org.opencv.dnn.DictValue; +import org.opencv.dnn.Layer; +import org.opencv.utils.Converters; + +// C++: class Net +//javadoc: Net +public class Net { + + protected final long nativeObj; + protected Net(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: Net() + // + + //javadoc: Net::Net() + public Net() + { + + nativeObj = Net_0(); + + return; + } + + + // + // C++: Mat forward(String outputName = String()) + // + + //javadoc: Net::forward(outputName) + public Mat forward(String outputName) + { + + Mat retVal = new Mat(forward_0(nativeObj, outputName)); + + return retVal; + } + + //javadoc: Net::forward() + public Mat forward() + { + + Mat retVal = new Mat(forward_1(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getParam(LayerId layer, int numParam = 0) + // + + //javadoc: Net::getParam(layer, numParam) + public Mat getParam(DictValue layer, int numParam) + { + + Mat retVal = new Mat(getParam_0(nativeObj, layer.getNativeObjAddr(), numParam)); + + return retVal; + } + + //javadoc: Net::getParam(layer) + public Mat getParam(DictValue layer) + { + + Mat retVal = new Mat(getParam_1(nativeObj, layer.getNativeObjAddr())); + + return retVal; + } + + + // + // C++: Ptr_Layer getLayer(LayerId layerId) + // + + //javadoc: Net::getLayer(layerId) + public Layer getLayer(DictValue layerId) + { + + Layer retVal = new Layer(getLayer_0(nativeObj, layerId.getNativeObjAddr())); + + return retVal; + } + + + // + // C++: bool empty() + // + + //javadoc: Net::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: int getLayerId(String layer) + // + + //javadoc: Net::getLayerId(layer) + public int getLayerId(String layer) + { + + int retVal = getLayerId_0(nativeObj, layer); + + return retVal; + } + + + // + // C++: int getLayersCount(String layerType) + // + + //javadoc: Net::getLayersCount(layerType) + public int getLayersCount(String layerType) + { + + int retVal = getLayersCount_0(nativeObj, layerType); + + return retVal; + } + + + // + // C++: int64 getFLOPS(MatShape netInputShape) + // + + //javadoc: Net::getFLOPS(netInputShape) + public long getFLOPS(MatOfInt netInputShape) + { + Mat netInputShape_mat = netInputShape; + long retVal = getFLOPS_0(nativeObj, netInputShape_mat.nativeObj); + + return retVal; + } + + + // + // C++: int64 getFLOPS(int layerId, MatShape netInputShape) + // + + //javadoc: Net::getFLOPS(layerId, netInputShape) + public long getFLOPS(int layerId, MatOfInt netInputShape) + { + Mat netInputShape_mat = netInputShape; + long retVal = getFLOPS_1(nativeObj, layerId, netInputShape_mat.nativeObj); + + return retVal; + } + + + // + // C++: int64 getFLOPS(int layerId, vector_MatShape netInputShapes) + // + + //javadoc: Net::getFLOPS(layerId, netInputShapes) + public long getFLOPS(int layerId, List netInputShapes) + { + + long retVal = getFLOPS_2(nativeObj, layerId, netInputShapes); + + return retVal; + } + + + // + // C++: int64 getFLOPS(vector_MatShape netInputShapes) + // + + //javadoc: Net::getFLOPS(netInputShapes) + public long getFLOPS(List netInputShapes) + { + + long retVal = getFLOPS_3(nativeObj, netInputShapes); + + return retVal; + } + + + // + // C++: vector_Ptr_Layer getLayerInputs(LayerId layerId) + // + + //javadoc: Net::getLayerInputs(layerId) + public List getLayerInputs(DictValue layerId) + { + + List retVal = getLayerInputs_0(nativeObj, layerId.getNativeObjAddr()); + + return retVal; + } + + + // + // C++: vector_String getLayerNames() + // + + //javadoc: Net::getLayerNames() + public List getLayerNames() + { + + List retVal = getLayerNames_0(nativeObj); + + return retVal; + } + + + // + // C++: vector_int getUnconnectedOutLayers() + // + + //javadoc: Net::getUnconnectedOutLayers() + public MatOfInt getUnconnectedOutLayers() + { + + MatOfInt retVal = MatOfInt.fromNativeAddr(getUnconnectedOutLayers_0(nativeObj)); + + return retVal; + } + + + // + // C++: void connect(String outPin, String inpPin) + // + + //javadoc: Net::connect(outPin, inpPin) + public void connect(String outPin, String inpPin) + { + + connect_0(nativeObj, outPin, inpPin); + + return; + } + + + // + // C++: void deleteLayer(LayerId layer) + // + + //javadoc: Net::deleteLayer(layer) + public void deleteLayer(DictValue layer) + { + + deleteLayer_0(nativeObj, layer.getNativeObjAddr()); + + return; + } + + + // + // C++: void enableFusion(bool fusion) + // + + //javadoc: Net::enableFusion(fusion) + public void enableFusion(boolean fusion) + { + + enableFusion_0(nativeObj, fusion); + + return; + } + + + // + // C++: void forward(vector_Mat outputBlobs, String outputName = String()) + // + + //javadoc: Net::forward(outputBlobs, outputName) + public void forward(List outputBlobs, String outputName) + { + Mat outputBlobs_mat = Converters.vector_Mat_to_Mat(outputBlobs); + forward_2(nativeObj, outputBlobs_mat.nativeObj, outputName); + + return; + } + + //javadoc: Net::forward(outputBlobs) + public void forward(List outputBlobs) + { + Mat outputBlobs_mat = Converters.vector_Mat_to_Mat(outputBlobs); + forward_3(nativeObj, outputBlobs_mat.nativeObj); + + return; + } + + + // + // C++: void forward(vector_Mat outputBlobs, vector_String outBlobNames) + // + + //javadoc: Net::forward(outputBlobs, outBlobNames) + public void forward(List outputBlobs, List outBlobNames) + { + Mat outputBlobs_mat = Converters.vector_Mat_to_Mat(outputBlobs); + forward_4(nativeObj, outputBlobs_mat.nativeObj, outBlobNames); + + return; + } + + + // + // C++: void forward(vector_vector_Mat outputBlobs, vector_String outBlobNames) + // + + // Unknown type 'vector_vector_Mat' (I), skipping the function + + + // + // C++: void getLayerShapes(MatShape netInputShape, int layerId, vector_MatShape* inLayerShapes, vector_MatShape* outLayerShapes) + // + + //javadoc: Net::getLayerShapes(netInputShape, layerId, inLayerShapes, outLayerShapes) + public void getLayerShapes(MatOfInt netInputShape, int layerId, List inLayerShapes, List outLayerShapes) + { + Mat netInputShape_mat = netInputShape; + getLayerShapes_0(nativeObj, netInputShape_mat.nativeObj, layerId, inLayerShapes, outLayerShapes); + + return; + } + + + // + // C++: void getLayerShapes(vector_MatShape netInputShapes, int layerId, vector_MatShape* inLayerShapes, vector_MatShape* outLayerShapes) + // + + //javadoc: Net::getLayerShapes(netInputShapes, layerId, inLayerShapes, outLayerShapes) + public void getLayerShapes(List netInputShapes, int layerId, List inLayerShapes, List outLayerShapes) + { + + getLayerShapes_1(nativeObj, netInputShapes, layerId, inLayerShapes, outLayerShapes); + + return; + } + + + // + // C++: void getLayerTypes(vector_String& layersTypes) + // + + //javadoc: Net::getLayerTypes(layersTypes) + public void getLayerTypes(List layersTypes) + { + + getLayerTypes_0(nativeObj, layersTypes); + + return; + } + + + // + // C++: void getLayersShapes(MatShape netInputShape, vector_int* layersIds, vector_vector_MatShape* inLayersShapes, vector_vector_MatShape* outLayersShapes) + // + + // Unknown type 'vector_vector_MatShape' (I), skipping the function + + + // + // C++: void getLayersShapes(vector_MatShape netInputShapes, vector_int* layersIds, vector_vector_MatShape* inLayersShapes, vector_vector_MatShape* outLayersShapes) + // + + // Unknown type 'vector_vector_MatShape' (I), skipping the function + + + // + // C++: void getMemoryConsumption(MatShape netInputShape, size_t& weights, size_t& blobs) + // + + //javadoc: Net::getMemoryConsumption(netInputShape, weights, blobs) + public void getMemoryConsumption(MatOfInt netInputShape, long[] weights, long[] blobs) + { + Mat netInputShape_mat = netInputShape; + double[] weights_out = new double[1]; + double[] blobs_out = new double[1]; + getMemoryConsumption_0(nativeObj, netInputShape_mat.nativeObj, weights_out, blobs_out); + if(weights!=null) weights[0] = (long)weights_out[0]; + if(blobs!=null) blobs[0] = (long)blobs_out[0]; + return; + } + + + // + // C++: void getMemoryConsumption(MatShape netInputShape, vector_int& layerIds, vector_size_t& weights, vector_size_t& blobs) + // + + //javadoc: Net::getMemoryConsumption(netInputShape, layerIds, weights, blobs) + public void getMemoryConsumption(MatOfInt netInputShape, MatOfInt layerIds, MatOfDouble weights, MatOfDouble blobs) + { + Mat netInputShape_mat = netInputShape; + Mat layerIds_mat = layerIds; + Mat weights_mat = weights; + Mat blobs_mat = blobs; + getMemoryConsumption_1(nativeObj, netInputShape_mat.nativeObj, layerIds_mat.nativeObj, weights_mat.nativeObj, blobs_mat.nativeObj); + + return; + } + + + // + // C++: void getMemoryConsumption(int layerId, MatShape netInputShape, size_t& weights, size_t& blobs) + // + + //javadoc: Net::getMemoryConsumption(layerId, netInputShape, weights, blobs) + public void getMemoryConsumption(int layerId, MatOfInt netInputShape, long[] weights, long[] blobs) + { + Mat netInputShape_mat = netInputShape; + double[] weights_out = new double[1]; + double[] blobs_out = new double[1]; + getMemoryConsumption_2(nativeObj, layerId, netInputShape_mat.nativeObj, weights_out, blobs_out); + if(weights!=null) weights[0] = (long)weights_out[0]; + if(blobs!=null) blobs[0] = (long)blobs_out[0]; + return; + } + + + // + // C++: void getMemoryConsumption(int layerId, vector_MatShape netInputShapes, size_t& weights, size_t& blobs) + // + + //javadoc: Net::getMemoryConsumption(layerId, netInputShapes, weights, blobs) + public void getMemoryConsumption(int layerId, List netInputShapes, long[] weights, long[] blobs) + { + double[] weights_out = new double[1]; + double[] blobs_out = new double[1]; + getMemoryConsumption_3(nativeObj, layerId, netInputShapes, weights_out, blobs_out); + if(weights!=null) weights[0] = (long)weights_out[0]; + if(blobs!=null) blobs[0] = (long)blobs_out[0]; + return; + } + + + // + // C++: void getMemoryConsumption(vector_MatShape netInputShapes, size_t& weights, size_t& blobs) + // + + //javadoc: Net::getMemoryConsumption(netInputShapes, weights, blobs) + public void getMemoryConsumption(List netInputShapes, long[] weights, long[] blobs) + { + double[] weights_out = new double[1]; + double[] blobs_out = new double[1]; + getMemoryConsumption_4(nativeObj, netInputShapes, weights_out, blobs_out); + if(weights!=null) weights[0] = (long)weights_out[0]; + if(blobs!=null) blobs[0] = (long)blobs_out[0]; + return; + } + + + // + // C++: void getMemoryConsumption(vector_MatShape netInputShapes, vector_int& layerIds, vector_size_t& weights, vector_size_t& blobs) + // + + //javadoc: Net::getMemoryConsumption(netInputShapes, layerIds, weights, blobs) + public void getMemoryConsumption(List netInputShapes, MatOfInt layerIds, MatOfDouble weights, MatOfDouble blobs) + { + Mat layerIds_mat = layerIds; + Mat weights_mat = weights; + Mat blobs_mat = blobs; + getMemoryConsumption_5(nativeObj, netInputShapes, layerIds_mat.nativeObj, weights_mat.nativeObj, blobs_mat.nativeObj); + + return; + } + + + // + // C++: void setInput(Mat blob, String name = "") + // + + //javadoc: Net::setInput(blob, name) + public void setInput(Mat blob, String name) + { + + setInput_0(nativeObj, blob.nativeObj, name); + + return; + } + + //javadoc: Net::setInput(blob) + public void setInput(Mat blob) + { + + setInput_1(nativeObj, blob.nativeObj); + + return; + } + + + // + // C++: void setInputsNames(vector_String inputBlobNames) + // + + //javadoc: Net::setInputsNames(inputBlobNames) + public void setInputsNames(List inputBlobNames) + { + + setInputsNames_0(nativeObj, inputBlobNames); + + return; + } + + + // + // C++: void setParam(LayerId layer, int numParam, Mat blob) + // + + //javadoc: Net::setParam(layer, numParam, blob) + public void setParam(DictValue layer, int numParam, Mat blob) + { + + setParam_0(nativeObj, layer.getNativeObjAddr(), numParam, blob.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Net() + private static native long Net_0(); + + // C++: Mat forward(String outputName = String()) + private static native long forward_0(long nativeObj, String outputName); + private static native long forward_1(long nativeObj); + + // C++: Mat getParam(LayerId layer, int numParam = 0) + private static native long getParam_0(long nativeObj, long layer_nativeObj, int numParam); + private static native long getParam_1(long nativeObj, long layer_nativeObj); + + // C++: Ptr_Layer getLayer(LayerId layerId) + private static native long getLayer_0(long nativeObj, long layerId_nativeObj); + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: int getLayerId(String layer) + private static native int getLayerId_0(long nativeObj, String layer); + + // C++: int getLayersCount(String layerType) + private static native int getLayersCount_0(long nativeObj, String layerType); + + // C++: int64 getFLOPS(MatShape netInputShape) + private static native long getFLOPS_0(long nativeObj, long netInputShape_mat_nativeObj); + + // C++: int64 getFLOPS(int layerId, MatShape netInputShape) + private static native long getFLOPS_1(long nativeObj, int layerId, long netInputShape_mat_nativeObj); + + // C++: int64 getFLOPS(int layerId, vector_MatShape netInputShapes) + private static native long getFLOPS_2(long nativeObj, int layerId, List netInputShapes); + + // C++: int64 getFLOPS(vector_MatShape netInputShapes) + private static native long getFLOPS_3(long nativeObj, List netInputShapes); + + // C++: vector_Ptr_Layer getLayerInputs(LayerId layerId) + private static native List getLayerInputs_0(long nativeObj, long layerId_nativeObj); + + // C++: vector_String getLayerNames() + private static native List getLayerNames_0(long nativeObj); + + // C++: vector_int getUnconnectedOutLayers() + private static native long getUnconnectedOutLayers_0(long nativeObj); + + // C++: void connect(String outPin, String inpPin) + private static native void connect_0(long nativeObj, String outPin, String inpPin); + + // C++: void deleteLayer(LayerId layer) + private static native void deleteLayer_0(long nativeObj, long layer_nativeObj); + + // C++: void enableFusion(bool fusion) + private static native void enableFusion_0(long nativeObj, boolean fusion); + + // C++: void forward(vector_Mat outputBlobs, String outputName = String()) + private static native void forward_2(long nativeObj, long outputBlobs_mat_nativeObj, String outputName); + private static native void forward_3(long nativeObj, long outputBlobs_mat_nativeObj); + + // C++: void forward(vector_Mat outputBlobs, vector_String outBlobNames) + private static native void forward_4(long nativeObj, long outputBlobs_mat_nativeObj, List outBlobNames); + + // C++: void getLayerShapes(MatShape netInputShape, int layerId, vector_MatShape* inLayerShapes, vector_MatShape* outLayerShapes) + private static native void getLayerShapes_0(long nativeObj, long netInputShape_mat_nativeObj, int layerId, List inLayerShapes, List outLayerShapes); + + // C++: void getLayerShapes(vector_MatShape netInputShapes, int layerId, vector_MatShape* inLayerShapes, vector_MatShape* outLayerShapes) + private static native void getLayerShapes_1(long nativeObj, List netInputShapes, int layerId, List inLayerShapes, List outLayerShapes); + + // C++: void getLayerTypes(vector_String& layersTypes) + private static native void getLayerTypes_0(long nativeObj, List layersTypes); + + // C++: void getMemoryConsumption(MatShape netInputShape, size_t& weights, size_t& blobs) + private static native void getMemoryConsumption_0(long nativeObj, long netInputShape_mat_nativeObj, double[] weights_out, double[] blobs_out); + + // C++: void getMemoryConsumption(MatShape netInputShape, vector_int& layerIds, vector_size_t& weights, vector_size_t& blobs) + private static native void getMemoryConsumption_1(long nativeObj, long netInputShape_mat_nativeObj, long layerIds_mat_nativeObj, long weights_mat_nativeObj, long blobs_mat_nativeObj); + + // C++: void getMemoryConsumption(int layerId, MatShape netInputShape, size_t& weights, size_t& blobs) + private static native void getMemoryConsumption_2(long nativeObj, int layerId, long netInputShape_mat_nativeObj, double[] weights_out, double[] blobs_out); + + // C++: void getMemoryConsumption(int layerId, vector_MatShape netInputShapes, size_t& weights, size_t& blobs) + private static native void getMemoryConsumption_3(long nativeObj, int layerId, List netInputShapes, double[] weights_out, double[] blobs_out); + + // C++: void getMemoryConsumption(vector_MatShape netInputShapes, size_t& weights, size_t& blobs) + private static native void getMemoryConsumption_4(long nativeObj, List netInputShapes, double[] weights_out, double[] blobs_out); + + // C++: void getMemoryConsumption(vector_MatShape netInputShapes, vector_int& layerIds, vector_size_t& weights, vector_size_t& blobs) + private static native void getMemoryConsumption_5(long nativeObj, List netInputShapes, long layerIds_mat_nativeObj, long weights_mat_nativeObj, long blobs_mat_nativeObj); + + // C++: void setInput(Mat blob, String name = "") + private static native void setInput_0(long nativeObj, long blob_nativeObj, String name); + private static native void setInput_1(long nativeObj, long blob_nativeObj); + + // C++: void setInputsNames(vector_String inputBlobNames) + private static native void setInputsNames_0(long nativeObj, List inputBlobNames); + + // C++: void setParam(LayerId layer, int numParam, Mat blob) + private static native void setParam_0(long nativeObj, long layer_nativeObj, int numParam, long blob_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/AKAZE.java b/openCVLibrary330/src/main/java/org/opencv/features2d/AKAZE.java new file mode 100644 index 00000000000..45f57c934f7 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/AKAZE.java @@ -0,0 +1,298 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class AKAZE +//javadoc: AKAZE +public class AKAZE extends Feature2D { + + protected AKAZE(long addr) { super(addr); } + + + public static final int + DESCRIPTOR_KAZE_UPRIGHT = 2, + DESCRIPTOR_KAZE = 3, + DESCRIPTOR_MLDB_UPRIGHT = 4, + DESCRIPTOR_MLDB = 5; + + + // + // C++: static Ptr_AKAZE create(int descriptor_type = AKAZE::DESCRIPTOR_MLDB, int descriptor_size = 0, int descriptor_channels = 3, float threshold = 0.001f, int nOctaves = 4, int nOctaveLayers = 4, int diffusivity = KAZE::DIFF_PM_G2) + // + + //javadoc: AKAZE::create(descriptor_type, descriptor_size, descriptor_channels, threshold, nOctaves, nOctaveLayers, diffusivity) + public static AKAZE create(int descriptor_type, int descriptor_size, int descriptor_channels, float threshold, int nOctaves, int nOctaveLayers, int diffusivity) + { + + AKAZE retVal = new AKAZE(create_0(descriptor_type, descriptor_size, descriptor_channels, threshold, nOctaves, nOctaveLayers, diffusivity)); + + return retVal; + } + + //javadoc: AKAZE::create() + public static AKAZE create() + { + + AKAZE retVal = new AKAZE(create_1()); + + return retVal; + } + + + // + // C++: double getThreshold() + // + + //javadoc: AKAZE::getThreshold() + public double getThreshold() + { + + double retVal = getThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDescriptorChannels() + // + + //javadoc: AKAZE::getDescriptorChannels() + public int getDescriptorChannels() + { + + int retVal = getDescriptorChannels_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDescriptorSize() + // + + //javadoc: AKAZE::getDescriptorSize() + public int getDescriptorSize() + { + + int retVal = getDescriptorSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDescriptorType() + // + + //javadoc: AKAZE::getDescriptorType() + public int getDescriptorType() + { + + int retVal = getDescriptorType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDiffusivity() + // + + //javadoc: AKAZE::getDiffusivity() + public int getDiffusivity() + { + + int retVal = getDiffusivity_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNOctaveLayers() + // + + //javadoc: AKAZE::getNOctaveLayers() + public int getNOctaveLayers() + { + + int retVal = getNOctaveLayers_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNOctaves() + // + + //javadoc: AKAZE::getNOctaves() + public int getNOctaves() + { + + int retVal = getNOctaves_0(nativeObj); + + return retVal; + } + + + // + // C++: void setDescriptorChannels(int dch) + // + + //javadoc: AKAZE::setDescriptorChannels(dch) + public void setDescriptorChannels(int dch) + { + + setDescriptorChannels_0(nativeObj, dch); + + return; + } + + + // + // C++: void setDescriptorSize(int dsize) + // + + //javadoc: AKAZE::setDescriptorSize(dsize) + public void setDescriptorSize(int dsize) + { + + setDescriptorSize_0(nativeObj, dsize); + + return; + } + + + // + // C++: void setDescriptorType(int dtype) + // + + //javadoc: AKAZE::setDescriptorType(dtype) + public void setDescriptorType(int dtype) + { + + setDescriptorType_0(nativeObj, dtype); + + return; + } + + + // + // C++: void setDiffusivity(int diff) + // + + //javadoc: AKAZE::setDiffusivity(diff) + public void setDiffusivity(int diff) + { + + setDiffusivity_0(nativeObj, diff); + + return; + } + + + // + // C++: void setNOctaveLayers(int octaveLayers) + // + + //javadoc: AKAZE::setNOctaveLayers(octaveLayers) + public void setNOctaveLayers(int octaveLayers) + { + + setNOctaveLayers_0(nativeObj, octaveLayers); + + return; + } + + + // + // C++: void setNOctaves(int octaves) + // + + //javadoc: AKAZE::setNOctaves(octaves) + public void setNOctaves(int octaves) + { + + setNOctaves_0(nativeObj, octaves); + + return; + } + + + // + // C++: void setThreshold(double threshold) + // + + //javadoc: AKAZE::setThreshold(threshold) + public void setThreshold(double threshold) + { + + setThreshold_0(nativeObj, threshold); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_AKAZE create(int descriptor_type = AKAZE::DESCRIPTOR_MLDB, int descriptor_size = 0, int descriptor_channels = 3, float threshold = 0.001f, int nOctaves = 4, int nOctaveLayers = 4, int diffusivity = KAZE::DIFF_PM_G2) + private static native long create_0(int descriptor_type, int descriptor_size, int descriptor_channels, float threshold, int nOctaves, int nOctaveLayers, int diffusivity); + private static native long create_1(); + + // C++: double getThreshold() + private static native double getThreshold_0(long nativeObj); + + // C++: int getDescriptorChannels() + private static native int getDescriptorChannels_0(long nativeObj); + + // C++: int getDescriptorSize() + private static native int getDescriptorSize_0(long nativeObj); + + // C++: int getDescriptorType() + private static native int getDescriptorType_0(long nativeObj); + + // C++: int getDiffusivity() + private static native int getDiffusivity_0(long nativeObj); + + // C++: int getNOctaveLayers() + private static native int getNOctaveLayers_0(long nativeObj); + + // C++: int getNOctaves() + private static native int getNOctaves_0(long nativeObj); + + // C++: void setDescriptorChannels(int dch) + private static native void setDescriptorChannels_0(long nativeObj, int dch); + + // C++: void setDescriptorSize(int dsize) + private static native void setDescriptorSize_0(long nativeObj, int dsize); + + // C++: void setDescriptorType(int dtype) + private static native void setDescriptorType_0(long nativeObj, int dtype); + + // C++: void setDiffusivity(int diff) + private static native void setDiffusivity_0(long nativeObj, int diff); + + // C++: void setNOctaveLayers(int octaveLayers) + private static native void setNOctaveLayers_0(long nativeObj, int octaveLayers); + + // C++: void setNOctaves(int octaves) + private static native void setNOctaves_0(long nativeObj, int octaves); + + // C++: void setThreshold(double threshold) + private static native void setThreshold_0(long nativeObj, double threshold); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/AgastFeatureDetector.java b/openCVLibrary330/src/main/java/org/opencv/features2d/AgastFeatureDetector.java new file mode 100644 index 00000000000..a1907a09c88 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/AgastFeatureDetector.java @@ -0,0 +1,164 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class AgastFeatureDetector +//javadoc: AgastFeatureDetector +public class AgastFeatureDetector extends Feature2D { + + protected AgastFeatureDetector(long addr) { super(addr); } + + + public static final int + AGAST_5_8 = 0, + AGAST_7_12d = 1, + AGAST_7_12s = 2, + OAST_9_16 = 3, + THRESHOLD = 10000, + NONMAX_SUPPRESSION = 10001; + + + // + // C++: static Ptr_AgastFeatureDetector create(int threshold = 10, bool nonmaxSuppression = true, int type = AgastFeatureDetector::OAST_9_16) + // + + //javadoc: AgastFeatureDetector::create(threshold, nonmaxSuppression, type) + public static AgastFeatureDetector create(int threshold, boolean nonmaxSuppression, int type) + { + + AgastFeatureDetector retVal = new AgastFeatureDetector(create_0(threshold, nonmaxSuppression, type)); + + return retVal; + } + + //javadoc: AgastFeatureDetector::create() + public static AgastFeatureDetector create() + { + + AgastFeatureDetector retVal = new AgastFeatureDetector(create_1()); + + return retVal; + } + + + // + // C++: bool getNonmaxSuppression() + // + + //javadoc: AgastFeatureDetector::getNonmaxSuppression() + public boolean getNonmaxSuppression() + { + + boolean retVal = getNonmaxSuppression_0(nativeObj); + + return retVal; + } + + + // + // C++: int getThreshold() + // + + //javadoc: AgastFeatureDetector::getThreshold() + public int getThreshold() + { + + int retVal = getThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getType() + // + + //javadoc: AgastFeatureDetector::getType() + public int getType() + { + + int retVal = getType_0(nativeObj); + + return retVal; + } + + + // + // C++: void setNonmaxSuppression(bool f) + // + + //javadoc: AgastFeatureDetector::setNonmaxSuppression(f) + public void setNonmaxSuppression(boolean f) + { + + setNonmaxSuppression_0(nativeObj, f); + + return; + } + + + // + // C++: void setThreshold(int threshold) + // + + //javadoc: AgastFeatureDetector::setThreshold(threshold) + public void setThreshold(int threshold) + { + + setThreshold_0(nativeObj, threshold); + + return; + } + + + // + // C++: void setType(int type) + // + + //javadoc: AgastFeatureDetector::setType(type) + public void setType(int type) + { + + setType_0(nativeObj, type); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_AgastFeatureDetector create(int threshold = 10, bool nonmaxSuppression = true, int type = AgastFeatureDetector::OAST_9_16) + private static native long create_0(int threshold, boolean nonmaxSuppression, int type); + private static native long create_1(); + + // C++: bool getNonmaxSuppression() + private static native boolean getNonmaxSuppression_0(long nativeObj); + + // C++: int getThreshold() + private static native int getThreshold_0(long nativeObj); + + // C++: int getType() + private static native int getType_0(long nativeObj); + + // C++: void setNonmaxSuppression(bool f) + private static native void setNonmaxSuppression_0(long nativeObj, boolean f); + + // C++: void setThreshold(int threshold) + private static native void setThreshold_0(long nativeObj, int threshold); + + // C++: void setType(int type) + private static native void setType_0(long nativeObj, int type); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/BFMatcher.java b/openCVLibrary330/src/main/java/org/opencv/features2d/BFMatcher.java new file mode 100644 index 00000000000..ff5a5db4140 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/BFMatcher.java @@ -0,0 +1,80 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class BFMatcher +//javadoc: BFMatcher +public class BFMatcher extends DescriptorMatcher { + + protected BFMatcher(long addr) { super(addr); } + + + // + // C++: BFMatcher(int normType = NORM_L2, bool crossCheck = false) + // + + //javadoc: BFMatcher::BFMatcher(normType, crossCheck) + public BFMatcher(int normType, boolean crossCheck) + { + + super( BFMatcher_0(normType, crossCheck) ); + + return; + } + + //javadoc: BFMatcher::BFMatcher() + public BFMatcher() + { + + super( BFMatcher_1() ); + + return; + } + + + // + // C++: static Ptr_BFMatcher create(int normType = NORM_L2, bool crossCheck = false) + // + + //javadoc: BFMatcher::create(normType, crossCheck) + public static BFMatcher create(int normType, boolean crossCheck) + { + + BFMatcher retVal = new BFMatcher(create_0(normType, crossCheck)); + + return retVal; + } + + //javadoc: BFMatcher::create() + public static BFMatcher create() + { + + BFMatcher retVal = new BFMatcher(create_1()); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: BFMatcher(int normType = NORM_L2, bool crossCheck = false) + private static native long BFMatcher_0(int normType, boolean crossCheck); + private static native long BFMatcher_1(); + + // C++: static Ptr_BFMatcher create(int normType = NORM_L2, bool crossCheck = false) + private static native long create_0(int normType, boolean crossCheck); + private static native long create_1(); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/BOWImgDescriptorExtractor.java b/openCVLibrary330/src/main/java/org/opencv/features2d/BOWImgDescriptorExtractor.java new file mode 100644 index 00000000000..69b9c930c23 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/BOWImgDescriptorExtractor.java @@ -0,0 +1,124 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfKeyPoint; +import org.opencv.utils.Converters; + +// C++: class BOWImgDescriptorExtractor +//javadoc: BOWImgDescriptorExtractor +public class BOWImgDescriptorExtractor { + + protected final long nativeObj; + protected BOWImgDescriptorExtractor(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: BOWImgDescriptorExtractor(Ptr_DescriptorExtractor dextractor, Ptr_DescriptorMatcher dmatcher) + // + + // Unknown type 'Ptr_DescriptorExtractor' (I), skipping the function + + + // + // C++: Mat getVocabulary() + // + + //javadoc: BOWImgDescriptorExtractor::getVocabulary() + public Mat getVocabulary() + { + + Mat retVal = new Mat(getVocabulary_0(nativeObj)); + + return retVal; + } + + + // + // C++: int descriptorSize() + // + + //javadoc: BOWImgDescriptorExtractor::descriptorSize() + public int descriptorSize() + { + + int retVal = descriptorSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int descriptorType() + // + + //javadoc: BOWImgDescriptorExtractor::descriptorType() + public int descriptorType() + { + + int retVal = descriptorType_0(nativeObj); + + return retVal; + } + + + // + // C++: void compute2(Mat image, vector_KeyPoint keypoints, Mat& imgDescriptor) + // + + //javadoc: BOWImgDescriptorExtractor::compute2(image, keypoints, imgDescriptor) + public void compute(Mat image, MatOfKeyPoint keypoints, Mat imgDescriptor) + { + Mat keypoints_mat = keypoints; + compute_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, imgDescriptor.nativeObj); + + return; + } + + + // + // C++: void setVocabulary(Mat vocabulary) + // + + //javadoc: BOWImgDescriptorExtractor::setVocabulary(vocabulary) + public void setVocabulary(Mat vocabulary) + { + + setVocabulary_0(nativeObj, vocabulary.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getVocabulary() + private static native long getVocabulary_0(long nativeObj); + + // C++: int descriptorSize() + private static native int descriptorSize_0(long nativeObj); + + // C++: int descriptorType() + private static native int descriptorType_0(long nativeObj); + + // C++: void compute2(Mat image, vector_KeyPoint keypoints, Mat& imgDescriptor) + private static native void compute_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long imgDescriptor_nativeObj); + + // C++: void setVocabulary(Mat vocabulary) + private static native void setVocabulary_0(long nativeObj, long vocabulary_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/BOWKMeansTrainer.java b/openCVLibrary330/src/main/java/org/opencv/features2d/BOWKMeansTrainer.java new file mode 100644 index 00000000000..fc91726d7d3 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/BOWKMeansTrainer.java @@ -0,0 +1,88 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; + +// C++: class BOWKMeansTrainer +//javadoc: BOWKMeansTrainer +public class BOWKMeansTrainer extends BOWTrainer { + + protected BOWKMeansTrainer(long addr) { super(addr); } + + + // + // C++: BOWKMeansTrainer(int clusterCount, TermCriteria termcrit = TermCriteria(), int attempts = 3, int flags = KMEANS_PP_CENTERS) + // + + //javadoc: BOWKMeansTrainer::BOWKMeansTrainer(clusterCount, termcrit, attempts, flags) + public BOWKMeansTrainer(int clusterCount, TermCriteria termcrit, int attempts, int flags) + { + + super( BOWKMeansTrainer_0(clusterCount, termcrit.type, termcrit.maxCount, termcrit.epsilon, attempts, flags) ); + + return; + } + + //javadoc: BOWKMeansTrainer::BOWKMeansTrainer(clusterCount) + public BOWKMeansTrainer(int clusterCount) + { + + super( BOWKMeansTrainer_1(clusterCount) ); + + return; + } + + + // + // C++: Mat cluster(Mat descriptors) + // + + //javadoc: BOWKMeansTrainer::cluster(descriptors) + public Mat cluster(Mat descriptors) + { + + Mat retVal = new Mat(cluster_0(nativeObj, descriptors.nativeObj)); + + return retVal; + } + + + // + // C++: Mat cluster() + // + + //javadoc: BOWKMeansTrainer::cluster() + public Mat cluster() + { + + Mat retVal = new Mat(cluster_1(nativeObj)); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: BOWKMeansTrainer(int clusterCount, TermCriteria termcrit = TermCriteria(), int attempts = 3, int flags = KMEANS_PP_CENTERS) + private static native long BOWKMeansTrainer_0(int clusterCount, int termcrit_type, int termcrit_maxCount, double termcrit_epsilon, int attempts, int flags); + private static native long BOWKMeansTrainer_1(int clusterCount); + + // C++: Mat cluster(Mat descriptors) + private static native long cluster_0(long nativeObj, long descriptors_nativeObj); + + // C++: Mat cluster() + private static native long cluster_1(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/BOWTrainer.java b/openCVLibrary330/src/main/java/org/opencv/features2d/BOWTrainer.java new file mode 100644 index 00000000000..8cc0efcc82a --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/BOWTrainer.java @@ -0,0 +1,133 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class BOWTrainer +//javadoc: BOWTrainer +public class BOWTrainer { + + protected final long nativeObj; + protected BOWTrainer(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: Mat cluster(Mat descriptors) + // + + //javadoc: BOWTrainer::cluster(descriptors) + public Mat cluster(Mat descriptors) + { + + Mat retVal = new Mat(cluster_0(nativeObj, descriptors.nativeObj)); + + return retVal; + } + + + // + // C++: Mat cluster() + // + + //javadoc: BOWTrainer::cluster() + public Mat cluster() + { + + Mat retVal = new Mat(cluster_1(nativeObj)); + + return retVal; + } + + + // + // C++: int descriptorsCount() + // + + //javadoc: BOWTrainer::descriptorsCount() + public int descriptorsCount() + { + + int retVal = descriptorsCount_0(nativeObj); + + return retVal; + } + + + // + // C++: vector_Mat getDescriptors() + // + + //javadoc: BOWTrainer::getDescriptors() + public List getDescriptors() + { + List retVal = new ArrayList(); + Mat retValMat = new Mat(getDescriptors_0(nativeObj)); + Converters.Mat_to_vector_Mat(retValMat, retVal); + return retVal; + } + + + // + // C++: void add(Mat descriptors) + // + + //javadoc: BOWTrainer::add(descriptors) + public void add(Mat descriptors) + { + + add_0(nativeObj, descriptors.nativeObj); + + return; + } + + + // + // C++: void clear() + // + + //javadoc: BOWTrainer::clear() + public void clear() + { + + clear_0(nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat cluster(Mat descriptors) + private static native long cluster_0(long nativeObj, long descriptors_nativeObj); + + // C++: Mat cluster() + private static native long cluster_1(long nativeObj); + + // C++: int descriptorsCount() + private static native int descriptorsCount_0(long nativeObj); + + // C++: vector_Mat getDescriptors() + private static native long getDescriptors_0(long nativeObj); + + // C++: void add(Mat descriptors) + private static native void add_0(long nativeObj, long descriptors_nativeObj); + + // C++: void clear() + private static native void clear_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/BRISK.java b/openCVLibrary330/src/main/java/org/opencv/features2d/BRISK.java new file mode 100644 index 00000000000..30d090f674d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/BRISK.java @@ -0,0 +1,88 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfFloat; +import org.opencv.core.MatOfInt; +import org.opencv.utils.Converters; + +// C++: class BRISK +//javadoc: BRISK +public class BRISK extends Feature2D { + + protected BRISK(long addr) { super(addr); } + + + // + // C++: static Ptr_BRISK create(int thresh = 30, int octaves = 3, float patternScale = 1.0f) + // + + //javadoc: BRISK::create(thresh, octaves, patternScale) + public static BRISK create(int thresh, int octaves, float patternScale) + { + + BRISK retVal = new BRISK(create_0(thresh, octaves, patternScale)); + + return retVal; + } + + //javadoc: BRISK::create() + public static BRISK create() + { + + BRISK retVal = new BRISK(create_1()); + + return retVal; + } + + + // + // C++: static Ptr_BRISK create(vector_float radiusList, vector_int numberList, float dMax = 5.85f, float dMin = 8.2f, vector_int indexChange = std::vector()) + // + + //javadoc: BRISK::create(radiusList, numberList, dMax, dMin, indexChange) + public static BRISK create(MatOfFloat radiusList, MatOfInt numberList, float dMax, float dMin, MatOfInt indexChange) + { + Mat radiusList_mat = radiusList; + Mat numberList_mat = numberList; + Mat indexChange_mat = indexChange; + BRISK retVal = new BRISK(create_2(radiusList_mat.nativeObj, numberList_mat.nativeObj, dMax, dMin, indexChange_mat.nativeObj)); + + return retVal; + } + + //javadoc: BRISK::create(radiusList, numberList) + public static BRISK create(MatOfFloat radiusList, MatOfInt numberList) + { + Mat radiusList_mat = radiusList; + Mat numberList_mat = numberList; + BRISK retVal = new BRISK(create_3(radiusList_mat.nativeObj, numberList_mat.nativeObj)); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_BRISK create(int thresh = 30, int octaves = 3, float patternScale = 1.0f) + private static native long create_0(int thresh, int octaves, float patternScale); + private static native long create_1(); + + // C++: static Ptr_BRISK create(vector_float radiusList, vector_int numberList, float dMax = 5.85f, float dMin = 8.2f, vector_int indexChange = std::vector()) + private static native long create_2(long radiusList_mat_nativeObj, long numberList_mat_nativeObj, float dMax, float dMin, long indexChange_mat_nativeObj); + private static native long create_3(long radiusList_mat_nativeObj, long numberList_mat_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/DescriptorExtractor.java b/openCVLibrary330/src/main/java/org/opencv/features2d/DescriptorExtractor.java new file mode 100644 index 00000000000..a5d80b21a3e --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/DescriptorExtractor.java @@ -0,0 +1,196 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfKeyPoint; +import org.opencv.utils.Converters; + +// C++: class javaDescriptorExtractor +//javadoc: javaDescriptorExtractor +public class DescriptorExtractor { + + protected final long nativeObj; + protected DescriptorExtractor(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + private static final int + OPPONENTEXTRACTOR = 1000; + + + public static final int + SIFT = 1, + SURF = 2, + ORB = 3, + BRIEF = 4, + BRISK = 5, + FREAK = 6, + AKAZE = 7, + OPPONENT_SIFT = OPPONENTEXTRACTOR + SIFT, + OPPONENT_SURF = OPPONENTEXTRACTOR + SURF, + OPPONENT_ORB = OPPONENTEXTRACTOR + ORB, + OPPONENT_BRIEF = OPPONENTEXTRACTOR + BRIEF, + OPPONENT_BRISK = OPPONENTEXTRACTOR + BRISK, + OPPONENT_FREAK = OPPONENTEXTRACTOR + FREAK, + OPPONENT_AKAZE = OPPONENTEXTRACTOR + AKAZE; + + + // + // C++: static Ptr_javaDescriptorExtractor create(int extractorType) + // + + //javadoc: javaDescriptorExtractor::create(extractorType) + public static DescriptorExtractor create(int extractorType) + { + + DescriptorExtractor retVal = new DescriptorExtractor(create_0(extractorType)); + + return retVal; + } + + + // + // C++: bool empty() + // + + //javadoc: javaDescriptorExtractor::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: int descriptorSize() + // + + //javadoc: javaDescriptorExtractor::descriptorSize() + public int descriptorSize() + { + + int retVal = descriptorSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int descriptorType() + // + + //javadoc: javaDescriptorExtractor::descriptorType() + public int descriptorType() + { + + int retVal = descriptorType_0(nativeObj); + + return retVal; + } + + + // + // C++: void compute(Mat image, vector_KeyPoint& keypoints, Mat descriptors) + // + + //javadoc: javaDescriptorExtractor::compute(image, keypoints, descriptors) + public void compute(Mat image, MatOfKeyPoint keypoints, Mat descriptors) + { + Mat keypoints_mat = keypoints; + compute_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, descriptors.nativeObj); + + return; + } + + + // + // C++: void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors) + // + + //javadoc: javaDescriptorExtractor::compute(images, keypoints, descriptors) + public void compute(List images, List keypoints, List descriptors) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + List keypoints_tmplm = new ArrayList((keypoints != null) ? keypoints.size() : 0); + Mat keypoints_mat = Converters.vector_vector_KeyPoint_to_Mat(keypoints, keypoints_tmplm); + Mat descriptors_mat = new Mat(); + compute_1(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj, descriptors_mat.nativeObj); + Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints); + keypoints_mat.release(); + Converters.Mat_to_vector_Mat(descriptors_mat, descriptors); + descriptors_mat.release(); + return; + } + + + // + // C++: void read(String fileName) + // + + //javadoc: javaDescriptorExtractor::read(fileName) + public void read(String fileName) + { + + read_0(nativeObj, fileName); + + return; + } + + + // + // C++: void write(String fileName) + // + + //javadoc: javaDescriptorExtractor::write(fileName) + public void write(String fileName) + { + + write_0(nativeObj, fileName); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_javaDescriptorExtractor create(int extractorType) + private static native long create_0(int extractorType); + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: int descriptorSize() + private static native int descriptorSize_0(long nativeObj); + + // C++: int descriptorType() + private static native int descriptorType_0(long nativeObj); + + // C++: void compute(Mat image, vector_KeyPoint& keypoints, Mat descriptors) + private static native void compute_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long descriptors_nativeObj); + + // C++: void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors) + private static native void compute_1(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj, long descriptors_mat_nativeObj); + + // C++: void read(String fileName) + private static native void read_0(long nativeObj, String fileName); + + // C++: void write(String fileName) + private static native void write_0(long nativeObj, String fileName); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/DescriptorMatcher.java b/openCVLibrary330/src/main/java/org/opencv/features2d/DescriptorMatcher.java new file mode 100644 index 00000000000..848ec073be4 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/DescriptorMatcher.java @@ -0,0 +1,411 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.core.MatOfDMatch; +import org.opencv.utils.Converters; + +// C++: class DescriptorMatcher +//javadoc: DescriptorMatcher +public class DescriptorMatcher extends Algorithm { + + protected DescriptorMatcher(long addr) { super(addr); } + + + public static final int + FLANNBASED = 1, + BRUTEFORCE = 2, + BRUTEFORCE_L1 = 3, + BRUTEFORCE_HAMMING = 4, + BRUTEFORCE_HAMMINGLUT = 5, + BRUTEFORCE_SL2 = 6; + + + // + // C++: Ptr_DescriptorMatcher clone(bool emptyTrainData = false) + // + + //javadoc: DescriptorMatcher::clone(emptyTrainData) + public DescriptorMatcher clone(boolean emptyTrainData) + { + + DescriptorMatcher retVal = new DescriptorMatcher(clone_0(nativeObj, emptyTrainData)); + + return retVal; + } + + //javadoc: DescriptorMatcher::clone() + public DescriptorMatcher clone() + { + + DescriptorMatcher retVal = new DescriptorMatcher(clone_1(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_DescriptorMatcher create(String descriptorMatcherType) + // + + //javadoc: DescriptorMatcher::create(descriptorMatcherType) + public static DescriptorMatcher create(String descriptorMatcherType) + { + + DescriptorMatcher retVal = new DescriptorMatcher(create_0(descriptorMatcherType)); + + return retVal; + } + + + // + // C++: static Ptr_DescriptorMatcher create(int matcherType) + // + + //javadoc: DescriptorMatcher::create(matcherType) + public static DescriptorMatcher create(int matcherType) + { + + DescriptorMatcher retVal = new DescriptorMatcher(create_1(matcherType)); + + return retVal; + } + + + // + // C++: bool empty() + // + + //javadoc: DescriptorMatcher::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isMaskSupported() + // + + //javadoc: DescriptorMatcher::isMaskSupported() + public boolean isMaskSupported() + { + + boolean retVal = isMaskSupported_0(nativeObj); + + return retVal; + } + + + // + // C++: vector_Mat getTrainDescriptors() + // + + //javadoc: DescriptorMatcher::getTrainDescriptors() + public List getTrainDescriptors() + { + List retVal = new ArrayList(); + Mat retValMat = new Mat(getTrainDescriptors_0(nativeObj)); + Converters.Mat_to_vector_Mat(retValMat, retVal); + return retVal; + } + + + // + // C++: void add(vector_Mat descriptors) + // + + //javadoc: DescriptorMatcher::add(descriptors) + public void add(List descriptors) + { + Mat descriptors_mat = Converters.vector_Mat_to_Mat(descriptors); + add_0(nativeObj, descriptors_mat.nativeObj); + + return; + } + + + // + // C++: void clear() + // + + //javadoc: DescriptorMatcher::clear() + public void clear() + { + + clear_0(nativeObj); + + return; + } + + + // + // C++: void knnMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, int k, Mat mask = Mat(), bool compactResult = false) + // + + //javadoc: DescriptorMatcher::knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult) + public void knnMatch(Mat queryDescriptors, Mat trainDescriptors, List matches, int k, Mat mask, boolean compactResult) + { + Mat matches_mat = new Mat(); + knnMatch_0(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, k, mask.nativeObj, compactResult); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + //javadoc: DescriptorMatcher::knnMatch(queryDescriptors, trainDescriptors, matches, k) + public void knnMatch(Mat queryDescriptors, Mat trainDescriptors, List matches, int k) + { + Mat matches_mat = new Mat(); + knnMatch_1(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, k); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + + // + // C++: void knnMatch(Mat queryDescriptors, vector_vector_DMatch& matches, int k, vector_Mat masks = vector_Mat(), bool compactResult = false) + // + + //javadoc: DescriptorMatcher::knnMatch(queryDescriptors, matches, k, masks, compactResult) + public void knnMatch(Mat queryDescriptors, List matches, int k, List masks, boolean compactResult) + { + Mat matches_mat = new Mat(); + Mat masks_mat = Converters.vector_Mat_to_Mat(masks); + knnMatch_2(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, k, masks_mat.nativeObj, compactResult); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + //javadoc: DescriptorMatcher::knnMatch(queryDescriptors, matches, k) + public void knnMatch(Mat queryDescriptors, List matches, int k) + { + Mat matches_mat = new Mat(); + knnMatch_3(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, k); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + + // + // C++: void match(Mat queryDescriptors, Mat trainDescriptors, vector_DMatch& matches, Mat mask = Mat()) + // + + //javadoc: DescriptorMatcher::match(queryDescriptors, trainDescriptors, matches, mask) + public void match(Mat queryDescriptors, Mat trainDescriptors, MatOfDMatch matches, Mat mask) + { + Mat matches_mat = matches; + match_0(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: DescriptorMatcher::match(queryDescriptors, trainDescriptors, matches) + public void match(Mat queryDescriptors, Mat trainDescriptors, MatOfDMatch matches) + { + Mat matches_mat = matches; + match_1(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj); + + return; + } + + + // + // C++: void match(Mat queryDescriptors, vector_DMatch& matches, vector_Mat masks = vector_Mat()) + // + + //javadoc: DescriptorMatcher::match(queryDescriptors, matches, masks) + public void match(Mat queryDescriptors, MatOfDMatch matches, List masks) + { + Mat matches_mat = matches; + Mat masks_mat = Converters.vector_Mat_to_Mat(masks); + match_2(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, masks_mat.nativeObj); + + return; + } + + //javadoc: DescriptorMatcher::match(queryDescriptors, matches) + public void match(Mat queryDescriptors, MatOfDMatch matches) + { + Mat matches_mat = matches; + match_3(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj); + + return; + } + + + // + // C++: void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, float maxDistance, Mat mask = Mat(), bool compactResult = false) + // + + //javadoc: DescriptorMatcher::radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult) + public void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, List matches, float maxDistance, Mat mask, boolean compactResult) + { + Mat matches_mat = new Mat(); + radiusMatch_0(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, maxDistance, mask.nativeObj, compactResult); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + //javadoc: DescriptorMatcher::radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance) + public void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, List matches, float maxDistance) + { + Mat matches_mat = new Mat(); + radiusMatch_1(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, maxDistance); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + + // + // C++: void radiusMatch(Mat queryDescriptors, vector_vector_DMatch& matches, float maxDistance, vector_Mat masks = vector_Mat(), bool compactResult = false) + // + + //javadoc: DescriptorMatcher::radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult) + public void radiusMatch(Mat queryDescriptors, List matches, float maxDistance, List masks, boolean compactResult) + { + Mat matches_mat = new Mat(); + Mat masks_mat = Converters.vector_Mat_to_Mat(masks); + radiusMatch_2(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, maxDistance, masks_mat.nativeObj, compactResult); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + //javadoc: DescriptorMatcher::radiusMatch(queryDescriptors, matches, maxDistance) + public void radiusMatch(Mat queryDescriptors, List matches, float maxDistance) + { + Mat matches_mat = new Mat(); + radiusMatch_3(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, maxDistance); + Converters.Mat_to_vector_vector_DMatch(matches_mat, matches); + matches_mat.release(); + return; + } + + + // + // C++: void read(String fileName) + // + + //javadoc: DescriptorMatcher::read(fileName) + public void read(String fileName) + { + + read_0(nativeObj, fileName); + + return; + } + + + // + // C++: void train() + // + + //javadoc: DescriptorMatcher::train() + public void train() + { + + train_0(nativeObj); + + return; + } + + + // + // C++: void write(String fileName) + // + + //javadoc: DescriptorMatcher::write(fileName) + public void write(String fileName) + { + + write_0(nativeObj, fileName); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Ptr_DescriptorMatcher clone(bool emptyTrainData = false) + private static native long clone_0(long nativeObj, boolean emptyTrainData); + private static native long clone_1(long nativeObj); + + // C++: static Ptr_DescriptorMatcher create(String descriptorMatcherType) + private static native long create_0(String descriptorMatcherType); + + // C++: static Ptr_DescriptorMatcher create(int matcherType) + private static native long create_1(int matcherType); + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: bool isMaskSupported() + private static native boolean isMaskSupported_0(long nativeObj); + + // C++: vector_Mat getTrainDescriptors() + private static native long getTrainDescriptors_0(long nativeObj); + + // C++: void add(vector_Mat descriptors) + private static native void add_0(long nativeObj, long descriptors_mat_nativeObj); + + // C++: void clear() + private static native void clear_0(long nativeObj); + + // C++: void knnMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, int k, Mat mask = Mat(), bool compactResult = false) + private static native void knnMatch_0(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, int k, long mask_nativeObj, boolean compactResult); + private static native void knnMatch_1(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, int k); + + // C++: void knnMatch(Mat queryDescriptors, vector_vector_DMatch& matches, int k, vector_Mat masks = vector_Mat(), bool compactResult = false) + private static native void knnMatch_2(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, int k, long masks_mat_nativeObj, boolean compactResult); + private static native void knnMatch_3(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, int k); + + // C++: void match(Mat queryDescriptors, Mat trainDescriptors, vector_DMatch& matches, Mat mask = Mat()) + private static native void match_0(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, long mask_nativeObj); + private static native void match_1(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj); + + // C++: void match(Mat queryDescriptors, vector_DMatch& matches, vector_Mat masks = vector_Mat()) + private static native void match_2(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, long masks_mat_nativeObj); + private static native void match_3(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj); + + // C++: void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, float maxDistance, Mat mask = Mat(), bool compactResult = false) + private static native void radiusMatch_0(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance, long mask_nativeObj, boolean compactResult); + private static native void radiusMatch_1(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance); + + // C++: void radiusMatch(Mat queryDescriptors, vector_vector_DMatch& matches, float maxDistance, vector_Mat masks = vector_Mat(), bool compactResult = false) + private static native void radiusMatch_2(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance, long masks_mat_nativeObj, boolean compactResult); + private static native void radiusMatch_3(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance); + + // C++: void read(String fileName) + private static native void read_0(long nativeObj, String fileName); + + // C++: void train() + private static native void train_0(long nativeObj); + + // C++: void write(String fileName) + private static native void write_0(long nativeObj, String fileName); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/FastFeatureDetector.java b/openCVLibrary330/src/main/java/org/opencv/features2d/FastFeatureDetector.java new file mode 100644 index 00000000000..728293d6e45 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/FastFeatureDetector.java @@ -0,0 +1,164 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class FastFeatureDetector +//javadoc: FastFeatureDetector +public class FastFeatureDetector extends Feature2D { + + protected FastFeatureDetector(long addr) { super(addr); } + + + public static final int + TYPE_5_8 = 0, + TYPE_7_12 = 1, + TYPE_9_16 = 2, + THRESHOLD = 10000, + NONMAX_SUPPRESSION = 10001, + FAST_N = 10002; + + + // + // C++: static Ptr_FastFeatureDetector create(int threshold = 10, bool nonmaxSuppression = true, int type = FastFeatureDetector::TYPE_9_16) + // + + //javadoc: FastFeatureDetector::create(threshold, nonmaxSuppression, type) + public static FastFeatureDetector create(int threshold, boolean nonmaxSuppression, int type) + { + + FastFeatureDetector retVal = new FastFeatureDetector(create_0(threshold, nonmaxSuppression, type)); + + return retVal; + } + + //javadoc: FastFeatureDetector::create() + public static FastFeatureDetector create() + { + + FastFeatureDetector retVal = new FastFeatureDetector(create_1()); + + return retVal; + } + + + // + // C++: bool getNonmaxSuppression() + // + + //javadoc: FastFeatureDetector::getNonmaxSuppression() + public boolean getNonmaxSuppression() + { + + boolean retVal = getNonmaxSuppression_0(nativeObj); + + return retVal; + } + + + // + // C++: int getThreshold() + // + + //javadoc: FastFeatureDetector::getThreshold() + public int getThreshold() + { + + int retVal = getThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getType() + // + + //javadoc: FastFeatureDetector::getType() + public int getType() + { + + int retVal = getType_0(nativeObj); + + return retVal; + } + + + // + // C++: void setNonmaxSuppression(bool f) + // + + //javadoc: FastFeatureDetector::setNonmaxSuppression(f) + public void setNonmaxSuppression(boolean f) + { + + setNonmaxSuppression_0(nativeObj, f); + + return; + } + + + // + // C++: void setThreshold(int threshold) + // + + //javadoc: FastFeatureDetector::setThreshold(threshold) + public void setThreshold(int threshold) + { + + setThreshold_0(nativeObj, threshold); + + return; + } + + + // + // C++: void setType(int type) + // + + //javadoc: FastFeatureDetector::setType(type) + public void setType(int type) + { + + setType_0(nativeObj, type); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_FastFeatureDetector create(int threshold = 10, bool nonmaxSuppression = true, int type = FastFeatureDetector::TYPE_9_16) + private static native long create_0(int threshold, boolean nonmaxSuppression, int type); + private static native long create_1(); + + // C++: bool getNonmaxSuppression() + private static native boolean getNonmaxSuppression_0(long nativeObj); + + // C++: int getThreshold() + private static native int getThreshold_0(long nativeObj); + + // C++: int getType() + private static native int getType_0(long nativeObj); + + // C++: void setNonmaxSuppression(bool f) + private static native void setNonmaxSuppression_0(long nativeObj, boolean f); + + // C++: void setThreshold(int threshold) + private static native void setThreshold_0(long nativeObj, int threshold); + + // C++: void setType(int type) + private static native void setType_0(long nativeObj, int type); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/Feature2D.java b/openCVLibrary330/src/main/java/org/opencv/features2d/Feature2D.java new file mode 100644 index 00000000000..ad2e05c857e --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/Feature2D.java @@ -0,0 +1,260 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.core.MatOfKeyPoint; +import org.opencv.utils.Converters; + +// C++: class Feature2D +//javadoc: Feature2D +public class Feature2D extends Algorithm { + + protected Feature2D(long addr) { super(addr); } + + + // + // C++: bool empty() + // + + //javadoc: Feature2D::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: int defaultNorm() + // + + //javadoc: Feature2D::defaultNorm() + public int defaultNorm() + { + + int retVal = defaultNorm_0(nativeObj); + + return retVal; + } + + + // + // C++: int descriptorSize() + // + + //javadoc: Feature2D::descriptorSize() + public int descriptorSize() + { + + int retVal = descriptorSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int descriptorType() + // + + //javadoc: Feature2D::descriptorType() + public int descriptorType() + { + + int retVal = descriptorType_0(nativeObj); + + return retVal; + } + + + // + // C++: void compute(Mat image, vector_KeyPoint& keypoints, Mat& descriptors) + // + + //javadoc: Feature2D::compute(image, keypoints, descriptors) + public void compute(Mat image, MatOfKeyPoint keypoints, Mat descriptors) + { + Mat keypoints_mat = keypoints; + compute_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, descriptors.nativeObj); + + return; + } + + + // + // C++: void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors) + // + + //javadoc: Feature2D::compute(images, keypoints, descriptors) + public void compute(List images, List keypoints, List descriptors) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + List keypoints_tmplm = new ArrayList((keypoints != null) ? keypoints.size() : 0); + Mat keypoints_mat = Converters.vector_vector_KeyPoint_to_Mat(keypoints, keypoints_tmplm); + Mat descriptors_mat = new Mat(); + compute_1(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj, descriptors_mat.nativeObj); + Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints); + keypoints_mat.release(); + Converters.Mat_to_vector_Mat(descriptors_mat, descriptors); + descriptors_mat.release(); + return; + } + + + // + // C++: void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat()) + // + + //javadoc: Feature2D::detect(image, keypoints, mask) + public void detect(Mat image, MatOfKeyPoint keypoints, Mat mask) + { + Mat keypoints_mat = keypoints; + detect_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: Feature2D::detect(image, keypoints) + public void detect(Mat image, MatOfKeyPoint keypoints) + { + Mat keypoints_mat = keypoints; + detect_1(nativeObj, image.nativeObj, keypoints_mat.nativeObj); + + return; + } + + + // + // C++: void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = vector_Mat()) + // + + //javadoc: Feature2D::detect(images, keypoints, masks) + public void detect(List images, List keypoints, List masks) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat keypoints_mat = new Mat(); + Mat masks_mat = Converters.vector_Mat_to_Mat(masks); + detect_2(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj, masks_mat.nativeObj); + Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints); + keypoints_mat.release(); + return; + } + + //javadoc: Feature2D::detect(images, keypoints) + public void detect(List images, List keypoints) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat keypoints_mat = new Mat(); + detect_3(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj); + Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints); + keypoints_mat.release(); + return; + } + + + // + // C++: void detectAndCompute(Mat image, Mat mask, vector_KeyPoint& keypoints, Mat& descriptors, bool useProvidedKeypoints = false) + // + + //javadoc: Feature2D::detectAndCompute(image, mask, keypoints, descriptors, useProvidedKeypoints) + public void detectAndCompute(Mat image, Mat mask, MatOfKeyPoint keypoints, Mat descriptors, boolean useProvidedKeypoints) + { + Mat keypoints_mat = keypoints; + detectAndCompute_0(nativeObj, image.nativeObj, mask.nativeObj, keypoints_mat.nativeObj, descriptors.nativeObj, useProvidedKeypoints); + + return; + } + + //javadoc: Feature2D::detectAndCompute(image, mask, keypoints, descriptors) + public void detectAndCompute(Mat image, Mat mask, MatOfKeyPoint keypoints, Mat descriptors) + { + Mat keypoints_mat = keypoints; + detectAndCompute_1(nativeObj, image.nativeObj, mask.nativeObj, keypoints_mat.nativeObj, descriptors.nativeObj); + + return; + } + + + // + // C++: void read(String fileName) + // + + //javadoc: Feature2D::read(fileName) + public void read(String fileName) + { + + read_0(nativeObj, fileName); + + return; + } + + + // + // C++: void write(String fileName) + // + + //javadoc: Feature2D::write(fileName) + public void write(String fileName) + { + + write_0(nativeObj, fileName); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: int defaultNorm() + private static native int defaultNorm_0(long nativeObj); + + // C++: int descriptorSize() + private static native int descriptorSize_0(long nativeObj); + + // C++: int descriptorType() + private static native int descriptorType_0(long nativeObj); + + // C++: void compute(Mat image, vector_KeyPoint& keypoints, Mat& descriptors) + private static native void compute_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long descriptors_nativeObj); + + // C++: void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors) + private static native void compute_1(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj, long descriptors_mat_nativeObj); + + // C++: void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat()) + private static native void detect_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long mask_nativeObj); + private static native void detect_1(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj); + + // C++: void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = vector_Mat()) + private static native void detect_2(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj, long masks_mat_nativeObj); + private static native void detect_3(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj); + + // C++: void detectAndCompute(Mat image, Mat mask, vector_KeyPoint& keypoints, Mat& descriptors, bool useProvidedKeypoints = false) + private static native void detectAndCompute_0(long nativeObj, long image_nativeObj, long mask_nativeObj, long keypoints_mat_nativeObj, long descriptors_nativeObj, boolean useProvidedKeypoints); + private static native void detectAndCompute_1(long nativeObj, long image_nativeObj, long mask_nativeObj, long keypoints_mat_nativeObj, long descriptors_nativeObj); + + // C++: void read(String fileName) + private static native void read_0(long nativeObj, String fileName); + + // C++: void write(String fileName) + private static native void write_0(long nativeObj, String fileName); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/FeatureDetector.java b/openCVLibrary330/src/main/java/org/opencv/features2d/FeatureDetector.java new file mode 100644 index 00000000000..c390459e331 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/FeatureDetector.java @@ -0,0 +1,217 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfKeyPoint; +import org.opencv.utils.Converters; + +// C++: class javaFeatureDetector +//javadoc: javaFeatureDetector +public class FeatureDetector { + + protected final long nativeObj; + protected FeatureDetector(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + private static final int + GRIDDETECTOR = 1000, + PYRAMIDDETECTOR = 2000, + DYNAMICDETECTOR = 3000; + + + public static final int + FAST = 1, + STAR = 2, + SIFT = 3, + SURF = 4, + ORB = 5, + MSER = 6, + GFTT = 7, + HARRIS = 8, + SIMPLEBLOB = 9, + DENSE = 10, + BRISK = 11, + AKAZE = 12, + GRID_FAST = GRIDDETECTOR + FAST, + GRID_STAR = GRIDDETECTOR + STAR, + GRID_SIFT = GRIDDETECTOR + SIFT, + GRID_SURF = GRIDDETECTOR + SURF, + GRID_ORB = GRIDDETECTOR + ORB, + GRID_MSER = GRIDDETECTOR + MSER, + GRID_GFTT = GRIDDETECTOR + GFTT, + GRID_HARRIS = GRIDDETECTOR + HARRIS, + GRID_SIMPLEBLOB = GRIDDETECTOR + SIMPLEBLOB, + GRID_DENSE = GRIDDETECTOR + DENSE, + GRID_BRISK = GRIDDETECTOR + BRISK, + GRID_AKAZE = GRIDDETECTOR + AKAZE, + PYRAMID_FAST = PYRAMIDDETECTOR + FAST, + PYRAMID_STAR = PYRAMIDDETECTOR + STAR, + PYRAMID_SIFT = PYRAMIDDETECTOR + SIFT, + PYRAMID_SURF = PYRAMIDDETECTOR + SURF, + PYRAMID_ORB = PYRAMIDDETECTOR + ORB, + PYRAMID_MSER = PYRAMIDDETECTOR + MSER, + PYRAMID_GFTT = PYRAMIDDETECTOR + GFTT, + PYRAMID_HARRIS = PYRAMIDDETECTOR + HARRIS, + PYRAMID_SIMPLEBLOB = PYRAMIDDETECTOR + SIMPLEBLOB, + PYRAMID_DENSE = PYRAMIDDETECTOR + DENSE, + PYRAMID_BRISK = PYRAMIDDETECTOR + BRISK, + PYRAMID_AKAZE = PYRAMIDDETECTOR + AKAZE, + DYNAMIC_FAST = DYNAMICDETECTOR + FAST, + DYNAMIC_STAR = DYNAMICDETECTOR + STAR, + DYNAMIC_SIFT = DYNAMICDETECTOR + SIFT, + DYNAMIC_SURF = DYNAMICDETECTOR + SURF, + DYNAMIC_ORB = DYNAMICDETECTOR + ORB, + DYNAMIC_MSER = DYNAMICDETECTOR + MSER, + DYNAMIC_GFTT = DYNAMICDETECTOR + GFTT, + DYNAMIC_HARRIS = DYNAMICDETECTOR + HARRIS, + DYNAMIC_SIMPLEBLOB = DYNAMICDETECTOR + SIMPLEBLOB, + DYNAMIC_DENSE = DYNAMICDETECTOR + DENSE, + DYNAMIC_BRISK = DYNAMICDETECTOR + BRISK, + DYNAMIC_AKAZE = DYNAMICDETECTOR + AKAZE; + + + // + // C++: static Ptr_javaFeatureDetector create(int detectorType) + // + + //javadoc: javaFeatureDetector::create(detectorType) + public static FeatureDetector create(int detectorType) + { + + FeatureDetector retVal = new FeatureDetector(create_0(detectorType)); + + return retVal; + } + + + // + // C++: bool empty() + // + + //javadoc: javaFeatureDetector::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat()) + // + + //javadoc: javaFeatureDetector::detect(image, keypoints, mask) + public void detect(Mat image, MatOfKeyPoint keypoints, Mat mask) + { + Mat keypoints_mat = keypoints; + detect_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: javaFeatureDetector::detect(image, keypoints) + public void detect(Mat image, MatOfKeyPoint keypoints) + { + Mat keypoints_mat = keypoints; + detect_1(nativeObj, image.nativeObj, keypoints_mat.nativeObj); + + return; + } + + + // + // C++: void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = std::vector()) + // + + //javadoc: javaFeatureDetector::detect(images, keypoints, masks) + public void detect(List images, List keypoints, List masks) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat keypoints_mat = new Mat(); + Mat masks_mat = Converters.vector_Mat_to_Mat(masks); + detect_2(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj, masks_mat.nativeObj); + Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints); + keypoints_mat.release(); + return; + } + + //javadoc: javaFeatureDetector::detect(images, keypoints) + public void detect(List images, List keypoints) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat keypoints_mat = new Mat(); + detect_3(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj); + Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints); + keypoints_mat.release(); + return; + } + + + // + // C++: void read(String fileName) + // + + //javadoc: javaFeatureDetector::read(fileName) + public void read(String fileName) + { + + read_0(nativeObj, fileName); + + return; + } + + + // + // C++: void write(String fileName) + // + + //javadoc: javaFeatureDetector::write(fileName) + public void write(String fileName) + { + + write_0(nativeObj, fileName); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_javaFeatureDetector create(int detectorType) + private static native long create_0(int detectorType); + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat()) + private static native void detect_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long mask_nativeObj); + private static native void detect_1(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj); + + // C++: void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = std::vector()) + private static native void detect_2(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj, long masks_mat_nativeObj); + private static native void detect_3(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj); + + // C++: void read(String fileName) + private static native void read_0(long nativeObj, String fileName); + + // C++: void write(String fileName) + private static native void write_0(long nativeObj, String fileName); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/Features2d.java b/openCVLibrary330/src/main/java/org/opencv/features2d/Features2d.java new file mode 100644 index 00000000000..d2a458d67ee --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/Features2d.java @@ -0,0 +1,155 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfByte; +import org.opencv.core.MatOfDMatch; +import org.opencv.core.MatOfKeyPoint; +import org.opencv.core.Scalar; +import org.opencv.utils.Converters; + +public class Features2d { + + public static final int + DRAW_OVER_OUTIMG = 1, + NOT_DRAW_SINGLE_POINTS = 2, + DRAW_RICH_KEYPOINTS = 4; + + + // + // C++: void drawKeypoints(Mat image, vector_KeyPoint keypoints, Mat& outImage, Scalar color = Scalar::all(-1), int flags = DrawMatchesFlags::DEFAULT) + // + + //javadoc: drawKeypoints(image, keypoints, outImage, color, flags) + public static void drawKeypoints(Mat image, MatOfKeyPoint keypoints, Mat outImage, Scalar color, int flags) + { + Mat keypoints_mat = keypoints; + drawKeypoints_0(image.nativeObj, keypoints_mat.nativeObj, outImage.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3], flags); + + return; + } + + //javadoc: drawKeypoints(image, keypoints, outImage) + public static void drawKeypoints(Mat image, MatOfKeyPoint keypoints, Mat outImage) + { + Mat keypoints_mat = keypoints; + drawKeypoints_1(image.nativeObj, keypoints_mat.nativeObj, outImage.nativeObj); + + return; + } + + + // + // C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_DMatch matches1to2, Mat& outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_char matchesMask = std::vector(), int flags = DrawMatchesFlags::DEFAULT) + // + + //javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, flags) + public static void drawMatches(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, MatOfDMatch matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, MatOfByte matchesMask, int flags) + { + Mat keypoints1_mat = keypoints1; + Mat keypoints2_mat = keypoints2; + Mat matches1to2_mat = matches1to2; + Mat matchesMask_mat = matchesMask; + drawMatches_0(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj, matchColor.val[0], matchColor.val[1], matchColor.val[2], matchColor.val[3], singlePointColor.val[0], singlePointColor.val[1], singlePointColor.val[2], singlePointColor.val[3], matchesMask_mat.nativeObj, flags); + + return; + } + + //javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg) + public static void drawMatches(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, MatOfDMatch matches1to2, Mat outImg) + { + Mat keypoints1_mat = keypoints1; + Mat keypoints2_mat = keypoints2; + Mat matches1to2_mat = matches1to2; + drawMatches_1(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj); + + return; + } + + + // + // C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector >(), int flags = 0) + // + + //javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, flags) + public static void drawMatches2(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, List matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, List matchesMask, int flags) + { + Mat keypoints1_mat = keypoints1; + Mat keypoints2_mat = keypoints2; + List matches1to2_tmplm = new ArrayList((matches1to2 != null) ? matches1to2.size() : 0); + Mat matches1to2_mat = Converters.vector_vector_DMatch_to_Mat(matches1to2, matches1to2_tmplm); + List matchesMask_tmplm = new ArrayList((matchesMask != null) ? matchesMask.size() : 0); + Mat matchesMask_mat = Converters.vector_vector_char_to_Mat(matchesMask, matchesMask_tmplm); + drawMatches2_0(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj, matchColor.val[0], matchColor.val[1], matchColor.val[2], matchColor.val[3], singlePointColor.val[0], singlePointColor.val[1], singlePointColor.val[2], singlePointColor.val[3], matchesMask_mat.nativeObj, flags); + + return; + } + + //javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg) + public static void drawMatches2(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, List matches1to2, Mat outImg) + { + Mat keypoints1_mat = keypoints1; + Mat keypoints2_mat = keypoints2; + List matches1to2_tmplm = new ArrayList((matches1to2 != null) ? matches1to2.size() : 0); + Mat matches1to2_mat = Converters.vector_vector_DMatch_to_Mat(matches1to2, matches1to2_tmplm); + drawMatches2_1(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj); + + return; + } + + + // + // C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat& outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector >(), int flags = DrawMatchesFlags::DEFAULT) + // + + //javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, flags) + public static void drawMatchesKnn(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, List matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, List matchesMask, int flags) + { + Mat keypoints1_mat = keypoints1; + Mat keypoints2_mat = keypoints2; + List matches1to2_tmplm = new ArrayList((matches1to2 != null) ? matches1to2.size() : 0); + Mat matches1to2_mat = Converters.vector_vector_DMatch_to_Mat(matches1to2, matches1to2_tmplm); + List matchesMask_tmplm = new ArrayList((matchesMask != null) ? matchesMask.size() : 0); + Mat matchesMask_mat = Converters.vector_vector_char_to_Mat(matchesMask, matchesMask_tmplm); + drawMatchesKnn_0(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj, matchColor.val[0], matchColor.val[1], matchColor.val[2], matchColor.val[3], singlePointColor.val[0], singlePointColor.val[1], singlePointColor.val[2], singlePointColor.val[3], matchesMask_mat.nativeObj, flags); + + return; + } + + //javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg) + public static void drawMatchesKnn(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, List matches1to2, Mat outImg) + { + Mat keypoints1_mat = keypoints1; + Mat keypoints2_mat = keypoints2; + List matches1to2_tmplm = new ArrayList((matches1to2 != null) ? matches1to2.size() : 0); + Mat matches1to2_mat = Converters.vector_vector_DMatch_to_Mat(matches1to2, matches1to2_tmplm); + drawMatchesKnn_1(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj); + + return; + } + + + + + // C++: void drawKeypoints(Mat image, vector_KeyPoint keypoints, Mat& outImage, Scalar color = Scalar::all(-1), int flags = DrawMatchesFlags::DEFAULT) + private static native void drawKeypoints_0(long image_nativeObj, long keypoints_mat_nativeObj, long outImage_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3, int flags); + private static native void drawKeypoints_1(long image_nativeObj, long keypoints_mat_nativeObj, long outImage_nativeObj); + + // C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_DMatch matches1to2, Mat& outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_char matchesMask = std::vector(), int flags = DrawMatchesFlags::DEFAULT) + private static native void drawMatches_0(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj, double matchColor_val0, double matchColor_val1, double matchColor_val2, double matchColor_val3, double singlePointColor_val0, double singlePointColor_val1, double singlePointColor_val2, double singlePointColor_val3, long matchesMask_mat_nativeObj, int flags); + private static native void drawMatches_1(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj); + + // C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector >(), int flags = 0) + private static native void drawMatches2_0(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj, double matchColor_val0, double matchColor_val1, double matchColor_val2, double matchColor_val3, double singlePointColor_val0, double singlePointColor_val1, double singlePointColor_val2, double singlePointColor_val3, long matchesMask_mat_nativeObj, int flags); + private static native void drawMatches2_1(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj); + + // C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat& outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector >(), int flags = DrawMatchesFlags::DEFAULT) + private static native void drawMatchesKnn_0(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj, double matchColor_val0, double matchColor_val1, double matchColor_val2, double matchColor_val3, double singlePointColor_val0, double singlePointColor_val1, double singlePointColor_val2, double singlePointColor_val3, long matchesMask_mat_nativeObj, int flags); + private static native void drawMatchesKnn_1(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/FlannBasedMatcher.java b/openCVLibrary330/src/main/java/org/opencv/features2d/FlannBasedMatcher.java new file mode 100644 index 00000000000..7a01864ded5 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/FlannBasedMatcher.java @@ -0,0 +1,60 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class FlannBasedMatcher +//javadoc: FlannBasedMatcher +public class FlannBasedMatcher extends DescriptorMatcher { + + protected FlannBasedMatcher(long addr) { super(addr); } + + + // + // C++: FlannBasedMatcher(Ptr_flann_IndexParams indexParams = makePtr(), Ptr_flann_SearchParams searchParams = makePtr()) + // + + //javadoc: FlannBasedMatcher::FlannBasedMatcher() + public FlannBasedMatcher() + { + + super( FlannBasedMatcher_0() ); + + return; + } + + + // + // C++: static Ptr_FlannBasedMatcher create() + // + + //javadoc: FlannBasedMatcher::create() + public static FlannBasedMatcher create() + { + + FlannBasedMatcher retVal = new FlannBasedMatcher(create_0()); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: FlannBasedMatcher(Ptr_flann_IndexParams indexParams = makePtr(), Ptr_flann_SearchParams searchParams = makePtr()) + private static native long FlannBasedMatcher_0(); + + // C++: static Ptr_FlannBasedMatcher create() + private static native long create_0(); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/GFTTDetector.java b/openCVLibrary330/src/main/java/org/opencv/features2d/GFTTDetector.java new file mode 100644 index 00000000000..785f7243df1 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/GFTTDetector.java @@ -0,0 +1,257 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class GFTTDetector +//javadoc: GFTTDetector +public class GFTTDetector extends Feature2D { + + protected GFTTDetector(long addr) { super(addr); } + + + // + // C++: static Ptr_GFTTDetector create(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 1, int blockSize = 3, bool useHarrisDetector = false, double k = 0.04) + // + + //javadoc: GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k) + public static GFTTDetector create(int maxCorners, double qualityLevel, double minDistance, int blockSize, boolean useHarrisDetector, double k) + { + + GFTTDetector retVal = new GFTTDetector(create_0(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k)); + + return retVal; + } + + //javadoc: GFTTDetector::create() + public static GFTTDetector create() + { + + GFTTDetector retVal = new GFTTDetector(create_1()); + + return retVal; + } + + + // + // C++: bool getHarrisDetector() + // + + //javadoc: GFTTDetector::getHarrisDetector() + public boolean getHarrisDetector() + { + + boolean retVal = getHarrisDetector_0(nativeObj); + + return retVal; + } + + + // + // C++: double getK() + // + + //javadoc: GFTTDetector::getK() + public double getK() + { + + double retVal = getK_0(nativeObj); + + return retVal; + } + + + // + // C++: double getMinDistance() + // + + //javadoc: GFTTDetector::getMinDistance() + public double getMinDistance() + { + + double retVal = getMinDistance_0(nativeObj); + + return retVal; + } + + + // + // C++: double getQualityLevel() + // + + //javadoc: GFTTDetector::getQualityLevel() + public double getQualityLevel() + { + + double retVal = getQualityLevel_0(nativeObj); + + return retVal; + } + + + // + // C++: int getBlockSize() + // + + //javadoc: GFTTDetector::getBlockSize() + public int getBlockSize() + { + + int retVal = getBlockSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxFeatures() + // + + //javadoc: GFTTDetector::getMaxFeatures() + public int getMaxFeatures() + { + + int retVal = getMaxFeatures_0(nativeObj); + + return retVal; + } + + + // + // C++: void setBlockSize(int blockSize) + // + + //javadoc: GFTTDetector::setBlockSize(blockSize) + public void setBlockSize(int blockSize) + { + + setBlockSize_0(nativeObj, blockSize); + + return; + } + + + // + // C++: void setHarrisDetector(bool val) + // + + //javadoc: GFTTDetector::setHarrisDetector(val) + public void setHarrisDetector(boolean val) + { + + setHarrisDetector_0(nativeObj, val); + + return; + } + + + // + // C++: void setK(double k) + // + + //javadoc: GFTTDetector::setK(k) + public void setK(double k) + { + + setK_0(nativeObj, k); + + return; + } + + + // + // C++: void setMaxFeatures(int maxFeatures) + // + + //javadoc: GFTTDetector::setMaxFeatures(maxFeatures) + public void setMaxFeatures(int maxFeatures) + { + + setMaxFeatures_0(nativeObj, maxFeatures); + + return; + } + + + // + // C++: void setMinDistance(double minDistance) + // + + //javadoc: GFTTDetector::setMinDistance(minDistance) + public void setMinDistance(double minDistance) + { + + setMinDistance_0(nativeObj, minDistance); + + return; + } + + + // + // C++: void setQualityLevel(double qlevel) + // + + //javadoc: GFTTDetector::setQualityLevel(qlevel) + public void setQualityLevel(double qlevel) + { + + setQualityLevel_0(nativeObj, qlevel); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_GFTTDetector create(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 1, int blockSize = 3, bool useHarrisDetector = false, double k = 0.04) + private static native long create_0(int maxCorners, double qualityLevel, double minDistance, int blockSize, boolean useHarrisDetector, double k); + private static native long create_1(); + + // C++: bool getHarrisDetector() + private static native boolean getHarrisDetector_0(long nativeObj); + + // C++: double getK() + private static native double getK_0(long nativeObj); + + // C++: double getMinDistance() + private static native double getMinDistance_0(long nativeObj); + + // C++: double getQualityLevel() + private static native double getQualityLevel_0(long nativeObj); + + // C++: int getBlockSize() + private static native int getBlockSize_0(long nativeObj); + + // C++: int getMaxFeatures() + private static native int getMaxFeatures_0(long nativeObj); + + // C++: void setBlockSize(int blockSize) + private static native void setBlockSize_0(long nativeObj, int blockSize); + + // C++: void setHarrisDetector(bool val) + private static native void setHarrisDetector_0(long nativeObj, boolean val); + + // C++: void setK(double k) + private static native void setK_0(long nativeObj, double k); + + // C++: void setMaxFeatures(int maxFeatures) + private static native void setMaxFeatures_0(long nativeObj, int maxFeatures); + + // C++: void setMinDistance(double minDistance) + private static native void setMinDistance_0(long nativeObj, double minDistance); + + // C++: void setQualityLevel(double qlevel) + private static native void setQualityLevel_0(long nativeObj, double qlevel); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/KAZE.java b/openCVLibrary330/src/main/java/org/opencv/features2d/KAZE.java new file mode 100644 index 00000000000..5482acea702 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/KAZE.java @@ -0,0 +1,264 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class KAZE +//javadoc: KAZE +public class KAZE extends Feature2D { + + protected KAZE(long addr) { super(addr); } + + + public static final int + DIFF_PM_G1 = 0, + DIFF_PM_G2 = 1, + DIFF_WEICKERT = 2, + DIFF_CHARBONNIER = 3; + + + // + // C++: static Ptr_KAZE create(bool extended = false, bool upright = false, float threshold = 0.001f, int nOctaves = 4, int nOctaveLayers = 4, int diffusivity = KAZE::DIFF_PM_G2) + // + + //javadoc: KAZE::create(extended, upright, threshold, nOctaves, nOctaveLayers, diffusivity) + public static KAZE create(boolean extended, boolean upright, float threshold, int nOctaves, int nOctaveLayers, int diffusivity) + { + + KAZE retVal = new KAZE(create_0(extended, upright, threshold, nOctaves, nOctaveLayers, diffusivity)); + + return retVal; + } + + //javadoc: KAZE::create() + public static KAZE create() + { + + KAZE retVal = new KAZE(create_1()); + + return retVal; + } + + + // + // C++: bool getExtended() + // + + //javadoc: KAZE::getExtended() + public boolean getExtended() + { + + boolean retVal = getExtended_0(nativeObj); + + return retVal; + } + + + // + // C++: bool getUpright() + // + + //javadoc: KAZE::getUpright() + public boolean getUpright() + { + + boolean retVal = getUpright_0(nativeObj); + + return retVal; + } + + + // + // C++: double getThreshold() + // + + //javadoc: KAZE::getThreshold() + public double getThreshold() + { + + double retVal = getThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDiffusivity() + // + + //javadoc: KAZE::getDiffusivity() + public int getDiffusivity() + { + + int retVal = getDiffusivity_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNOctaveLayers() + // + + //javadoc: KAZE::getNOctaveLayers() + public int getNOctaveLayers() + { + + int retVal = getNOctaveLayers_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNOctaves() + // + + //javadoc: KAZE::getNOctaves() + public int getNOctaves() + { + + int retVal = getNOctaves_0(nativeObj); + + return retVal; + } + + + // + // C++: void setDiffusivity(int diff) + // + + //javadoc: KAZE::setDiffusivity(diff) + public void setDiffusivity(int diff) + { + + setDiffusivity_0(nativeObj, diff); + + return; + } + + + // + // C++: void setExtended(bool extended) + // + + //javadoc: KAZE::setExtended(extended) + public void setExtended(boolean extended) + { + + setExtended_0(nativeObj, extended); + + return; + } + + + // + // C++: void setNOctaveLayers(int octaveLayers) + // + + //javadoc: KAZE::setNOctaveLayers(octaveLayers) + public void setNOctaveLayers(int octaveLayers) + { + + setNOctaveLayers_0(nativeObj, octaveLayers); + + return; + } + + + // + // C++: void setNOctaves(int octaves) + // + + //javadoc: KAZE::setNOctaves(octaves) + public void setNOctaves(int octaves) + { + + setNOctaves_0(nativeObj, octaves); + + return; + } + + + // + // C++: void setThreshold(double threshold) + // + + //javadoc: KAZE::setThreshold(threshold) + public void setThreshold(double threshold) + { + + setThreshold_0(nativeObj, threshold); + + return; + } + + + // + // C++: void setUpright(bool upright) + // + + //javadoc: KAZE::setUpright(upright) + public void setUpright(boolean upright) + { + + setUpright_0(nativeObj, upright); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_KAZE create(bool extended = false, bool upright = false, float threshold = 0.001f, int nOctaves = 4, int nOctaveLayers = 4, int diffusivity = KAZE::DIFF_PM_G2) + private static native long create_0(boolean extended, boolean upright, float threshold, int nOctaves, int nOctaveLayers, int diffusivity); + private static native long create_1(); + + // C++: bool getExtended() + private static native boolean getExtended_0(long nativeObj); + + // C++: bool getUpright() + private static native boolean getUpright_0(long nativeObj); + + // C++: double getThreshold() + private static native double getThreshold_0(long nativeObj); + + // C++: int getDiffusivity() + private static native int getDiffusivity_0(long nativeObj); + + // C++: int getNOctaveLayers() + private static native int getNOctaveLayers_0(long nativeObj); + + // C++: int getNOctaves() + private static native int getNOctaves_0(long nativeObj); + + // C++: void setDiffusivity(int diff) + private static native void setDiffusivity_0(long nativeObj, int diff); + + // C++: void setExtended(bool extended) + private static native void setExtended_0(long nativeObj, boolean extended); + + // C++: void setNOctaveLayers(int octaveLayers) + private static native void setNOctaveLayers_0(long nativeObj, int octaveLayers); + + // C++: void setNOctaves(int octaves) + private static native void setNOctaves_0(long nativeObj, int octaves); + + // C++: void setThreshold(double threshold) + private static native void setThreshold_0(long nativeObj, double threshold); + + // C++: void setUpright(bool upright) + private static native void setUpright_0(long nativeObj, boolean upright); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/MSER.java b/openCVLibrary330/src/main/java/org/opencv/features2d/MSER.java new file mode 100644 index 00000000000..850e13efc42 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/MSER.java @@ -0,0 +1,213 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfPoint; +import org.opencv.core.MatOfRect; +import org.opencv.utils.Converters; + +// C++: class MSER +//javadoc: MSER +public class MSER extends Feature2D { + + protected MSER(long addr) { super(addr); } + + + // + // C++: static Ptr_MSER create(int _delta = 5, int _min_area = 60, int _max_area = 14400, double _max_variation = 0.25, double _min_diversity = .2, int _max_evolution = 200, double _area_threshold = 1.01, double _min_margin = 0.003, int _edge_blur_size = 5) + // + + //javadoc: MSER::create(_delta, _min_area, _max_area, _max_variation, _min_diversity, _max_evolution, _area_threshold, _min_margin, _edge_blur_size) + public static MSER create(int _delta, int _min_area, int _max_area, double _max_variation, double _min_diversity, int _max_evolution, double _area_threshold, double _min_margin, int _edge_blur_size) + { + + MSER retVal = new MSER(create_0(_delta, _min_area, _max_area, _max_variation, _min_diversity, _max_evolution, _area_threshold, _min_margin, _edge_blur_size)); + + return retVal; + } + + //javadoc: MSER::create() + public static MSER create() + { + + MSER retVal = new MSER(create_1()); + + return retVal; + } + + + // + // C++: bool getPass2Only() + // + + //javadoc: MSER::getPass2Only() + public boolean getPass2Only() + { + + boolean retVal = getPass2Only_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDelta() + // + + //javadoc: MSER::getDelta() + public int getDelta() + { + + int retVal = getDelta_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxArea() + // + + //javadoc: MSER::getMaxArea() + public int getMaxArea() + { + + int retVal = getMaxArea_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMinArea() + // + + //javadoc: MSER::getMinArea() + public int getMinArea() + { + + int retVal = getMinArea_0(nativeObj); + + return retVal; + } + + + // + // C++: void detectRegions(Mat image, vector_vector_Point& msers, vector_Rect& bboxes) + // + + //javadoc: MSER::detectRegions(image, msers, bboxes) + public void detectRegions(Mat image, List msers, MatOfRect bboxes) + { + Mat msers_mat = new Mat(); + Mat bboxes_mat = bboxes; + detectRegions_0(nativeObj, image.nativeObj, msers_mat.nativeObj, bboxes_mat.nativeObj); + Converters.Mat_to_vector_vector_Point(msers_mat, msers); + msers_mat.release(); + return; + } + + + // + // C++: void setDelta(int delta) + // + + //javadoc: MSER::setDelta(delta) + public void setDelta(int delta) + { + + setDelta_0(nativeObj, delta); + + return; + } + + + // + // C++: void setMaxArea(int maxArea) + // + + //javadoc: MSER::setMaxArea(maxArea) + public void setMaxArea(int maxArea) + { + + setMaxArea_0(nativeObj, maxArea); + + return; + } + + + // + // C++: void setMinArea(int minArea) + // + + //javadoc: MSER::setMinArea(minArea) + public void setMinArea(int minArea) + { + + setMinArea_0(nativeObj, minArea); + + return; + } + + + // + // C++: void setPass2Only(bool f) + // + + //javadoc: MSER::setPass2Only(f) + public void setPass2Only(boolean f) + { + + setPass2Only_0(nativeObj, f); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_MSER create(int _delta = 5, int _min_area = 60, int _max_area = 14400, double _max_variation = 0.25, double _min_diversity = .2, int _max_evolution = 200, double _area_threshold = 1.01, double _min_margin = 0.003, int _edge_blur_size = 5) + private static native long create_0(int _delta, int _min_area, int _max_area, double _max_variation, double _min_diversity, int _max_evolution, double _area_threshold, double _min_margin, int _edge_blur_size); + private static native long create_1(); + + // C++: bool getPass2Only() + private static native boolean getPass2Only_0(long nativeObj); + + // C++: int getDelta() + private static native int getDelta_0(long nativeObj); + + // C++: int getMaxArea() + private static native int getMaxArea_0(long nativeObj); + + // C++: int getMinArea() + private static native int getMinArea_0(long nativeObj); + + // C++: void detectRegions(Mat image, vector_vector_Point& msers, vector_Rect& bboxes) + private static native void detectRegions_0(long nativeObj, long image_nativeObj, long msers_mat_nativeObj, long bboxes_mat_nativeObj); + + // C++: void setDelta(int delta) + private static native void setDelta_0(long nativeObj, int delta); + + // C++: void setMaxArea(int maxArea) + private static native void setMaxArea_0(long nativeObj, int maxArea); + + // C++: void setMinArea(int minArea) + private static native void setMinArea_0(long nativeObj, int minArea); + + // C++: void setPass2Only(bool f) + private static native void setPass2Only_0(long nativeObj, boolean f); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/ORB.java b/openCVLibrary330/src/main/java/org/opencv/features2d/ORB.java new file mode 100644 index 00000000000..8b10afa770d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/ORB.java @@ -0,0 +1,365 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class ORB +//javadoc: ORB +public class ORB extends Feature2D { + + protected ORB(long addr) { super(addr); } + + + public static final int + kBytes = 32, + HARRIS_SCORE = 0, + FAST_SCORE = 1; + + + // + // C++: static Ptr_ORB create(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31, int firstLevel = 0, int WTA_K = 2, int scoreType = ORB::HARRIS_SCORE, int patchSize = 31, int fastThreshold = 20) + // + + //javadoc: ORB::create(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold) + public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold) + { + + ORB retVal = new ORB(create_0(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold)); + + return retVal; + } + + //javadoc: ORB::create() + public static ORB create() + { + + ORB retVal = new ORB(create_1()); + + return retVal; + } + + + // + // C++: double getScaleFactor() + // + + //javadoc: ORB::getScaleFactor() + public double getScaleFactor() + { + + double retVal = getScaleFactor_0(nativeObj); + + return retVal; + } + + + // + // C++: int getEdgeThreshold() + // + + //javadoc: ORB::getEdgeThreshold() + public int getEdgeThreshold() + { + + int retVal = getEdgeThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getFastThreshold() + // + + //javadoc: ORB::getFastThreshold() + public int getFastThreshold() + { + + int retVal = getFastThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getFirstLevel() + // + + //javadoc: ORB::getFirstLevel() + public int getFirstLevel() + { + + int retVal = getFirstLevel_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxFeatures() + // + + //javadoc: ORB::getMaxFeatures() + public int getMaxFeatures() + { + + int retVal = getMaxFeatures_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNLevels() + // + + //javadoc: ORB::getNLevels() + public int getNLevels() + { + + int retVal = getNLevels_0(nativeObj); + + return retVal; + } + + + // + // C++: int getPatchSize() + // + + //javadoc: ORB::getPatchSize() + public int getPatchSize() + { + + int retVal = getPatchSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getScoreType() + // + + //javadoc: ORB::getScoreType() + public int getScoreType() + { + + int retVal = getScoreType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getWTA_K() + // + + //javadoc: ORB::getWTA_K() + public int getWTA_K() + { + + int retVal = getWTA_K_0(nativeObj); + + return retVal; + } + + + // + // C++: void setEdgeThreshold(int edgeThreshold) + // + + //javadoc: ORB::setEdgeThreshold(edgeThreshold) + public void setEdgeThreshold(int edgeThreshold) + { + + setEdgeThreshold_0(nativeObj, edgeThreshold); + + return; + } + + + // + // C++: void setFastThreshold(int fastThreshold) + // + + //javadoc: ORB::setFastThreshold(fastThreshold) + public void setFastThreshold(int fastThreshold) + { + + setFastThreshold_0(nativeObj, fastThreshold); + + return; + } + + + // + // C++: void setFirstLevel(int firstLevel) + // + + //javadoc: ORB::setFirstLevel(firstLevel) + public void setFirstLevel(int firstLevel) + { + + setFirstLevel_0(nativeObj, firstLevel); + + return; + } + + + // + // C++: void setMaxFeatures(int maxFeatures) + // + + //javadoc: ORB::setMaxFeatures(maxFeatures) + public void setMaxFeatures(int maxFeatures) + { + + setMaxFeatures_0(nativeObj, maxFeatures); + + return; + } + + + // + // C++: void setNLevels(int nlevels) + // + + //javadoc: ORB::setNLevels(nlevels) + public void setNLevels(int nlevels) + { + + setNLevels_0(nativeObj, nlevels); + + return; + } + + + // + // C++: void setPatchSize(int patchSize) + // + + //javadoc: ORB::setPatchSize(patchSize) + public void setPatchSize(int patchSize) + { + + setPatchSize_0(nativeObj, patchSize); + + return; + } + + + // + // C++: void setScaleFactor(double scaleFactor) + // + + //javadoc: ORB::setScaleFactor(scaleFactor) + public void setScaleFactor(double scaleFactor) + { + + setScaleFactor_0(nativeObj, scaleFactor); + + return; + } + + + // + // C++: void setScoreType(int scoreType) + // + + //javadoc: ORB::setScoreType(scoreType) + public void setScoreType(int scoreType) + { + + setScoreType_0(nativeObj, scoreType); + + return; + } + + + // + // C++: void setWTA_K(int wta_k) + // + + //javadoc: ORB::setWTA_K(wta_k) + public void setWTA_K(int wta_k) + { + + setWTA_K_0(nativeObj, wta_k); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_ORB create(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31, int firstLevel = 0, int WTA_K = 2, int scoreType = ORB::HARRIS_SCORE, int patchSize = 31, int fastThreshold = 20) + private static native long create_0(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold); + private static native long create_1(); + + // C++: double getScaleFactor() + private static native double getScaleFactor_0(long nativeObj); + + // C++: int getEdgeThreshold() + private static native int getEdgeThreshold_0(long nativeObj); + + // C++: int getFastThreshold() + private static native int getFastThreshold_0(long nativeObj); + + // C++: int getFirstLevel() + private static native int getFirstLevel_0(long nativeObj); + + // C++: int getMaxFeatures() + private static native int getMaxFeatures_0(long nativeObj); + + // C++: int getNLevels() + private static native int getNLevels_0(long nativeObj); + + // C++: int getPatchSize() + private static native int getPatchSize_0(long nativeObj); + + // C++: int getScoreType() + private static native int getScoreType_0(long nativeObj); + + // C++: int getWTA_K() + private static native int getWTA_K_0(long nativeObj); + + // C++: void setEdgeThreshold(int edgeThreshold) + private static native void setEdgeThreshold_0(long nativeObj, int edgeThreshold); + + // C++: void setFastThreshold(int fastThreshold) + private static native void setFastThreshold_0(long nativeObj, int fastThreshold); + + // C++: void setFirstLevel(int firstLevel) + private static native void setFirstLevel_0(long nativeObj, int firstLevel); + + // C++: void setMaxFeatures(int maxFeatures) + private static native void setMaxFeatures_0(long nativeObj, int maxFeatures); + + // C++: void setNLevels(int nlevels) + private static native void setNLevels_0(long nativeObj, int nlevels); + + // C++: void setPatchSize(int patchSize) + private static native void setPatchSize_0(long nativeObj, int patchSize); + + // C++: void setScaleFactor(double scaleFactor) + private static native void setScaleFactor_0(long nativeObj, double scaleFactor); + + // C++: void setScoreType(int scoreType) + private static native void setScoreType_0(long nativeObj, int scoreType); + + // C++: void setWTA_K(int wta_k) + private static native void setWTA_K_0(long nativeObj, int wta_k); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/features2d/Params.java b/openCVLibrary330/src/main/java/org/opencv/features2d/Params.java new file mode 100644 index 00000000000..46478523b11 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/features2d/Params.java @@ -0,0 +1,671 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.features2d; + + + +// C++: class Params +//javadoc: Params +public class Params { + + protected final long nativeObj; + protected Params(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: Params() + // + + //javadoc: Params::Params() + public Params() + { + + nativeObj = Params_0(); + + return; + } + + + // + // C++: float Params::thresholdStep + // + + //javadoc: Params::get_thresholdStep() + public float get_thresholdStep() + { + + float retVal = get_thresholdStep_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::thresholdStep + // + + //javadoc: Params::set_thresholdStep(thresholdStep) + public void set_thresholdStep(float thresholdStep) + { + + set_thresholdStep_0(nativeObj, thresholdStep); + + return; + } + + + // + // C++: float Params::minThreshold + // + + //javadoc: Params::get_minThreshold() + public float get_minThreshold() + { + + float retVal = get_minThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minThreshold + // + + //javadoc: Params::set_minThreshold(minThreshold) + public void set_minThreshold(float minThreshold) + { + + set_minThreshold_0(nativeObj, minThreshold); + + return; + } + + + // + // C++: float Params::maxThreshold + // + + //javadoc: Params::get_maxThreshold() + public float get_maxThreshold() + { + + float retVal = get_maxThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::maxThreshold + // + + //javadoc: Params::set_maxThreshold(maxThreshold) + public void set_maxThreshold(float maxThreshold) + { + + set_maxThreshold_0(nativeObj, maxThreshold); + + return; + } + + + // + // C++: size_t Params::minRepeatability + // + + //javadoc: Params::get_minRepeatability() + public long get_minRepeatability() + { + + long retVal = get_minRepeatability_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minRepeatability + // + + //javadoc: Params::set_minRepeatability(minRepeatability) + public void set_minRepeatability(long minRepeatability) + { + + set_minRepeatability_0(nativeObj, minRepeatability); + + return; + } + + + // + // C++: float Params::minDistBetweenBlobs + // + + //javadoc: Params::get_minDistBetweenBlobs() + public float get_minDistBetweenBlobs() + { + + float retVal = get_minDistBetweenBlobs_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minDistBetweenBlobs + // + + //javadoc: Params::set_minDistBetweenBlobs(minDistBetweenBlobs) + public void set_minDistBetweenBlobs(float minDistBetweenBlobs) + { + + set_minDistBetweenBlobs_0(nativeObj, minDistBetweenBlobs); + + return; + } + + + // + // C++: bool Params::filterByColor + // + + //javadoc: Params::get_filterByColor() + public boolean get_filterByColor() + { + + boolean retVal = get_filterByColor_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::filterByColor + // + + //javadoc: Params::set_filterByColor(filterByColor) + public void set_filterByColor(boolean filterByColor) + { + + set_filterByColor_0(nativeObj, filterByColor); + + return; + } + + + // + // C++: uchar Params::blobColor + // + + // Return type 'uchar' is not supported, skipping the function + + + // + // C++: void Params::blobColor + // + + // Unknown type 'uchar' (I), skipping the function + + + // + // C++: bool Params::filterByArea + // + + //javadoc: Params::get_filterByArea() + public boolean get_filterByArea() + { + + boolean retVal = get_filterByArea_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::filterByArea + // + + //javadoc: Params::set_filterByArea(filterByArea) + public void set_filterByArea(boolean filterByArea) + { + + set_filterByArea_0(nativeObj, filterByArea); + + return; + } + + + // + // C++: float Params::minArea + // + + //javadoc: Params::get_minArea() + public float get_minArea() + { + + float retVal = get_minArea_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minArea + // + + //javadoc: Params::set_minArea(minArea) + public void set_minArea(float minArea) + { + + set_minArea_0(nativeObj, minArea); + + return; + } + + + // + // C++: float Params::maxArea + // + + //javadoc: Params::get_maxArea() + public float get_maxArea() + { + + float retVal = get_maxArea_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::maxArea + // + + //javadoc: Params::set_maxArea(maxArea) + public void set_maxArea(float maxArea) + { + + set_maxArea_0(nativeObj, maxArea); + + return; + } + + + // + // C++: bool Params::filterByCircularity + // + + //javadoc: Params::get_filterByCircularity() + public boolean get_filterByCircularity() + { + + boolean retVal = get_filterByCircularity_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::filterByCircularity + // + + //javadoc: Params::set_filterByCircularity(filterByCircularity) + public void set_filterByCircularity(boolean filterByCircularity) + { + + set_filterByCircularity_0(nativeObj, filterByCircularity); + + return; + } + + + // + // C++: float Params::minCircularity + // + + //javadoc: Params::get_minCircularity() + public float get_minCircularity() + { + + float retVal = get_minCircularity_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minCircularity + // + + //javadoc: Params::set_minCircularity(minCircularity) + public void set_minCircularity(float minCircularity) + { + + set_minCircularity_0(nativeObj, minCircularity); + + return; + } + + + // + // C++: float Params::maxCircularity + // + + //javadoc: Params::get_maxCircularity() + public float get_maxCircularity() + { + + float retVal = get_maxCircularity_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::maxCircularity + // + + //javadoc: Params::set_maxCircularity(maxCircularity) + public void set_maxCircularity(float maxCircularity) + { + + set_maxCircularity_0(nativeObj, maxCircularity); + + return; + } + + + // + // C++: bool Params::filterByInertia + // + + //javadoc: Params::get_filterByInertia() + public boolean get_filterByInertia() + { + + boolean retVal = get_filterByInertia_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::filterByInertia + // + + //javadoc: Params::set_filterByInertia(filterByInertia) + public void set_filterByInertia(boolean filterByInertia) + { + + set_filterByInertia_0(nativeObj, filterByInertia); + + return; + } + + + // + // C++: float Params::minInertiaRatio + // + + //javadoc: Params::get_minInertiaRatio() + public float get_minInertiaRatio() + { + + float retVal = get_minInertiaRatio_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minInertiaRatio + // + + //javadoc: Params::set_minInertiaRatio(minInertiaRatio) + public void set_minInertiaRatio(float minInertiaRatio) + { + + set_minInertiaRatio_0(nativeObj, minInertiaRatio); + + return; + } + + + // + // C++: float Params::maxInertiaRatio + // + + //javadoc: Params::get_maxInertiaRatio() + public float get_maxInertiaRatio() + { + + float retVal = get_maxInertiaRatio_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::maxInertiaRatio + // + + //javadoc: Params::set_maxInertiaRatio(maxInertiaRatio) + public void set_maxInertiaRatio(float maxInertiaRatio) + { + + set_maxInertiaRatio_0(nativeObj, maxInertiaRatio); + + return; + } + + + // + // C++: bool Params::filterByConvexity + // + + //javadoc: Params::get_filterByConvexity() + public boolean get_filterByConvexity() + { + + boolean retVal = get_filterByConvexity_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::filterByConvexity + // + + //javadoc: Params::set_filterByConvexity(filterByConvexity) + public void set_filterByConvexity(boolean filterByConvexity) + { + + set_filterByConvexity_0(nativeObj, filterByConvexity); + + return; + } + + + // + // C++: float Params::minConvexity + // + + //javadoc: Params::get_minConvexity() + public float get_minConvexity() + { + + float retVal = get_minConvexity_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::minConvexity + // + + //javadoc: Params::set_minConvexity(minConvexity) + public void set_minConvexity(float minConvexity) + { + + set_minConvexity_0(nativeObj, minConvexity); + + return; + } + + + // + // C++: float Params::maxConvexity + // + + //javadoc: Params::get_maxConvexity() + public float get_maxConvexity() + { + + float retVal = get_maxConvexity_0(nativeObj); + + return retVal; + } + + + // + // C++: void Params::maxConvexity + // + + //javadoc: Params::set_maxConvexity(maxConvexity) + public void set_maxConvexity(float maxConvexity) + { + + set_maxConvexity_0(nativeObj, maxConvexity); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Params() + private static native long Params_0(); + + // C++: float Params::thresholdStep + private static native float get_thresholdStep_0(long nativeObj); + + // C++: void Params::thresholdStep + private static native void set_thresholdStep_0(long nativeObj, float thresholdStep); + + // C++: float Params::minThreshold + private static native float get_minThreshold_0(long nativeObj); + + // C++: void Params::minThreshold + private static native void set_minThreshold_0(long nativeObj, float minThreshold); + + // C++: float Params::maxThreshold + private static native float get_maxThreshold_0(long nativeObj); + + // C++: void Params::maxThreshold + private static native void set_maxThreshold_0(long nativeObj, float maxThreshold); + + // C++: size_t Params::minRepeatability + private static native long get_minRepeatability_0(long nativeObj); + + // C++: void Params::minRepeatability + private static native void set_minRepeatability_0(long nativeObj, long minRepeatability); + + // C++: float Params::minDistBetweenBlobs + private static native float get_minDistBetweenBlobs_0(long nativeObj); + + // C++: void Params::minDistBetweenBlobs + private static native void set_minDistBetweenBlobs_0(long nativeObj, float minDistBetweenBlobs); + + // C++: bool Params::filterByColor + private static native boolean get_filterByColor_0(long nativeObj); + + // C++: void Params::filterByColor + private static native void set_filterByColor_0(long nativeObj, boolean filterByColor); + + // C++: bool Params::filterByArea + private static native boolean get_filterByArea_0(long nativeObj); + + // C++: void Params::filterByArea + private static native void set_filterByArea_0(long nativeObj, boolean filterByArea); + + // C++: float Params::minArea + private static native float get_minArea_0(long nativeObj); + + // C++: void Params::minArea + private static native void set_minArea_0(long nativeObj, float minArea); + + // C++: float Params::maxArea + private static native float get_maxArea_0(long nativeObj); + + // C++: void Params::maxArea + private static native void set_maxArea_0(long nativeObj, float maxArea); + + // C++: bool Params::filterByCircularity + private static native boolean get_filterByCircularity_0(long nativeObj); + + // C++: void Params::filterByCircularity + private static native void set_filterByCircularity_0(long nativeObj, boolean filterByCircularity); + + // C++: float Params::minCircularity + private static native float get_minCircularity_0(long nativeObj); + + // C++: void Params::minCircularity + private static native void set_minCircularity_0(long nativeObj, float minCircularity); + + // C++: float Params::maxCircularity + private static native float get_maxCircularity_0(long nativeObj); + + // C++: void Params::maxCircularity + private static native void set_maxCircularity_0(long nativeObj, float maxCircularity); + + // C++: bool Params::filterByInertia + private static native boolean get_filterByInertia_0(long nativeObj); + + // C++: void Params::filterByInertia + private static native void set_filterByInertia_0(long nativeObj, boolean filterByInertia); + + // C++: float Params::minInertiaRatio + private static native float get_minInertiaRatio_0(long nativeObj); + + // C++: void Params::minInertiaRatio + private static native void set_minInertiaRatio_0(long nativeObj, float minInertiaRatio); + + // C++: float Params::maxInertiaRatio + private static native float get_maxInertiaRatio_0(long nativeObj); + + // C++: void Params::maxInertiaRatio + private static native void set_maxInertiaRatio_0(long nativeObj, float maxInertiaRatio); + + // C++: bool Params::filterByConvexity + private static native boolean get_filterByConvexity_0(long nativeObj); + + // C++: void Params::filterByConvexity + private static native void set_filterByConvexity_0(long nativeObj, boolean filterByConvexity); + + // C++: float Params::minConvexity + private static native float get_minConvexity_0(long nativeObj); + + // C++: void Params::minConvexity + private static native void set_minConvexity_0(long nativeObj, float minConvexity); + + // C++: float Params::maxConvexity + private static native float get_maxConvexity_0(long nativeObj); + + // C++: void Params::maxConvexity + private static native void set_maxConvexity_0(long nativeObj, float maxConvexity); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/imgcodecs/Imgcodecs.java b/openCVLibrary330/src/main/java/org/opencv/imgcodecs/Imgcodecs.java new file mode 100644 index 00000000000..c1ec1a0aaf0 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/imgcodecs/Imgcodecs.java @@ -0,0 +1,215 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.imgcodecs; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfByte; +import org.opencv.core.MatOfInt; +import org.opencv.utils.Converters; + +public class Imgcodecs { + + public static final int + CV_LOAD_IMAGE_UNCHANGED = -1, + CV_LOAD_IMAGE_GRAYSCALE = 0, + CV_LOAD_IMAGE_COLOR = 1, + CV_LOAD_IMAGE_ANYDEPTH = 2, + CV_LOAD_IMAGE_ANYCOLOR = 4, + CV_LOAD_IMAGE_IGNORE_ORIENTATION = 128, + CV_IMWRITE_JPEG_QUALITY = 1, + CV_IMWRITE_JPEG_PROGRESSIVE = 2, + CV_IMWRITE_JPEG_OPTIMIZE = 3, + CV_IMWRITE_JPEG_RST_INTERVAL = 4, + CV_IMWRITE_JPEG_LUMA_QUALITY = 5, + CV_IMWRITE_JPEG_CHROMA_QUALITY = 6, + CV_IMWRITE_PNG_COMPRESSION = 16, + CV_IMWRITE_PNG_STRATEGY = 17, + CV_IMWRITE_PNG_BILEVEL = 18, + CV_IMWRITE_PNG_STRATEGY_DEFAULT = 0, + CV_IMWRITE_PNG_STRATEGY_FILTERED = 1, + CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2, + CV_IMWRITE_PNG_STRATEGY_RLE = 3, + CV_IMWRITE_PNG_STRATEGY_FIXED = 4, + CV_IMWRITE_PXM_BINARY = 32, + CV_IMWRITE_WEBP_QUALITY = 64, + CV_IMWRITE_PAM_TUPLETYPE = 128, + CV_IMWRITE_PAM_FORMAT_NULL = 0, + CV_IMWRITE_PAM_FORMAT_BLACKANDWHITE = 1, + CV_IMWRITE_PAM_FORMAT_GRAYSCALE = 2, + CV_IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA = 3, + CV_IMWRITE_PAM_FORMAT_RGB = 4, + CV_IMWRITE_PAM_FORMAT_RGB_ALPHA = 5, + CV_CVTIMG_FLIP = 1, + CV_CVTIMG_SWAP_RB = 2, + IMREAD_UNCHANGED = -1, + IMREAD_GRAYSCALE = 0, + IMREAD_COLOR = 1, + IMREAD_ANYDEPTH = 2, + IMREAD_ANYCOLOR = 4, + IMREAD_LOAD_GDAL = 8, + IMREAD_REDUCED_GRAYSCALE_2 = 16, + IMREAD_REDUCED_COLOR_2 = 17, + IMREAD_REDUCED_GRAYSCALE_4 = 32, + IMREAD_REDUCED_COLOR_4 = 33, + IMREAD_REDUCED_GRAYSCALE_8 = 64, + IMREAD_REDUCED_COLOR_8 = 65, + IMREAD_IGNORE_ORIENTATION = 128, + IMWRITE_JPEG_QUALITY = 1, + IMWRITE_JPEG_PROGRESSIVE = 2, + IMWRITE_JPEG_OPTIMIZE = 3, + IMWRITE_JPEG_RST_INTERVAL = 4, + IMWRITE_JPEG_LUMA_QUALITY = 5, + IMWRITE_JPEG_CHROMA_QUALITY = 6, + IMWRITE_PNG_COMPRESSION = 16, + IMWRITE_PNG_STRATEGY = 17, + IMWRITE_PNG_BILEVEL = 18, + IMWRITE_PXM_BINARY = 32, + IMWRITE_WEBP_QUALITY = 64, + IMWRITE_PAM_TUPLETYPE = 128, + IMWRITE_PNG_STRATEGY_DEFAULT = 0, + IMWRITE_PNG_STRATEGY_FILTERED = 1, + IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2, + IMWRITE_PNG_STRATEGY_RLE = 3, + IMWRITE_PNG_STRATEGY_FIXED = 4, + IMWRITE_PAM_FORMAT_NULL = 0, + IMWRITE_PAM_FORMAT_BLACKANDWHITE = 1, + IMWRITE_PAM_FORMAT_GRAYSCALE = 2, + IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA = 3, + IMWRITE_PAM_FORMAT_RGB = 4, + IMWRITE_PAM_FORMAT_RGB_ALPHA = 5; + + + // + // C++: Mat imdecode(Mat buf, int flags) + // + + //javadoc: imdecode(buf, flags) + public static Mat imdecode(Mat buf, int flags) + { + + Mat retVal = new Mat(imdecode_0(buf.nativeObj, flags)); + + return retVal; + } + + + // + // C++: Mat imread(String filename, int flags = IMREAD_COLOR) + // + + //javadoc: imread(filename, flags) + public static Mat imread(String filename, int flags) + { + + Mat retVal = new Mat(imread_0(filename, flags)); + + return retVal; + } + + //javadoc: imread(filename) + public static Mat imread(String filename) + { + + Mat retVal = new Mat(imread_1(filename)); + + return retVal; + } + + + // + // C++: bool imencode(String ext, Mat img, vector_uchar& buf, vector_int params = std::vector()) + // + + //javadoc: imencode(ext, img, buf, params) + public static boolean imencode(String ext, Mat img, MatOfByte buf, MatOfInt params) + { + Mat buf_mat = buf; + Mat params_mat = params; + boolean retVal = imencode_0(ext, img.nativeObj, buf_mat.nativeObj, params_mat.nativeObj); + + return retVal; + } + + //javadoc: imencode(ext, img, buf) + public static boolean imencode(String ext, Mat img, MatOfByte buf) + { + Mat buf_mat = buf; + boolean retVal = imencode_1(ext, img.nativeObj, buf_mat.nativeObj); + + return retVal; + } + + + // + // C++: bool imreadmulti(String filename, vector_Mat mats, int flags = IMREAD_ANYCOLOR) + // + + //javadoc: imreadmulti(filename, mats, flags) + public static boolean imreadmulti(String filename, List mats, int flags) + { + Mat mats_mat = Converters.vector_Mat_to_Mat(mats); + boolean retVal = imreadmulti_0(filename, mats_mat.nativeObj, flags); + + return retVal; + } + + //javadoc: imreadmulti(filename, mats) + public static boolean imreadmulti(String filename, List mats) + { + Mat mats_mat = Converters.vector_Mat_to_Mat(mats); + boolean retVal = imreadmulti_1(filename, mats_mat.nativeObj); + + return retVal; + } + + + // + // C++: bool imwrite(String filename, Mat img, vector_int params = std::vector()) + // + + //javadoc: imwrite(filename, img, params) + public static boolean imwrite(String filename, Mat img, MatOfInt params) + { + Mat params_mat = params; + boolean retVal = imwrite_0(filename, img.nativeObj, params_mat.nativeObj); + + return retVal; + } + + //javadoc: imwrite(filename, img) + public static boolean imwrite(String filename, Mat img) + { + + boolean retVal = imwrite_1(filename, img.nativeObj); + + return retVal; + } + + + + + // C++: Mat imdecode(Mat buf, int flags) + private static native long imdecode_0(long buf_nativeObj, int flags); + + // C++: Mat imread(String filename, int flags = IMREAD_COLOR) + private static native long imread_0(String filename, int flags); + private static native long imread_1(String filename); + + // C++: bool imencode(String ext, Mat img, vector_uchar& buf, vector_int params = std::vector()) + private static native boolean imencode_0(String ext, long img_nativeObj, long buf_mat_nativeObj, long params_mat_nativeObj); + private static native boolean imencode_1(String ext, long img_nativeObj, long buf_mat_nativeObj); + + // C++: bool imreadmulti(String filename, vector_Mat mats, int flags = IMREAD_ANYCOLOR) + private static native boolean imreadmulti_0(String filename, long mats_mat_nativeObj, int flags); + private static native boolean imreadmulti_1(String filename, long mats_mat_nativeObj); + + // C++: bool imwrite(String filename, Mat img, vector_int params = std::vector()) + private static native boolean imwrite_0(String filename, long img_nativeObj, long params_mat_nativeObj); + private static native boolean imwrite_1(String filename, long img_nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/imgproc/CLAHE.java b/openCVLibrary330/src/main/java/org/opencv/imgproc/CLAHE.java new file mode 100644 index 00000000000..9c53b6f31f5 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/imgproc/CLAHE.java @@ -0,0 +1,130 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.imgproc; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.core.Size; + +// C++: class CLAHE +//javadoc: CLAHE +public class CLAHE extends Algorithm { + + protected CLAHE(long addr) { super(addr); } + + + // + // C++: Size getTilesGridSize() + // + + //javadoc: CLAHE::getTilesGridSize() + public Size getTilesGridSize() + { + + Size retVal = new Size(getTilesGridSize_0(nativeObj)); + + return retVal; + } + + + // + // C++: double getClipLimit() + // + + //javadoc: CLAHE::getClipLimit() + public double getClipLimit() + { + + double retVal = getClipLimit_0(nativeObj); + + return retVal; + } + + + // + // C++: void apply(Mat src, Mat& dst) + // + + //javadoc: CLAHE::apply(src, dst) + public void apply(Mat src, Mat dst) + { + + apply_0(nativeObj, src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void collectGarbage() + // + + //javadoc: CLAHE::collectGarbage() + public void collectGarbage() + { + + collectGarbage_0(nativeObj); + + return; + } + + + // + // C++: void setClipLimit(double clipLimit) + // + + //javadoc: CLAHE::setClipLimit(clipLimit) + public void setClipLimit(double clipLimit) + { + + setClipLimit_0(nativeObj, clipLimit); + + return; + } + + + // + // C++: void setTilesGridSize(Size tileGridSize) + // + + //javadoc: CLAHE::setTilesGridSize(tileGridSize) + public void setTilesGridSize(Size tileGridSize) + { + + setTilesGridSize_0(nativeObj, tileGridSize.width, tileGridSize.height); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Size getTilesGridSize() + private static native double[] getTilesGridSize_0(long nativeObj); + + // C++: double getClipLimit() + private static native double getClipLimit_0(long nativeObj); + + // C++: void apply(Mat src, Mat& dst) + private static native void apply_0(long nativeObj, long src_nativeObj, long dst_nativeObj); + + // C++: void collectGarbage() + private static native void collectGarbage_0(long nativeObj); + + // C++: void setClipLimit(double clipLimit) + private static native void setClipLimit_0(long nativeObj, double clipLimit); + + // C++: void setTilesGridSize(Size tileGridSize) + private static native void setTilesGridSize_0(long nativeObj, double tileGridSize_width, double tileGridSize_height); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/imgproc/Imgproc.java b/openCVLibrary330/src/main/java/org/opencv/imgproc/Imgproc.java new file mode 100644 index 00000000000..ebfd31dcda2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/imgproc/Imgproc.java @@ -0,0 +1,3511 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.imgproc; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfFloat; +import org.opencv.core.MatOfInt; +import org.opencv.core.MatOfInt4; +import org.opencv.core.MatOfPoint; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.Point; +import org.opencv.core.Rect; +import org.opencv.core.RotatedRect; +import org.opencv.core.Scalar; +import org.opencv.core.Size; +import org.opencv.core.TermCriteria; +import org.opencv.utils.Converters; + +public class Imgproc { + + private static final int + IPL_BORDER_CONSTANT = 0, + IPL_BORDER_REPLICATE = 1, + IPL_BORDER_REFLECT = 2, + IPL_BORDER_WRAP = 3, + IPL_BORDER_REFLECT_101 = 4, + IPL_BORDER_TRANSPARENT = 5, + CV_INTER_NN = 0, + CV_INTER_LINEAR = 1, + CV_INTER_CUBIC = 2, + CV_INTER_AREA = 3, + CV_INTER_LANCZOS4 = 4, + CV_MOP_ERODE = 0, + CV_MOP_DILATE = 1, + CV_MOP_OPEN = 2, + CV_MOP_CLOSE = 3, + CV_MOP_GRADIENT = 4, + CV_MOP_TOPHAT = 5, + CV_MOP_BLACKHAT = 6, + CV_RETR_EXTERNAL = 0, + CV_RETR_LIST = 1, + CV_RETR_CCOMP = 2, + CV_RETR_TREE = 3, + CV_RETR_FLOODFILL = 4, + CV_CHAIN_APPROX_NONE = 1, + CV_CHAIN_APPROX_SIMPLE = 2, + CV_CHAIN_APPROX_TC89_L1 = 3, + CV_CHAIN_APPROX_TC89_KCOS = 4, + CV_THRESH_BINARY = 0, + CV_THRESH_BINARY_INV = 1, + CV_THRESH_TRUNC = 2, + CV_THRESH_TOZERO = 3, + CV_THRESH_TOZERO_INV = 4, + CV_THRESH_MASK = 7, + CV_THRESH_OTSU = 8, + CV_THRESH_TRIANGLE = 16; + + + public static final int + LINE_AA = 16, + LINE_8 = 8, + LINE_4 = 4, + CV_BLUR_NO_SCALE = 0, + CV_BLUR = 1, + CV_GAUSSIAN = 2, + CV_MEDIAN = 3, + CV_BILATERAL = 4, + CV_GAUSSIAN_5x5 = 7, + CV_SCHARR = -1, + CV_MAX_SOBEL_KSIZE = 7, + CV_RGBA2mRGBA = 125, + CV_mRGBA2RGBA = 126, + CV_WARP_FILL_OUTLIERS = 8, + CV_WARP_INVERSE_MAP = 16, + CV_SHAPE_RECT = 0, + CV_SHAPE_CROSS = 1, + CV_SHAPE_ELLIPSE = 2, + CV_SHAPE_CUSTOM = 100, + CV_CHAIN_CODE = 0, + CV_LINK_RUNS = 5, + CV_POLY_APPROX_DP = 0, + CV_CONTOURS_MATCH_I1 = 1, + CV_CONTOURS_MATCH_I2 = 2, + CV_CONTOURS_MATCH_I3 = 3, + CV_CLOCKWISE = 1, + CV_COUNTER_CLOCKWISE = 2, + CV_COMP_CORREL = 0, + CV_COMP_CHISQR = 1, + CV_COMP_INTERSECT = 2, + CV_COMP_BHATTACHARYYA = 3, + CV_COMP_HELLINGER = CV_COMP_BHATTACHARYYA, + CV_COMP_CHISQR_ALT = 4, + CV_COMP_KL_DIV = 5, + CV_DIST_MASK_3 = 3, + CV_DIST_MASK_5 = 5, + CV_DIST_MASK_PRECISE = 0, + CV_DIST_LABEL_CCOMP = 0, + CV_DIST_LABEL_PIXEL = 1, + CV_DIST_USER = -1, + CV_DIST_L1 = 1, + CV_DIST_L2 = 2, + CV_DIST_C = 3, + CV_DIST_L12 = 4, + CV_DIST_FAIR = 5, + CV_DIST_WELSCH = 6, + CV_DIST_HUBER = 7, + CV_CANNY_L2_GRADIENT = (1 << 31), + CV_HOUGH_STANDARD = 0, + CV_HOUGH_PROBABILISTIC = 1, + CV_HOUGH_MULTI_SCALE = 2, + CV_HOUGH_GRADIENT = 3, + MORPH_ERODE = 0, + MORPH_DILATE = 1, + MORPH_OPEN = 2, + MORPH_CLOSE = 3, + MORPH_GRADIENT = 4, + MORPH_TOPHAT = 5, + MORPH_BLACKHAT = 6, + MORPH_HITMISS = 7, + MORPH_RECT = 0, + MORPH_CROSS = 1, + MORPH_ELLIPSE = 2, + INTER_NEAREST = 0, + INTER_LINEAR = 1, + INTER_CUBIC = 2, + INTER_AREA = 3, + INTER_LANCZOS4 = 4, + INTER_MAX = 7, + WARP_FILL_OUTLIERS = 8, + WARP_INVERSE_MAP = 16, + INTER_BITS = 5, + INTER_BITS2 = INTER_BITS * 2, + INTER_TAB_SIZE = 1 << INTER_BITS, + INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE, + DIST_USER = -1, + DIST_L1 = 1, + DIST_L2 = 2, + DIST_C = 3, + DIST_L12 = 4, + DIST_FAIR = 5, + DIST_WELSCH = 6, + DIST_HUBER = 7, + DIST_MASK_3 = 3, + DIST_MASK_5 = 5, + DIST_MASK_PRECISE = 0, + THRESH_BINARY = 0, + THRESH_BINARY_INV = 1, + THRESH_TRUNC = 2, + THRESH_TOZERO = 3, + THRESH_TOZERO_INV = 4, + THRESH_MASK = 7, + THRESH_OTSU = 8, + THRESH_TRIANGLE = 16, + ADAPTIVE_THRESH_MEAN_C = 0, + ADAPTIVE_THRESH_GAUSSIAN_C = 1, + PROJ_SPHERICAL_ORTHO = 0, + PROJ_SPHERICAL_EQRECT = 1, + GC_BGD = 0, + GC_FGD = 1, + GC_PR_BGD = 2, + GC_PR_FGD = 3, + GC_INIT_WITH_RECT = 0, + GC_INIT_WITH_MASK = 1, + GC_EVAL = 2, + DIST_LABEL_CCOMP = 0, + DIST_LABEL_PIXEL = 1, + FLOODFILL_FIXED_RANGE = 1 << 16, + FLOODFILL_MASK_ONLY = 1 << 17, + CC_STAT_LEFT = 0, + CC_STAT_TOP = 1, + CC_STAT_WIDTH = 2, + CC_STAT_HEIGHT = 3, + CC_STAT_AREA = 4, + CC_STAT_MAX = 5, + CCL_WU = 0, + CCL_DEFAULT = -1, + CCL_GRANA = 1, + RETR_EXTERNAL = 0, + RETR_LIST = 1, + RETR_CCOMP = 2, + RETR_TREE = 3, + RETR_FLOODFILL = 4, + CHAIN_APPROX_NONE = 1, + CHAIN_APPROX_SIMPLE = 2, + CHAIN_APPROX_TC89_L1 = 3, + CHAIN_APPROX_TC89_KCOS = 4, + CONTOURS_MATCH_I1 = 1, + CONTOURS_MATCH_I2 = 2, + CONTOURS_MATCH_I3 = 3, + HOUGH_STANDARD = 0, + HOUGH_PROBABILISTIC = 1, + HOUGH_MULTI_SCALE = 2, + HOUGH_GRADIENT = 3, + LSD_REFINE_NONE = 0, + LSD_REFINE_STD = 1, + LSD_REFINE_ADV = 2, + HISTCMP_CORREL = 0, + HISTCMP_CHISQR = 1, + HISTCMP_INTERSECT = 2, + HISTCMP_BHATTACHARYYA = 3, + HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA, + HISTCMP_CHISQR_ALT = 4, + HISTCMP_KL_DIV = 5, + COLOR_BGR2BGRA = 0, + COLOR_RGB2RGBA = COLOR_BGR2BGRA, + COLOR_BGRA2BGR = 1, + COLOR_RGBA2RGB = COLOR_BGRA2BGR, + COLOR_BGR2RGBA = 2, + COLOR_RGB2BGRA = COLOR_BGR2RGBA, + COLOR_RGBA2BGR = 3, + COLOR_BGRA2RGB = COLOR_RGBA2BGR, + COLOR_BGR2RGB = 4, + COLOR_RGB2BGR = COLOR_BGR2RGB, + COLOR_BGRA2RGBA = 5, + COLOR_RGBA2BGRA = COLOR_BGRA2RGBA, + COLOR_BGR2GRAY = 6, + COLOR_RGB2GRAY = 7, + COLOR_GRAY2BGR = 8, + COLOR_GRAY2RGB = COLOR_GRAY2BGR, + COLOR_GRAY2BGRA = 9, + COLOR_GRAY2RGBA = COLOR_GRAY2BGRA, + COLOR_BGRA2GRAY = 10, + COLOR_RGBA2GRAY = 11, + COLOR_BGR2BGR565 = 12, + COLOR_RGB2BGR565 = 13, + COLOR_BGR5652BGR = 14, + COLOR_BGR5652RGB = 15, + COLOR_BGRA2BGR565 = 16, + COLOR_RGBA2BGR565 = 17, + COLOR_BGR5652BGRA = 18, + COLOR_BGR5652RGBA = 19, + COLOR_GRAY2BGR565 = 20, + COLOR_BGR5652GRAY = 21, + COLOR_BGR2BGR555 = 22, + COLOR_RGB2BGR555 = 23, + COLOR_BGR5552BGR = 24, + COLOR_BGR5552RGB = 25, + COLOR_BGRA2BGR555 = 26, + COLOR_RGBA2BGR555 = 27, + COLOR_BGR5552BGRA = 28, + COLOR_BGR5552RGBA = 29, + COLOR_GRAY2BGR555 = 30, + COLOR_BGR5552GRAY = 31, + COLOR_BGR2XYZ = 32, + COLOR_RGB2XYZ = 33, + COLOR_XYZ2BGR = 34, + COLOR_XYZ2RGB = 35, + COLOR_BGR2YCrCb = 36, + COLOR_RGB2YCrCb = 37, + COLOR_YCrCb2BGR = 38, + COLOR_YCrCb2RGB = 39, + COLOR_BGR2HSV = 40, + COLOR_RGB2HSV = 41, + COLOR_BGR2Lab = 44, + COLOR_RGB2Lab = 45, + COLOR_BGR2Luv = 50, + COLOR_RGB2Luv = 51, + COLOR_BGR2HLS = 52, + COLOR_RGB2HLS = 53, + COLOR_HSV2BGR = 54, + COLOR_HSV2RGB = 55, + COLOR_Lab2BGR = 56, + COLOR_Lab2RGB = 57, + COLOR_Luv2BGR = 58, + COLOR_Luv2RGB = 59, + COLOR_HLS2BGR = 60, + COLOR_HLS2RGB = 61, + COLOR_BGR2HSV_FULL = 66, + COLOR_RGB2HSV_FULL = 67, + COLOR_BGR2HLS_FULL = 68, + COLOR_RGB2HLS_FULL = 69, + COLOR_HSV2BGR_FULL = 70, + COLOR_HSV2RGB_FULL = 71, + COLOR_HLS2BGR_FULL = 72, + COLOR_HLS2RGB_FULL = 73, + COLOR_LBGR2Lab = 74, + COLOR_LRGB2Lab = 75, + COLOR_LBGR2Luv = 76, + COLOR_LRGB2Luv = 77, + COLOR_Lab2LBGR = 78, + COLOR_Lab2LRGB = 79, + COLOR_Luv2LBGR = 80, + COLOR_Luv2LRGB = 81, + COLOR_BGR2YUV = 82, + COLOR_RGB2YUV = 83, + COLOR_YUV2BGR = 84, + COLOR_YUV2RGB = 85, + COLOR_YUV2RGB_NV12 = 90, + COLOR_YUV2BGR_NV12 = 91, + COLOR_YUV2RGB_NV21 = 92, + COLOR_YUV2BGR_NV21 = 93, + COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21, + COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21, + COLOR_YUV2RGBA_NV12 = 94, + COLOR_YUV2BGRA_NV12 = 95, + COLOR_YUV2RGBA_NV21 = 96, + COLOR_YUV2BGRA_NV21 = 97, + COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, + COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21, + COLOR_YUV2RGB_YV12 = 98, + COLOR_YUV2BGR_YV12 = 99, + COLOR_YUV2RGB_IYUV = 100, + COLOR_YUV2BGR_IYUV = 101, + COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV, + COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV, + COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12, + COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12, + COLOR_YUV2RGBA_YV12 = 102, + COLOR_YUV2BGRA_YV12 = 103, + COLOR_YUV2RGBA_IYUV = 104, + COLOR_YUV2BGRA_IYUV = 105, + COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, + COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, + COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12, + COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12, + COLOR_YUV2GRAY_420 = 106, + COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, + COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, + COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420, + COLOR_YUV2RGB_UYVY = 107, + COLOR_YUV2BGR_UYVY = 108, + COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, + COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY, + COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, + COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, + COLOR_YUV2RGBA_UYVY = 111, + COLOR_YUV2BGRA_UYVY = 112, + COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, + COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, + COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, + COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY, + COLOR_YUV2RGB_YUY2 = 115, + COLOR_YUV2BGR_YUY2 = 116, + COLOR_YUV2RGB_YVYU = 117, + COLOR_YUV2BGR_YVYU = 118, + COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, + COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, + COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, + COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2, + COLOR_YUV2RGBA_YUY2 = 119, + COLOR_YUV2BGRA_YUY2 = 120, + COLOR_YUV2RGBA_YVYU = 121, + COLOR_YUV2BGRA_YVYU = 122, + COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, + COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, + COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, + COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2, + COLOR_YUV2GRAY_UYVY = 123, + COLOR_YUV2GRAY_YUY2 = 124, + COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, + COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY, + COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, + COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, + COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, + COLOR_RGBA2mRGBA = 125, + COLOR_mRGBA2RGBA = 126, + COLOR_RGB2YUV_I420 = 127, + COLOR_BGR2YUV_I420 = 128, + COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420, + COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420, + COLOR_RGBA2YUV_I420 = 129, + COLOR_BGRA2YUV_I420 = 130, + COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420, + COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, + COLOR_RGB2YUV_YV12 = 131, + COLOR_BGR2YUV_YV12 = 132, + COLOR_RGBA2YUV_YV12 = 133, + COLOR_BGRA2YUV_YV12 = 134, + COLOR_BayerBG2BGR = 46, + COLOR_BayerGB2BGR = 47, + COLOR_BayerRG2BGR = 48, + COLOR_BayerGR2BGR = 49, + COLOR_BayerBG2RGB = COLOR_BayerRG2BGR, + COLOR_BayerGB2RGB = COLOR_BayerGR2BGR, + COLOR_BayerRG2RGB = COLOR_BayerBG2BGR, + COLOR_BayerGR2RGB = COLOR_BayerGB2BGR, + COLOR_BayerBG2GRAY = 86, + COLOR_BayerGB2GRAY = 87, + COLOR_BayerRG2GRAY = 88, + COLOR_BayerGR2GRAY = 89, + COLOR_BayerBG2BGR_VNG = 62, + COLOR_BayerGB2BGR_VNG = 63, + COLOR_BayerRG2BGR_VNG = 64, + COLOR_BayerGR2BGR_VNG = 65, + COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG, + COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG, + COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG, + COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG, + COLOR_BayerBG2BGR_EA = 135, + COLOR_BayerGB2BGR_EA = 136, + COLOR_BayerRG2BGR_EA = 137, + COLOR_BayerGR2BGR_EA = 138, + COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA, + COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA, + COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA, + COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA, + COLOR_BayerBG2BGRA = 139, + COLOR_BayerGB2BGRA = 140, + COLOR_BayerRG2BGRA = 141, + COLOR_BayerGR2BGRA = 142, + COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA, + COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA, + COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA, + COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA, + COLOR_COLORCVT_MAX = 143, + INTERSECT_NONE = 0, + INTERSECT_PARTIAL = 1, + INTERSECT_FULL = 2, + TM_SQDIFF = 0, + TM_SQDIFF_NORMED = 1, + TM_CCORR = 2, + TM_CCORR_NORMED = 3, + TM_CCOEFF = 4, + TM_CCOEFF_NORMED = 5, + COLORMAP_AUTUMN = 0, + COLORMAP_BONE = 1, + COLORMAP_JET = 2, + COLORMAP_WINTER = 3, + COLORMAP_RAINBOW = 4, + COLORMAP_OCEAN = 5, + COLORMAP_SUMMER = 6, + COLORMAP_SPRING = 7, + COLORMAP_COOL = 8, + COLORMAP_HSV = 9, + COLORMAP_PINK = 10, + COLORMAP_HOT = 11, + COLORMAP_PARULA = 12, + MARKER_CROSS = 0, + MARKER_TILTED_CROSS = 1, + MARKER_STAR = 2, + MARKER_DIAMOND = 3, + MARKER_SQUARE = 4, + MARKER_TRIANGLE_UP = 5, + MARKER_TRIANGLE_DOWN = 6; + + + // + // C++: Mat getAffineTransform(vector_Point2f src, vector_Point2f dst) + // + + //javadoc: getAffineTransform(src, dst) + public static Mat getAffineTransform(MatOfPoint2f src, MatOfPoint2f dst) + { + Mat src_mat = src; + Mat dst_mat = dst; + Mat retVal = new Mat(getAffineTransform_0(src_mat.nativeObj, dst_mat.nativeObj)); + + return retVal; + } + + + // + // C++: Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize = Size(), bool centerPrincipalPoint = false) + // + + //javadoc: getDefaultNewCameraMatrix(cameraMatrix, imgsize, centerPrincipalPoint) + public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize, boolean centerPrincipalPoint) + { + + Mat retVal = new Mat(getDefaultNewCameraMatrix_0(cameraMatrix.nativeObj, imgsize.width, imgsize.height, centerPrincipalPoint)); + + return retVal; + } + + //javadoc: getDefaultNewCameraMatrix(cameraMatrix) + public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix) + { + + Mat retVal = new Mat(getDefaultNewCameraMatrix_1(cameraMatrix.nativeObj)); + + return retVal; + } + + + // + // C++: Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi = CV_PI*0.5, int ktype = CV_64F) + // + + //javadoc: getGaborKernel(ksize, sigma, theta, lambd, gamma, psi, ktype) + public static Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype) + { + + Mat retVal = new Mat(getGaborKernel_0(ksize.width, ksize.height, sigma, theta, lambd, gamma, psi, ktype)); + + return retVal; + } + + //javadoc: getGaborKernel(ksize, sigma, theta, lambd, gamma) + public static Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma) + { + + Mat retVal = new Mat(getGaborKernel_1(ksize.width, ksize.height, sigma, theta, lambd, gamma)); + + return retVal; + } + + + // + // C++: Mat getGaussianKernel(int ksize, double sigma, int ktype = CV_64F) + // + + //javadoc: getGaussianKernel(ksize, sigma, ktype) + public static Mat getGaussianKernel(int ksize, double sigma, int ktype) + { + + Mat retVal = new Mat(getGaussianKernel_0(ksize, sigma, ktype)); + + return retVal; + } + + //javadoc: getGaussianKernel(ksize, sigma) + public static Mat getGaussianKernel(int ksize, double sigma) + { + + Mat retVal = new Mat(getGaussianKernel_1(ksize, sigma)); + + return retVal; + } + + + // + // C++: Mat getPerspectiveTransform(Mat src, Mat dst) + // + + //javadoc: getPerspectiveTransform(src, dst) + public static Mat getPerspectiveTransform(Mat src, Mat dst) + { + + Mat retVal = new Mat(getPerspectiveTransform_0(src.nativeObj, dst.nativeObj)); + + return retVal; + } + + + // + // C++: Mat getRotationMatrix2D(Point2f center, double angle, double scale) + // + + //javadoc: getRotationMatrix2D(center, angle, scale) + public static Mat getRotationMatrix2D(Point center, double angle, double scale) + { + + Mat retVal = new Mat(getRotationMatrix2D_0(center.x, center.y, angle, scale)); + + return retVal; + } + + + // + // C++: Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1)) + // + + //javadoc: getStructuringElement(shape, ksize, anchor) + public static Mat getStructuringElement(int shape, Size ksize, Point anchor) + { + + Mat retVal = new Mat(getStructuringElement_0(shape, ksize.width, ksize.height, anchor.x, anchor.y)); + + return retVal; + } + + //javadoc: getStructuringElement(shape, ksize) + public static Mat getStructuringElement(int shape, Size ksize) + { + + Mat retVal = new Mat(getStructuringElement_1(shape, ksize.width, ksize.height)); + + return retVal; + } + + + // + // C++: Moments moments(Mat array, bool binaryImage = false) + // + + //javadoc: moments(array, binaryImage) + public static Moments moments(Mat array, boolean binaryImage) + { + + Moments retVal = new Moments(moments_0(array.nativeObj, binaryImage)); + + return retVal; + } + + //javadoc: moments(array) + public static Moments moments(Mat array) + { + + Moments retVal = new Moments(moments_1(array.nativeObj)); + + return retVal; + } + + + // + // C++: Point2d phaseCorrelate(Mat src1, Mat src2, Mat window = Mat(), double* response = 0) + // + + //javadoc: phaseCorrelate(src1, src2, window, response) + public static Point phaseCorrelate(Mat src1, Mat src2, Mat window, double[] response) + { + double[] response_out = new double[1]; + Point retVal = new Point(phaseCorrelate_0(src1.nativeObj, src2.nativeObj, window.nativeObj, response_out)); + if(response!=null) response[0] = (double)response_out[0]; + return retVal; + } + + //javadoc: phaseCorrelate(src1, src2) + public static Point phaseCorrelate(Mat src1, Mat src2) + { + + Point retVal = new Point(phaseCorrelate_1(src1.nativeObj, src2.nativeObj)); + + return retVal; + } + + + // + // C++: Ptr_CLAHE createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8)) + // + + //javadoc: createCLAHE(clipLimit, tileGridSize) + public static CLAHE createCLAHE(double clipLimit, Size tileGridSize) + { + + CLAHE retVal = new CLAHE(createCLAHE_0(clipLimit, tileGridSize.width, tileGridSize.height)); + + return retVal; + } + + //javadoc: createCLAHE() + public static CLAHE createCLAHE() + { + + CLAHE retVal = new CLAHE(createCLAHE_1()); + + return retVal; + } + + + // + // C++: Ptr_LineSegmentDetector createLineSegmentDetector(int _refine = LSD_REFINE_STD, double _scale = 0.8, double _sigma_scale = 0.6, double _quant = 2.0, double _ang_th = 22.5, double _log_eps = 0, double _density_th = 0.7, int _n_bins = 1024) + // + + //javadoc: createLineSegmentDetector(_refine, _scale, _sigma_scale, _quant, _ang_th, _log_eps, _density_th, _n_bins) + public static LineSegmentDetector createLineSegmentDetector(int _refine, double _scale, double _sigma_scale, double _quant, double _ang_th, double _log_eps, double _density_th, int _n_bins) + { + + LineSegmentDetector retVal = new LineSegmentDetector(createLineSegmentDetector_0(_refine, _scale, _sigma_scale, _quant, _ang_th, _log_eps, _density_th, _n_bins)); + + return retVal; + } + + //javadoc: createLineSegmentDetector() + public static LineSegmentDetector createLineSegmentDetector() + { + + LineSegmentDetector retVal = new LineSegmentDetector(createLineSegmentDetector_1()); + + return retVal; + } + + + // + // C++: Rect boundingRect(vector_Point points) + // + + //javadoc: boundingRect(points) + public static Rect boundingRect(MatOfPoint points) + { + Mat points_mat = points; + Rect retVal = new Rect(boundingRect_0(points_mat.nativeObj)); + + return retVal; + } + + + // + // C++: RotatedRect fitEllipse(vector_Point2f points) + // + + //javadoc: fitEllipse(points) + public static RotatedRect fitEllipse(MatOfPoint2f points) + { + Mat points_mat = points; + RotatedRect retVal = new RotatedRect(fitEllipse_0(points_mat.nativeObj)); + + return retVal; + } + + + // + // C++: RotatedRect minAreaRect(vector_Point2f points) + // + + //javadoc: minAreaRect(points) + public static RotatedRect minAreaRect(MatOfPoint2f points) + { + Mat points_mat = points; + RotatedRect retVal = new RotatedRect(minAreaRect_0(points_mat.nativeObj)); + + return retVal; + } + + + // + // C++: bool clipLine(Rect imgRect, Point& pt1, Point& pt2) + // + + //javadoc: clipLine(imgRect, pt1, pt2) + public static boolean clipLine(Rect imgRect, Point pt1, Point pt2) + { + double[] pt1_out = new double[2]; + double[] pt2_out = new double[2]; + boolean retVal = clipLine_0(imgRect.x, imgRect.y, imgRect.width, imgRect.height, pt1.x, pt1.y, pt1_out, pt2.x, pt2.y, pt2_out); + if(pt1!=null){ pt1.x = pt1_out[0]; pt1.y = pt1_out[1]; } + if(pt2!=null){ pt2.x = pt2_out[0]; pt2.y = pt2_out[1]; } + return retVal; + } + + + // + // C++: bool isContourConvex(vector_Point contour) + // + + //javadoc: isContourConvex(contour) + public static boolean isContourConvex(MatOfPoint contour) + { + Mat contour_mat = contour; + boolean retVal = isContourConvex_0(contour_mat.nativeObj); + + return retVal; + } + + + // + // C++: double arcLength(vector_Point2f curve, bool closed) + // + + //javadoc: arcLength(curve, closed) + public static double arcLength(MatOfPoint2f curve, boolean closed) + { + Mat curve_mat = curve; + double retVal = arcLength_0(curve_mat.nativeObj, closed); + + return retVal; + } + + + // + // C++: double compareHist(Mat H1, Mat H2, int method) + // + + //javadoc: compareHist(H1, H2, method) + public static double compareHist(Mat H1, Mat H2, int method) + { + + double retVal = compareHist_0(H1.nativeObj, H2.nativeObj, method); + + return retVal; + } + + + // + // C++: double contourArea(Mat contour, bool oriented = false) + // + + //javadoc: contourArea(contour, oriented) + public static double contourArea(Mat contour, boolean oriented) + { + + double retVal = contourArea_0(contour.nativeObj, oriented); + + return retVal; + } + + //javadoc: contourArea(contour) + public static double contourArea(Mat contour) + { + + double retVal = contourArea_1(contour.nativeObj); + + return retVal; + } + + + // + // C++: double matchShapes(Mat contour1, Mat contour2, int method, double parameter) + // + + //javadoc: matchShapes(contour1, contour2, method, parameter) + public static double matchShapes(Mat contour1, Mat contour2, int method, double parameter) + { + + double retVal = matchShapes_0(contour1.nativeObj, contour2.nativeObj, method, parameter); + + return retVal; + } + + + // + // C++: double minEnclosingTriangle(Mat points, Mat& triangle) + // + + //javadoc: minEnclosingTriangle(points, triangle) + public static double minEnclosingTriangle(Mat points, Mat triangle) + { + + double retVal = minEnclosingTriangle_0(points.nativeObj, triangle.nativeObj); + + return retVal; + } + + + // + // C++: double pointPolygonTest(vector_Point2f contour, Point2f pt, bool measureDist) + // + + //javadoc: pointPolygonTest(contour, pt, measureDist) + public static double pointPolygonTest(MatOfPoint2f contour, Point pt, boolean measureDist) + { + Mat contour_mat = contour; + double retVal = pointPolygonTest_0(contour_mat.nativeObj, pt.x, pt.y, measureDist); + + return retVal; + } + + + // + // C++: double threshold(Mat src, Mat& dst, double thresh, double maxval, int type) + // + + //javadoc: threshold(src, dst, thresh, maxval, type) + public static double threshold(Mat src, Mat dst, double thresh, double maxval, int type) + { + + double retVal = threshold_0(src.nativeObj, dst.nativeObj, thresh, maxval, type); + + return retVal; + } + + + // + // C++: float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat& map1, Mat& map2, int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0) + // + + //javadoc: initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth, m1type, map1, map2, projType, alpha) + public static float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2, int projType, double alpha) + { + + float retVal = initWideAngleProjMap_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, destImageWidth, m1type, map1.nativeObj, map2.nativeObj, projType, alpha); + + return retVal; + } + + //javadoc: initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth, m1type, map1, map2) + public static float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2) + { + + float retVal = initWideAngleProjMap_1(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, destImageWidth, m1type, map1.nativeObj, map2.nativeObj); + + return retVal; + } + + + // + // C++: float intersectConvexConvex(Mat _p1, Mat _p2, Mat& _p12, bool handleNested = true) + // + + //javadoc: intersectConvexConvex(_p1, _p2, _p12, handleNested) + public static float intersectConvexConvex(Mat _p1, Mat _p2, Mat _p12, boolean handleNested) + { + + float retVal = intersectConvexConvex_0(_p1.nativeObj, _p2.nativeObj, _p12.nativeObj, handleNested); + + return retVal; + } + + //javadoc: intersectConvexConvex(_p1, _p2, _p12) + public static float intersectConvexConvex(Mat _p1, Mat _p2, Mat _p12) + { + + float retVal = intersectConvexConvex_1(_p1.nativeObj, _p2.nativeObj, _p12.nativeObj); + + return retVal; + } + + + // + // C++: float wrapperEMD(Mat signature1, Mat signature2, int distType, Mat cost = Mat(), Ptr_float& lowerBound = Ptr(), Mat& flow = Mat()) + // + + //javadoc: wrapperEMD(signature1, signature2, distType, cost, flow) + public static float EMD(Mat signature1, Mat signature2, int distType, Mat cost, Mat flow) + { + + float retVal = EMD_0(signature1.nativeObj, signature2.nativeObj, distType, cost.nativeObj, flow.nativeObj); + + return retVal; + } + + //javadoc: wrapperEMD(signature1, signature2, distType) + public static float EMD(Mat signature1, Mat signature2, int distType) + { + + float retVal = EMD_1(signature1.nativeObj, signature2.nativeObj, distType); + + return retVal; + } + + + // + // C++: int connectedComponents(Mat image, Mat& labels, int connectivity, int ltype, int ccltype) + // + + //javadoc: connectedComponents(image, labels, connectivity, ltype, ccltype) + public static int connectedComponentsWithAlgorithm(Mat image, Mat labels, int connectivity, int ltype, int ccltype) + { + + int retVal = connectedComponentsWithAlgorithm_0(image.nativeObj, labels.nativeObj, connectivity, ltype, ccltype); + + return retVal; + } + + + // + // C++: int connectedComponents(Mat image, Mat& labels, int connectivity = 8, int ltype = CV_32S) + // + + //javadoc: connectedComponents(image, labels, connectivity, ltype) + public static int connectedComponents(Mat image, Mat labels, int connectivity, int ltype) + { + + int retVal = connectedComponents_0(image.nativeObj, labels.nativeObj, connectivity, ltype); + + return retVal; + } + + //javadoc: connectedComponents(image, labels) + public static int connectedComponents(Mat image, Mat labels) + { + + int retVal = connectedComponents_1(image.nativeObj, labels.nativeObj); + + return retVal; + } + + + // + // C++: int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity, int ltype, int ccltype) + // + + //javadoc: connectedComponentsWithStats(image, labels, stats, centroids, connectivity, ltype, ccltype) + public static int connectedComponentsWithStatsWithAlgorithm(Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype, int ccltype) + { + + int retVal = connectedComponentsWithStatsWithAlgorithm_0(image.nativeObj, labels.nativeObj, stats.nativeObj, centroids.nativeObj, connectivity, ltype, ccltype); + + return retVal; + } + + + // + // C++: int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity = 8, int ltype = CV_32S) + // + + //javadoc: connectedComponentsWithStats(image, labels, stats, centroids, connectivity, ltype) + public static int connectedComponentsWithStats(Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype) + { + + int retVal = connectedComponentsWithStats_0(image.nativeObj, labels.nativeObj, stats.nativeObj, centroids.nativeObj, connectivity, ltype); + + return retVal; + } + + //javadoc: connectedComponentsWithStats(image, labels, stats, centroids) + public static int connectedComponentsWithStats(Mat image, Mat labels, Mat stats, Mat centroids) + { + + int retVal = connectedComponentsWithStats_1(image.nativeObj, labels.nativeObj, stats.nativeObj, centroids.nativeObj); + + return retVal; + } + + + // + // C++: int floodFill(Mat& image, Mat& mask, Point seedPoint, Scalar newVal, Rect* rect = 0, Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), int flags = 4) + // + + //javadoc: floodFill(image, mask, seedPoint, newVal, rect, loDiff, upDiff, flags) + public static int floodFill(Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff, Scalar upDiff, int flags) + { + double[] rect_out = new double[4]; + int retVal = floodFill_0(image.nativeObj, mask.nativeObj, seedPoint.x, seedPoint.y, newVal.val[0], newVal.val[1], newVal.val[2], newVal.val[3], rect_out, loDiff.val[0], loDiff.val[1], loDiff.val[2], loDiff.val[3], upDiff.val[0], upDiff.val[1], upDiff.val[2], upDiff.val[3], flags); + if(rect!=null){ rect.x = (int)rect_out[0]; rect.y = (int)rect_out[1]; rect.width = (int)rect_out[2]; rect.height = (int)rect_out[3]; } + return retVal; + } + + //javadoc: floodFill(image, mask, seedPoint, newVal) + public static int floodFill(Mat image, Mat mask, Point seedPoint, Scalar newVal) + { + + int retVal = floodFill_1(image.nativeObj, mask.nativeObj, seedPoint.x, seedPoint.y, newVal.val[0], newVal.val[1], newVal.val[2], newVal.val[3]); + + return retVal; + } + + + // + // C++: int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat& intersectingRegion) + // + + //javadoc: rotatedRectangleIntersection(rect1, rect2, intersectingRegion) + public static int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat intersectingRegion) + { + + int retVal = rotatedRectangleIntersection_0(rect1.center.x, rect1.center.y, rect1.size.width, rect1.size.height, rect1.angle, rect2.center.x, rect2.center.y, rect2.size.width, rect2.size.height, rect2.angle, intersectingRegion.nativeObj); + + return retVal; + } + + + // + // C++: void Canny(Mat dx, Mat dy, Mat& edges, double threshold1, double threshold2, bool L2gradient = false) + // + + //javadoc: Canny(dx, dy, edges, threshold1, threshold2, L2gradient) + public static void Canny(Mat dx, Mat dy, Mat edges, double threshold1, double threshold2, boolean L2gradient) + { + + Canny_0(dx.nativeObj, dy.nativeObj, edges.nativeObj, threshold1, threshold2, L2gradient); + + return; + } + + //javadoc: Canny(dx, dy, edges, threshold1, threshold2) + public static void Canny(Mat dx, Mat dy, Mat edges, double threshold1, double threshold2) + { + + Canny_1(dx.nativeObj, dy.nativeObj, edges.nativeObj, threshold1, threshold2); + + return; + } + + + // + // C++: void Canny(Mat image, Mat& edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false) + // + + //javadoc: Canny(image, edges, threshold1, threshold2, apertureSize, L2gradient) + public static void Canny(Mat image, Mat edges, double threshold1, double threshold2, int apertureSize, boolean L2gradient) + { + + Canny_2(image.nativeObj, edges.nativeObj, threshold1, threshold2, apertureSize, L2gradient); + + return; + } + + //javadoc: Canny(image, edges, threshold1, threshold2) + public static void Canny(Mat image, Mat edges, double threshold1, double threshold2) + { + + Canny_3(image.nativeObj, edges.nativeObj, threshold1, threshold2); + + return; + } + + + // + // C++: void GaussianBlur(Mat src, Mat& dst, Size ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT) + // + + //javadoc: GaussianBlur(src, dst, ksize, sigmaX, sigmaY, borderType) + public static void GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY, int borderType) + { + + GaussianBlur_0(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, sigmaX, sigmaY, borderType); + + return; + } + + //javadoc: GaussianBlur(src, dst, ksize, sigmaX, sigmaY) + public static void GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY) + { + + GaussianBlur_1(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, sigmaX, sigmaY); + + return; + } + + //javadoc: GaussianBlur(src, dst, ksize, sigmaX) + public static void GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX) + { + + GaussianBlur_2(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, sigmaX); + + return; + } + + + // + // C++: void HoughCircles(Mat image, Mat& circles, int method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0) + // + + //javadoc: HoughCircles(image, circles, method, dp, minDist, param1, param2, minRadius, maxRadius) + public static void HoughCircles(Mat image, Mat circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius) + { + + HoughCircles_0(image.nativeObj, circles.nativeObj, method, dp, minDist, param1, param2, minRadius, maxRadius); + + return; + } + + //javadoc: HoughCircles(image, circles, method, dp, minDist) + public static void HoughCircles(Mat image, Mat circles, int method, double dp, double minDist) + { + + HoughCircles_1(image.nativeObj, circles.nativeObj, method, dp, minDist); + + return; + } + + + // + // C++: void HoughLines(Mat image, Mat& lines, double rho, double theta, int threshold, double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI) + // + + //javadoc: HoughLines(image, lines, rho, theta, threshold, srn, stn, min_theta, max_theta) + public static void HoughLines(Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta) + { + + HoughLines_0(image.nativeObj, lines.nativeObj, rho, theta, threshold, srn, stn, min_theta, max_theta); + + return; + } + + //javadoc: HoughLines(image, lines, rho, theta, threshold) + public static void HoughLines(Mat image, Mat lines, double rho, double theta, int threshold) + { + + HoughLines_1(image.nativeObj, lines.nativeObj, rho, theta, threshold); + + return; + } + + + // + // C++: void HoughLinesP(Mat image, Mat& lines, double rho, double theta, int threshold, double minLineLength = 0, double maxLineGap = 0) + // + + //javadoc: HoughLinesP(image, lines, rho, theta, threshold, minLineLength, maxLineGap) + public static void HoughLinesP(Mat image, Mat lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap) + { + + HoughLinesP_0(image.nativeObj, lines.nativeObj, rho, theta, threshold, minLineLength, maxLineGap); + + return; + } + + //javadoc: HoughLinesP(image, lines, rho, theta, threshold) + public static void HoughLinesP(Mat image, Mat lines, double rho, double theta, int threshold) + { + + HoughLinesP_1(image.nativeObj, lines.nativeObj, rho, theta, threshold); + + return; + } + + + // + // C++: void HuMoments(Moments m, Mat& hu) + // + + //javadoc: HuMoments(m, hu) + public static void HuMoments(Moments m, Mat hu) + { + + HuMoments_0(m.m00, m.m10, m.m01, m.m20, m.m11, m.m02, m.m30, m.m21, m.m12, m.m03, hu.nativeObj); + + return; + } + + + // + // C++: void Laplacian(Mat src, Mat& dst, int ddepth, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) + // + + //javadoc: Laplacian(src, dst, ddepth, ksize, scale, delta, borderType) + public static void Laplacian(Mat src, Mat dst, int ddepth, int ksize, double scale, double delta, int borderType) + { + + Laplacian_0(src.nativeObj, dst.nativeObj, ddepth, ksize, scale, delta, borderType); + + return; + } + + //javadoc: Laplacian(src, dst, ddepth, ksize, scale, delta) + public static void Laplacian(Mat src, Mat dst, int ddepth, int ksize, double scale, double delta) + { + + Laplacian_1(src.nativeObj, dst.nativeObj, ddepth, ksize, scale, delta); + + return; + } + + //javadoc: Laplacian(src, dst, ddepth) + public static void Laplacian(Mat src, Mat dst, int ddepth) + { + + Laplacian_2(src.nativeObj, dst.nativeObj, ddepth); + + return; + } + + + // + // C++: void Scharr(Mat src, Mat& dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) + // + + //javadoc: Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType) + public static void Scharr(Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta, int borderType) + { + + Scharr_0(src.nativeObj, dst.nativeObj, ddepth, dx, dy, scale, delta, borderType); + + return; + } + + //javadoc: Scharr(src, dst, ddepth, dx, dy, scale, delta) + public static void Scharr(Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta) + { + + Scharr_1(src.nativeObj, dst.nativeObj, ddepth, dx, dy, scale, delta); + + return; + } + + //javadoc: Scharr(src, dst, ddepth, dx, dy) + public static void Scharr(Mat src, Mat dst, int ddepth, int dx, int dy) + { + + Scharr_2(src.nativeObj, dst.nativeObj, ddepth, dx, dy); + + return; + } + + + // + // C++: void Sobel(Mat src, Mat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) + // + + //javadoc: Sobel(src, dst, ddepth, dx, dy, ksize, scale, delta, borderType) + public static void Sobel(Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType) + { + + Sobel_0(src.nativeObj, dst.nativeObj, ddepth, dx, dy, ksize, scale, delta, borderType); + + return; + } + + //javadoc: Sobel(src, dst, ddepth, dx, dy, ksize, scale, delta) + public static void Sobel(Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta) + { + + Sobel_1(src.nativeObj, dst.nativeObj, ddepth, dx, dy, ksize, scale, delta); + + return; + } + + //javadoc: Sobel(src, dst, ddepth, dx, dy) + public static void Sobel(Mat src, Mat dst, int ddepth, int dx, int dy) + { + + Sobel_2(src.nativeObj, dst.nativeObj, ddepth, dx, dy); + + return; + } + + + // + // C++: void accumulate(Mat src, Mat& dst, Mat mask = Mat()) + // + + //javadoc: accumulate(src, dst, mask) + public static void accumulate(Mat src, Mat dst, Mat mask) + { + + accumulate_0(src.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: accumulate(src, dst) + public static void accumulate(Mat src, Mat dst) + { + + accumulate_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void accumulateProduct(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + // + + //javadoc: accumulateProduct(src1, src2, dst, mask) + public static void accumulateProduct(Mat src1, Mat src2, Mat dst, Mat mask) + { + + accumulateProduct_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: accumulateProduct(src1, src2, dst) + public static void accumulateProduct(Mat src1, Mat src2, Mat dst) + { + + accumulateProduct_1(src1.nativeObj, src2.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void accumulateSquare(Mat src, Mat& dst, Mat mask = Mat()) + // + + //javadoc: accumulateSquare(src, dst, mask) + public static void accumulateSquare(Mat src, Mat dst, Mat mask) + { + + accumulateSquare_0(src.nativeObj, dst.nativeObj, mask.nativeObj); + + return; + } + + //javadoc: accumulateSquare(src, dst) + public static void accumulateSquare(Mat src, Mat dst) + { + + accumulateSquare_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void accumulateWeighted(Mat src, Mat& dst, double alpha, Mat mask = Mat()) + // + + //javadoc: accumulateWeighted(src, dst, alpha, mask) + public static void accumulateWeighted(Mat src, Mat dst, double alpha, Mat mask) + { + + accumulateWeighted_0(src.nativeObj, dst.nativeObj, alpha, mask.nativeObj); + + return; + } + + //javadoc: accumulateWeighted(src, dst, alpha) + public static void accumulateWeighted(Mat src, Mat dst, double alpha) + { + + accumulateWeighted_1(src.nativeObj, dst.nativeObj, alpha); + + return; + } + + + // + // C++: void adaptiveThreshold(Mat src, Mat& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) + // + + //javadoc: adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C) + public static void adaptiveThreshold(Mat src, Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) + { + + adaptiveThreshold_0(src.nativeObj, dst.nativeObj, maxValue, adaptiveMethod, thresholdType, blockSize, C); + + return; + } + + + // + // C++: void applyColorMap(Mat src, Mat& dst, Mat userColor) + // + + //javadoc: applyColorMap(src, dst, userColor) + public static void applyColorMap(Mat src, Mat dst, Mat userColor) + { + + applyColorMap_0(src.nativeObj, dst.nativeObj, userColor.nativeObj); + + return; + } + + + // + // C++: void applyColorMap(Mat src, Mat& dst, int colormap) + // + + //javadoc: applyColorMap(src, dst, colormap) + public static void applyColorMap(Mat src, Mat dst, int colormap) + { + + applyColorMap_1(src.nativeObj, dst.nativeObj, colormap); + + return; + } + + + // + // C++: void approxPolyDP(vector_Point2f curve, vector_Point2f& approxCurve, double epsilon, bool closed) + // + + //javadoc: approxPolyDP(curve, approxCurve, epsilon, closed) + public static void approxPolyDP(MatOfPoint2f curve, MatOfPoint2f approxCurve, double epsilon, boolean closed) + { + Mat curve_mat = curve; + Mat approxCurve_mat = approxCurve; + approxPolyDP_0(curve_mat.nativeObj, approxCurve_mat.nativeObj, epsilon, closed); + + return; + } + + + // + // C++: void arrowedLine(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1) + // + + //javadoc: arrowedLine(img, pt1, pt2, color, thickness, line_type, shift, tipLength) + public static void arrowedLine(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int line_type, int shift, double tipLength) + { + + arrowedLine_0(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness, line_type, shift, tipLength); + + return; + } + + //javadoc: arrowedLine(img, pt1, pt2, color) + public static void arrowedLine(Mat img, Point pt1, Point pt2, Scalar color) + { + + arrowedLine_1(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void bilateralFilter(Mat src, Mat& dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT) + // + + //javadoc: bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, borderType) + public static void bilateralFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType) + { + + bilateralFilter_0(src.nativeObj, dst.nativeObj, d, sigmaColor, sigmaSpace, borderType); + + return; + } + + //javadoc: bilateralFilter(src, dst, d, sigmaColor, sigmaSpace) + public static void bilateralFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace) + { + + bilateralFilter_1(src.nativeObj, dst.nativeObj, d, sigmaColor, sigmaSpace); + + return; + } + + + // + // C++: void blur(Mat src, Mat& dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT) + // + + //javadoc: blur(src, dst, ksize, anchor, borderType) + public static void blur(Mat src, Mat dst, Size ksize, Point anchor, int borderType) + { + + blur_0(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, anchor.x, anchor.y, borderType); + + return; + } + + //javadoc: blur(src, dst, ksize, anchor) + public static void blur(Mat src, Mat dst, Size ksize, Point anchor) + { + + blur_1(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, anchor.x, anchor.y); + + return; + } + + //javadoc: blur(src, dst, ksize) + public static void blur(Mat src, Mat dst, Size ksize) + { + + blur_2(src.nativeObj, dst.nativeObj, ksize.width, ksize.height); + + return; + } + + + // + // C++: void boxFilter(Mat src, Mat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), bool normalize = true, int borderType = BORDER_DEFAULT) + // + + //javadoc: boxFilter(src, dst, ddepth, ksize, anchor, normalize, borderType) + public static void boxFilter(Mat src, Mat dst, int ddepth, Size ksize, Point anchor, boolean normalize, int borderType) + { + + boxFilter_0(src.nativeObj, dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize, borderType); + + return; + } + + //javadoc: boxFilter(src, dst, ddepth, ksize, anchor, normalize) + public static void boxFilter(Mat src, Mat dst, int ddepth, Size ksize, Point anchor, boolean normalize) + { + + boxFilter_1(src.nativeObj, dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize); + + return; + } + + //javadoc: boxFilter(src, dst, ddepth, ksize) + public static void boxFilter(Mat src, Mat dst, int ddepth, Size ksize) + { + + boxFilter_2(src.nativeObj, dst.nativeObj, ddepth, ksize.width, ksize.height); + + return; + } + + + // + // C++: void boxPoints(RotatedRect box, Mat& points) + // + + //javadoc: boxPoints(box, points) + public static void boxPoints(RotatedRect box, Mat points) + { + + boxPoints_0(box.center.x, box.center.y, box.size.width, box.size.height, box.angle, points.nativeObj); + + return; + } + + + // + // C++: void calcBackProject(vector_Mat images, vector_int channels, Mat hist, Mat& dst, vector_float ranges, double scale) + // + + //javadoc: calcBackProject(images, channels, hist, dst, ranges, scale) + public static void calcBackProject(List images, MatOfInt channels, Mat hist, Mat dst, MatOfFloat ranges, double scale) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat channels_mat = channels; + Mat ranges_mat = ranges; + calcBackProject_0(images_mat.nativeObj, channels_mat.nativeObj, hist.nativeObj, dst.nativeObj, ranges_mat.nativeObj, scale); + + return; + } + + + // + // C++: void calcHist(vector_Mat images, vector_int channels, Mat mask, Mat& hist, vector_int histSize, vector_float ranges, bool accumulate = false) + // + + //javadoc: calcHist(images, channels, mask, hist, histSize, ranges, accumulate) + public static void calcHist(List images, MatOfInt channels, Mat mask, Mat hist, MatOfInt histSize, MatOfFloat ranges, boolean accumulate) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat channels_mat = channels; + Mat histSize_mat = histSize; + Mat ranges_mat = ranges; + calcHist_0(images_mat.nativeObj, channels_mat.nativeObj, mask.nativeObj, hist.nativeObj, histSize_mat.nativeObj, ranges_mat.nativeObj, accumulate); + + return; + } + + //javadoc: calcHist(images, channels, mask, hist, histSize, ranges) + public static void calcHist(List images, MatOfInt channels, Mat mask, Mat hist, MatOfInt histSize, MatOfFloat ranges) + { + Mat images_mat = Converters.vector_Mat_to_Mat(images); + Mat channels_mat = channels; + Mat histSize_mat = histSize; + Mat ranges_mat = ranges; + calcHist_1(images_mat.nativeObj, channels_mat.nativeObj, mask.nativeObj, hist.nativeObj, histSize_mat.nativeObj, ranges_mat.nativeObj); + + return; + } + + + // + // C++: void circle(Mat& img, Point center, int radius, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + // + + //javadoc: circle(img, center, radius, color, thickness, lineType, shift) + public static void circle(Mat img, Point center, int radius, Scalar color, int thickness, int lineType, int shift) + { + + circle_0(img.nativeObj, center.x, center.y, radius, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift); + + return; + } + + //javadoc: circle(img, center, radius, color, thickness) + public static void circle(Mat img, Point center, int radius, Scalar color, int thickness) + { + + circle_1(img.nativeObj, center.x, center.y, radius, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: circle(img, center, radius, color) + public static void circle(Mat img, Point center, int radius, Scalar color) + { + + circle_2(img.nativeObj, center.x, center.y, radius, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void convertMaps(Mat map1, Mat map2, Mat& dstmap1, Mat& dstmap2, int dstmap1type, bool nninterpolation = false) + // + + //javadoc: convertMaps(map1, map2, dstmap1, dstmap2, dstmap1type, nninterpolation) + public static void convertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type, boolean nninterpolation) + { + + convertMaps_0(map1.nativeObj, map2.nativeObj, dstmap1.nativeObj, dstmap2.nativeObj, dstmap1type, nninterpolation); + + return; + } + + //javadoc: convertMaps(map1, map2, dstmap1, dstmap2, dstmap1type) + public static void convertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type) + { + + convertMaps_1(map1.nativeObj, map2.nativeObj, dstmap1.nativeObj, dstmap2.nativeObj, dstmap1type); + + return; + } + + + // + // C++: void convexHull(vector_Point points, vector_int& hull, bool clockwise = false, _hidden_ returnPoints = true) + // + + //javadoc: convexHull(points, hull, clockwise) + public static void convexHull(MatOfPoint points, MatOfInt hull, boolean clockwise) + { + Mat points_mat = points; + Mat hull_mat = hull; + convexHull_0(points_mat.nativeObj, hull_mat.nativeObj, clockwise); + + return; + } + + //javadoc: convexHull(points, hull) + public static void convexHull(MatOfPoint points, MatOfInt hull) + { + Mat points_mat = points; + Mat hull_mat = hull; + convexHull_1(points_mat.nativeObj, hull_mat.nativeObj); + + return; + } + + + // + // C++: void convexityDefects(vector_Point contour, vector_int convexhull, vector_Vec4i& convexityDefects) + // + + //javadoc: convexityDefects(contour, convexhull, convexityDefects) + public static void convexityDefects(MatOfPoint contour, MatOfInt convexhull, MatOfInt4 convexityDefects) + { + Mat contour_mat = contour; + Mat convexhull_mat = convexhull; + Mat convexityDefects_mat = convexityDefects; + convexityDefects_0(contour_mat.nativeObj, convexhull_mat.nativeObj, convexityDefects_mat.nativeObj); + + return; + } + + + // + // C++: void cornerEigenValsAndVecs(Mat src, Mat& dst, int blockSize, int ksize, int borderType = BORDER_DEFAULT) + // + + //javadoc: cornerEigenValsAndVecs(src, dst, blockSize, ksize, borderType) + public static void cornerEigenValsAndVecs(Mat src, Mat dst, int blockSize, int ksize, int borderType) + { + + cornerEigenValsAndVecs_0(src.nativeObj, dst.nativeObj, blockSize, ksize, borderType); + + return; + } + + //javadoc: cornerEigenValsAndVecs(src, dst, blockSize, ksize) + public static void cornerEigenValsAndVecs(Mat src, Mat dst, int blockSize, int ksize) + { + + cornerEigenValsAndVecs_1(src.nativeObj, dst.nativeObj, blockSize, ksize); + + return; + } + + + // + // C++: void cornerHarris(Mat src, Mat& dst, int blockSize, int ksize, double k, int borderType = BORDER_DEFAULT) + // + + //javadoc: cornerHarris(src, dst, blockSize, ksize, k, borderType) + public static void cornerHarris(Mat src, Mat dst, int blockSize, int ksize, double k, int borderType) + { + + cornerHarris_0(src.nativeObj, dst.nativeObj, blockSize, ksize, k, borderType); + + return; + } + + //javadoc: cornerHarris(src, dst, blockSize, ksize, k) + public static void cornerHarris(Mat src, Mat dst, int blockSize, int ksize, double k) + { + + cornerHarris_1(src.nativeObj, dst.nativeObj, blockSize, ksize, k); + + return; + } + + + // + // C++: void cornerMinEigenVal(Mat src, Mat& dst, int blockSize, int ksize = 3, int borderType = BORDER_DEFAULT) + // + + //javadoc: cornerMinEigenVal(src, dst, blockSize, ksize, borderType) + public static void cornerMinEigenVal(Mat src, Mat dst, int blockSize, int ksize, int borderType) + { + + cornerMinEigenVal_0(src.nativeObj, dst.nativeObj, blockSize, ksize, borderType); + + return; + } + + //javadoc: cornerMinEigenVal(src, dst, blockSize, ksize) + public static void cornerMinEigenVal(Mat src, Mat dst, int blockSize, int ksize) + { + + cornerMinEigenVal_1(src.nativeObj, dst.nativeObj, blockSize, ksize); + + return; + } + + //javadoc: cornerMinEigenVal(src, dst, blockSize) + public static void cornerMinEigenVal(Mat src, Mat dst, int blockSize) + { + + cornerMinEigenVal_2(src.nativeObj, dst.nativeObj, blockSize); + + return; + } + + + // + // C++: void cornerSubPix(Mat image, Mat& corners, Size winSize, Size zeroZone, TermCriteria criteria) + // + + //javadoc: cornerSubPix(image, corners, winSize, zeroZone, criteria) + public static void cornerSubPix(Mat image, Mat corners, Size winSize, Size zeroZone, TermCriteria criteria) + { + + cornerSubPix_0(image.nativeObj, corners.nativeObj, winSize.width, winSize.height, zeroZone.width, zeroZone.height, criteria.type, criteria.maxCount, criteria.epsilon); + + return; + } + + + // + // C++: void createHanningWindow(Mat& dst, Size winSize, int type) + // + + //javadoc: createHanningWindow(dst, winSize, type) + public static void createHanningWindow(Mat dst, Size winSize, int type) + { + + createHanningWindow_0(dst.nativeObj, winSize.width, winSize.height, type); + + return; + } + + + // + // C++: void cvtColor(Mat src, Mat& dst, int code, int dstCn = 0) + // + + //javadoc: cvtColor(src, dst, code, dstCn) + public static void cvtColor(Mat src, Mat dst, int code, int dstCn) + { + + cvtColor_0(src.nativeObj, dst.nativeObj, code, dstCn); + + return; + } + + //javadoc: cvtColor(src, dst, code) + public static void cvtColor(Mat src, Mat dst, int code) + { + + cvtColor_1(src.nativeObj, dst.nativeObj, code); + + return; + } + + + // + // C++: void demosaicing(Mat _src, Mat& _dst, int code, int dcn = 0) + // + + //javadoc: demosaicing(_src, _dst, code, dcn) + public static void demosaicing(Mat _src, Mat _dst, int code, int dcn) + { + + demosaicing_0(_src.nativeObj, _dst.nativeObj, code, dcn); + + return; + } + + //javadoc: demosaicing(_src, _dst, code) + public static void demosaicing(Mat _src, Mat _dst, int code) + { + + demosaicing_1(_src.nativeObj, _dst.nativeObj, code); + + return; + } + + + // + // C++: void dilate(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) + // + + //javadoc: dilate(src, dst, kernel, anchor, iterations, borderType, borderValue) + public static void dilate(Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue) + { + + dilate_0(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations, borderType, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]); + + return; + } + + //javadoc: dilate(src, dst, kernel, anchor, iterations) + public static void dilate(Mat src, Mat dst, Mat kernel, Point anchor, int iterations) + { + + dilate_1(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations); + + return; + } + + //javadoc: dilate(src, dst, kernel) + public static void dilate(Mat src, Mat dst, Mat kernel) + { + + dilate_2(src.nativeObj, dst.nativeObj, kernel.nativeObj); + + return; + } + + + // + // C++: void distanceTransform(Mat src, Mat& dst, Mat& labels, int distanceType, int maskSize, int labelType = DIST_LABEL_CCOMP) + // + + //javadoc: distanceTransform(src, dst, labels, distanceType, maskSize, labelType) + public static void distanceTransformWithLabels(Mat src, Mat dst, Mat labels, int distanceType, int maskSize, int labelType) + { + + distanceTransformWithLabels_0(src.nativeObj, dst.nativeObj, labels.nativeObj, distanceType, maskSize, labelType); + + return; + } + + //javadoc: distanceTransform(src, dst, labels, distanceType, maskSize) + public static void distanceTransformWithLabels(Mat src, Mat dst, Mat labels, int distanceType, int maskSize) + { + + distanceTransformWithLabels_1(src.nativeObj, dst.nativeObj, labels.nativeObj, distanceType, maskSize); + + return; + } + + + // + // C++: void distanceTransform(Mat src, Mat& dst, int distanceType, int maskSize, int dstType = CV_32F) + // + + //javadoc: distanceTransform(src, dst, distanceType, maskSize, dstType) + public static void distanceTransform(Mat src, Mat dst, int distanceType, int maskSize, int dstType) + { + + distanceTransform_0(src.nativeObj, dst.nativeObj, distanceType, maskSize, dstType); + + return; + } + + //javadoc: distanceTransform(src, dst, distanceType, maskSize) + public static void distanceTransform(Mat src, Mat dst, int distanceType, int maskSize) + { + + distanceTransform_1(src.nativeObj, dst.nativeObj, distanceType, maskSize); + + return; + } + + + // + // C++: void drawContours(Mat& image, vector_vector_Point contours, int contourIdx, Scalar color, int thickness = 1, int lineType = LINE_8, Mat hierarchy = Mat(), int maxLevel = INT_MAX, Point offset = Point()) + // + + //javadoc: drawContours(image, contours, contourIdx, color, thickness, lineType, hierarchy, maxLevel, offset) + public static void drawContours(Mat image, List contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel, Point offset) + { + List contours_tmplm = new ArrayList((contours != null) ? contours.size() : 0); + Mat contours_mat = Converters.vector_vector_Point_to_Mat(contours, contours_tmplm); + drawContours_0(image.nativeObj, contours_mat.nativeObj, contourIdx, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, hierarchy.nativeObj, maxLevel, offset.x, offset.y); + + return; + } + + //javadoc: drawContours(image, contours, contourIdx, color, thickness) + public static void drawContours(Mat image, List contours, int contourIdx, Scalar color, int thickness) + { + List contours_tmplm = new ArrayList((contours != null) ? contours.size() : 0); + Mat contours_mat = Converters.vector_vector_Point_to_Mat(contours, contours_tmplm); + drawContours_1(image.nativeObj, contours_mat.nativeObj, contourIdx, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: drawContours(image, contours, contourIdx, color) + public static void drawContours(Mat image, List contours, int contourIdx, Scalar color) + { + List contours_tmplm = new ArrayList((contours != null) ? contours.size() : 0); + Mat contours_mat = Converters.vector_vector_Point_to_Mat(contours, contours_tmplm); + drawContours_2(image.nativeObj, contours_mat.nativeObj, contourIdx, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void drawMarker(Mat& img, Point position, Scalar color, int markerType = MARKER_CROSS, int markerSize = 20, int thickness = 1, int line_type = 8) + // + + //javadoc: drawMarker(img, position, color, markerType, markerSize, thickness, line_type) + public static void drawMarker(Mat img, Point position, Scalar color, int markerType, int markerSize, int thickness, int line_type) + { + + drawMarker_0(img.nativeObj, position.x, position.y, color.val[0], color.val[1], color.val[2], color.val[3], markerType, markerSize, thickness, line_type); + + return; + } + + //javadoc: drawMarker(img, position, color) + public static void drawMarker(Mat img, Point position, Scalar color) + { + + drawMarker_1(img.nativeObj, position.x, position.y, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + // + + //javadoc: ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness, lineType, shift) + public static void ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness, int lineType, int shift) + { + + ellipse_0(img.nativeObj, center.x, center.y, axes.width, axes.height, angle, startAngle, endAngle, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift); + + return; + } + + //javadoc: ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness) + public static void ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness) + { + + ellipse_1(img.nativeObj, center.x, center.y, axes.width, axes.height, angle, startAngle, endAngle, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: ellipse(img, center, axes, angle, startAngle, endAngle, color) + public static void ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color) + { + + ellipse_2(img.nativeObj, center.x, center.y, axes.width, axes.height, angle, startAngle, endAngle, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void ellipse(Mat& img, RotatedRect box, Scalar color, int thickness = 1, int lineType = LINE_8) + // + + //javadoc: ellipse(img, box, color, thickness, lineType) + public static void ellipse(Mat img, RotatedRect box, Scalar color, int thickness, int lineType) + { + + ellipse_3(img.nativeObj, box.center.x, box.center.y, box.size.width, box.size.height, box.angle, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType); + + return; + } + + //javadoc: ellipse(img, box, color, thickness) + public static void ellipse(Mat img, RotatedRect box, Scalar color, int thickness) + { + + ellipse_4(img.nativeObj, box.center.x, box.center.y, box.size.width, box.size.height, box.angle, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: ellipse(img, box, color) + public static void ellipse(Mat img, RotatedRect box, Scalar color) + { + + ellipse_5(img.nativeObj, box.center.x, box.center.y, box.size.width, box.size.height, box.angle, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, vector_Point& pts) + // + + //javadoc: ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta, pts) + public static void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, MatOfPoint pts) + { + Mat pts_mat = pts; + ellipse2Poly_0(center.x, center.y, axes.width, axes.height, angle, arcStart, arcEnd, delta, pts_mat.nativeObj); + + return; + } + + + // + // C++: void equalizeHist(Mat src, Mat& dst) + // + + //javadoc: equalizeHist(src, dst) + public static void equalizeHist(Mat src, Mat dst) + { + + equalizeHist_0(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void erode(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) + // + + //javadoc: erode(src, dst, kernel, anchor, iterations, borderType, borderValue) + public static void erode(Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue) + { + + erode_0(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations, borderType, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]); + + return; + } + + //javadoc: erode(src, dst, kernel, anchor, iterations) + public static void erode(Mat src, Mat dst, Mat kernel, Point anchor, int iterations) + { + + erode_1(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations); + + return; + } + + //javadoc: erode(src, dst, kernel) + public static void erode(Mat src, Mat dst, Mat kernel) + { + + erode_2(src.nativeObj, dst.nativeObj, kernel.nativeObj); + + return; + } + + + // + // C++: void fillConvexPoly(Mat& img, vector_Point points, Scalar color, int lineType = LINE_8, int shift = 0) + // + + //javadoc: fillConvexPoly(img, points, color, lineType, shift) + public static void fillConvexPoly(Mat img, MatOfPoint points, Scalar color, int lineType, int shift) + { + Mat points_mat = points; + fillConvexPoly_0(img.nativeObj, points_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3], lineType, shift); + + return; + } + + //javadoc: fillConvexPoly(img, points, color) + public static void fillConvexPoly(Mat img, MatOfPoint points, Scalar color) + { + Mat points_mat = points; + fillConvexPoly_1(img.nativeObj, points_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void fillPoly(Mat& img, vector_vector_Point pts, Scalar color, int lineType = LINE_8, int shift = 0, Point offset = Point()) + // + + //javadoc: fillPoly(img, pts, color, lineType, shift, offset) + public static void fillPoly(Mat img, List pts, Scalar color, int lineType, int shift, Point offset) + { + List pts_tmplm = new ArrayList((pts != null) ? pts.size() : 0); + Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm); + fillPoly_0(img.nativeObj, pts_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3], lineType, shift, offset.x, offset.y); + + return; + } + + //javadoc: fillPoly(img, pts, color) + public static void fillPoly(Mat img, List pts, Scalar color) + { + List pts_tmplm = new ArrayList((pts != null) ? pts.size() : 0); + Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm); + fillPoly_1(img.nativeObj, pts_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void filter2D(Mat src, Mat& dst, int ddepth, Mat kernel, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT) + // + + //javadoc: filter2D(src, dst, ddepth, kernel, anchor, delta, borderType) + public static void filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta, int borderType) + { + + filter2D_0(src.nativeObj, dst.nativeObj, ddepth, kernel.nativeObj, anchor.x, anchor.y, delta, borderType); + + return; + } + + //javadoc: filter2D(src, dst, ddepth, kernel, anchor, delta) + public static void filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta) + { + + filter2D_1(src.nativeObj, dst.nativeObj, ddepth, kernel.nativeObj, anchor.x, anchor.y, delta); + + return; + } + + //javadoc: filter2D(src, dst, ddepth, kernel) + public static void filter2D(Mat src, Mat dst, int ddepth, Mat kernel) + { + + filter2D_2(src.nativeObj, dst.nativeObj, ddepth, kernel.nativeObj); + + return; + } + + + // + // C++: void findContours(Mat& image, vector_vector_Point& contours, Mat& hierarchy, int mode, int method, Point offset = Point()) + // + + //javadoc: findContours(image, contours, hierarchy, mode, method, offset) + public static void findContours(Mat image, List contours, Mat hierarchy, int mode, int method, Point offset) + { + Mat contours_mat = new Mat(); + findContours_0(image.nativeObj, contours_mat.nativeObj, hierarchy.nativeObj, mode, method, offset.x, offset.y); + Converters.Mat_to_vector_vector_Point(contours_mat, contours); + contours_mat.release(); + return; + } + + //javadoc: findContours(image, contours, hierarchy, mode, method) + public static void findContours(Mat image, List contours, Mat hierarchy, int mode, int method) + { + Mat contours_mat = new Mat(); + findContours_1(image.nativeObj, contours_mat.nativeObj, hierarchy.nativeObj, mode, method); + Converters.Mat_to_vector_vector_Point(contours_mat, contours); + contours_mat.release(); + return; + } + + + // + // C++: void fitLine(Mat points, Mat& line, int distType, double param, double reps, double aeps) + // + + //javadoc: fitLine(points, line, distType, param, reps, aeps) + public static void fitLine(Mat points, Mat line, int distType, double param, double reps, double aeps) + { + + fitLine_0(points.nativeObj, line.nativeObj, distType, param, reps, aeps); + + return; + } + + + // + // C++: void getDerivKernels(Mat& kx, Mat& ky, int dx, int dy, int ksize, bool normalize = false, int ktype = CV_32F) + // + + //javadoc: getDerivKernels(kx, ky, dx, dy, ksize, normalize, ktype) + public static void getDerivKernels(Mat kx, Mat ky, int dx, int dy, int ksize, boolean normalize, int ktype) + { + + getDerivKernels_0(kx.nativeObj, ky.nativeObj, dx, dy, ksize, normalize, ktype); + + return; + } + + //javadoc: getDerivKernels(kx, ky, dx, dy, ksize) + public static void getDerivKernels(Mat kx, Mat ky, int dx, int dy, int ksize) + { + + getDerivKernels_1(kx.nativeObj, ky.nativeObj, dx, dy, ksize); + + return; + } + + + // + // C++: void getRectSubPix(Mat image, Size patchSize, Point2f center, Mat& patch, int patchType = -1) + // + + //javadoc: getRectSubPix(image, patchSize, center, patch, patchType) + public static void getRectSubPix(Mat image, Size patchSize, Point center, Mat patch, int patchType) + { + + getRectSubPix_0(image.nativeObj, patchSize.width, patchSize.height, center.x, center.y, patch.nativeObj, patchType); + + return; + } + + //javadoc: getRectSubPix(image, patchSize, center, patch) + public static void getRectSubPix(Mat image, Size patchSize, Point center, Mat patch) + { + + getRectSubPix_1(image.nativeObj, patchSize.width, patchSize.height, center.x, center.y, patch.nativeObj); + + return; + } + + + // + // C++: void goodFeaturesToTrack(Mat image, vector_Point& corners, int maxCorners, double qualityLevel, double minDistance, Mat mask = Mat(), int blockSize = 3, bool useHarrisDetector = false, double k = 0.04) + // + + //javadoc: goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance, mask, blockSize, useHarrisDetector, k) + public static void goodFeaturesToTrack(Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, boolean useHarrisDetector, double k) + { + Mat corners_mat = corners; + goodFeaturesToTrack_0(image.nativeObj, corners_mat.nativeObj, maxCorners, qualityLevel, minDistance, mask.nativeObj, blockSize, useHarrisDetector, k); + + return; + } + + //javadoc: goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance) + public static void goodFeaturesToTrack(Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance) + { + Mat corners_mat = corners; + goodFeaturesToTrack_1(image.nativeObj, corners_mat.nativeObj, maxCorners, qualityLevel, minDistance); + + return; + } + + + // + // C++: void grabCut(Mat img, Mat& mask, Rect rect, Mat& bgdModel, Mat& fgdModel, int iterCount, int mode = GC_EVAL) + // + + //javadoc: grabCut(img, mask, rect, bgdModel, fgdModel, iterCount, mode) + public static void grabCut(Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount, int mode) + { + + grabCut_0(img.nativeObj, mask.nativeObj, rect.x, rect.y, rect.width, rect.height, bgdModel.nativeObj, fgdModel.nativeObj, iterCount, mode); + + return; + } + + //javadoc: grabCut(img, mask, rect, bgdModel, fgdModel, iterCount) + public static void grabCut(Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount) + { + + grabCut_1(img.nativeObj, mask.nativeObj, rect.x, rect.y, rect.width, rect.height, bgdModel.nativeObj, fgdModel.nativeObj, iterCount); + + return; + } + + + // + // C++: void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2) + // + + //javadoc: initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, m1type, map1, map2) + public static void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2) + { + + initUndistortRectifyMap_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, R.nativeObj, newCameraMatrix.nativeObj, size.width, size.height, m1type, map1.nativeObj, map2.nativeObj); + + return; + } + + + // + // C++: void integral(Mat src, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth = -1, int sqdepth = -1) + // + + //javadoc: integral(src, sum, sqsum, tilted, sdepth, sqdepth) + public static void integral3(Mat src, Mat sum, Mat sqsum, Mat tilted, int sdepth, int sqdepth) + { + + integral3_0(src.nativeObj, sum.nativeObj, sqsum.nativeObj, tilted.nativeObj, sdepth, sqdepth); + + return; + } + + //javadoc: integral(src, sum, sqsum, tilted) + public static void integral3(Mat src, Mat sum, Mat sqsum, Mat tilted) + { + + integral3_1(src.nativeObj, sum.nativeObj, sqsum.nativeObj, tilted.nativeObj); + + return; + } + + + // + // C++: void integral(Mat src, Mat& sum, Mat& sqsum, int sdepth = -1, int sqdepth = -1) + // + + //javadoc: integral(src, sum, sqsum, sdepth, sqdepth) + public static void integral2(Mat src, Mat sum, Mat sqsum, int sdepth, int sqdepth) + { + + integral2_0(src.nativeObj, sum.nativeObj, sqsum.nativeObj, sdepth, sqdepth); + + return; + } + + //javadoc: integral(src, sum, sqsum) + public static void integral2(Mat src, Mat sum, Mat sqsum) + { + + integral2_1(src.nativeObj, sum.nativeObj, sqsum.nativeObj); + + return; + } + + + // + // C++: void integral(Mat src, Mat& sum, int sdepth = -1) + // + + //javadoc: integral(src, sum, sdepth) + public static void integral(Mat src, Mat sum, int sdepth) + { + + integral_0(src.nativeObj, sum.nativeObj, sdepth); + + return; + } + + //javadoc: integral(src, sum) + public static void integral(Mat src, Mat sum) + { + + integral_1(src.nativeObj, sum.nativeObj); + + return; + } + + + // + // C++: void invertAffineTransform(Mat M, Mat& iM) + // + + //javadoc: invertAffineTransform(M, iM) + public static void invertAffineTransform(Mat M, Mat iM) + { + + invertAffineTransform_0(M.nativeObj, iM.nativeObj); + + return; + } + + + // + // C++: void line(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + // + + //javadoc: line(img, pt1, pt2, color, thickness, lineType, shift) + public static void line(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift) + { + + line_0(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift); + + return; + } + + //javadoc: line(img, pt1, pt2, color, thickness) + public static void line(Mat img, Point pt1, Point pt2, Scalar color, int thickness) + { + + line_1(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: line(img, pt1, pt2, color) + public static void line(Mat img, Point pt1, Point pt2, Scalar color) + { + + line_2(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void linearPolar(Mat src, Mat& dst, Point2f center, double maxRadius, int flags) + // + + //javadoc: linearPolar(src, dst, center, maxRadius, flags) + public static void linearPolar(Mat src, Mat dst, Point center, double maxRadius, int flags) + { + + linearPolar_0(src.nativeObj, dst.nativeObj, center.x, center.y, maxRadius, flags); + + return; + } + + + // + // C++: void logPolar(Mat src, Mat& dst, Point2f center, double M, int flags) + // + + //javadoc: logPolar(src, dst, center, M, flags) + public static void logPolar(Mat src, Mat dst, Point center, double M, int flags) + { + + logPolar_0(src.nativeObj, dst.nativeObj, center.x, center.y, M, flags); + + return; + } + + + // + // C++: void matchTemplate(Mat image, Mat templ, Mat& result, int method, Mat mask = Mat()) + // + + //javadoc: matchTemplate(image, templ, result, method, mask) + public static void matchTemplate(Mat image, Mat templ, Mat result, int method, Mat mask) + { + + matchTemplate_0(image.nativeObj, templ.nativeObj, result.nativeObj, method, mask.nativeObj); + + return; + } + + //javadoc: matchTemplate(image, templ, result, method) + public static void matchTemplate(Mat image, Mat templ, Mat result, int method) + { + + matchTemplate_1(image.nativeObj, templ.nativeObj, result.nativeObj, method); + + return; + } + + + // + // C++: void medianBlur(Mat src, Mat& dst, int ksize) + // + + //javadoc: medianBlur(src, dst, ksize) + public static void medianBlur(Mat src, Mat dst, int ksize) + { + + medianBlur_0(src.nativeObj, dst.nativeObj, ksize); + + return; + } + + + // + // C++: void minEnclosingCircle(vector_Point2f points, Point2f& center, float& radius) + // + + //javadoc: minEnclosingCircle(points, center, radius) + public static void minEnclosingCircle(MatOfPoint2f points, Point center, float[] radius) + { + Mat points_mat = points; + double[] center_out = new double[2]; + double[] radius_out = new double[1]; + minEnclosingCircle_0(points_mat.nativeObj, center_out, radius_out); + if(center!=null){ center.x = center_out[0]; center.y = center_out[1]; } + if(radius!=null) radius[0] = (float)radius_out[0]; + return; + } + + + // + // C++: void morphologyEx(Mat src, Mat& dst, int op, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) + // + + //javadoc: morphologyEx(src, dst, op, kernel, anchor, iterations, borderType, borderValue) + public static void morphologyEx(Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue) + { + + morphologyEx_0(src.nativeObj, dst.nativeObj, op, kernel.nativeObj, anchor.x, anchor.y, iterations, borderType, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]); + + return; + } + + //javadoc: morphologyEx(src, dst, op, kernel, anchor, iterations) + public static void morphologyEx(Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations) + { + + morphologyEx_1(src.nativeObj, dst.nativeObj, op, kernel.nativeObj, anchor.x, anchor.y, iterations); + + return; + } + + //javadoc: morphologyEx(src, dst, op, kernel) + public static void morphologyEx(Mat src, Mat dst, int op, Mat kernel) + { + + morphologyEx_2(src.nativeObj, dst.nativeObj, op, kernel.nativeObj); + + return; + } + + + // + // C++: void polylines(Mat& img, vector_vector_Point pts, bool isClosed, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + // + + //javadoc: polylines(img, pts, isClosed, color, thickness, lineType, shift) + public static void polylines(Mat img, List pts, boolean isClosed, Scalar color, int thickness, int lineType, int shift) + { + List pts_tmplm = new ArrayList((pts != null) ? pts.size() : 0); + Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm); + polylines_0(img.nativeObj, pts_mat.nativeObj, isClosed, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift); + + return; + } + + //javadoc: polylines(img, pts, isClosed, color, thickness) + public static void polylines(Mat img, List pts, boolean isClosed, Scalar color, int thickness) + { + List pts_tmplm = new ArrayList((pts != null) ? pts.size() : 0); + Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm); + polylines_1(img.nativeObj, pts_mat.nativeObj, isClosed, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: polylines(img, pts, isClosed, color) + public static void polylines(Mat img, List pts, boolean isClosed, Scalar color) + { + List pts_tmplm = new ArrayList((pts != null) ? pts.size() : 0); + Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm); + polylines_2(img.nativeObj, pts_mat.nativeObj, isClosed, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void preCornerDetect(Mat src, Mat& dst, int ksize, int borderType = BORDER_DEFAULT) + // + + //javadoc: preCornerDetect(src, dst, ksize, borderType) + public static void preCornerDetect(Mat src, Mat dst, int ksize, int borderType) + { + + preCornerDetect_0(src.nativeObj, dst.nativeObj, ksize, borderType); + + return; + } + + //javadoc: preCornerDetect(src, dst, ksize) + public static void preCornerDetect(Mat src, Mat dst, int ksize) + { + + preCornerDetect_1(src.nativeObj, dst.nativeObj, ksize); + + return; + } + + + // + // C++: void putText(Mat& img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false) + // + + //javadoc: putText(img, text, org, fontFace, fontScale, color, thickness, lineType, bottomLeftOrigin) + public static void putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType, boolean bottomLeftOrigin) + { + + putText_0(img.nativeObj, text, org.x, org.y, fontFace, fontScale, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, bottomLeftOrigin); + + return; + } + + //javadoc: putText(img, text, org, fontFace, fontScale, color, thickness) + public static void putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness) + { + + putText_1(img.nativeObj, text, org.x, org.y, fontFace, fontScale, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: putText(img, text, org, fontFace, fontScale, color) + public static void putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color) + { + + putText_2(img.nativeObj, text, org.x, org.y, fontFace, fontScale, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void pyrDown(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT) + // + + //javadoc: pyrDown(src, dst, dstsize, borderType) + public static void pyrDown(Mat src, Mat dst, Size dstsize, int borderType) + { + + pyrDown_0(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height, borderType); + + return; + } + + //javadoc: pyrDown(src, dst, dstsize) + public static void pyrDown(Mat src, Mat dst, Size dstsize) + { + + pyrDown_1(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height); + + return; + } + + //javadoc: pyrDown(src, dst) + public static void pyrDown(Mat src, Mat dst) + { + + pyrDown_2(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void pyrMeanShiftFiltering(Mat src, Mat& dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1)) + // + + //javadoc: pyrMeanShiftFiltering(src, dst, sp, sr, maxLevel, termcrit) + public static void pyrMeanShiftFiltering(Mat src, Mat dst, double sp, double sr, int maxLevel, TermCriteria termcrit) + { + + pyrMeanShiftFiltering_0(src.nativeObj, dst.nativeObj, sp, sr, maxLevel, termcrit.type, termcrit.maxCount, termcrit.epsilon); + + return; + } + + //javadoc: pyrMeanShiftFiltering(src, dst, sp, sr) + public static void pyrMeanShiftFiltering(Mat src, Mat dst, double sp, double sr) + { + + pyrMeanShiftFiltering_1(src.nativeObj, dst.nativeObj, sp, sr); + + return; + } + + + // + // C++: void pyrUp(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT) + // + + //javadoc: pyrUp(src, dst, dstsize, borderType) + public static void pyrUp(Mat src, Mat dst, Size dstsize, int borderType) + { + + pyrUp_0(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height, borderType); + + return; + } + + //javadoc: pyrUp(src, dst, dstsize) + public static void pyrUp(Mat src, Mat dst, Size dstsize) + { + + pyrUp_1(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height); + + return; + } + + //javadoc: pyrUp(src, dst) + public static void pyrUp(Mat src, Mat dst) + { + + pyrUp_2(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void rectangle(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + // + + //javadoc: rectangle(img, pt1, pt2, color, thickness, lineType, shift) + public static void rectangle(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift) + { + + rectangle_0(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift); + + return; + } + + //javadoc: rectangle(img, pt1, pt2, color, thickness) + public static void rectangle(Mat img, Point pt1, Point pt2, Scalar color, int thickness) + { + + rectangle_1(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness); + + return; + } + + //javadoc: rectangle(img, pt1, pt2, color) + public static void rectangle(Mat img, Point pt1, Point pt2, Scalar color) + { + + rectangle_2(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3]); + + return; + } + + + // + // C++: void remap(Mat src, Mat& dst, Mat map1, Mat map2, int interpolation, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) + // + + //javadoc: remap(src, dst, map1, map2, interpolation, borderMode, borderValue) + public static void remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation, int borderMode, Scalar borderValue) + { + + remap_0(src.nativeObj, dst.nativeObj, map1.nativeObj, map2.nativeObj, interpolation, borderMode, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]); + + return; + } + + //javadoc: remap(src, dst, map1, map2, interpolation) + public static void remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation) + { + + remap_1(src.nativeObj, dst.nativeObj, map1.nativeObj, map2.nativeObj, interpolation); + + return; + } + + + // + // C++: void resize(Mat src, Mat& dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR) + // + + //javadoc: resize(src, dst, dsize, fx, fy, interpolation) + public static void resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation) + { + + resize_0(src.nativeObj, dst.nativeObj, dsize.width, dsize.height, fx, fy, interpolation); + + return; + } + + //javadoc: resize(src, dst, dsize) + public static void resize(Mat src, Mat dst, Size dsize) + { + + resize_1(src.nativeObj, dst.nativeObj, dsize.width, dsize.height); + + return; + } + + + // + // C++: void sepFilter2D(Mat src, Mat& dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT) + // + + //javadoc: sepFilter2D(src, dst, ddepth, kernelX, kernelY, anchor, delta, borderType) + public static void sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta, int borderType) + { + + sepFilter2D_0(src.nativeObj, dst.nativeObj, ddepth, kernelX.nativeObj, kernelY.nativeObj, anchor.x, anchor.y, delta, borderType); + + return; + } + + //javadoc: sepFilter2D(src, dst, ddepth, kernelX, kernelY, anchor, delta) + public static void sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta) + { + + sepFilter2D_1(src.nativeObj, dst.nativeObj, ddepth, kernelX.nativeObj, kernelY.nativeObj, anchor.x, anchor.y, delta); + + return; + } + + //javadoc: sepFilter2D(src, dst, ddepth, kernelX, kernelY) + public static void sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY) + { + + sepFilter2D_2(src.nativeObj, dst.nativeObj, ddepth, kernelX.nativeObj, kernelY.nativeObj); + + return; + } + + + // + // C++: void spatialGradient(Mat src, Mat& dx, Mat& dy, int ksize = 3, int borderType = BORDER_DEFAULT) + // + + //javadoc: spatialGradient(src, dx, dy, ksize, borderType) + public static void spatialGradient(Mat src, Mat dx, Mat dy, int ksize, int borderType) + { + + spatialGradient_0(src.nativeObj, dx.nativeObj, dy.nativeObj, ksize, borderType); + + return; + } + + //javadoc: spatialGradient(src, dx, dy, ksize) + public static void spatialGradient(Mat src, Mat dx, Mat dy, int ksize) + { + + spatialGradient_1(src.nativeObj, dx.nativeObj, dy.nativeObj, ksize); + + return; + } + + //javadoc: spatialGradient(src, dx, dy) + public static void spatialGradient(Mat src, Mat dx, Mat dy) + { + + spatialGradient_2(src.nativeObj, dx.nativeObj, dy.nativeObj); + + return; + } + + + // + // C++: void sqrBoxFilter(Mat _src, Mat& _dst, int ddepth, Size ksize, Point anchor = Point(-1, -1), bool normalize = true, int borderType = BORDER_DEFAULT) + // + + //javadoc: sqrBoxFilter(_src, _dst, ddepth, ksize, anchor, normalize, borderType) + public static void sqrBoxFilter(Mat _src, Mat _dst, int ddepth, Size ksize, Point anchor, boolean normalize, int borderType) + { + + sqrBoxFilter_0(_src.nativeObj, _dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize, borderType); + + return; + } + + //javadoc: sqrBoxFilter(_src, _dst, ddepth, ksize, anchor, normalize) + public static void sqrBoxFilter(Mat _src, Mat _dst, int ddepth, Size ksize, Point anchor, boolean normalize) + { + + sqrBoxFilter_1(_src.nativeObj, _dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize); + + return; + } + + //javadoc: sqrBoxFilter(_src, _dst, ddepth, ksize) + public static void sqrBoxFilter(Mat _src, Mat _dst, int ddepth, Size ksize) + { + + sqrBoxFilter_2(_src.nativeObj, _dst.nativeObj, ddepth, ksize.width, ksize.height); + + return; + } + + + // + // C++: void undistort(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix = Mat()) + // + + //javadoc: undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix) + public static void undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix) + { + + undistort_0(src.nativeObj, dst.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, newCameraMatrix.nativeObj); + + return; + } + + //javadoc: undistort(src, dst, cameraMatrix, distCoeffs) + public static void undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs) + { + + undistort_1(src.nativeObj, dst.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj); + + return; + } + + + // + // C++: void undistortPoints(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat R = Mat(), Mat P = Mat()) + // + + //javadoc: undistortPoints(src, dst, cameraMatrix, distCoeffs, R, P) + public static void undistortPoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P) + { + + undistortPoints_0(src.nativeObj, dst.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, R.nativeObj, P.nativeObj); + + return; + } + + //javadoc: undistortPoints(src, dst, cameraMatrix, distCoeffs) + public static void undistortPoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs) + { + + undistortPoints_1(src.nativeObj, dst.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj); + + return; + } + + + // + // C++: void warpAffine(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) + // + + //javadoc: warpAffine(src, dst, M, dsize, flags, borderMode, borderValue) + public static void warpAffine(Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue) + { + + warpAffine_0(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags, borderMode, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]); + + return; + } + + //javadoc: warpAffine(src, dst, M, dsize, flags) + public static void warpAffine(Mat src, Mat dst, Mat M, Size dsize, int flags) + { + + warpAffine_1(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags); + + return; + } + + //javadoc: warpAffine(src, dst, M, dsize) + public static void warpAffine(Mat src, Mat dst, Mat M, Size dsize) + { + + warpAffine_2(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height); + + return; + } + + + // + // C++: void warpPerspective(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) + // + + //javadoc: warpPerspective(src, dst, M, dsize, flags, borderMode, borderValue) + public static void warpPerspective(Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue) + { + + warpPerspective_0(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags, borderMode, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]); + + return; + } + + //javadoc: warpPerspective(src, dst, M, dsize, flags) + public static void warpPerspective(Mat src, Mat dst, Mat M, Size dsize, int flags) + { + + warpPerspective_1(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags); + + return; + } + + //javadoc: warpPerspective(src, dst, M, dsize) + public static void warpPerspective(Mat src, Mat dst, Mat M, Size dsize) + { + + warpPerspective_2(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height); + + return; + } + + + // + // C++: void watershed(Mat image, Mat& markers) + // + + //javadoc: watershed(image, markers) + public static void watershed(Mat image, Mat markers) + { + + watershed_0(image.nativeObj, markers.nativeObj); + + return; + } + + + +// C++: Size getTextSize(const String& text, int fontFace, double fontScale, int thickness, int* baseLine); +//javadoc:getTextSize(text, fontFace, fontScale, thickness, baseLine) +public static Size getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine) { + if(baseLine != null && baseLine.length != 1) + throw new java.lang.IllegalArgumentException("'baseLine' must be 'int[1]' or 'null'."); + Size retVal = new Size(n_getTextSize(text, fontFace, fontScale, thickness, baseLine)); + return retVal; +} + + + + + // C++: Mat getAffineTransform(vector_Point2f src, vector_Point2f dst) + private static native long getAffineTransform_0(long src_mat_nativeObj, long dst_mat_nativeObj); + + // C++: Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize = Size(), bool centerPrincipalPoint = false) + private static native long getDefaultNewCameraMatrix_0(long cameraMatrix_nativeObj, double imgsize_width, double imgsize_height, boolean centerPrincipalPoint); + private static native long getDefaultNewCameraMatrix_1(long cameraMatrix_nativeObj); + + // C++: Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi = CV_PI*0.5, int ktype = CV_64F) + private static native long getGaborKernel_0(double ksize_width, double ksize_height, double sigma, double theta, double lambd, double gamma, double psi, int ktype); + private static native long getGaborKernel_1(double ksize_width, double ksize_height, double sigma, double theta, double lambd, double gamma); + + // C++: Mat getGaussianKernel(int ksize, double sigma, int ktype = CV_64F) + private static native long getGaussianKernel_0(int ksize, double sigma, int ktype); + private static native long getGaussianKernel_1(int ksize, double sigma); + + // C++: Mat getPerspectiveTransform(Mat src, Mat dst) + private static native long getPerspectiveTransform_0(long src_nativeObj, long dst_nativeObj); + + // C++: Mat getRotationMatrix2D(Point2f center, double angle, double scale) + private static native long getRotationMatrix2D_0(double center_x, double center_y, double angle, double scale); + + // C++: Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1)) + private static native long getStructuringElement_0(int shape, double ksize_width, double ksize_height, double anchor_x, double anchor_y); + private static native long getStructuringElement_1(int shape, double ksize_width, double ksize_height); + + // C++: Moments moments(Mat array, bool binaryImage = false) + private static native double[] moments_0(long array_nativeObj, boolean binaryImage); + private static native double[] moments_1(long array_nativeObj); + + // C++: Point2d phaseCorrelate(Mat src1, Mat src2, Mat window = Mat(), double* response = 0) + private static native double[] phaseCorrelate_0(long src1_nativeObj, long src2_nativeObj, long window_nativeObj, double[] response_out); + private static native double[] phaseCorrelate_1(long src1_nativeObj, long src2_nativeObj); + + // C++: Ptr_CLAHE createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8)) + private static native long createCLAHE_0(double clipLimit, double tileGridSize_width, double tileGridSize_height); + private static native long createCLAHE_1(); + + // C++: Ptr_LineSegmentDetector createLineSegmentDetector(int _refine = LSD_REFINE_STD, double _scale = 0.8, double _sigma_scale = 0.6, double _quant = 2.0, double _ang_th = 22.5, double _log_eps = 0, double _density_th = 0.7, int _n_bins = 1024) + private static native long createLineSegmentDetector_0(int _refine, double _scale, double _sigma_scale, double _quant, double _ang_th, double _log_eps, double _density_th, int _n_bins); + private static native long createLineSegmentDetector_1(); + + // C++: Rect boundingRect(vector_Point points) + private static native double[] boundingRect_0(long points_mat_nativeObj); + + // C++: RotatedRect fitEllipse(vector_Point2f points) + private static native double[] fitEllipse_0(long points_mat_nativeObj); + + // C++: RotatedRect minAreaRect(vector_Point2f points) + private static native double[] minAreaRect_0(long points_mat_nativeObj); + + // C++: bool clipLine(Rect imgRect, Point& pt1, Point& pt2) + private static native boolean clipLine_0(int imgRect_x, int imgRect_y, int imgRect_width, int imgRect_height, double pt1_x, double pt1_y, double[] pt1_out, double pt2_x, double pt2_y, double[] pt2_out); + + // C++: bool isContourConvex(vector_Point contour) + private static native boolean isContourConvex_0(long contour_mat_nativeObj); + + // C++: double arcLength(vector_Point2f curve, bool closed) + private static native double arcLength_0(long curve_mat_nativeObj, boolean closed); + + // C++: double compareHist(Mat H1, Mat H2, int method) + private static native double compareHist_0(long H1_nativeObj, long H2_nativeObj, int method); + + // C++: double contourArea(Mat contour, bool oriented = false) + private static native double contourArea_0(long contour_nativeObj, boolean oriented); + private static native double contourArea_1(long contour_nativeObj); + + // C++: double matchShapes(Mat contour1, Mat contour2, int method, double parameter) + private static native double matchShapes_0(long contour1_nativeObj, long contour2_nativeObj, int method, double parameter); + + // C++: double minEnclosingTriangle(Mat points, Mat& triangle) + private static native double minEnclosingTriangle_0(long points_nativeObj, long triangle_nativeObj); + + // C++: double pointPolygonTest(vector_Point2f contour, Point2f pt, bool measureDist) + private static native double pointPolygonTest_0(long contour_mat_nativeObj, double pt_x, double pt_y, boolean measureDist); + + // C++: double threshold(Mat src, Mat& dst, double thresh, double maxval, int type) + private static native double threshold_0(long src_nativeObj, long dst_nativeObj, double thresh, double maxval, int type); + + // C++: float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat& map1, Mat& map2, int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0) + private static native float initWideAngleProjMap_0(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, int destImageWidth, int m1type, long map1_nativeObj, long map2_nativeObj, int projType, double alpha); + private static native float initWideAngleProjMap_1(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, int destImageWidth, int m1type, long map1_nativeObj, long map2_nativeObj); + + // C++: float intersectConvexConvex(Mat _p1, Mat _p2, Mat& _p12, bool handleNested = true) + private static native float intersectConvexConvex_0(long _p1_nativeObj, long _p2_nativeObj, long _p12_nativeObj, boolean handleNested); + private static native float intersectConvexConvex_1(long _p1_nativeObj, long _p2_nativeObj, long _p12_nativeObj); + + // C++: float wrapperEMD(Mat signature1, Mat signature2, int distType, Mat cost = Mat(), Ptr_float& lowerBound = Ptr(), Mat& flow = Mat()) + private static native float EMD_0(long signature1_nativeObj, long signature2_nativeObj, int distType, long cost_nativeObj, long flow_nativeObj); + private static native float EMD_1(long signature1_nativeObj, long signature2_nativeObj, int distType); + + // C++: int connectedComponents(Mat image, Mat& labels, int connectivity, int ltype, int ccltype) + private static native int connectedComponentsWithAlgorithm_0(long image_nativeObj, long labels_nativeObj, int connectivity, int ltype, int ccltype); + + // C++: int connectedComponents(Mat image, Mat& labels, int connectivity = 8, int ltype = CV_32S) + private static native int connectedComponents_0(long image_nativeObj, long labels_nativeObj, int connectivity, int ltype); + private static native int connectedComponents_1(long image_nativeObj, long labels_nativeObj); + + // C++: int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity, int ltype, int ccltype) + private static native int connectedComponentsWithStatsWithAlgorithm_0(long image_nativeObj, long labels_nativeObj, long stats_nativeObj, long centroids_nativeObj, int connectivity, int ltype, int ccltype); + + // C++: int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity = 8, int ltype = CV_32S) + private static native int connectedComponentsWithStats_0(long image_nativeObj, long labels_nativeObj, long stats_nativeObj, long centroids_nativeObj, int connectivity, int ltype); + private static native int connectedComponentsWithStats_1(long image_nativeObj, long labels_nativeObj, long stats_nativeObj, long centroids_nativeObj); + + // C++: int floodFill(Mat& image, Mat& mask, Point seedPoint, Scalar newVal, Rect* rect = 0, Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), int flags = 4) + private static native int floodFill_0(long image_nativeObj, long mask_nativeObj, double seedPoint_x, double seedPoint_y, double newVal_val0, double newVal_val1, double newVal_val2, double newVal_val3, double[] rect_out, double loDiff_val0, double loDiff_val1, double loDiff_val2, double loDiff_val3, double upDiff_val0, double upDiff_val1, double upDiff_val2, double upDiff_val3, int flags); + private static native int floodFill_1(long image_nativeObj, long mask_nativeObj, double seedPoint_x, double seedPoint_y, double newVal_val0, double newVal_val1, double newVal_val2, double newVal_val3); + + // C++: int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat& intersectingRegion) + private static native int rotatedRectangleIntersection_0(double rect1_center_x, double rect1_center_y, double rect1_size_width, double rect1_size_height, double rect1_angle, double rect2_center_x, double rect2_center_y, double rect2_size_width, double rect2_size_height, double rect2_angle, long intersectingRegion_nativeObj); + + // C++: void Canny(Mat dx, Mat dy, Mat& edges, double threshold1, double threshold2, bool L2gradient = false) + private static native void Canny_0(long dx_nativeObj, long dy_nativeObj, long edges_nativeObj, double threshold1, double threshold2, boolean L2gradient); + private static native void Canny_1(long dx_nativeObj, long dy_nativeObj, long edges_nativeObj, double threshold1, double threshold2); + + // C++: void Canny(Mat image, Mat& edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false) + private static native void Canny_2(long image_nativeObj, long edges_nativeObj, double threshold1, double threshold2, int apertureSize, boolean L2gradient); + private static native void Canny_3(long image_nativeObj, long edges_nativeObj, double threshold1, double threshold2); + + // C++: void GaussianBlur(Mat src, Mat& dst, Size ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT) + private static native void GaussianBlur_0(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double sigmaX, double sigmaY, int borderType); + private static native void GaussianBlur_1(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double sigmaX, double sigmaY); + private static native void GaussianBlur_2(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double sigmaX); + + // C++: void HoughCircles(Mat image, Mat& circles, int method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0) + private static native void HoughCircles_0(long image_nativeObj, long circles_nativeObj, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius); + private static native void HoughCircles_1(long image_nativeObj, long circles_nativeObj, int method, double dp, double minDist); + + // C++: void HoughLines(Mat image, Mat& lines, double rho, double theta, int threshold, double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI) + private static native void HoughLines_0(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta); + private static native void HoughLines_1(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold); + + // C++: void HoughLinesP(Mat image, Mat& lines, double rho, double theta, int threshold, double minLineLength = 0, double maxLineGap = 0) + private static native void HoughLinesP_0(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold, double minLineLength, double maxLineGap); + private static native void HoughLinesP_1(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold); + + // C++: void HuMoments(Moments m, Mat& hu) + private static native void HuMoments_0(double m_m00, double m_m10, double m_m01, double m_m20, double m_m11, double m_m02, double m_m30, double m_m21, double m_m12, double m_m03, long hu_nativeObj); + + // C++: void Laplacian(Mat src, Mat& dst, int ddepth, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) + private static native void Laplacian_0(long src_nativeObj, long dst_nativeObj, int ddepth, int ksize, double scale, double delta, int borderType); + private static native void Laplacian_1(long src_nativeObj, long dst_nativeObj, int ddepth, int ksize, double scale, double delta); + private static native void Laplacian_2(long src_nativeObj, long dst_nativeObj, int ddepth); + + // C++: void Scharr(Mat src, Mat& dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) + private static native void Scharr_0(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, double scale, double delta, int borderType); + private static native void Scharr_1(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, double scale, double delta); + private static native void Scharr_2(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy); + + // C++: void Sobel(Mat src, Mat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) + private static native void Sobel_0(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType); + private static native void Sobel_1(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, int ksize, double scale, double delta); + private static native void Sobel_2(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy); + + // C++: void accumulate(Mat src, Mat& dst, Mat mask = Mat()) + private static native void accumulate_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void accumulate_1(long src_nativeObj, long dst_nativeObj); + + // C++: void accumulateProduct(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) + private static native void accumulateProduct_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void accumulateProduct_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj); + + // C++: void accumulateSquare(Mat src, Mat& dst, Mat mask = Mat()) + private static native void accumulateSquare_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj); + private static native void accumulateSquare_1(long src_nativeObj, long dst_nativeObj); + + // C++: void accumulateWeighted(Mat src, Mat& dst, double alpha, Mat mask = Mat()) + private static native void accumulateWeighted_0(long src_nativeObj, long dst_nativeObj, double alpha, long mask_nativeObj); + private static native void accumulateWeighted_1(long src_nativeObj, long dst_nativeObj, double alpha); + + // C++: void adaptiveThreshold(Mat src, Mat& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) + private static native void adaptiveThreshold_0(long src_nativeObj, long dst_nativeObj, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C); + + // C++: void applyColorMap(Mat src, Mat& dst, Mat userColor) + private static native void applyColorMap_0(long src_nativeObj, long dst_nativeObj, long userColor_nativeObj); + + // C++: void applyColorMap(Mat src, Mat& dst, int colormap) + private static native void applyColorMap_1(long src_nativeObj, long dst_nativeObj, int colormap); + + // C++: void approxPolyDP(vector_Point2f curve, vector_Point2f& approxCurve, double epsilon, bool closed) + private static native void approxPolyDP_0(long curve_mat_nativeObj, long approxCurve_mat_nativeObj, double epsilon, boolean closed); + + // C++: void arrowedLine(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1) + private static native void arrowedLine_0(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int line_type, int shift, double tipLength); + private static native void arrowedLine_1(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void bilateralFilter(Mat src, Mat& dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT) + private static native void bilateralFilter_0(long src_nativeObj, long dst_nativeObj, int d, double sigmaColor, double sigmaSpace, int borderType); + private static native void bilateralFilter_1(long src_nativeObj, long dst_nativeObj, int d, double sigmaColor, double sigmaSpace); + + // C++: void blur(Mat src, Mat& dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT) + private static native void blur_0(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double anchor_x, double anchor_y, int borderType); + private static native void blur_1(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double anchor_x, double anchor_y); + private static native void blur_2(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height); + + // C++: void boxFilter(Mat src, Mat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), bool normalize = true, int borderType = BORDER_DEFAULT) + private static native void boxFilter_0(long src_nativeObj, long dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize, int borderType); + private static native void boxFilter_1(long src_nativeObj, long dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize); + private static native void boxFilter_2(long src_nativeObj, long dst_nativeObj, int ddepth, double ksize_width, double ksize_height); + + // C++: void boxPoints(RotatedRect box, Mat& points) + private static native void boxPoints_0(double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, long points_nativeObj); + + // C++: void calcBackProject(vector_Mat images, vector_int channels, Mat hist, Mat& dst, vector_float ranges, double scale) + private static native void calcBackProject_0(long images_mat_nativeObj, long channels_mat_nativeObj, long hist_nativeObj, long dst_nativeObj, long ranges_mat_nativeObj, double scale); + + // C++: void calcHist(vector_Mat images, vector_int channels, Mat mask, Mat& hist, vector_int histSize, vector_float ranges, bool accumulate = false) + private static native void calcHist_0(long images_mat_nativeObj, long channels_mat_nativeObj, long mask_nativeObj, long hist_nativeObj, long histSize_mat_nativeObj, long ranges_mat_nativeObj, boolean accumulate); + private static native void calcHist_1(long images_mat_nativeObj, long channels_mat_nativeObj, long mask_nativeObj, long hist_nativeObj, long histSize_mat_nativeObj, long ranges_mat_nativeObj); + + // C++: void circle(Mat& img, Point center, int radius, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + private static native void circle_0(long img_nativeObj, double center_x, double center_y, int radius, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift); + private static native void circle_1(long img_nativeObj, double center_x, double center_y, int radius, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void circle_2(long img_nativeObj, double center_x, double center_y, int radius, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void convertMaps(Mat map1, Mat map2, Mat& dstmap1, Mat& dstmap2, int dstmap1type, bool nninterpolation = false) + private static native void convertMaps_0(long map1_nativeObj, long map2_nativeObj, long dstmap1_nativeObj, long dstmap2_nativeObj, int dstmap1type, boolean nninterpolation); + private static native void convertMaps_1(long map1_nativeObj, long map2_nativeObj, long dstmap1_nativeObj, long dstmap2_nativeObj, int dstmap1type); + + // C++: void convexHull(vector_Point points, vector_int& hull, bool clockwise = false, _hidden_ returnPoints = true) + private static native void convexHull_0(long points_mat_nativeObj, long hull_mat_nativeObj, boolean clockwise); + private static native void convexHull_1(long points_mat_nativeObj, long hull_mat_nativeObj); + + // C++: void convexityDefects(vector_Point contour, vector_int convexhull, vector_Vec4i& convexityDefects) + private static native void convexityDefects_0(long contour_mat_nativeObj, long convexhull_mat_nativeObj, long convexityDefects_mat_nativeObj); + + // C++: void cornerEigenValsAndVecs(Mat src, Mat& dst, int blockSize, int ksize, int borderType = BORDER_DEFAULT) + private static native void cornerEigenValsAndVecs_0(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, int borderType); + private static native void cornerEigenValsAndVecs_1(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize); + + // C++: void cornerHarris(Mat src, Mat& dst, int blockSize, int ksize, double k, int borderType = BORDER_DEFAULT) + private static native void cornerHarris_0(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, double k, int borderType); + private static native void cornerHarris_1(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, double k); + + // C++: void cornerMinEigenVal(Mat src, Mat& dst, int blockSize, int ksize = 3, int borderType = BORDER_DEFAULT) + private static native void cornerMinEigenVal_0(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, int borderType); + private static native void cornerMinEigenVal_1(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize); + private static native void cornerMinEigenVal_2(long src_nativeObj, long dst_nativeObj, int blockSize); + + // C++: void cornerSubPix(Mat image, Mat& corners, Size winSize, Size zeroZone, TermCriteria criteria) + private static native void cornerSubPix_0(long image_nativeObj, long corners_nativeObj, double winSize_width, double winSize_height, double zeroZone_width, double zeroZone_height, int criteria_type, int criteria_maxCount, double criteria_epsilon); + + // C++: void createHanningWindow(Mat& dst, Size winSize, int type) + private static native void createHanningWindow_0(long dst_nativeObj, double winSize_width, double winSize_height, int type); + + // C++: void cvtColor(Mat src, Mat& dst, int code, int dstCn = 0) + private static native void cvtColor_0(long src_nativeObj, long dst_nativeObj, int code, int dstCn); + private static native void cvtColor_1(long src_nativeObj, long dst_nativeObj, int code); + + // C++: void demosaicing(Mat _src, Mat& _dst, int code, int dcn = 0) + private static native void demosaicing_0(long _src_nativeObj, long _dst_nativeObj, int code, int dcn); + private static native void demosaicing_1(long _src_nativeObj, long _dst_nativeObj, int code); + + // C++: void dilate(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) + private static native void dilate_0(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations, int borderType, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3); + private static native void dilate_1(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations); + private static native void dilate_2(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj); + + // C++: void distanceTransform(Mat src, Mat& dst, Mat& labels, int distanceType, int maskSize, int labelType = DIST_LABEL_CCOMP) + private static native void distanceTransformWithLabels_0(long src_nativeObj, long dst_nativeObj, long labels_nativeObj, int distanceType, int maskSize, int labelType); + private static native void distanceTransformWithLabels_1(long src_nativeObj, long dst_nativeObj, long labels_nativeObj, int distanceType, int maskSize); + + // C++: void distanceTransform(Mat src, Mat& dst, int distanceType, int maskSize, int dstType = CV_32F) + private static native void distanceTransform_0(long src_nativeObj, long dst_nativeObj, int distanceType, int maskSize, int dstType); + private static native void distanceTransform_1(long src_nativeObj, long dst_nativeObj, int distanceType, int maskSize); + + // C++: void drawContours(Mat& image, vector_vector_Point contours, int contourIdx, Scalar color, int thickness = 1, int lineType = LINE_8, Mat hierarchy = Mat(), int maxLevel = INT_MAX, Point offset = Point()) + private static native void drawContours_0(long image_nativeObj, long contours_mat_nativeObj, int contourIdx, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, long hierarchy_nativeObj, int maxLevel, double offset_x, double offset_y); + private static native void drawContours_1(long image_nativeObj, long contours_mat_nativeObj, int contourIdx, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void drawContours_2(long image_nativeObj, long contours_mat_nativeObj, int contourIdx, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void drawMarker(Mat& img, Point position, Scalar color, int markerType = MARKER_CROSS, int markerSize = 20, int thickness = 1, int line_type = 8) + private static native void drawMarker_0(long img_nativeObj, double position_x, double position_y, double color_val0, double color_val1, double color_val2, double color_val3, int markerType, int markerSize, int thickness, int line_type); + private static native void drawMarker_1(long img_nativeObj, double position_x, double position_y, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + private static native void ellipse_0(long img_nativeObj, double center_x, double center_y, double axes_width, double axes_height, double angle, double startAngle, double endAngle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift); + private static native void ellipse_1(long img_nativeObj, double center_x, double center_y, double axes_width, double axes_height, double angle, double startAngle, double endAngle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void ellipse_2(long img_nativeObj, double center_x, double center_y, double axes_width, double axes_height, double angle, double startAngle, double endAngle, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void ellipse(Mat& img, RotatedRect box, Scalar color, int thickness = 1, int lineType = LINE_8) + private static native void ellipse_3(long img_nativeObj, double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType); + private static native void ellipse_4(long img_nativeObj, double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void ellipse_5(long img_nativeObj, double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, vector_Point& pts) + private static native void ellipse2Poly_0(double center_x, double center_y, double axes_width, double axes_height, int angle, int arcStart, int arcEnd, int delta, long pts_mat_nativeObj); + + // C++: void equalizeHist(Mat src, Mat& dst) + private static native void equalizeHist_0(long src_nativeObj, long dst_nativeObj); + + // C++: void erode(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) + private static native void erode_0(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations, int borderType, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3); + private static native void erode_1(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations); + private static native void erode_2(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj); + + // C++: void fillConvexPoly(Mat& img, vector_Point points, Scalar color, int lineType = LINE_8, int shift = 0) + private static native void fillConvexPoly_0(long img_nativeObj, long points_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3, int lineType, int shift); + private static native void fillConvexPoly_1(long img_nativeObj, long points_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void fillPoly(Mat& img, vector_vector_Point pts, Scalar color, int lineType = LINE_8, int shift = 0, Point offset = Point()) + private static native void fillPoly_0(long img_nativeObj, long pts_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3, int lineType, int shift, double offset_x, double offset_y); + private static native void fillPoly_1(long img_nativeObj, long pts_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void filter2D(Mat src, Mat& dst, int ddepth, Mat kernel, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT) + private static native void filter2D_0(long src_nativeObj, long dst_nativeObj, int ddepth, long kernel_nativeObj, double anchor_x, double anchor_y, double delta, int borderType); + private static native void filter2D_1(long src_nativeObj, long dst_nativeObj, int ddepth, long kernel_nativeObj, double anchor_x, double anchor_y, double delta); + private static native void filter2D_2(long src_nativeObj, long dst_nativeObj, int ddepth, long kernel_nativeObj); + + // C++: void findContours(Mat& image, vector_vector_Point& contours, Mat& hierarchy, int mode, int method, Point offset = Point()) + private static native void findContours_0(long image_nativeObj, long contours_mat_nativeObj, long hierarchy_nativeObj, int mode, int method, double offset_x, double offset_y); + private static native void findContours_1(long image_nativeObj, long contours_mat_nativeObj, long hierarchy_nativeObj, int mode, int method); + + // C++: void fitLine(Mat points, Mat& line, int distType, double param, double reps, double aeps) + private static native void fitLine_0(long points_nativeObj, long line_nativeObj, int distType, double param, double reps, double aeps); + + // C++: void getDerivKernels(Mat& kx, Mat& ky, int dx, int dy, int ksize, bool normalize = false, int ktype = CV_32F) + private static native void getDerivKernels_0(long kx_nativeObj, long ky_nativeObj, int dx, int dy, int ksize, boolean normalize, int ktype); + private static native void getDerivKernels_1(long kx_nativeObj, long ky_nativeObj, int dx, int dy, int ksize); + + // C++: void getRectSubPix(Mat image, Size patchSize, Point2f center, Mat& patch, int patchType = -1) + private static native void getRectSubPix_0(long image_nativeObj, double patchSize_width, double patchSize_height, double center_x, double center_y, long patch_nativeObj, int patchType); + private static native void getRectSubPix_1(long image_nativeObj, double patchSize_width, double patchSize_height, double center_x, double center_y, long patch_nativeObj); + + // C++: void goodFeaturesToTrack(Mat image, vector_Point& corners, int maxCorners, double qualityLevel, double minDistance, Mat mask = Mat(), int blockSize = 3, bool useHarrisDetector = false, double k = 0.04) + private static native void goodFeaturesToTrack_0(long image_nativeObj, long corners_mat_nativeObj, int maxCorners, double qualityLevel, double minDistance, long mask_nativeObj, int blockSize, boolean useHarrisDetector, double k); + private static native void goodFeaturesToTrack_1(long image_nativeObj, long corners_mat_nativeObj, int maxCorners, double qualityLevel, double minDistance); + + // C++: void grabCut(Mat img, Mat& mask, Rect rect, Mat& bgdModel, Mat& fgdModel, int iterCount, int mode = GC_EVAL) + private static native void grabCut_0(long img_nativeObj, long mask_nativeObj, int rect_x, int rect_y, int rect_width, int rect_height, long bgdModel_nativeObj, long fgdModel_nativeObj, int iterCount, int mode); + private static native void grabCut_1(long img_nativeObj, long mask_nativeObj, int rect_x, int rect_y, int rect_width, int rect_height, long bgdModel_nativeObj, long fgdModel_nativeObj, int iterCount); + + // C++: void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2) + private static native void initUndistortRectifyMap_0(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long R_nativeObj, long newCameraMatrix_nativeObj, double size_width, double size_height, int m1type, long map1_nativeObj, long map2_nativeObj); + + // C++: void integral(Mat src, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth = -1, int sqdepth = -1) + private static native void integral3_0(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj, long tilted_nativeObj, int sdepth, int sqdepth); + private static native void integral3_1(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj, long tilted_nativeObj); + + // C++: void integral(Mat src, Mat& sum, Mat& sqsum, int sdepth = -1, int sqdepth = -1) + private static native void integral2_0(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj, int sdepth, int sqdepth); + private static native void integral2_1(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj); + + // C++: void integral(Mat src, Mat& sum, int sdepth = -1) + private static native void integral_0(long src_nativeObj, long sum_nativeObj, int sdepth); + private static native void integral_1(long src_nativeObj, long sum_nativeObj); + + // C++: void invertAffineTransform(Mat M, Mat& iM) + private static native void invertAffineTransform_0(long M_nativeObj, long iM_nativeObj); + + // C++: void line(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + private static native void line_0(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift); + private static native void line_1(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void line_2(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void linearPolar(Mat src, Mat& dst, Point2f center, double maxRadius, int flags) + private static native void linearPolar_0(long src_nativeObj, long dst_nativeObj, double center_x, double center_y, double maxRadius, int flags); + + // C++: void logPolar(Mat src, Mat& dst, Point2f center, double M, int flags) + private static native void logPolar_0(long src_nativeObj, long dst_nativeObj, double center_x, double center_y, double M, int flags); + + // C++: void matchTemplate(Mat image, Mat templ, Mat& result, int method, Mat mask = Mat()) + private static native void matchTemplate_0(long image_nativeObj, long templ_nativeObj, long result_nativeObj, int method, long mask_nativeObj); + private static native void matchTemplate_1(long image_nativeObj, long templ_nativeObj, long result_nativeObj, int method); + + // C++: void medianBlur(Mat src, Mat& dst, int ksize) + private static native void medianBlur_0(long src_nativeObj, long dst_nativeObj, int ksize); + + // C++: void minEnclosingCircle(vector_Point2f points, Point2f& center, float& radius) + private static native void minEnclosingCircle_0(long points_mat_nativeObj, double[] center_out, double[] radius_out); + + // C++: void morphologyEx(Mat src, Mat& dst, int op, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) + private static native void morphologyEx_0(long src_nativeObj, long dst_nativeObj, int op, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations, int borderType, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3); + private static native void morphologyEx_1(long src_nativeObj, long dst_nativeObj, int op, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations); + private static native void morphologyEx_2(long src_nativeObj, long dst_nativeObj, int op, long kernel_nativeObj); + + // C++: void polylines(Mat& img, vector_vector_Point pts, bool isClosed, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + private static native void polylines_0(long img_nativeObj, long pts_mat_nativeObj, boolean isClosed, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift); + private static native void polylines_1(long img_nativeObj, long pts_mat_nativeObj, boolean isClosed, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void polylines_2(long img_nativeObj, long pts_mat_nativeObj, boolean isClosed, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void preCornerDetect(Mat src, Mat& dst, int ksize, int borderType = BORDER_DEFAULT) + private static native void preCornerDetect_0(long src_nativeObj, long dst_nativeObj, int ksize, int borderType); + private static native void preCornerDetect_1(long src_nativeObj, long dst_nativeObj, int ksize); + + // C++: void putText(Mat& img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false) + private static native void putText_0(long img_nativeObj, String text, double org_x, double org_y, int fontFace, double fontScale, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, boolean bottomLeftOrigin); + private static native void putText_1(long img_nativeObj, String text, double org_x, double org_y, int fontFace, double fontScale, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void putText_2(long img_nativeObj, String text, double org_x, double org_y, int fontFace, double fontScale, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void pyrDown(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT) + private static native void pyrDown_0(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height, int borderType); + private static native void pyrDown_1(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height); + private static native void pyrDown_2(long src_nativeObj, long dst_nativeObj); + + // C++: void pyrMeanShiftFiltering(Mat src, Mat& dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1)) + private static native void pyrMeanShiftFiltering_0(long src_nativeObj, long dst_nativeObj, double sp, double sr, int maxLevel, int termcrit_type, int termcrit_maxCount, double termcrit_epsilon); + private static native void pyrMeanShiftFiltering_1(long src_nativeObj, long dst_nativeObj, double sp, double sr); + + // C++: void pyrUp(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT) + private static native void pyrUp_0(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height, int borderType); + private static native void pyrUp_1(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height); + private static native void pyrUp_2(long src_nativeObj, long dst_nativeObj); + + // C++: void rectangle(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) + private static native void rectangle_0(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift); + private static native void rectangle_1(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness); + private static native void rectangle_2(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3); + + // C++: void remap(Mat src, Mat& dst, Mat map1, Mat map2, int interpolation, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) + private static native void remap_0(long src_nativeObj, long dst_nativeObj, long map1_nativeObj, long map2_nativeObj, int interpolation, int borderMode, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3); + private static native void remap_1(long src_nativeObj, long dst_nativeObj, long map1_nativeObj, long map2_nativeObj, int interpolation); + + // C++: void resize(Mat src, Mat& dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR) + private static native void resize_0(long src_nativeObj, long dst_nativeObj, double dsize_width, double dsize_height, double fx, double fy, int interpolation); + private static native void resize_1(long src_nativeObj, long dst_nativeObj, double dsize_width, double dsize_height); + + // C++: void sepFilter2D(Mat src, Mat& dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT) + private static native void sepFilter2D_0(long src_nativeObj, long dst_nativeObj, int ddepth, long kernelX_nativeObj, long kernelY_nativeObj, double anchor_x, double anchor_y, double delta, int borderType); + private static native void sepFilter2D_1(long src_nativeObj, long dst_nativeObj, int ddepth, long kernelX_nativeObj, long kernelY_nativeObj, double anchor_x, double anchor_y, double delta); + private static native void sepFilter2D_2(long src_nativeObj, long dst_nativeObj, int ddepth, long kernelX_nativeObj, long kernelY_nativeObj); + + // C++: void spatialGradient(Mat src, Mat& dx, Mat& dy, int ksize = 3, int borderType = BORDER_DEFAULT) + private static native void spatialGradient_0(long src_nativeObj, long dx_nativeObj, long dy_nativeObj, int ksize, int borderType); + private static native void spatialGradient_1(long src_nativeObj, long dx_nativeObj, long dy_nativeObj, int ksize); + private static native void spatialGradient_2(long src_nativeObj, long dx_nativeObj, long dy_nativeObj); + + // C++: void sqrBoxFilter(Mat _src, Mat& _dst, int ddepth, Size ksize, Point anchor = Point(-1, -1), bool normalize = true, int borderType = BORDER_DEFAULT) + private static native void sqrBoxFilter_0(long _src_nativeObj, long _dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize, int borderType); + private static native void sqrBoxFilter_1(long _src_nativeObj, long _dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize); + private static native void sqrBoxFilter_2(long _src_nativeObj, long _dst_nativeObj, int ddepth, double ksize_width, double ksize_height); + + // C++: void undistort(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix = Mat()) + private static native void undistort_0(long src_nativeObj, long dst_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long newCameraMatrix_nativeObj); + private static native void undistort_1(long src_nativeObj, long dst_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj); + + // C++: void undistortPoints(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat R = Mat(), Mat P = Mat()) + private static native void undistortPoints_0(long src_nativeObj, long dst_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long R_nativeObj, long P_nativeObj); + private static native void undistortPoints_1(long src_nativeObj, long dst_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj); + + // C++: void warpAffine(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) + private static native void warpAffine_0(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags, int borderMode, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3); + private static native void warpAffine_1(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags); + private static native void warpAffine_2(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height); + + // C++: void warpPerspective(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) + private static native void warpPerspective_0(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags, int borderMode, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3); + private static native void warpPerspective_1(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags); + private static native void warpPerspective_2(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height); + + // C++: void watershed(Mat image, Mat& markers) + private static native void watershed_0(long image_nativeObj, long markers_nativeObj); +private static native double[] n_getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/imgproc/LineSegmentDetector.java b/openCVLibrary330/src/main/java/org/opencv/imgproc/LineSegmentDetector.java new file mode 100644 index 00000000000..24003a6faa5 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/imgproc/LineSegmentDetector.java @@ -0,0 +1,99 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.imgproc; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.core.Size; + +// C++: class LineSegmentDetector +//javadoc: LineSegmentDetector +public class LineSegmentDetector extends Algorithm { + + protected LineSegmentDetector(long addr) { super(addr); } + + + // + // C++: int compareSegments(Size size, Mat lines1, Mat lines2, Mat& _image = Mat()) + // + + //javadoc: LineSegmentDetector::compareSegments(size, lines1, lines2, _image) + public int compareSegments(Size size, Mat lines1, Mat lines2, Mat _image) + { + + int retVal = compareSegments_0(nativeObj, size.width, size.height, lines1.nativeObj, lines2.nativeObj, _image.nativeObj); + + return retVal; + } + + //javadoc: LineSegmentDetector::compareSegments(size, lines1, lines2) + public int compareSegments(Size size, Mat lines1, Mat lines2) + { + + int retVal = compareSegments_1(nativeObj, size.width, size.height, lines1.nativeObj, lines2.nativeObj); + + return retVal; + } + + + // + // C++: void detect(Mat _image, Mat& _lines, Mat& width = Mat(), Mat& prec = Mat(), Mat& nfa = Mat()) + // + + //javadoc: LineSegmentDetector::detect(_image, _lines, width, prec, nfa) + public void detect(Mat _image, Mat _lines, Mat width, Mat prec, Mat nfa) + { + + detect_0(nativeObj, _image.nativeObj, _lines.nativeObj, width.nativeObj, prec.nativeObj, nfa.nativeObj); + + return; + } + + //javadoc: LineSegmentDetector::detect(_image, _lines) + public void detect(Mat _image, Mat _lines) + { + + detect_1(nativeObj, _image.nativeObj, _lines.nativeObj); + + return; + } + + + // + // C++: void drawSegments(Mat& _image, Mat lines) + // + + //javadoc: LineSegmentDetector::drawSegments(_image, lines) + public void drawSegments(Mat _image, Mat lines) + { + + drawSegments_0(nativeObj, _image.nativeObj, lines.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: int compareSegments(Size size, Mat lines1, Mat lines2, Mat& _image = Mat()) + private static native int compareSegments_0(long nativeObj, double size_width, double size_height, long lines1_nativeObj, long lines2_nativeObj, long _image_nativeObj); + private static native int compareSegments_1(long nativeObj, double size_width, double size_height, long lines1_nativeObj, long lines2_nativeObj); + + // C++: void detect(Mat _image, Mat& _lines, Mat& width = Mat(), Mat& prec = Mat(), Mat& nfa = Mat()) + private static native void detect_0(long nativeObj, long _image_nativeObj, long _lines_nativeObj, long width_nativeObj, long prec_nativeObj, long nfa_nativeObj); + private static native void detect_1(long nativeObj, long _image_nativeObj, long _lines_nativeObj); + + // C++: void drawSegments(Mat& _image, Mat lines) + private static native void drawSegments_0(long nativeObj, long _image_nativeObj, long lines_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/imgproc/Moments.java b/openCVLibrary330/src/main/java/org/opencv/imgproc/Moments.java new file mode 100644 index 00000000000..2eeebc9875b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/imgproc/Moments.java @@ -0,0 +1,244 @@ +package org.opencv.imgproc; + +import java.lang.Math; + +//javadoc:Moments +public class Moments { + + public double m00; + public double m10; + public double m01; + public double m20; + public double m11; + public double m02; + public double m30; + public double m21; + public double m12; + public double m03; + + public double mu20; + public double mu11; + public double mu02; + public double mu30; + public double mu21; + public double mu12; + public double mu03; + + public double nu20; + public double nu11; + public double nu02; + public double nu30; + public double nu21; + public double nu12; + public double nu03; + + public Moments( + double m00, + double m10, + double m01, + double m20, + double m11, + double m02, + double m30, + double m21, + double m12, + double m03) + { + this.m00 = m00; + this.m10 = m10; + this.m01 = m01; + this.m20 = m20; + this.m11 = m11; + this.m02 = m02; + this.m30 = m30; + this.m21 = m21; + this.m12 = m12; + this.m03 = m03; + this.completeState(); + } + + public Moments() { + this(0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } + + public Moments(double[] vals) { + set(vals); + } + + public void set(double[] vals) { + if (vals != null) { + m00 = vals.length > 0 ? vals[0] : 0; + m10 = vals.length > 1 ? vals[1] : 0; + m01 = vals.length > 2 ? vals[2] : 0; + m20 = vals.length > 3 ? vals[3] : 0; + m11 = vals.length > 4 ? vals[4] : 0; + m02 = vals.length > 5 ? vals[5] : 0; + m30 = vals.length > 6 ? vals[6] : 0; + m21 = vals.length > 7 ? vals[7] : 0; + m12 = vals.length > 8 ? vals[8] : 0; + m03 = vals.length > 9 ? vals[9] : 0; + this.completeState(); + } else { + m00 = 0; + m10 = 0; + m01 = 0; + m20 = 0; + m11 = 0; + m02 = 0; + m30 = 0; + m21 = 0; + m12 = 0; + m03 = 0; + mu20 = 0; + mu11 = 0; + mu02 = 0; + mu30 = 0; + mu21 = 0; + mu12 = 0; + mu03 = 0; + nu20 = 0; + nu11 = 0; + nu02 = 0; + nu30 = 0; + nu21 = 0; + nu12 = 0; + nu03 = 0; + } + } + + @Override + public String toString() { + return "Moments [ " + + "\n" + + "m00=" + m00 + ", " + + "\n" + + "m10=" + m10 + ", " + + "m01=" + m01 + ", " + + "\n" + + "m20=" + m20 + ", " + + "m11=" + m11 + ", " + + "m02=" + m02 + ", " + + "\n" + + "m30=" + m30 + ", " + + "m21=" + m21 + ", " + + "m12=" + m12 + ", " + + "m03=" + m03 + ", " + + "\n" + + "mu20=" + mu20 + ", " + + "mu11=" + mu11 + ", " + + "mu02=" + mu02 + ", " + + "\n" + + "mu30=" + mu30 + ", " + + "mu21=" + mu21 + ", " + + "mu12=" + mu12 + ", " + + "mu03=" + mu03 + ", " + + "\n" + + "nu20=" + nu20 + ", " + + "nu11=" + nu11 + ", " + + "nu02=" + nu02 + ", " + + "\n" + + "nu30=" + nu30 + ", " + + "nu21=" + nu21 + ", " + + "nu12=" + nu12 + ", " + + "nu03=" + nu03 + ", " + + "\n]"; + } + + protected void completeState() + { + double cx = 0, cy = 0; + double mu20, mu11, mu02; + double inv_m00 = 0.0; + + if( Math.abs(this.m00) > 0.00000001 ) + { + inv_m00 = 1. / this.m00; + cx = this.m10 * inv_m00; + cy = this.m01 * inv_m00; + } + + // mu20 = m20 - m10*cx + mu20 = this.m20 - this.m10 * cx; + // mu11 = m11 - m10*cy + mu11 = this.m11 - this.m10 * cy; + // mu02 = m02 - m01*cy + mu02 = this.m02 - this.m01 * cy; + + this.mu20 = mu20; + this.mu11 = mu11; + this.mu02 = mu02; + + // mu30 = m30 - cx*(3*mu20 + cx*m10) + this.mu30 = this.m30 - cx * (3 * mu20 + cx * this.m10); + mu11 += mu11; + // mu21 = m21 - cx*(2*mu11 + cx*m01) - cy*mu20 + this.mu21 = this.m21 - cx * (mu11 + cx * this.m01) - cy * mu20; + // mu12 = m12 - cy*(2*mu11 + cy*m10) - cx*mu02 + this.mu12 = this.m12 - cy * (mu11 + cy * this.m10) - cx * mu02; + // mu03 = m03 - cy*(3*mu02 + cy*m01) + this.mu03 = this.m03 - cy * (3 * mu02 + cy * this.m01); + + + double inv_sqrt_m00 = Math.sqrt(Math.abs(inv_m00)); + double s2 = inv_m00*inv_m00, s3 = s2*inv_sqrt_m00; + + this.nu20 = this.mu20*s2; + this.nu11 = this.mu11*s2; + this.nu02 = this.mu02*s2; + this.nu30 = this.mu30*s3; + this.nu21 = this.mu21*s3; + this.nu12 = this.mu12*s3; + this.nu03 = this.mu03*s3; + + } + + public double get_m00() { return this.m00; } + public double get_m10() { return this.m10; } + public double get_m01() { return this.m01; } + public double get_m20() { return this.m20; } + public double get_m11() { return this.m11; } + public double get_m02() { return this.m02; } + public double get_m30() { return this.m30; } + public double get_m21() { return this.m21; } + public double get_m12() { return this.m12; } + public double get_m03() { return this.m03; } + public double get_mu20() { return this.mu20; } + public double get_mu11() { return this.mu11; } + public double get_mu02() { return this.mu02; } + public double get_mu30() { return this.mu30; } + public double get_mu21() { return this.mu21; } + public double get_mu12() { return this.mu12; } + public double get_mu03() { return this.mu03; } + public double get_nu20() { return this.nu20; } + public double get_nu11() { return this.nu11; } + public double get_nu02() { return this.nu02; } + public double get_nu30() { return this.nu30; } + public double get_nu21() { return this.nu21; } + public double get_nu12() { return this.nu12; } + public double get_nu03() { return this.nu03; } + + public void set_m00(double m00) { this.m00 = m00; } + public void set_m10(double m10) { this.m10 = m10; } + public void set_m01(double m01) { this.m01 = m01; } + public void set_m20(double m20) { this.m20 = m20; } + public void set_m11(double m11) { this.m11 = m11; } + public void set_m02(double m02) { this.m02 = m02; } + public void set_m30(double m30) { this.m30 = m30; } + public void set_m21(double m21) { this.m21 = m21; } + public void set_m12(double m12) { this.m12 = m12; } + public void set_m03(double m03) { this.m03 = m03; } + public void set_mu20(double mu20) { this.mu20 = mu20; } + public void set_mu11(double mu11) { this.mu11 = mu11; } + public void set_mu02(double mu02) { this.mu02 = mu02; } + public void set_mu30(double mu30) { this.mu30 = mu30; } + public void set_mu21(double mu21) { this.mu21 = mu21; } + public void set_mu12(double mu12) { this.mu12 = mu12; } + public void set_mu03(double mu03) { this.mu03 = mu03; } + public void set_nu20(double nu20) { this.nu20 = nu20; } + public void set_nu11(double nu11) { this.nu11 = nu11; } + public void set_nu02(double nu02) { this.nu02 = nu02; } + public void set_nu30(double nu30) { this.nu30 = nu30; } + public void set_nu21(double nu21) { this.nu21 = nu21; } + public void set_nu12(double nu12) { this.nu12 = nu12; } + public void set_nu03(double nu03) { this.nu03 = nu03; } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/imgproc/Subdiv2D.java b/openCVLibrary330/src/main/java/org/opencv/imgproc/Subdiv2D.java new file mode 100644 index 00000000000..36ee6cad27b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/imgproc/Subdiv2D.java @@ -0,0 +1,404 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.imgproc; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfFloat4; +import org.opencv.core.MatOfFloat6; +import org.opencv.core.MatOfInt; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.Point; +import org.opencv.core.Rect; +import org.opencv.utils.Converters; + +// C++: class Subdiv2D +//javadoc: Subdiv2D +public class Subdiv2D { + + protected final long nativeObj; + protected Subdiv2D(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + public static final int + PTLOC_ERROR = -2, + PTLOC_OUTSIDE_RECT = -1, + PTLOC_INSIDE = 0, + PTLOC_VERTEX = 1, + PTLOC_ON_EDGE = 2, + NEXT_AROUND_ORG = 0x00, + NEXT_AROUND_DST = 0x22, + PREV_AROUND_ORG = 0x11, + PREV_AROUND_DST = 0x33, + NEXT_AROUND_LEFT = 0x13, + NEXT_AROUND_RIGHT = 0x31, + PREV_AROUND_LEFT = 0x20, + PREV_AROUND_RIGHT = 0x02; + + + // + // C++: Subdiv2D(Rect rect) + // + + //javadoc: Subdiv2D::Subdiv2D(rect) + public Subdiv2D(Rect rect) + { + + nativeObj = Subdiv2D_0(rect.x, rect.y, rect.width, rect.height); + + return; + } + + + // + // C++: Subdiv2D() + // + + //javadoc: Subdiv2D::Subdiv2D() + public Subdiv2D() + { + + nativeObj = Subdiv2D_1(); + + return; + } + + + // + // C++: Point2f getVertex(int vertex, int* firstEdge = 0) + // + + //javadoc: Subdiv2D::getVertex(vertex, firstEdge) + public Point getVertex(int vertex, int[] firstEdge) + { + double[] firstEdge_out = new double[1]; + Point retVal = new Point(getVertex_0(nativeObj, vertex, firstEdge_out)); + if(firstEdge!=null) firstEdge[0] = (int)firstEdge_out[0]; + return retVal; + } + + //javadoc: Subdiv2D::getVertex(vertex) + public Point getVertex(int vertex) + { + + Point retVal = new Point(getVertex_1(nativeObj, vertex)); + + return retVal; + } + + + // + // C++: int edgeDst(int edge, Point2f* dstpt = 0) + // + + //javadoc: Subdiv2D::edgeDst(edge, dstpt) + public int edgeDst(int edge, Point dstpt) + { + double[] dstpt_out = new double[2]; + int retVal = edgeDst_0(nativeObj, edge, dstpt_out); + if(dstpt!=null){ dstpt.x = dstpt_out[0]; dstpt.y = dstpt_out[1]; } + return retVal; + } + + //javadoc: Subdiv2D::edgeDst(edge) + public int edgeDst(int edge) + { + + int retVal = edgeDst_1(nativeObj, edge); + + return retVal; + } + + + // + // C++: int edgeOrg(int edge, Point2f* orgpt = 0) + // + + //javadoc: Subdiv2D::edgeOrg(edge, orgpt) + public int edgeOrg(int edge, Point orgpt) + { + double[] orgpt_out = new double[2]; + int retVal = edgeOrg_0(nativeObj, edge, orgpt_out); + if(orgpt!=null){ orgpt.x = orgpt_out[0]; orgpt.y = orgpt_out[1]; } + return retVal; + } + + //javadoc: Subdiv2D::edgeOrg(edge) + public int edgeOrg(int edge) + { + + int retVal = edgeOrg_1(nativeObj, edge); + + return retVal; + } + + + // + // C++: int findNearest(Point2f pt, Point2f* nearestPt = 0) + // + + //javadoc: Subdiv2D::findNearest(pt, nearestPt) + public int findNearest(Point pt, Point nearestPt) + { + double[] nearestPt_out = new double[2]; + int retVal = findNearest_0(nativeObj, pt.x, pt.y, nearestPt_out); + if(nearestPt!=null){ nearestPt.x = nearestPt_out[0]; nearestPt.y = nearestPt_out[1]; } + return retVal; + } + + //javadoc: Subdiv2D::findNearest(pt) + public int findNearest(Point pt) + { + + int retVal = findNearest_1(nativeObj, pt.x, pt.y); + + return retVal; + } + + + // + // C++: int getEdge(int edge, int nextEdgeType) + // + + //javadoc: Subdiv2D::getEdge(edge, nextEdgeType) + public int getEdge(int edge, int nextEdgeType) + { + + int retVal = getEdge_0(nativeObj, edge, nextEdgeType); + + return retVal; + } + + + // + // C++: int insert(Point2f pt) + // + + //javadoc: Subdiv2D::insert(pt) + public int insert(Point pt) + { + + int retVal = insert_0(nativeObj, pt.x, pt.y); + + return retVal; + } + + + // + // C++: int locate(Point2f pt, int& edge, int& vertex) + // + + //javadoc: Subdiv2D::locate(pt, edge, vertex) + public int locate(Point pt, int[] edge, int[] vertex) + { + double[] edge_out = new double[1]; + double[] vertex_out = new double[1]; + int retVal = locate_0(nativeObj, pt.x, pt.y, edge_out, vertex_out); + if(edge!=null) edge[0] = (int)edge_out[0]; + if(vertex!=null) vertex[0] = (int)vertex_out[0]; + return retVal; + } + + + // + // C++: int nextEdge(int edge) + // + + //javadoc: Subdiv2D::nextEdge(edge) + public int nextEdge(int edge) + { + + int retVal = nextEdge_0(nativeObj, edge); + + return retVal; + } + + + // + // C++: int rotateEdge(int edge, int rotate) + // + + //javadoc: Subdiv2D::rotateEdge(edge, rotate) + public int rotateEdge(int edge, int rotate) + { + + int retVal = rotateEdge_0(nativeObj, edge, rotate); + + return retVal; + } + + + // + // C++: int symEdge(int edge) + // + + //javadoc: Subdiv2D::symEdge(edge) + public int symEdge(int edge) + { + + int retVal = symEdge_0(nativeObj, edge); + + return retVal; + } + + + // + // C++: void getEdgeList(vector_Vec4f& edgeList) + // + + //javadoc: Subdiv2D::getEdgeList(edgeList) + public void getEdgeList(MatOfFloat4 edgeList) + { + Mat edgeList_mat = edgeList; + getEdgeList_0(nativeObj, edgeList_mat.nativeObj); + + return; + } + + + // + // C++: void getLeadingEdgeList(vector_int& leadingEdgeList) + // + + //javadoc: Subdiv2D::getLeadingEdgeList(leadingEdgeList) + public void getLeadingEdgeList(MatOfInt leadingEdgeList) + { + Mat leadingEdgeList_mat = leadingEdgeList; + getLeadingEdgeList_0(nativeObj, leadingEdgeList_mat.nativeObj); + + return; + } + + + // + // C++: void getTriangleList(vector_Vec6f& triangleList) + // + + //javadoc: Subdiv2D::getTriangleList(triangleList) + public void getTriangleList(MatOfFloat6 triangleList) + { + Mat triangleList_mat = triangleList; + getTriangleList_0(nativeObj, triangleList_mat.nativeObj); + + return; + } + + + // + // C++: void getVoronoiFacetList(vector_int idx, vector_vector_Point2f& facetList, vector_Point2f& facetCenters) + // + + //javadoc: Subdiv2D::getVoronoiFacetList(idx, facetList, facetCenters) + public void getVoronoiFacetList(MatOfInt idx, List facetList, MatOfPoint2f facetCenters) + { + Mat idx_mat = idx; + Mat facetList_mat = new Mat(); + Mat facetCenters_mat = facetCenters; + getVoronoiFacetList_0(nativeObj, idx_mat.nativeObj, facetList_mat.nativeObj, facetCenters_mat.nativeObj); + Converters.Mat_to_vector_vector_Point2f(facetList_mat, facetList); + facetList_mat.release(); + return; + } + + + // + // C++: void initDelaunay(Rect rect) + // + + //javadoc: Subdiv2D::initDelaunay(rect) + public void initDelaunay(Rect rect) + { + + initDelaunay_0(nativeObj, rect.x, rect.y, rect.width, rect.height); + + return; + } + + + // + // C++: void insert(vector_Point2f ptvec) + // + + //javadoc: Subdiv2D::insert(ptvec) + public void insert(MatOfPoint2f ptvec) + { + Mat ptvec_mat = ptvec; + insert_1(nativeObj, ptvec_mat.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Subdiv2D(Rect rect) + private static native long Subdiv2D_0(int rect_x, int rect_y, int rect_width, int rect_height); + + // C++: Subdiv2D() + private static native long Subdiv2D_1(); + + // C++: Point2f getVertex(int vertex, int* firstEdge = 0) + private static native double[] getVertex_0(long nativeObj, int vertex, double[] firstEdge_out); + private static native double[] getVertex_1(long nativeObj, int vertex); + + // C++: int edgeDst(int edge, Point2f* dstpt = 0) + private static native int edgeDst_0(long nativeObj, int edge, double[] dstpt_out); + private static native int edgeDst_1(long nativeObj, int edge); + + // C++: int edgeOrg(int edge, Point2f* orgpt = 0) + private static native int edgeOrg_0(long nativeObj, int edge, double[] orgpt_out); + private static native int edgeOrg_1(long nativeObj, int edge); + + // C++: int findNearest(Point2f pt, Point2f* nearestPt = 0) + private static native int findNearest_0(long nativeObj, double pt_x, double pt_y, double[] nearestPt_out); + private static native int findNearest_1(long nativeObj, double pt_x, double pt_y); + + // C++: int getEdge(int edge, int nextEdgeType) + private static native int getEdge_0(long nativeObj, int edge, int nextEdgeType); + + // C++: int insert(Point2f pt) + private static native int insert_0(long nativeObj, double pt_x, double pt_y); + + // C++: int locate(Point2f pt, int& edge, int& vertex) + private static native int locate_0(long nativeObj, double pt_x, double pt_y, double[] edge_out, double[] vertex_out); + + // C++: int nextEdge(int edge) + private static native int nextEdge_0(long nativeObj, int edge); + + // C++: int rotateEdge(int edge, int rotate) + private static native int rotateEdge_0(long nativeObj, int edge, int rotate); + + // C++: int symEdge(int edge) + private static native int symEdge_0(long nativeObj, int edge); + + // C++: void getEdgeList(vector_Vec4f& edgeList) + private static native void getEdgeList_0(long nativeObj, long edgeList_mat_nativeObj); + + // C++: void getLeadingEdgeList(vector_int& leadingEdgeList) + private static native void getLeadingEdgeList_0(long nativeObj, long leadingEdgeList_mat_nativeObj); + + // C++: void getTriangleList(vector_Vec6f& triangleList) + private static native void getTriangleList_0(long nativeObj, long triangleList_mat_nativeObj); + + // C++: void getVoronoiFacetList(vector_int idx, vector_vector_Point2f& facetList, vector_Point2f& facetCenters) + private static native void getVoronoiFacetList_0(long nativeObj, long idx_mat_nativeObj, long facetList_mat_nativeObj, long facetCenters_mat_nativeObj); + + // C++: void initDelaunay(Rect rect) + private static native void initDelaunay_0(long nativeObj, int rect_x, int rect_y, int rect_width, int rect_height); + + // C++: void insert(vector_Point2f ptvec) + private static native void insert_1(long nativeObj, long ptvec_mat_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/ANN_MLP.java b/openCVLibrary330/src/main/java/org/opencv/ml/ANN_MLP.java new file mode 100644 index 00000000000..43f48878260 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/ANN_MLP.java @@ -0,0 +1,467 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; + +// C++: class ANN_MLP +//javadoc: ANN_MLP +public class ANN_MLP extends StatModel { + + protected ANN_MLP(long addr) { super(addr); } + + + public static final int + BACKPROP = 0, + RPROP = 1, + IDENTITY = 0, + SIGMOID_SYM = 1, + GAUSSIAN = 2, + UPDATE_WEIGHTS = 1, + NO_INPUT_SCALE = 2, + NO_OUTPUT_SCALE = 4; + + + // + // C++: Mat getLayerSizes() + // + + //javadoc: ANN_MLP::getLayerSizes() + public Mat getLayerSizes() + { + + Mat retVal = new Mat(getLayerSizes_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getWeights(int layerIdx) + // + + //javadoc: ANN_MLP::getWeights(layerIdx) + public Mat getWeights(int layerIdx) + { + + Mat retVal = new Mat(getWeights_0(nativeObj, layerIdx)); + + return retVal; + } + + + // + // C++: static Ptr_ANN_MLP create() + // + + //javadoc: ANN_MLP::create() + public static ANN_MLP create() + { + + ANN_MLP retVal = new ANN_MLP(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_ANN_MLP load(String filepath) + // + + //javadoc: ANN_MLP::load(filepath) + public static ANN_MLP load(String filepath) + { + + ANN_MLP retVal = new ANN_MLP(load_0(filepath)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: ANN_MLP::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: double getBackpropMomentumScale() + // + + //javadoc: ANN_MLP::getBackpropMomentumScale() + public double getBackpropMomentumScale() + { + + double retVal = getBackpropMomentumScale_0(nativeObj); + + return retVal; + } + + + // + // C++: double getBackpropWeightScale() + // + + //javadoc: ANN_MLP::getBackpropWeightScale() + public double getBackpropWeightScale() + { + + double retVal = getBackpropWeightScale_0(nativeObj); + + return retVal; + } + + + // + // C++: double getRpropDW0() + // + + //javadoc: ANN_MLP::getRpropDW0() + public double getRpropDW0() + { + + double retVal = getRpropDW0_0(nativeObj); + + return retVal; + } + + + // + // C++: double getRpropDWMax() + // + + //javadoc: ANN_MLP::getRpropDWMax() + public double getRpropDWMax() + { + + double retVal = getRpropDWMax_0(nativeObj); + + return retVal; + } + + + // + // C++: double getRpropDWMin() + // + + //javadoc: ANN_MLP::getRpropDWMin() + public double getRpropDWMin() + { + + double retVal = getRpropDWMin_0(nativeObj); + + return retVal; + } + + + // + // C++: double getRpropDWMinus() + // + + //javadoc: ANN_MLP::getRpropDWMinus() + public double getRpropDWMinus() + { + + double retVal = getRpropDWMinus_0(nativeObj); + + return retVal; + } + + + // + // C++: double getRpropDWPlus() + // + + //javadoc: ANN_MLP::getRpropDWPlus() + public double getRpropDWPlus() + { + + double retVal = getRpropDWPlus_0(nativeObj); + + return retVal; + } + + + // + // C++: int getTrainMethod() + // + + //javadoc: ANN_MLP::getTrainMethod() + public int getTrainMethod() + { + + int retVal = getTrainMethod_0(nativeObj); + + return retVal; + } + + + // + // C++: void setActivationFunction(int type, double param1 = 0, double param2 = 0) + // + + //javadoc: ANN_MLP::setActivationFunction(type, param1, param2) + public void setActivationFunction(int type, double param1, double param2) + { + + setActivationFunction_0(nativeObj, type, param1, param2); + + return; + } + + //javadoc: ANN_MLP::setActivationFunction(type) + public void setActivationFunction(int type) + { + + setActivationFunction_1(nativeObj, type); + + return; + } + + + // + // C++: void setBackpropMomentumScale(double val) + // + + //javadoc: ANN_MLP::setBackpropMomentumScale(val) + public void setBackpropMomentumScale(double val) + { + + setBackpropMomentumScale_0(nativeObj, val); + + return; + } + + + // + // C++: void setBackpropWeightScale(double val) + // + + //javadoc: ANN_MLP::setBackpropWeightScale(val) + public void setBackpropWeightScale(double val) + { + + setBackpropWeightScale_0(nativeObj, val); + + return; + } + + + // + // C++: void setLayerSizes(Mat _layer_sizes) + // + + //javadoc: ANN_MLP::setLayerSizes(_layer_sizes) + public void setLayerSizes(Mat _layer_sizes) + { + + setLayerSizes_0(nativeObj, _layer_sizes.nativeObj); + + return; + } + + + // + // C++: void setRpropDW0(double val) + // + + //javadoc: ANN_MLP::setRpropDW0(val) + public void setRpropDW0(double val) + { + + setRpropDW0_0(nativeObj, val); + + return; + } + + + // + // C++: void setRpropDWMax(double val) + // + + //javadoc: ANN_MLP::setRpropDWMax(val) + public void setRpropDWMax(double val) + { + + setRpropDWMax_0(nativeObj, val); + + return; + } + + + // + // C++: void setRpropDWMin(double val) + // + + //javadoc: ANN_MLP::setRpropDWMin(val) + public void setRpropDWMin(double val) + { + + setRpropDWMin_0(nativeObj, val); + + return; + } + + + // + // C++: void setRpropDWMinus(double val) + // + + //javadoc: ANN_MLP::setRpropDWMinus(val) + public void setRpropDWMinus(double val) + { + + setRpropDWMinus_0(nativeObj, val); + + return; + } + + + // + // C++: void setRpropDWPlus(double val) + // + + //javadoc: ANN_MLP::setRpropDWPlus(val) + public void setRpropDWPlus(double val) + { + + setRpropDWPlus_0(nativeObj, val); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria val) + // + + //javadoc: ANN_MLP::setTermCriteria(val) + public void setTermCriteria(TermCriteria val) + { + + setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon); + + return; + } + + + // + // C++: void setTrainMethod(int method, double param1 = 0, double param2 = 0) + // + + //javadoc: ANN_MLP::setTrainMethod(method, param1, param2) + public void setTrainMethod(int method, double param1, double param2) + { + + setTrainMethod_0(nativeObj, method, param1, param2); + + return; + } + + //javadoc: ANN_MLP::setTrainMethod(method) + public void setTrainMethod(int method) + { + + setTrainMethod_1(nativeObj, method); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getLayerSizes() + private static native long getLayerSizes_0(long nativeObj); + + // C++: Mat getWeights(int layerIdx) + private static native long getWeights_0(long nativeObj, int layerIdx); + + // C++: static Ptr_ANN_MLP create() + private static native long create_0(); + + // C++: static Ptr_ANN_MLP load(String filepath) + private static native long load_0(String filepath); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: double getBackpropMomentumScale() + private static native double getBackpropMomentumScale_0(long nativeObj); + + // C++: double getBackpropWeightScale() + private static native double getBackpropWeightScale_0(long nativeObj); + + // C++: double getRpropDW0() + private static native double getRpropDW0_0(long nativeObj); + + // C++: double getRpropDWMax() + private static native double getRpropDWMax_0(long nativeObj); + + // C++: double getRpropDWMin() + private static native double getRpropDWMin_0(long nativeObj); + + // C++: double getRpropDWMinus() + private static native double getRpropDWMinus_0(long nativeObj); + + // C++: double getRpropDWPlus() + private static native double getRpropDWPlus_0(long nativeObj); + + // C++: int getTrainMethod() + private static native int getTrainMethod_0(long nativeObj); + + // C++: void setActivationFunction(int type, double param1 = 0, double param2 = 0) + private static native void setActivationFunction_0(long nativeObj, int type, double param1, double param2); + private static native void setActivationFunction_1(long nativeObj, int type); + + // C++: void setBackpropMomentumScale(double val) + private static native void setBackpropMomentumScale_0(long nativeObj, double val); + + // C++: void setBackpropWeightScale(double val) + private static native void setBackpropWeightScale_0(long nativeObj, double val); + + // C++: void setLayerSizes(Mat _layer_sizes) + private static native void setLayerSizes_0(long nativeObj, long _layer_sizes_nativeObj); + + // C++: void setRpropDW0(double val) + private static native void setRpropDW0_0(long nativeObj, double val); + + // C++: void setRpropDWMax(double val) + private static native void setRpropDWMax_0(long nativeObj, double val); + + // C++: void setRpropDWMin(double val) + private static native void setRpropDWMin_0(long nativeObj, double val); + + // C++: void setRpropDWMinus(double val) + private static native void setRpropDWMinus_0(long nativeObj, double val); + + // C++: void setRpropDWPlus(double val) + private static native void setRpropDWPlus_0(long nativeObj, double val); + + // C++: void setTermCriteria(TermCriteria val) + private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon); + + // C++: void setTrainMethod(int method, double param1 = 0, double param2 = 0) + private static native void setTrainMethod_0(long nativeObj, int method, double param1, double param2); + private static native void setTrainMethod_1(long nativeObj, int method); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/Boost.java b/openCVLibrary330/src/main/java/org/opencv/ml/Boost.java new file mode 100644 index 00000000000..0aa015ba96d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/Boost.java @@ -0,0 +1,179 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; + +// C++: class Boost +//javadoc: Boost +public class Boost extends DTrees { + + protected Boost(long addr) { super(addr); } + + + public static final int + DISCRETE = 0, + REAL = 1, + LOGIT = 2, + GENTLE = 3; + + + // + // C++: static Ptr_Boost create() + // + + //javadoc: Boost::create() + public static Boost create() + { + + Boost retVal = new Boost(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_Boost load(String filepath, String nodeName = String()) + // + + //javadoc: Boost::load(filepath, nodeName) + public static Boost load(String filepath, String nodeName) + { + + Boost retVal = new Boost(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: Boost::load(filepath) + public static Boost load(String filepath) + { + + Boost retVal = new Boost(load_1(filepath)); + + return retVal; + } + + + // + // C++: double getWeightTrimRate() + // + + //javadoc: Boost::getWeightTrimRate() + public double getWeightTrimRate() + { + + double retVal = getWeightTrimRate_0(nativeObj); + + return retVal; + } + + + // + // C++: int getBoostType() + // + + //javadoc: Boost::getBoostType() + public int getBoostType() + { + + int retVal = getBoostType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getWeakCount() + // + + //javadoc: Boost::getWeakCount() + public int getWeakCount() + { + + int retVal = getWeakCount_0(nativeObj); + + return retVal; + } + + + // + // C++: void setBoostType(int val) + // + + //javadoc: Boost::setBoostType(val) + public void setBoostType(int val) + { + + setBoostType_0(nativeObj, val); + + return; + } + + + // + // C++: void setWeakCount(int val) + // + + //javadoc: Boost::setWeakCount(val) + public void setWeakCount(int val) + { + + setWeakCount_0(nativeObj, val); + + return; + } + + + // + // C++: void setWeightTrimRate(double val) + // + + //javadoc: Boost::setWeightTrimRate(val) + public void setWeightTrimRate(double val) + { + + setWeightTrimRate_0(nativeObj, val); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_Boost create() + private static native long create_0(); + + // C++: static Ptr_Boost load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: double getWeightTrimRate() + private static native double getWeightTrimRate_0(long nativeObj); + + // C++: int getBoostType() + private static native int getBoostType_0(long nativeObj); + + // C++: int getWeakCount() + private static native int getWeakCount_0(long nativeObj); + + // C++: void setBoostType(int val) + private static native void setBoostType_0(long nativeObj, int val); + + // C++: void setWeakCount(int val) + private static native void setWeakCount_0(long nativeObj, int val); + + // C++: void setWeightTrimRate(double val) + private static native void setWeightTrimRate_0(long nativeObj, double val); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/DTrees.java b/openCVLibrary330/src/main/java/org/opencv/ml/DTrees.java new file mode 100644 index 00000000000..563cbd4c5ce --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/DTrees.java @@ -0,0 +1,384 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; + +// C++: class DTrees +//javadoc: DTrees +public class DTrees extends StatModel { + + protected DTrees(long addr) { super(addr); } + + + public static final int + PREDICT_AUTO = 0, + PREDICT_SUM = (1<<8), + PREDICT_MAX_VOTE = (2<<8), + PREDICT_MASK = (3<<8); + + + // + // C++: Mat getPriors() + // + + //javadoc: DTrees::getPriors() + public Mat getPriors() + { + + Mat retVal = new Mat(getPriors_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_DTrees create() + // + + //javadoc: DTrees::create() + public static DTrees create() + { + + DTrees retVal = new DTrees(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_DTrees load(String filepath, String nodeName = String()) + // + + //javadoc: DTrees::load(filepath, nodeName) + public static DTrees load(String filepath, String nodeName) + { + + DTrees retVal = new DTrees(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: DTrees::load(filepath) + public static DTrees load(String filepath) + { + + DTrees retVal = new DTrees(load_1(filepath)); + + return retVal; + } + + + // + // C++: bool getTruncatePrunedTree() + // + + //javadoc: DTrees::getTruncatePrunedTree() + public boolean getTruncatePrunedTree() + { + + boolean retVal = getTruncatePrunedTree_0(nativeObj); + + return retVal; + } + + + // + // C++: bool getUse1SERule() + // + + //javadoc: DTrees::getUse1SERule() + public boolean getUse1SERule() + { + + boolean retVal = getUse1SERule_0(nativeObj); + + return retVal; + } + + + // + // C++: bool getUseSurrogates() + // + + //javadoc: DTrees::getUseSurrogates() + public boolean getUseSurrogates() + { + + boolean retVal = getUseSurrogates_0(nativeObj); + + return retVal; + } + + + // + // C++: float getRegressionAccuracy() + // + + //javadoc: DTrees::getRegressionAccuracy() + public float getRegressionAccuracy() + { + + float retVal = getRegressionAccuracy_0(nativeObj); + + return retVal; + } + + + // + // C++: int getCVFolds() + // + + //javadoc: DTrees::getCVFolds() + public int getCVFolds() + { + + int retVal = getCVFolds_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxCategories() + // + + //javadoc: DTrees::getMaxCategories() + public int getMaxCategories() + { + + int retVal = getMaxCategories_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxDepth() + // + + //javadoc: DTrees::getMaxDepth() + public int getMaxDepth() + { + + int retVal = getMaxDepth_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMinSampleCount() + // + + //javadoc: DTrees::getMinSampleCount() + public int getMinSampleCount() + { + + int retVal = getMinSampleCount_0(nativeObj); + + return retVal; + } + + + // + // C++: void setCVFolds(int val) + // + + //javadoc: DTrees::setCVFolds(val) + public void setCVFolds(int val) + { + + setCVFolds_0(nativeObj, val); + + return; + } + + + // + // C++: void setMaxCategories(int val) + // + + //javadoc: DTrees::setMaxCategories(val) + public void setMaxCategories(int val) + { + + setMaxCategories_0(nativeObj, val); + + return; + } + + + // + // C++: void setMaxDepth(int val) + // + + //javadoc: DTrees::setMaxDepth(val) + public void setMaxDepth(int val) + { + + setMaxDepth_0(nativeObj, val); + + return; + } + + + // + // C++: void setMinSampleCount(int val) + // + + //javadoc: DTrees::setMinSampleCount(val) + public void setMinSampleCount(int val) + { + + setMinSampleCount_0(nativeObj, val); + + return; + } + + + // + // C++: void setPriors(Mat val) + // + + //javadoc: DTrees::setPriors(val) + public void setPriors(Mat val) + { + + setPriors_0(nativeObj, val.nativeObj); + + return; + } + + + // + // C++: void setRegressionAccuracy(float val) + // + + //javadoc: DTrees::setRegressionAccuracy(val) + public void setRegressionAccuracy(float val) + { + + setRegressionAccuracy_0(nativeObj, val); + + return; + } + + + // + // C++: void setTruncatePrunedTree(bool val) + // + + //javadoc: DTrees::setTruncatePrunedTree(val) + public void setTruncatePrunedTree(boolean val) + { + + setTruncatePrunedTree_0(nativeObj, val); + + return; + } + + + // + // C++: void setUse1SERule(bool val) + // + + //javadoc: DTrees::setUse1SERule(val) + public void setUse1SERule(boolean val) + { + + setUse1SERule_0(nativeObj, val); + + return; + } + + + // + // C++: void setUseSurrogates(bool val) + // + + //javadoc: DTrees::setUseSurrogates(val) + public void setUseSurrogates(boolean val) + { + + setUseSurrogates_0(nativeObj, val); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getPriors() + private static native long getPriors_0(long nativeObj); + + // C++: static Ptr_DTrees create() + private static native long create_0(); + + // C++: static Ptr_DTrees load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: bool getTruncatePrunedTree() + private static native boolean getTruncatePrunedTree_0(long nativeObj); + + // C++: bool getUse1SERule() + private static native boolean getUse1SERule_0(long nativeObj); + + // C++: bool getUseSurrogates() + private static native boolean getUseSurrogates_0(long nativeObj); + + // C++: float getRegressionAccuracy() + private static native float getRegressionAccuracy_0(long nativeObj); + + // C++: int getCVFolds() + private static native int getCVFolds_0(long nativeObj); + + // C++: int getMaxCategories() + private static native int getMaxCategories_0(long nativeObj); + + // C++: int getMaxDepth() + private static native int getMaxDepth_0(long nativeObj); + + // C++: int getMinSampleCount() + private static native int getMinSampleCount_0(long nativeObj); + + // C++: void setCVFolds(int val) + private static native void setCVFolds_0(long nativeObj, int val); + + // C++: void setMaxCategories(int val) + private static native void setMaxCategories_0(long nativeObj, int val); + + // C++: void setMaxDepth(int val) + private static native void setMaxDepth_0(long nativeObj, int val); + + // C++: void setMinSampleCount(int val) + private static native void setMinSampleCount_0(long nativeObj, int val); + + // C++: void setPriors(Mat val) + private static native void setPriors_0(long nativeObj, long val_nativeObj); + + // C++: void setRegressionAccuracy(float val) + private static native void setRegressionAccuracy_0(long nativeObj, float val); + + // C++: void setTruncatePrunedTree(bool val) + private static native void setTruncatePrunedTree_0(long nativeObj, boolean val); + + // C++: void setUse1SERule(bool val) + private static native void setUse1SERule_0(long nativeObj, boolean val); + + // C++: void setUseSurrogates(bool val) + private static native void setUseSurrogates_0(long nativeObj, boolean val); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/EM.java b/openCVLibrary330/src/main/java/org/opencv/ml/EM.java new file mode 100644 index 00000000000..97bc708ae50 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/EM.java @@ -0,0 +1,366 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; +import org.opencv.utils.Converters; + +// C++: class EM +//javadoc: EM +public class EM extends StatModel { + + protected EM(long addr) { super(addr); } + + + public static final int + COV_MAT_SPHERICAL = 0, + COV_MAT_DIAGONAL = 1, + COV_MAT_GENERIC = 2, + COV_MAT_DEFAULT = COV_MAT_DIAGONAL, + DEFAULT_NCLUSTERS = 5, + DEFAULT_MAX_ITERS = 100, + START_E_STEP = 1, + START_M_STEP = 2, + START_AUTO_STEP = 0; + + + // + // C++: Mat getMeans() + // + + //javadoc: EM::getMeans() + public Mat getMeans() + { + + Mat retVal = new Mat(getMeans_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getWeights() + // + + //javadoc: EM::getWeights() + public Mat getWeights() + { + + Mat retVal = new Mat(getWeights_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_EM create() + // + + //javadoc: EM::create() + public static EM create() + { + + EM retVal = new EM(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_EM load(String filepath, String nodeName = String()) + // + + //javadoc: EM::load(filepath, nodeName) + public static EM load(String filepath, String nodeName) + { + + EM retVal = new EM(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: EM::load(filepath) + public static EM load(String filepath) + { + + EM retVal = new EM(load_1(filepath)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: EM::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: Vec2d predict2(Mat sample, Mat& probs) + // + + //javadoc: EM::predict2(sample, probs) + public double[] predict2(Mat sample, Mat probs) + { + + double[] retVal = predict2_0(nativeObj, sample.nativeObj, probs.nativeObj); + + return retVal; + } + + + // + // C++: bool trainE(Mat samples, Mat means0, Mat covs0 = Mat(), Mat weights0 = Mat(), Mat& logLikelihoods = Mat(), Mat& labels = Mat(), Mat& probs = Mat()) + // + + //javadoc: EM::trainE(samples, means0, covs0, weights0, logLikelihoods, labels, probs) + public boolean trainE(Mat samples, Mat means0, Mat covs0, Mat weights0, Mat logLikelihoods, Mat labels, Mat probs) + { + + boolean retVal = trainE_0(nativeObj, samples.nativeObj, means0.nativeObj, covs0.nativeObj, weights0.nativeObj, logLikelihoods.nativeObj, labels.nativeObj, probs.nativeObj); + + return retVal; + } + + //javadoc: EM::trainE(samples, means0) + public boolean trainE(Mat samples, Mat means0) + { + + boolean retVal = trainE_1(nativeObj, samples.nativeObj, means0.nativeObj); + + return retVal; + } + + + // + // C++: bool trainEM(Mat samples, Mat& logLikelihoods = Mat(), Mat& labels = Mat(), Mat& probs = Mat()) + // + + //javadoc: EM::trainEM(samples, logLikelihoods, labels, probs) + public boolean trainEM(Mat samples, Mat logLikelihoods, Mat labels, Mat probs) + { + + boolean retVal = trainEM_0(nativeObj, samples.nativeObj, logLikelihoods.nativeObj, labels.nativeObj, probs.nativeObj); + + return retVal; + } + + //javadoc: EM::trainEM(samples) + public boolean trainEM(Mat samples) + { + + boolean retVal = trainEM_1(nativeObj, samples.nativeObj); + + return retVal; + } + + + // + // C++: bool trainM(Mat samples, Mat probs0, Mat& logLikelihoods = Mat(), Mat& labels = Mat(), Mat& probs = Mat()) + // + + //javadoc: EM::trainM(samples, probs0, logLikelihoods, labels, probs) + public boolean trainM(Mat samples, Mat probs0, Mat logLikelihoods, Mat labels, Mat probs) + { + + boolean retVal = trainM_0(nativeObj, samples.nativeObj, probs0.nativeObj, logLikelihoods.nativeObj, labels.nativeObj, probs.nativeObj); + + return retVal; + } + + //javadoc: EM::trainM(samples, probs0) + public boolean trainM(Mat samples, Mat probs0) + { + + boolean retVal = trainM_1(nativeObj, samples.nativeObj, probs0.nativeObj); + + return retVal; + } + + + // + // C++: float predict(Mat samples, Mat& results = Mat(), int flags = 0) + // + + //javadoc: EM::predict(samples, results, flags) + public float predict(Mat samples, Mat results, int flags) + { + + float retVal = predict_0(nativeObj, samples.nativeObj, results.nativeObj, flags); + + return retVal; + } + + //javadoc: EM::predict(samples) + public float predict(Mat samples) + { + + float retVal = predict_1(nativeObj, samples.nativeObj); + + return retVal; + } + + + // + // C++: int getClustersNumber() + // + + //javadoc: EM::getClustersNumber() + public int getClustersNumber() + { + + int retVal = getClustersNumber_0(nativeObj); + + return retVal; + } + + + // + // C++: int getCovarianceMatrixType() + // + + //javadoc: EM::getCovarianceMatrixType() + public int getCovarianceMatrixType() + { + + int retVal = getCovarianceMatrixType_0(nativeObj); + + return retVal; + } + + + // + // C++: void getCovs(vector_Mat& covs) + // + + //javadoc: EM::getCovs(covs) + public void getCovs(List covs) + { + Mat covs_mat = new Mat(); + getCovs_0(nativeObj, covs_mat.nativeObj); + Converters.Mat_to_vector_Mat(covs_mat, covs); + covs_mat.release(); + return; + } + + + // + // C++: void setClustersNumber(int val) + // + + //javadoc: EM::setClustersNumber(val) + public void setClustersNumber(int val) + { + + setClustersNumber_0(nativeObj, val); + + return; + } + + + // + // C++: void setCovarianceMatrixType(int val) + // + + //javadoc: EM::setCovarianceMatrixType(val) + public void setCovarianceMatrixType(int val) + { + + setCovarianceMatrixType_0(nativeObj, val); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria val) + // + + //javadoc: EM::setTermCriteria(val) + public void setTermCriteria(TermCriteria val) + { + + setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getMeans() + private static native long getMeans_0(long nativeObj); + + // C++: Mat getWeights() + private static native long getWeights_0(long nativeObj); + + // C++: static Ptr_EM create() + private static native long create_0(); + + // C++: static Ptr_EM load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: Vec2d predict2(Mat sample, Mat& probs) + private static native double[] predict2_0(long nativeObj, long sample_nativeObj, long probs_nativeObj); + + // C++: bool trainE(Mat samples, Mat means0, Mat covs0 = Mat(), Mat weights0 = Mat(), Mat& logLikelihoods = Mat(), Mat& labels = Mat(), Mat& probs = Mat()) + private static native boolean trainE_0(long nativeObj, long samples_nativeObj, long means0_nativeObj, long covs0_nativeObj, long weights0_nativeObj, long logLikelihoods_nativeObj, long labels_nativeObj, long probs_nativeObj); + private static native boolean trainE_1(long nativeObj, long samples_nativeObj, long means0_nativeObj); + + // C++: bool trainEM(Mat samples, Mat& logLikelihoods = Mat(), Mat& labels = Mat(), Mat& probs = Mat()) + private static native boolean trainEM_0(long nativeObj, long samples_nativeObj, long logLikelihoods_nativeObj, long labels_nativeObj, long probs_nativeObj); + private static native boolean trainEM_1(long nativeObj, long samples_nativeObj); + + // C++: bool trainM(Mat samples, Mat probs0, Mat& logLikelihoods = Mat(), Mat& labels = Mat(), Mat& probs = Mat()) + private static native boolean trainM_0(long nativeObj, long samples_nativeObj, long probs0_nativeObj, long logLikelihoods_nativeObj, long labels_nativeObj, long probs_nativeObj); + private static native boolean trainM_1(long nativeObj, long samples_nativeObj, long probs0_nativeObj); + + // C++: float predict(Mat samples, Mat& results = Mat(), int flags = 0) + private static native float predict_0(long nativeObj, long samples_nativeObj, long results_nativeObj, int flags); + private static native float predict_1(long nativeObj, long samples_nativeObj); + + // C++: int getClustersNumber() + private static native int getClustersNumber_0(long nativeObj); + + // C++: int getCovarianceMatrixType() + private static native int getCovarianceMatrixType_0(long nativeObj); + + // C++: void getCovs(vector_Mat& covs) + private static native void getCovs_0(long nativeObj, long covs_mat_nativeObj); + + // C++: void setClustersNumber(int val) + private static native void setClustersNumber_0(long nativeObj, int val); + + // C++: void setCovarianceMatrixType(int val) + private static native void setCovarianceMatrixType_0(long nativeObj, int val); + + // C++: void setTermCriteria(TermCriteria val) + private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/KNearest.java b/openCVLibrary330/src/main/java/org/opencv/ml/KNearest.java new file mode 100644 index 00000000000..6d4b641adf3 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/KNearest.java @@ -0,0 +1,211 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import org.opencv.core.Mat; + +// C++: class KNearest +//javadoc: KNearest +public class KNearest extends StatModel { + + protected KNearest(long addr) { super(addr); } + + + public static final int + BRUTE_FORCE = 1, + KDTREE = 2; + + + // + // C++: static Ptr_KNearest create() + // + + //javadoc: KNearest::create() + public static KNearest create() + { + + KNearest retVal = new KNearest(create_0()); + + return retVal; + } + + + // + // C++: bool getIsClassifier() + // + + //javadoc: KNearest::getIsClassifier() + public boolean getIsClassifier() + { + + boolean retVal = getIsClassifier_0(nativeObj); + + return retVal; + } + + + // + // C++: float findNearest(Mat samples, int k, Mat& results, Mat& neighborResponses = Mat(), Mat& dist = Mat()) + // + + //javadoc: KNearest::findNearest(samples, k, results, neighborResponses, dist) + public float findNearest(Mat samples, int k, Mat results, Mat neighborResponses, Mat dist) + { + + float retVal = findNearest_0(nativeObj, samples.nativeObj, k, results.nativeObj, neighborResponses.nativeObj, dist.nativeObj); + + return retVal; + } + + //javadoc: KNearest::findNearest(samples, k, results) + public float findNearest(Mat samples, int k, Mat results) + { + + float retVal = findNearest_1(nativeObj, samples.nativeObj, k, results.nativeObj); + + return retVal; + } + + + // + // C++: int getAlgorithmType() + // + + //javadoc: KNearest::getAlgorithmType() + public int getAlgorithmType() + { + + int retVal = getAlgorithmType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getDefaultK() + // + + //javadoc: KNearest::getDefaultK() + public int getDefaultK() + { + + int retVal = getDefaultK_0(nativeObj); + + return retVal; + } + + + // + // C++: int getEmax() + // + + //javadoc: KNearest::getEmax() + public int getEmax() + { + + int retVal = getEmax_0(nativeObj); + + return retVal; + } + + + // + // C++: void setAlgorithmType(int val) + // + + //javadoc: KNearest::setAlgorithmType(val) + public void setAlgorithmType(int val) + { + + setAlgorithmType_0(nativeObj, val); + + return; + } + + + // + // C++: void setDefaultK(int val) + // + + //javadoc: KNearest::setDefaultK(val) + public void setDefaultK(int val) + { + + setDefaultK_0(nativeObj, val); + + return; + } + + + // + // C++: void setEmax(int val) + // + + //javadoc: KNearest::setEmax(val) + public void setEmax(int val) + { + + setEmax_0(nativeObj, val); + + return; + } + + + // + // C++: void setIsClassifier(bool val) + // + + //javadoc: KNearest::setIsClassifier(val) + public void setIsClassifier(boolean val) + { + + setIsClassifier_0(nativeObj, val); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_KNearest create() + private static native long create_0(); + + // C++: bool getIsClassifier() + private static native boolean getIsClassifier_0(long nativeObj); + + // C++: float findNearest(Mat samples, int k, Mat& results, Mat& neighborResponses = Mat(), Mat& dist = Mat()) + private static native float findNearest_0(long nativeObj, long samples_nativeObj, int k, long results_nativeObj, long neighborResponses_nativeObj, long dist_nativeObj); + private static native float findNearest_1(long nativeObj, long samples_nativeObj, int k, long results_nativeObj); + + // C++: int getAlgorithmType() + private static native int getAlgorithmType_0(long nativeObj); + + // C++: int getDefaultK() + private static native int getDefaultK_0(long nativeObj); + + // C++: int getEmax() + private static native int getEmax_0(long nativeObj); + + // C++: void setAlgorithmType(int val) + private static native void setAlgorithmType_0(long nativeObj, int val); + + // C++: void setDefaultK(int val) + private static native void setDefaultK_0(long nativeObj, int val); + + // C++: void setEmax(int val) + private static native void setEmax_0(long nativeObj, int val); + + // C++: void setIsClassifier(bool val) + private static native void setIsClassifier_0(long nativeObj, boolean val); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/LogisticRegression.java b/openCVLibrary330/src/main/java/org/opencv/ml/LogisticRegression.java new file mode 100644 index 00000000000..41118e96df0 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/LogisticRegression.java @@ -0,0 +1,328 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; + +// C++: class LogisticRegression +//javadoc: LogisticRegression +public class LogisticRegression extends StatModel { + + protected LogisticRegression(long addr) { super(addr); } + + + public static final int + REG_DISABLE = -1, + REG_L1 = 0, + REG_L2 = 1, + BATCH = 0, + MINI_BATCH = 1; + + + // + // C++: Mat get_learnt_thetas() + // + + //javadoc: LogisticRegression::get_learnt_thetas() + public Mat get_learnt_thetas() + { + + Mat retVal = new Mat(get_learnt_thetas_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_LogisticRegression create() + // + + //javadoc: LogisticRegression::create() + public static LogisticRegression create() + { + + LogisticRegression retVal = new LogisticRegression(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_LogisticRegression load(String filepath, String nodeName = String()) + // + + //javadoc: LogisticRegression::load(filepath, nodeName) + public static LogisticRegression load(String filepath, String nodeName) + { + + LogisticRegression retVal = new LogisticRegression(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: LogisticRegression::load(filepath) + public static LogisticRegression load(String filepath) + { + + LogisticRegression retVal = new LogisticRegression(load_1(filepath)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: LogisticRegression::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: double getLearningRate() + // + + //javadoc: LogisticRegression::getLearningRate() + public double getLearningRate() + { + + double retVal = getLearningRate_0(nativeObj); + + return retVal; + } + + + // + // C++: float predict(Mat samples, Mat& results = Mat(), int flags = 0) + // + + //javadoc: LogisticRegression::predict(samples, results, flags) + public float predict(Mat samples, Mat results, int flags) + { + + float retVal = predict_0(nativeObj, samples.nativeObj, results.nativeObj, flags); + + return retVal; + } + + //javadoc: LogisticRegression::predict(samples) + public float predict(Mat samples) + { + + float retVal = predict_1(nativeObj, samples.nativeObj); + + return retVal; + } + + + // + // C++: int getIterations() + // + + //javadoc: LogisticRegression::getIterations() + public int getIterations() + { + + int retVal = getIterations_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMiniBatchSize() + // + + //javadoc: LogisticRegression::getMiniBatchSize() + public int getMiniBatchSize() + { + + int retVal = getMiniBatchSize_0(nativeObj); + + return retVal; + } + + + // + // C++: int getRegularization() + // + + //javadoc: LogisticRegression::getRegularization() + public int getRegularization() + { + + int retVal = getRegularization_0(nativeObj); + + return retVal; + } + + + // + // C++: int getTrainMethod() + // + + //javadoc: LogisticRegression::getTrainMethod() + public int getTrainMethod() + { + + int retVal = getTrainMethod_0(nativeObj); + + return retVal; + } + + + // + // C++: void setIterations(int val) + // + + //javadoc: LogisticRegression::setIterations(val) + public void setIterations(int val) + { + + setIterations_0(nativeObj, val); + + return; + } + + + // + // C++: void setLearningRate(double val) + // + + //javadoc: LogisticRegression::setLearningRate(val) + public void setLearningRate(double val) + { + + setLearningRate_0(nativeObj, val); + + return; + } + + + // + // C++: void setMiniBatchSize(int val) + // + + //javadoc: LogisticRegression::setMiniBatchSize(val) + public void setMiniBatchSize(int val) + { + + setMiniBatchSize_0(nativeObj, val); + + return; + } + + + // + // C++: void setRegularization(int val) + // + + //javadoc: LogisticRegression::setRegularization(val) + public void setRegularization(int val) + { + + setRegularization_0(nativeObj, val); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria val) + // + + //javadoc: LogisticRegression::setTermCriteria(val) + public void setTermCriteria(TermCriteria val) + { + + setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon); + + return; + } + + + // + // C++: void setTrainMethod(int val) + // + + //javadoc: LogisticRegression::setTrainMethod(val) + public void setTrainMethod(int val) + { + + setTrainMethod_0(nativeObj, val); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat get_learnt_thetas() + private static native long get_learnt_thetas_0(long nativeObj); + + // C++: static Ptr_LogisticRegression create() + private static native long create_0(); + + // C++: static Ptr_LogisticRegression load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: double getLearningRate() + private static native double getLearningRate_0(long nativeObj); + + // C++: float predict(Mat samples, Mat& results = Mat(), int flags = 0) + private static native float predict_0(long nativeObj, long samples_nativeObj, long results_nativeObj, int flags); + private static native float predict_1(long nativeObj, long samples_nativeObj); + + // C++: int getIterations() + private static native int getIterations_0(long nativeObj); + + // C++: int getMiniBatchSize() + private static native int getMiniBatchSize_0(long nativeObj); + + // C++: int getRegularization() + private static native int getRegularization_0(long nativeObj); + + // C++: int getTrainMethod() + private static native int getTrainMethod_0(long nativeObj); + + // C++: void setIterations(int val) + private static native void setIterations_0(long nativeObj, int val); + + // C++: void setLearningRate(double val) + private static native void setLearningRate_0(long nativeObj, double val); + + // C++: void setMiniBatchSize(int val) + private static native void setMiniBatchSize_0(long nativeObj, int val); + + // C++: void setRegularization(int val) + private static native void setRegularization_0(long nativeObj, int val); + + // C++: void setTermCriteria(TermCriteria val) + private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon); + + // C++: void setTrainMethod(int val) + private static native void setTrainMethod_0(long nativeObj, int val); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/Ml.java b/openCVLibrary330/src/main/java/org/opencv/ml/Ml.java new file mode 100644 index 00000000000..e8f317d74fa --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/Ml.java @@ -0,0 +1,23 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + + + +public class Ml { + + public static final int + VAR_NUMERICAL = 0, + VAR_ORDERED = 0, + VAR_CATEGORICAL = 1, + TEST_ERROR = 0, + TRAIN_ERROR = 1, + ROW_SAMPLE = 0, + COL_SAMPLE = 1; + + + + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/NormalBayesClassifier.java b/openCVLibrary330/src/main/java/org/opencv/ml/NormalBayesClassifier.java new file mode 100644 index 00000000000..3a6c05474eb --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/NormalBayesClassifier.java @@ -0,0 +1,98 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; + +// C++: class NormalBayesClassifier +//javadoc: NormalBayesClassifier +public class NormalBayesClassifier extends StatModel { + + protected NormalBayesClassifier(long addr) { super(addr); } + + + // + // C++: static Ptr_NormalBayesClassifier create() + // + + //javadoc: NormalBayesClassifier::create() + public static NormalBayesClassifier create() + { + + NormalBayesClassifier retVal = new NormalBayesClassifier(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_NormalBayesClassifier load(String filepath, String nodeName = String()) + // + + //javadoc: NormalBayesClassifier::load(filepath, nodeName) + public static NormalBayesClassifier load(String filepath, String nodeName) + { + + NormalBayesClassifier retVal = new NormalBayesClassifier(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: NormalBayesClassifier::load(filepath) + public static NormalBayesClassifier load(String filepath) + { + + NormalBayesClassifier retVal = new NormalBayesClassifier(load_1(filepath)); + + return retVal; + } + + + // + // C++: float predictProb(Mat inputs, Mat& outputs, Mat& outputProbs, int flags = 0) + // + + //javadoc: NormalBayesClassifier::predictProb(inputs, outputs, outputProbs, flags) + public float predictProb(Mat inputs, Mat outputs, Mat outputProbs, int flags) + { + + float retVal = predictProb_0(nativeObj, inputs.nativeObj, outputs.nativeObj, outputProbs.nativeObj, flags); + + return retVal; + } + + //javadoc: NormalBayesClassifier::predictProb(inputs, outputs, outputProbs) + public float predictProb(Mat inputs, Mat outputs, Mat outputProbs) + { + + float retVal = predictProb_1(nativeObj, inputs.nativeObj, outputs.nativeObj, outputProbs.nativeObj); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_NormalBayesClassifier create() + private static native long create_0(); + + // C++: static Ptr_NormalBayesClassifier load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: float predictProb(Mat inputs, Mat& outputs, Mat& outputProbs, int flags = 0) + private static native float predictProb_0(long nativeObj, long inputs_nativeObj, long outputs_nativeObj, long outputProbs_nativeObj, int flags); + private static native float predictProb_1(long nativeObj, long inputs_nativeObj, long outputs_nativeObj, long outputProbs_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/ParamGrid.java b/openCVLibrary330/src/main/java/org/opencv/ml/ParamGrid.java new file mode 100644 index 00000000000..9f21f7c538f --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/ParamGrid.java @@ -0,0 +1,157 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + + + +// C++: class ParamGrid +//javadoc: ParamGrid +public class ParamGrid { + + protected final long nativeObj; + protected ParamGrid(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: static Ptr_ParamGrid create(double minVal = 0., double maxVal = 0., double logstep = 1.) + // + + //javadoc: ParamGrid::create(minVal, maxVal, logstep) + public static ParamGrid create(double minVal, double maxVal, double logstep) + { + + ParamGrid retVal = new ParamGrid(create_0(minVal, maxVal, logstep)); + + return retVal; + } + + //javadoc: ParamGrid::create() + public static ParamGrid create() + { + + ParamGrid retVal = new ParamGrid(create_1()); + + return retVal; + } + + + // + // C++: double ParamGrid::minVal + // + + //javadoc: ParamGrid::get_minVal() + public double get_minVal() + { + + double retVal = get_minVal_0(nativeObj); + + return retVal; + } + + + // + // C++: void ParamGrid::minVal + // + + //javadoc: ParamGrid::set_minVal(minVal) + public void set_minVal(double minVal) + { + + set_minVal_0(nativeObj, minVal); + + return; + } + + + // + // C++: double ParamGrid::maxVal + // + + //javadoc: ParamGrid::get_maxVal() + public double get_maxVal() + { + + double retVal = get_maxVal_0(nativeObj); + + return retVal; + } + + + // + // C++: void ParamGrid::maxVal + // + + //javadoc: ParamGrid::set_maxVal(maxVal) + public void set_maxVal(double maxVal) + { + + set_maxVal_0(nativeObj, maxVal); + + return; + } + + + // + // C++: double ParamGrid::logStep + // + + //javadoc: ParamGrid::get_logStep() + public double get_logStep() + { + + double retVal = get_logStep_0(nativeObj); + + return retVal; + } + + + // + // C++: void ParamGrid::logStep + // + + //javadoc: ParamGrid::set_logStep(logStep) + public void set_logStep(double logStep) + { + + set_logStep_0(nativeObj, logStep); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_ParamGrid create(double minVal = 0., double maxVal = 0., double logstep = 1.) + private static native long create_0(double minVal, double maxVal, double logstep); + private static native long create_1(); + + // C++: double ParamGrid::minVal + private static native double get_minVal_0(long nativeObj); + + // C++: void ParamGrid::minVal + private static native void set_minVal_0(long nativeObj, double minVal); + + // C++: double ParamGrid::maxVal + private static native double get_maxVal_0(long nativeObj); + + // C++: void ParamGrid::maxVal + private static native void set_maxVal_0(long nativeObj, double maxVal); + + // C++: double ParamGrid::logStep + private static native double get_logStep_0(long nativeObj); + + // C++: void ParamGrid::logStep + private static native void set_logStep_0(long nativeObj, double logStep); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/RTrees.java b/openCVLibrary330/src/main/java/org/opencv/ml/RTrees.java new file mode 100644 index 00000000000..a6ebf8bfc6b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/RTrees.java @@ -0,0 +1,208 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; + +// C++: class RTrees +//javadoc: RTrees +public class RTrees extends DTrees { + + protected RTrees(long addr) { super(addr); } + + + // + // C++: Mat getVarImportance() + // + + //javadoc: RTrees::getVarImportance() + public Mat getVarImportance() + { + + Mat retVal = new Mat(getVarImportance_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_RTrees create() + // + + //javadoc: RTrees::create() + public static RTrees create() + { + + RTrees retVal = new RTrees(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_RTrees load(String filepath, String nodeName = String()) + // + + //javadoc: RTrees::load(filepath, nodeName) + public static RTrees load(String filepath, String nodeName) + { + + RTrees retVal = new RTrees(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: RTrees::load(filepath) + public static RTrees load(String filepath) + { + + RTrees retVal = new RTrees(load_1(filepath)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: RTrees::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: bool getCalculateVarImportance() + // + + //javadoc: RTrees::getCalculateVarImportance() + public boolean getCalculateVarImportance() + { + + boolean retVal = getCalculateVarImportance_0(nativeObj); + + return retVal; + } + + + // + // C++: int getActiveVarCount() + // + + //javadoc: RTrees::getActiveVarCount() + public int getActiveVarCount() + { + + int retVal = getActiveVarCount_0(nativeObj); + + return retVal; + } + + + // + // C++: void getVotes(Mat samples, Mat& results, int flags) + // + + //javadoc: RTrees::getVotes(samples, results, flags) + public void getVotes(Mat samples, Mat results, int flags) + { + + getVotes_0(nativeObj, samples.nativeObj, results.nativeObj, flags); + + return; + } + + + // + // C++: void setActiveVarCount(int val) + // + + //javadoc: RTrees::setActiveVarCount(val) + public void setActiveVarCount(int val) + { + + setActiveVarCount_0(nativeObj, val); + + return; + } + + + // + // C++: void setCalculateVarImportance(bool val) + // + + //javadoc: RTrees::setCalculateVarImportance(val) + public void setCalculateVarImportance(boolean val) + { + + setCalculateVarImportance_0(nativeObj, val); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria val) + // + + //javadoc: RTrees::setTermCriteria(val) + public void setTermCriteria(TermCriteria val) + { + + setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getVarImportance() + private static native long getVarImportance_0(long nativeObj); + + // C++: static Ptr_RTrees create() + private static native long create_0(); + + // C++: static Ptr_RTrees load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: bool getCalculateVarImportance() + private static native boolean getCalculateVarImportance_0(long nativeObj); + + // C++: int getActiveVarCount() + private static native int getActiveVarCount_0(long nativeObj); + + // C++: void getVotes(Mat samples, Mat& results, int flags) + private static native void getVotes_0(long nativeObj, long samples_nativeObj, long results_nativeObj, int flags); + + // C++: void setActiveVarCount(int val) + private static native void setActiveVarCount_0(long nativeObj, int val); + + // C++: void setCalculateVarImportance(bool val) + private static native void setCalculateVarImportance_0(long nativeObj, boolean val); + + // C++: void setTermCriteria(TermCriteria val) + private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/SVM.java b/openCVLibrary330/src/main/java/org/opencv/ml/SVM.java new file mode 100644 index 00000000000..876efddaf3e --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/SVM.java @@ -0,0 +1,518 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; + +// C++: class SVM +//javadoc: SVM +public class SVM extends StatModel { + + protected SVM(long addr) { super(addr); } + + + public static final int + C_SVC = 100, + NU_SVC = 101, + ONE_CLASS = 102, + EPS_SVR = 103, + NU_SVR = 104, + CUSTOM = -1, + LINEAR = 0, + POLY = 1, + RBF = 2, + SIGMOID = 3, + CHI2 = 4, + INTER = 5, + C = 0, + GAMMA = 1, + P = 2, + NU = 3, + COEF = 4, + DEGREE = 5; + + + // + // C++: Mat getClassWeights() + // + + //javadoc: SVM::getClassWeights() + public Mat getClassWeights() + { + + Mat retVal = new Mat(getClassWeights_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getSupportVectors() + // + + //javadoc: SVM::getSupportVectors() + public Mat getSupportVectors() + { + + Mat retVal = new Mat(getSupportVectors_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getUncompressedSupportVectors() + // + + //javadoc: SVM::getUncompressedSupportVectors() + public Mat getUncompressedSupportVectors() + { + + Mat retVal = new Mat(getUncompressedSupportVectors_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_ParamGrid getDefaultGridPtr(int param_id) + // + + //javadoc: SVM::getDefaultGridPtr(param_id) + public static ParamGrid getDefaultGridPtr(int param_id) + { + + ParamGrid retVal = new ParamGrid(getDefaultGridPtr_0(param_id)); + + return retVal; + } + + + // + // C++: static Ptr_SVM create() + // + + //javadoc: SVM::create() + public static SVM create() + { + + SVM retVal = new SVM(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_SVM load(String filepath) + // + + //javadoc: SVM::load(filepath) + public static SVM load(String filepath) + { + + SVM retVal = new SVM(load_0(filepath)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: SVM::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: bool trainAuto(Mat samples, int layout, Mat responses, int kFold = 10, Ptr_ParamGrid Cgrid = SVM::getDefaultGridPtr(SVM::C), Ptr_ParamGrid gammaGrid = SVM::getDefaultGridPtr(SVM::GAMMA), Ptr_ParamGrid pGrid = SVM::getDefaultGridPtr(SVM::P), Ptr_ParamGrid nuGrid = SVM::getDefaultGridPtr(SVM::NU), Ptr_ParamGrid coeffGrid = SVM::getDefaultGridPtr(SVM::COEF), Ptr_ParamGrid degreeGrid = SVM::getDefaultGridPtr(SVM::DEGREE), bool balanced = false) + // + + //javadoc: SVM::trainAuto(samples, layout, responses, kFold, Cgrid, gammaGrid, pGrid, nuGrid, coeffGrid, degreeGrid, balanced) + public boolean trainAuto(Mat samples, int layout, Mat responses, int kFold, ParamGrid Cgrid, ParamGrid gammaGrid, ParamGrid pGrid, ParamGrid nuGrid, ParamGrid coeffGrid, ParamGrid degreeGrid, boolean balanced) + { + + boolean retVal = trainAuto_0(nativeObj, samples.nativeObj, layout, responses.nativeObj, kFold, Cgrid.getNativeObjAddr(), gammaGrid.getNativeObjAddr(), pGrid.getNativeObjAddr(), nuGrid.getNativeObjAddr(), coeffGrid.getNativeObjAddr(), degreeGrid.getNativeObjAddr(), balanced); + + return retVal; + } + + //javadoc: SVM::trainAuto(samples, layout, responses) + public boolean trainAuto(Mat samples, int layout, Mat responses) + { + + boolean retVal = trainAuto_1(nativeObj, samples.nativeObj, layout, responses.nativeObj); + + return retVal; + } + + + // + // C++: double getC() + // + + //javadoc: SVM::getC() + public double getC() + { + + double retVal = getC_0(nativeObj); + + return retVal; + } + + + // + // C++: double getCoef0() + // + + //javadoc: SVM::getCoef0() + public double getCoef0() + { + + double retVal = getCoef0_0(nativeObj); + + return retVal; + } + + + // + // C++: double getDecisionFunction(int i, Mat& alpha, Mat& svidx) + // + + //javadoc: SVM::getDecisionFunction(i, alpha, svidx) + public double getDecisionFunction(int i, Mat alpha, Mat svidx) + { + + double retVal = getDecisionFunction_0(nativeObj, i, alpha.nativeObj, svidx.nativeObj); + + return retVal; + } + + + // + // C++: double getDegree() + // + + //javadoc: SVM::getDegree() + public double getDegree() + { + + double retVal = getDegree_0(nativeObj); + + return retVal; + } + + + // + // C++: double getGamma() + // + + //javadoc: SVM::getGamma() + public double getGamma() + { + + double retVal = getGamma_0(nativeObj); + + return retVal; + } + + + // + // C++: double getNu() + // + + //javadoc: SVM::getNu() + public double getNu() + { + + double retVal = getNu_0(nativeObj); + + return retVal; + } + + + // + // C++: double getP() + // + + //javadoc: SVM::getP() + public double getP() + { + + double retVal = getP_0(nativeObj); + + return retVal; + } + + + // + // C++: int getKernelType() + // + + //javadoc: SVM::getKernelType() + public int getKernelType() + { + + int retVal = getKernelType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getType() + // + + //javadoc: SVM::getType() + public int getType() + { + + int retVal = getType_0(nativeObj); + + return retVal; + } + + + // + // C++: void setC(double val) + // + + //javadoc: SVM::setC(val) + public void setC(double val) + { + + setC_0(nativeObj, val); + + return; + } + + + // + // C++: void setClassWeights(Mat val) + // + + //javadoc: SVM::setClassWeights(val) + public void setClassWeights(Mat val) + { + + setClassWeights_0(nativeObj, val.nativeObj); + + return; + } + + + // + // C++: void setCoef0(double val) + // + + //javadoc: SVM::setCoef0(val) + public void setCoef0(double val) + { + + setCoef0_0(nativeObj, val); + + return; + } + + + // + // C++: void setDegree(double val) + // + + //javadoc: SVM::setDegree(val) + public void setDegree(double val) + { + + setDegree_0(nativeObj, val); + + return; + } + + + // + // C++: void setGamma(double val) + // + + //javadoc: SVM::setGamma(val) + public void setGamma(double val) + { + + setGamma_0(nativeObj, val); + + return; + } + + + // + // C++: void setKernel(int kernelType) + // + + //javadoc: SVM::setKernel(kernelType) + public void setKernel(int kernelType) + { + + setKernel_0(nativeObj, kernelType); + + return; + } + + + // + // C++: void setNu(double val) + // + + //javadoc: SVM::setNu(val) + public void setNu(double val) + { + + setNu_0(nativeObj, val); + + return; + } + + + // + // C++: void setP(double val) + // + + //javadoc: SVM::setP(val) + public void setP(double val) + { + + setP_0(nativeObj, val); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria val) + // + + //javadoc: SVM::setTermCriteria(val) + public void setTermCriteria(TermCriteria val) + { + + setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon); + + return; + } + + + // + // C++: void setType(int val) + // + + //javadoc: SVM::setType(val) + public void setType(int val) + { + + setType_0(nativeObj, val); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getClassWeights() + private static native long getClassWeights_0(long nativeObj); + + // C++: Mat getSupportVectors() + private static native long getSupportVectors_0(long nativeObj); + + // C++: Mat getUncompressedSupportVectors() + private static native long getUncompressedSupportVectors_0(long nativeObj); + + // C++: static Ptr_ParamGrid getDefaultGridPtr(int param_id) + private static native long getDefaultGridPtr_0(int param_id); + + // C++: static Ptr_SVM create() + private static native long create_0(); + + // C++: static Ptr_SVM load(String filepath) + private static native long load_0(String filepath); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: bool trainAuto(Mat samples, int layout, Mat responses, int kFold = 10, Ptr_ParamGrid Cgrid = SVM::getDefaultGridPtr(SVM::C), Ptr_ParamGrid gammaGrid = SVM::getDefaultGridPtr(SVM::GAMMA), Ptr_ParamGrid pGrid = SVM::getDefaultGridPtr(SVM::P), Ptr_ParamGrid nuGrid = SVM::getDefaultGridPtr(SVM::NU), Ptr_ParamGrid coeffGrid = SVM::getDefaultGridPtr(SVM::COEF), Ptr_ParamGrid degreeGrid = SVM::getDefaultGridPtr(SVM::DEGREE), bool balanced = false) + private static native boolean trainAuto_0(long nativeObj, long samples_nativeObj, int layout, long responses_nativeObj, int kFold, long Cgrid_nativeObj, long gammaGrid_nativeObj, long pGrid_nativeObj, long nuGrid_nativeObj, long coeffGrid_nativeObj, long degreeGrid_nativeObj, boolean balanced); + private static native boolean trainAuto_1(long nativeObj, long samples_nativeObj, int layout, long responses_nativeObj); + + // C++: double getC() + private static native double getC_0(long nativeObj); + + // C++: double getCoef0() + private static native double getCoef0_0(long nativeObj); + + // C++: double getDecisionFunction(int i, Mat& alpha, Mat& svidx) + private static native double getDecisionFunction_0(long nativeObj, int i, long alpha_nativeObj, long svidx_nativeObj); + + // C++: double getDegree() + private static native double getDegree_0(long nativeObj); + + // C++: double getGamma() + private static native double getGamma_0(long nativeObj); + + // C++: double getNu() + private static native double getNu_0(long nativeObj); + + // C++: double getP() + private static native double getP_0(long nativeObj); + + // C++: int getKernelType() + private static native int getKernelType_0(long nativeObj); + + // C++: int getType() + private static native int getType_0(long nativeObj); + + // C++: void setC(double val) + private static native void setC_0(long nativeObj, double val); + + // C++: void setClassWeights(Mat val) + private static native void setClassWeights_0(long nativeObj, long val_nativeObj); + + // C++: void setCoef0(double val) + private static native void setCoef0_0(long nativeObj, double val); + + // C++: void setDegree(double val) + private static native void setDegree_0(long nativeObj, double val); + + // C++: void setGamma(double val) + private static native void setGamma_0(long nativeObj, double val); + + // C++: void setKernel(int kernelType) + private static native void setKernel_0(long nativeObj, int kernelType); + + // C++: void setNu(double val) + private static native void setNu_0(long nativeObj, double val); + + // C++: void setP(double val) + private static native void setP_0(long nativeObj, double val); + + // C++: void setTermCriteria(TermCriteria val) + private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon); + + // C++: void setType(int val) + private static native void setType_0(long nativeObj, int val); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/SVMSGD.java b/openCVLibrary330/src/main/java/org/opencv/ml/SVMSGD.java new file mode 100644 index 00000000000..0910cbb374d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/SVMSGD.java @@ -0,0 +1,344 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import org.opencv.core.Mat; +import org.opencv.core.TermCriteria; + +// C++: class SVMSGD +//javadoc: SVMSGD +public class SVMSGD extends StatModel { + + protected SVMSGD(long addr) { super(addr); } + + + public static final int + SGD = 0, + ASGD = 1, + SOFT_MARGIN = 0, + HARD_MARGIN = 1; + + + // + // C++: Mat getWeights() + // + + //javadoc: SVMSGD::getWeights() + public Mat getWeights() + { + + Mat retVal = new Mat(getWeights_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_SVMSGD create() + // + + //javadoc: SVMSGD::create() + public static SVMSGD create() + { + + SVMSGD retVal = new SVMSGD(create_0()); + + return retVal; + } + + + // + // C++: static Ptr_SVMSGD load(String filepath, String nodeName = String()) + // + + //javadoc: SVMSGD::load(filepath, nodeName) + public static SVMSGD load(String filepath, String nodeName) + { + + SVMSGD retVal = new SVMSGD(load_0(filepath, nodeName)); + + return retVal; + } + + //javadoc: SVMSGD::load(filepath) + public static SVMSGD load(String filepath) + { + + SVMSGD retVal = new SVMSGD(load_1(filepath)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: SVMSGD::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: float getInitialStepSize() + // + + //javadoc: SVMSGD::getInitialStepSize() + public float getInitialStepSize() + { + + float retVal = getInitialStepSize_0(nativeObj); + + return retVal; + } + + + // + // C++: float getMarginRegularization() + // + + //javadoc: SVMSGD::getMarginRegularization() + public float getMarginRegularization() + { + + float retVal = getMarginRegularization_0(nativeObj); + + return retVal; + } + + + // + // C++: float getShift() + // + + //javadoc: SVMSGD::getShift() + public float getShift() + { + + float retVal = getShift_0(nativeObj); + + return retVal; + } + + + // + // C++: float getStepDecreasingPower() + // + + //javadoc: SVMSGD::getStepDecreasingPower() + public float getStepDecreasingPower() + { + + float retVal = getStepDecreasingPower_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMarginType() + // + + //javadoc: SVMSGD::getMarginType() + public int getMarginType() + { + + int retVal = getMarginType_0(nativeObj); + + return retVal; + } + + + // + // C++: int getSvmsgdType() + // + + //javadoc: SVMSGD::getSvmsgdType() + public int getSvmsgdType() + { + + int retVal = getSvmsgdType_0(nativeObj); + + return retVal; + } + + + // + // C++: void setInitialStepSize(float InitialStepSize) + // + + //javadoc: SVMSGD::setInitialStepSize(InitialStepSize) + public void setInitialStepSize(float InitialStepSize) + { + + setInitialStepSize_0(nativeObj, InitialStepSize); + + return; + } + + + // + // C++: void setMarginRegularization(float marginRegularization) + // + + //javadoc: SVMSGD::setMarginRegularization(marginRegularization) + public void setMarginRegularization(float marginRegularization) + { + + setMarginRegularization_0(nativeObj, marginRegularization); + + return; + } + + + // + // C++: void setMarginType(int marginType) + // + + //javadoc: SVMSGD::setMarginType(marginType) + public void setMarginType(int marginType) + { + + setMarginType_0(nativeObj, marginType); + + return; + } + + + // + // C++: void setOptimalParameters(int svmsgdType = SVMSGD::ASGD, int marginType = SVMSGD::SOFT_MARGIN) + // + + //javadoc: SVMSGD::setOptimalParameters(svmsgdType, marginType) + public void setOptimalParameters(int svmsgdType, int marginType) + { + + setOptimalParameters_0(nativeObj, svmsgdType, marginType); + + return; + } + + //javadoc: SVMSGD::setOptimalParameters() + public void setOptimalParameters() + { + + setOptimalParameters_1(nativeObj); + + return; + } + + + // + // C++: void setStepDecreasingPower(float stepDecreasingPower) + // + + //javadoc: SVMSGD::setStepDecreasingPower(stepDecreasingPower) + public void setStepDecreasingPower(float stepDecreasingPower) + { + + setStepDecreasingPower_0(nativeObj, stepDecreasingPower); + + return; + } + + + // + // C++: void setSvmsgdType(int svmsgdType) + // + + //javadoc: SVMSGD::setSvmsgdType(svmsgdType) + public void setSvmsgdType(int svmsgdType) + { + + setSvmsgdType_0(nativeObj, svmsgdType); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria val) + // + + //javadoc: SVMSGD::setTermCriteria(val) + public void setTermCriteria(TermCriteria val) + { + + setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getWeights() + private static native long getWeights_0(long nativeObj); + + // C++: static Ptr_SVMSGD create() + private static native long create_0(); + + // C++: static Ptr_SVMSGD load(String filepath, String nodeName = String()) + private static native long load_0(String filepath, String nodeName); + private static native long load_1(String filepath); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: float getInitialStepSize() + private static native float getInitialStepSize_0(long nativeObj); + + // C++: float getMarginRegularization() + private static native float getMarginRegularization_0(long nativeObj); + + // C++: float getShift() + private static native float getShift_0(long nativeObj); + + // C++: float getStepDecreasingPower() + private static native float getStepDecreasingPower_0(long nativeObj); + + // C++: int getMarginType() + private static native int getMarginType_0(long nativeObj); + + // C++: int getSvmsgdType() + private static native int getSvmsgdType_0(long nativeObj); + + // C++: void setInitialStepSize(float InitialStepSize) + private static native void setInitialStepSize_0(long nativeObj, float InitialStepSize); + + // C++: void setMarginRegularization(float marginRegularization) + private static native void setMarginRegularization_0(long nativeObj, float marginRegularization); + + // C++: void setMarginType(int marginType) + private static native void setMarginType_0(long nativeObj, int marginType); + + // C++: void setOptimalParameters(int svmsgdType = SVMSGD::ASGD, int marginType = SVMSGD::SOFT_MARGIN) + private static native void setOptimalParameters_0(long nativeObj, int svmsgdType, int marginType); + private static native void setOptimalParameters_1(long nativeObj); + + // C++: void setStepDecreasingPower(float stepDecreasingPower) + private static native void setStepDecreasingPower_0(long nativeObj, float stepDecreasingPower); + + // C++: void setSvmsgdType(int svmsgdType) + private static native void setSvmsgdType_0(long nativeObj, int svmsgdType); + + // C++: void setTermCriteria(TermCriteria val) + private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/StatModel.java b/openCVLibrary330/src/main/java/org/opencv/ml/StatModel.java new file mode 100644 index 00000000000..8649019c95b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/StatModel.java @@ -0,0 +1,190 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; + +// C++: class StatModel +//javadoc: StatModel +public class StatModel extends Algorithm { + + protected StatModel(long addr) { super(addr); } + + + public static final int + UPDATE_MODEL = 1, + RAW_OUTPUT = 1, + COMPRESSED_INPUT = 2, + PREPROCESSED_INPUT = 4; + + + // + // C++: bool empty() + // + + //javadoc: StatModel::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isClassifier() + // + + //javadoc: StatModel::isClassifier() + public boolean isClassifier() + { + + boolean retVal = isClassifier_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isTrained() + // + + //javadoc: StatModel::isTrained() + public boolean isTrained() + { + + boolean retVal = isTrained_0(nativeObj); + + return retVal; + } + + + // + // C++: bool train(Mat samples, int layout, Mat responses) + // + + //javadoc: StatModel::train(samples, layout, responses) + public boolean train(Mat samples, int layout, Mat responses) + { + + boolean retVal = train_0(nativeObj, samples.nativeObj, layout, responses.nativeObj); + + return retVal; + } + + + // + // C++: bool train(Ptr_TrainData trainData, int flags = 0) + // + + //javadoc: StatModel::train(trainData, flags) + public boolean train(TrainData trainData, int flags) + { + + boolean retVal = train_1(nativeObj, trainData.getNativeObjAddr(), flags); + + return retVal; + } + + //javadoc: StatModel::train(trainData) + public boolean train(TrainData trainData) + { + + boolean retVal = train_2(nativeObj, trainData.getNativeObjAddr()); + + return retVal; + } + + + // + // C++: float calcError(Ptr_TrainData data, bool test, Mat& resp) + // + + //javadoc: StatModel::calcError(data, test, resp) + public float calcError(TrainData data, boolean test, Mat resp) + { + + float retVal = calcError_0(nativeObj, data.getNativeObjAddr(), test, resp.nativeObj); + + return retVal; + } + + + // + // C++: float predict(Mat samples, Mat& results = Mat(), int flags = 0) + // + + //javadoc: StatModel::predict(samples, results, flags) + public float predict(Mat samples, Mat results, int flags) + { + + float retVal = predict_0(nativeObj, samples.nativeObj, results.nativeObj, flags); + + return retVal; + } + + //javadoc: StatModel::predict(samples) + public float predict(Mat samples) + { + + float retVal = predict_1(nativeObj, samples.nativeObj); + + return retVal; + } + + + // + // C++: int getVarCount() + // + + //javadoc: StatModel::getVarCount() + public int getVarCount() + { + + int retVal = getVarCount_0(nativeObj); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: bool isClassifier() + private static native boolean isClassifier_0(long nativeObj); + + // C++: bool isTrained() + private static native boolean isTrained_0(long nativeObj); + + // C++: bool train(Mat samples, int layout, Mat responses) + private static native boolean train_0(long nativeObj, long samples_nativeObj, int layout, long responses_nativeObj); + + // C++: bool train(Ptr_TrainData trainData, int flags = 0) + private static native boolean train_1(long nativeObj, long trainData_nativeObj, int flags); + private static native boolean train_2(long nativeObj, long trainData_nativeObj); + + // C++: float calcError(Ptr_TrainData data, bool test, Mat& resp) + private static native float calcError_0(long nativeObj, long data_nativeObj, boolean test, long resp_nativeObj); + + // C++: float predict(Mat samples, Mat& results = Mat(), int flags = 0) + private static native float predict_0(long nativeObj, long samples_nativeObj, long results_nativeObj, int flags); + private static native float predict_1(long nativeObj, long samples_nativeObj); + + // C++: int getVarCount() + private static native int getVarCount_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/ml/TrainData.java b/openCVLibrary330/src/main/java/org/opencv/ml/TrainData.java new file mode 100644 index 00000000000..b63f3883d5e --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/ml/TrainData.java @@ -0,0 +1,718 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.ml; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class TrainData +//javadoc: TrainData +public class TrainData { + + protected final long nativeObj; + protected TrainData(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: Mat getCatMap() + // + + //javadoc: TrainData::getCatMap() + public Mat getCatMap() + { + + Mat retVal = new Mat(getCatMap_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getCatOfs() + // + + //javadoc: TrainData::getCatOfs() + public Mat getCatOfs() + { + + Mat retVal = new Mat(getCatOfs_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getClassLabels() + // + + //javadoc: TrainData::getClassLabels() + public Mat getClassLabels() + { + + Mat retVal = new Mat(getClassLabels_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getDefaultSubstValues() + // + + //javadoc: TrainData::getDefaultSubstValues() + public Mat getDefaultSubstValues() + { + + Mat retVal = new Mat(getDefaultSubstValues_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getMissing() + // + + //javadoc: TrainData::getMissing() + public Mat getMissing() + { + + Mat retVal = new Mat(getMissing_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getNormCatResponses() + // + + //javadoc: TrainData::getNormCatResponses() + public Mat getNormCatResponses() + { + + Mat retVal = new Mat(getNormCatResponses_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getResponses() + // + + //javadoc: TrainData::getResponses() + public Mat getResponses() + { + + Mat retVal = new Mat(getResponses_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getSampleWeights() + // + + //javadoc: TrainData::getSampleWeights() + public Mat getSampleWeights() + { + + Mat retVal = new Mat(getSampleWeights_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getSamples() + // + + //javadoc: TrainData::getSamples() + public Mat getSamples() + { + + Mat retVal = new Mat(getSamples_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Mat getSubVector(Mat vec, Mat idx) + // + + //javadoc: TrainData::getSubVector(vec, idx) + public static Mat getSubVector(Mat vec, Mat idx) + { + + Mat retVal = new Mat(getSubVector_0(vec.nativeObj, idx.nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTestNormCatResponses() + // + + //javadoc: TrainData::getTestNormCatResponses() + public Mat getTestNormCatResponses() + { + + Mat retVal = new Mat(getTestNormCatResponses_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTestResponses() + // + + //javadoc: TrainData::getTestResponses() + public Mat getTestResponses() + { + + Mat retVal = new Mat(getTestResponses_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTestSampleIdx() + // + + //javadoc: TrainData::getTestSampleIdx() + public Mat getTestSampleIdx() + { + + Mat retVal = new Mat(getTestSampleIdx_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTestSampleWeights() + // + + //javadoc: TrainData::getTestSampleWeights() + public Mat getTestSampleWeights() + { + + Mat retVal = new Mat(getTestSampleWeights_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTestSamples() + // + + //javadoc: TrainData::getTestSamples() + public Mat getTestSamples() + { + + Mat retVal = new Mat(getTestSamples_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTrainNormCatResponses() + // + + //javadoc: TrainData::getTrainNormCatResponses() + public Mat getTrainNormCatResponses() + { + + Mat retVal = new Mat(getTrainNormCatResponses_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTrainResponses() + // + + //javadoc: TrainData::getTrainResponses() + public Mat getTrainResponses() + { + + Mat retVal = new Mat(getTrainResponses_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTrainSampleIdx() + // + + //javadoc: TrainData::getTrainSampleIdx() + public Mat getTrainSampleIdx() + { + + Mat retVal = new Mat(getTrainSampleIdx_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTrainSampleWeights() + // + + //javadoc: TrainData::getTrainSampleWeights() + public Mat getTrainSampleWeights() + { + + Mat retVal = new Mat(getTrainSampleWeights_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getTrainSamples(int layout = ROW_SAMPLE, bool compressSamples = true, bool compressVars = true) + // + + //javadoc: TrainData::getTrainSamples(layout, compressSamples, compressVars) + public Mat getTrainSamples(int layout, boolean compressSamples, boolean compressVars) + { + + Mat retVal = new Mat(getTrainSamples_0(nativeObj, layout, compressSamples, compressVars)); + + return retVal; + } + + //javadoc: TrainData::getTrainSamples() + public Mat getTrainSamples() + { + + Mat retVal = new Mat(getTrainSamples_1(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getVarIdx() + // + + //javadoc: TrainData::getVarIdx() + public Mat getVarIdx() + { + + Mat retVal = new Mat(getVarIdx_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getVarSymbolFlags() + // + + //javadoc: TrainData::getVarSymbolFlags() + public Mat getVarSymbolFlags() + { + + Mat retVal = new Mat(getVarSymbolFlags_0(nativeObj)); + + return retVal; + } + + + // + // C++: Mat getVarType() + // + + //javadoc: TrainData::getVarType() + public Mat getVarType() + { + + Mat retVal = new Mat(getVarType_0(nativeObj)); + + return retVal; + } + + + // + // C++: static Ptr_TrainData create(Mat samples, int layout, Mat responses, Mat varIdx = Mat(), Mat sampleIdx = Mat(), Mat sampleWeights = Mat(), Mat varType = Mat()) + // + + //javadoc: TrainData::create(samples, layout, responses, varIdx, sampleIdx, sampleWeights, varType) + public static TrainData create(Mat samples, int layout, Mat responses, Mat varIdx, Mat sampleIdx, Mat sampleWeights, Mat varType) + { + + TrainData retVal = new TrainData(create_0(samples.nativeObj, layout, responses.nativeObj, varIdx.nativeObj, sampleIdx.nativeObj, sampleWeights.nativeObj, varType.nativeObj)); + + return retVal; + } + + //javadoc: TrainData::create(samples, layout, responses) + public static TrainData create(Mat samples, int layout, Mat responses) + { + + TrainData retVal = new TrainData(create_1(samples.nativeObj, layout, responses.nativeObj)); + + return retVal; + } + + + // + // C++: int getCatCount(int vi) + // + + //javadoc: TrainData::getCatCount(vi) + public int getCatCount(int vi) + { + + int retVal = getCatCount_0(nativeObj, vi); + + return retVal; + } + + + // + // C++: int getLayout() + // + + //javadoc: TrainData::getLayout() + public int getLayout() + { + + int retVal = getLayout_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNAllVars() + // + + //javadoc: TrainData::getNAllVars() + public int getNAllVars() + { + + int retVal = getNAllVars_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNSamples() + // + + //javadoc: TrainData::getNSamples() + public int getNSamples() + { + + int retVal = getNSamples_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNTestSamples() + // + + //javadoc: TrainData::getNTestSamples() + public int getNTestSamples() + { + + int retVal = getNTestSamples_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNTrainSamples() + // + + //javadoc: TrainData::getNTrainSamples() + public int getNTrainSamples() + { + + int retVal = getNTrainSamples_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNVars() + // + + //javadoc: TrainData::getNVars() + public int getNVars() + { + + int retVal = getNVars_0(nativeObj); + + return retVal; + } + + + // + // C++: int getResponseType() + // + + //javadoc: TrainData::getResponseType() + public int getResponseType() + { + + int retVal = getResponseType_0(nativeObj); + + return retVal; + } + + + // + // C++: void getNames(vector_String names) + // + + //javadoc: TrainData::getNames(names) + public void getNames(List names) + { + + getNames_0(nativeObj, names); + + return; + } + + + // + // C++: void getSample(Mat varIdx, int sidx, float* buf) + // + + //javadoc: TrainData::getSample(varIdx, sidx, buf) + public void getSample(Mat varIdx, int sidx, float buf) + { + + getSample_0(nativeObj, varIdx.nativeObj, sidx, buf); + + return; + } + + + // + // C++: void getValues(int vi, Mat sidx, float* values) + // + + //javadoc: TrainData::getValues(vi, sidx, values) + public void getValues(int vi, Mat sidx, float values) + { + + getValues_0(nativeObj, vi, sidx.nativeObj, values); + + return; + } + + + // + // C++: void setTrainTestSplit(int count, bool shuffle = true) + // + + //javadoc: TrainData::setTrainTestSplit(count, shuffle) + public void setTrainTestSplit(int count, boolean shuffle) + { + + setTrainTestSplit_0(nativeObj, count, shuffle); + + return; + } + + //javadoc: TrainData::setTrainTestSplit(count) + public void setTrainTestSplit(int count) + { + + setTrainTestSplit_1(nativeObj, count); + + return; + } + + + // + // C++: void setTrainTestSplitRatio(double ratio, bool shuffle = true) + // + + //javadoc: TrainData::setTrainTestSplitRatio(ratio, shuffle) + public void setTrainTestSplitRatio(double ratio, boolean shuffle) + { + + setTrainTestSplitRatio_0(nativeObj, ratio, shuffle); + + return; + } + + //javadoc: TrainData::setTrainTestSplitRatio(ratio) + public void setTrainTestSplitRatio(double ratio) + { + + setTrainTestSplitRatio_1(nativeObj, ratio); + + return; + } + + + // + // C++: void shuffleTrainTest() + // + + //javadoc: TrainData::shuffleTrainTest() + public void shuffleTrainTest() + { + + shuffleTrainTest_0(nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getCatMap() + private static native long getCatMap_0(long nativeObj); + + // C++: Mat getCatOfs() + private static native long getCatOfs_0(long nativeObj); + + // C++: Mat getClassLabels() + private static native long getClassLabels_0(long nativeObj); + + // C++: Mat getDefaultSubstValues() + private static native long getDefaultSubstValues_0(long nativeObj); + + // C++: Mat getMissing() + private static native long getMissing_0(long nativeObj); + + // C++: Mat getNormCatResponses() + private static native long getNormCatResponses_0(long nativeObj); + + // C++: Mat getResponses() + private static native long getResponses_0(long nativeObj); + + // C++: Mat getSampleWeights() + private static native long getSampleWeights_0(long nativeObj); + + // C++: Mat getSamples() + private static native long getSamples_0(long nativeObj); + + // C++: static Mat getSubVector(Mat vec, Mat idx) + private static native long getSubVector_0(long vec_nativeObj, long idx_nativeObj); + + // C++: Mat getTestNormCatResponses() + private static native long getTestNormCatResponses_0(long nativeObj); + + // C++: Mat getTestResponses() + private static native long getTestResponses_0(long nativeObj); + + // C++: Mat getTestSampleIdx() + private static native long getTestSampleIdx_0(long nativeObj); + + // C++: Mat getTestSampleWeights() + private static native long getTestSampleWeights_0(long nativeObj); + + // C++: Mat getTestSamples() + private static native long getTestSamples_0(long nativeObj); + + // C++: Mat getTrainNormCatResponses() + private static native long getTrainNormCatResponses_0(long nativeObj); + + // C++: Mat getTrainResponses() + private static native long getTrainResponses_0(long nativeObj); + + // C++: Mat getTrainSampleIdx() + private static native long getTrainSampleIdx_0(long nativeObj); + + // C++: Mat getTrainSampleWeights() + private static native long getTrainSampleWeights_0(long nativeObj); + + // C++: Mat getTrainSamples(int layout = ROW_SAMPLE, bool compressSamples = true, bool compressVars = true) + private static native long getTrainSamples_0(long nativeObj, int layout, boolean compressSamples, boolean compressVars); + private static native long getTrainSamples_1(long nativeObj); + + // C++: Mat getVarIdx() + private static native long getVarIdx_0(long nativeObj); + + // C++: Mat getVarSymbolFlags() + private static native long getVarSymbolFlags_0(long nativeObj); + + // C++: Mat getVarType() + private static native long getVarType_0(long nativeObj); + + // C++: static Ptr_TrainData create(Mat samples, int layout, Mat responses, Mat varIdx = Mat(), Mat sampleIdx = Mat(), Mat sampleWeights = Mat(), Mat varType = Mat()) + private static native long create_0(long samples_nativeObj, int layout, long responses_nativeObj, long varIdx_nativeObj, long sampleIdx_nativeObj, long sampleWeights_nativeObj, long varType_nativeObj); + private static native long create_1(long samples_nativeObj, int layout, long responses_nativeObj); + + // C++: int getCatCount(int vi) + private static native int getCatCount_0(long nativeObj, int vi); + + // C++: int getLayout() + private static native int getLayout_0(long nativeObj); + + // C++: int getNAllVars() + private static native int getNAllVars_0(long nativeObj); + + // C++: int getNSamples() + private static native int getNSamples_0(long nativeObj); + + // C++: int getNTestSamples() + private static native int getNTestSamples_0(long nativeObj); + + // C++: int getNTrainSamples() + private static native int getNTrainSamples_0(long nativeObj); + + // C++: int getNVars() + private static native int getNVars_0(long nativeObj); + + // C++: int getResponseType() + private static native int getResponseType_0(long nativeObj); + + // C++: void getNames(vector_String names) + private static native void getNames_0(long nativeObj, List names); + + // C++: void getSample(Mat varIdx, int sidx, float* buf) + private static native void getSample_0(long nativeObj, long varIdx_nativeObj, int sidx, float buf); + + // C++: void getValues(int vi, Mat sidx, float* values) + private static native void getValues_0(long nativeObj, int vi, long sidx_nativeObj, float values); + + // C++: void setTrainTestSplit(int count, bool shuffle = true) + private static native void setTrainTestSplit_0(long nativeObj, int count, boolean shuffle); + private static native void setTrainTestSplit_1(long nativeObj, int count); + + // C++: void setTrainTestSplitRatio(double ratio, bool shuffle = true) + private static native void setTrainTestSplitRatio_0(long nativeObj, double ratio, boolean shuffle); + private static native void setTrainTestSplitRatio_1(long nativeObj, double ratio); + + // C++: void shuffleTrainTest() + private static native void shuffleTrainTest_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/objdetect/BaseCascadeClassifier.java b/openCVLibrary330/src/main/java/org/opencv/objdetect/BaseCascadeClassifier.java new file mode 100644 index 00000000000..21c8db72e4a --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/objdetect/BaseCascadeClassifier.java @@ -0,0 +1,26 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.objdetect; + +import org.opencv.core.Algorithm; + +// C++: class BaseCascadeClassifier +//javadoc: BaseCascadeClassifier +public class BaseCascadeClassifier extends Algorithm { + + protected BaseCascadeClassifier(long addr) { super(addr); } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/objdetect/CascadeClassifier.java b/openCVLibrary330/src/main/java/org/opencv/objdetect/CascadeClassifier.java new file mode 100644 index 00000000000..4ca9f658b6e --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/objdetect/CascadeClassifier.java @@ -0,0 +1,266 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.objdetect; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfDouble; +import org.opencv.core.MatOfInt; +import org.opencv.core.MatOfRect; +import org.opencv.core.Size; +import org.opencv.utils.Converters; + +// C++: class CascadeClassifier +//javadoc: CascadeClassifier +public class CascadeClassifier { + + protected final long nativeObj; + protected CascadeClassifier(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: CascadeClassifier(String filename) + // + + //javadoc: CascadeClassifier::CascadeClassifier(filename) + public CascadeClassifier(String filename) + { + + nativeObj = CascadeClassifier_0(filename); + + return; + } + + + // + // C++: CascadeClassifier() + // + + //javadoc: CascadeClassifier::CascadeClassifier() + public CascadeClassifier() + { + + nativeObj = CascadeClassifier_1(); + + return; + } + + + // + // C++: Size getOriginalWindowSize() + // + + //javadoc: CascadeClassifier::getOriginalWindowSize() + public Size getOriginalWindowSize() + { + + Size retVal = new Size(getOriginalWindowSize_0(nativeObj)); + + return retVal; + } + + + // + // C++: static bool convert(String oldcascade, String newcascade) + // + + //javadoc: CascadeClassifier::convert(oldcascade, newcascade) + public static boolean convert(String oldcascade, String newcascade) + { + + boolean retVal = convert_0(oldcascade, newcascade); + + return retVal; + } + + + // + // C++: bool empty() + // + + //javadoc: CascadeClassifier::empty() + public boolean empty() + { + + boolean retVal = empty_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isOldFormatCascade() + // + + //javadoc: CascadeClassifier::isOldFormatCascade() + public boolean isOldFormatCascade() + { + + boolean retVal = isOldFormatCascade_0(nativeObj); + + return retVal; + } + + + // + // C++: bool load(String filename) + // + + //javadoc: CascadeClassifier::load(filename) + public boolean load(String filename) + { + + boolean retVal = load_0(nativeObj, filename); + + return retVal; + } + + + // + // C++: bool read(FileNode node) + // + + // Unknown type 'FileNode' (I), skipping the function + + + // + // C++: int getFeatureType() + // + + //javadoc: CascadeClassifier::getFeatureType() + public int getFeatureType() + { + + int retVal = getFeatureType_0(nativeObj); + + return retVal; + } + + + // + // C++: void detectMultiScale(Mat image, vector_Rect& objects, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size()) + // + + //javadoc: CascadeClassifier::detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize) + public void detectMultiScale(Mat image, MatOfRect objects, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize) + { + Mat objects_mat = objects; + detectMultiScale_0(nativeObj, image.nativeObj, objects_mat.nativeObj, scaleFactor, minNeighbors, flags, minSize.width, minSize.height, maxSize.width, maxSize.height); + + return; + } + + //javadoc: CascadeClassifier::detectMultiScale(image, objects) + public void detectMultiScale(Mat image, MatOfRect objects) + { + Mat objects_mat = objects; + detectMultiScale_1(nativeObj, image.nativeObj, objects_mat.nativeObj); + + return; + } + + + // + // C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& numDetections, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size()) + // + + //javadoc: CascadeClassifier::detectMultiScale(image, objects, numDetections, scaleFactor, minNeighbors, flags, minSize, maxSize) + public void detectMultiScale2(Mat image, MatOfRect objects, MatOfInt numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize) + { + Mat objects_mat = objects; + Mat numDetections_mat = numDetections; + detectMultiScale2_0(nativeObj, image.nativeObj, objects_mat.nativeObj, numDetections_mat.nativeObj, scaleFactor, minNeighbors, flags, minSize.width, minSize.height, maxSize.width, maxSize.height); + + return; + } + + //javadoc: CascadeClassifier::detectMultiScale(image, objects, numDetections) + public void detectMultiScale2(Mat image, MatOfRect objects, MatOfInt numDetections) + { + Mat objects_mat = objects; + Mat numDetections_mat = numDetections; + detectMultiScale2_1(nativeObj, image.nativeObj, objects_mat.nativeObj, numDetections_mat.nativeObj); + + return; + } + + + // + // C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& rejectLevels, vector_double& levelWeights, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size(), bool outputRejectLevels = false) + // + + //javadoc: CascadeClassifier::detectMultiScale(image, objects, rejectLevels, levelWeights, scaleFactor, minNeighbors, flags, minSize, maxSize, outputRejectLevels) + public void detectMultiScale3(Mat image, MatOfRect objects, MatOfInt rejectLevels, MatOfDouble levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels) + { + Mat objects_mat = objects; + Mat rejectLevels_mat = rejectLevels; + Mat levelWeights_mat = levelWeights; + detectMultiScale3_0(nativeObj, image.nativeObj, objects_mat.nativeObj, rejectLevels_mat.nativeObj, levelWeights_mat.nativeObj, scaleFactor, minNeighbors, flags, minSize.width, minSize.height, maxSize.width, maxSize.height, outputRejectLevels); + + return; + } + + //javadoc: CascadeClassifier::detectMultiScale(image, objects, rejectLevels, levelWeights) + public void detectMultiScale3(Mat image, MatOfRect objects, MatOfInt rejectLevels, MatOfDouble levelWeights) + { + Mat objects_mat = objects; + Mat rejectLevels_mat = rejectLevels; + Mat levelWeights_mat = levelWeights; + detectMultiScale3_1(nativeObj, image.nativeObj, objects_mat.nativeObj, rejectLevels_mat.nativeObj, levelWeights_mat.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: CascadeClassifier(String filename) + private static native long CascadeClassifier_0(String filename); + + // C++: CascadeClassifier() + private static native long CascadeClassifier_1(); + + // C++: Size getOriginalWindowSize() + private static native double[] getOriginalWindowSize_0(long nativeObj); + + // C++: static bool convert(String oldcascade, String newcascade) + private static native boolean convert_0(String oldcascade, String newcascade); + + // C++: bool empty() + private static native boolean empty_0(long nativeObj); + + // C++: bool isOldFormatCascade() + private static native boolean isOldFormatCascade_0(long nativeObj); + + // C++: bool load(String filename) + private static native boolean load_0(long nativeObj, String filename); + + // C++: int getFeatureType() + private static native int getFeatureType_0(long nativeObj); + + // C++: void detectMultiScale(Mat image, vector_Rect& objects, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size()) + private static native void detectMultiScale_0(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, double scaleFactor, int minNeighbors, int flags, double minSize_width, double minSize_height, double maxSize_width, double maxSize_height); + private static native void detectMultiScale_1(long nativeObj, long image_nativeObj, long objects_mat_nativeObj); + + // C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& numDetections, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size()) + private static native void detectMultiScale2_0(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long numDetections_mat_nativeObj, double scaleFactor, int minNeighbors, int flags, double minSize_width, double minSize_height, double maxSize_width, double maxSize_height); + private static native void detectMultiScale2_1(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long numDetections_mat_nativeObj); + + // C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& rejectLevels, vector_double& levelWeights, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size(), bool outputRejectLevels = false) + private static native void detectMultiScale3_0(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long rejectLevels_mat_nativeObj, long levelWeights_mat_nativeObj, double scaleFactor, int minNeighbors, int flags, double minSize_width, double minSize_height, double maxSize_width, double maxSize_height, boolean outputRejectLevels); + private static native void detectMultiScale3_1(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long rejectLevels_mat_nativeObj, long levelWeights_mat_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/objdetect/HOGDescriptor.java b/openCVLibrary330/src/main/java/org/opencv/objdetect/HOGDescriptor.java new file mode 100644 index 00000000000..b6ab8ca9b8b --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/objdetect/HOGDescriptor.java @@ -0,0 +1,594 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.objdetect; + +import java.lang.String; +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfDouble; +import org.opencv.core.MatOfFloat; +import org.opencv.core.MatOfPoint; +import org.opencv.core.MatOfRect; +import org.opencv.core.Size; +import org.opencv.utils.Converters; + +// C++: class HOGDescriptor +//javadoc: HOGDescriptor +public class HOGDescriptor { + + protected final long nativeObj; + protected HOGDescriptor(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + public static final int + L2Hys = 0, + DEFAULT_NLEVELS = 64; + + + // + // C++: HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture = 1, double _winSigma = -1, int _histogramNormType = HOGDescriptor::L2Hys, double _L2HysThreshold = 0.2, bool _gammaCorrection = false, int _nlevels = HOGDescriptor::DEFAULT_NLEVELS, bool _signedGradient = false) + // + + //javadoc: HOGDescriptor::HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels, _signedGradient) + public HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, boolean _gammaCorrection, int _nlevels, boolean _signedGradient) + { + + nativeObj = HOGDescriptor_0(_winSize.width, _winSize.height, _blockSize.width, _blockSize.height, _blockStride.width, _blockStride.height, _cellSize.width, _cellSize.height, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels, _signedGradient); + + return; + } + + //javadoc: HOGDescriptor::HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins) + public HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins) + { + + nativeObj = HOGDescriptor_1(_winSize.width, _winSize.height, _blockSize.width, _blockSize.height, _blockStride.width, _blockStride.height, _cellSize.width, _cellSize.height, _nbins); + + return; + } + + + // + // C++: HOGDescriptor(String filename) + // + + //javadoc: HOGDescriptor::HOGDescriptor(filename) + public HOGDescriptor(String filename) + { + + nativeObj = HOGDescriptor_2(filename); + + return; + } + + + // + // C++: HOGDescriptor() + // + + //javadoc: HOGDescriptor::HOGDescriptor() + public HOGDescriptor() + { + + nativeObj = HOGDescriptor_3(); + + return; + } + + + // + // C++: bool checkDetectorSize() + // + + //javadoc: HOGDescriptor::checkDetectorSize() + public boolean checkDetectorSize() + { + + boolean retVal = checkDetectorSize_0(nativeObj); + + return retVal; + } + + + // + // C++: bool load(String filename, String objname = String()) + // + + //javadoc: HOGDescriptor::load(filename, objname) + public boolean load(String filename, String objname) + { + + boolean retVal = load_0(nativeObj, filename, objname); + + return retVal; + } + + //javadoc: HOGDescriptor::load(filename) + public boolean load(String filename) + { + + boolean retVal = load_1(nativeObj, filename); + + return retVal; + } + + + // + // C++: double getWinSigma() + // + + //javadoc: HOGDescriptor::getWinSigma() + public double getWinSigma() + { + + double retVal = getWinSigma_0(nativeObj); + + return retVal; + } + + + // + // C++: size_t getDescriptorSize() + // + + //javadoc: HOGDescriptor::getDescriptorSize() + public long getDescriptorSize() + { + + long retVal = getDescriptorSize_0(nativeObj); + + return retVal; + } + + + // + // C++: static vector_float getDaimlerPeopleDetector() + // + + //javadoc: HOGDescriptor::getDaimlerPeopleDetector() + public static MatOfFloat getDaimlerPeopleDetector() + { + + MatOfFloat retVal = MatOfFloat.fromNativeAddr(getDaimlerPeopleDetector_0()); + + return retVal; + } + + + // + // C++: static vector_float getDefaultPeopleDetector() + // + + //javadoc: HOGDescriptor::getDefaultPeopleDetector() + public static MatOfFloat getDefaultPeopleDetector() + { + + MatOfFloat retVal = MatOfFloat.fromNativeAddr(getDefaultPeopleDetector_0()); + + return retVal; + } + + + // + // C++: void compute(Mat img, vector_float& descriptors, Size winStride = Size(), Size padding = Size(), vector_Point locations = std::vector()) + // + + //javadoc: HOGDescriptor::compute(img, descriptors, winStride, padding, locations) + public void compute(Mat img, MatOfFloat descriptors, Size winStride, Size padding, MatOfPoint locations) + { + Mat descriptors_mat = descriptors; + Mat locations_mat = locations; + compute_0(nativeObj, img.nativeObj, descriptors_mat.nativeObj, winStride.width, winStride.height, padding.width, padding.height, locations_mat.nativeObj); + + return; + } + + //javadoc: HOGDescriptor::compute(img, descriptors) + public void compute(Mat img, MatOfFloat descriptors) + { + Mat descriptors_mat = descriptors; + compute_1(nativeObj, img.nativeObj, descriptors_mat.nativeObj); + + return; + } + + + // + // C++: void computeGradient(Mat img, Mat& grad, Mat& angleOfs, Size paddingTL = Size(), Size paddingBR = Size()) + // + + //javadoc: HOGDescriptor::computeGradient(img, grad, angleOfs, paddingTL, paddingBR) + public void computeGradient(Mat img, Mat grad, Mat angleOfs, Size paddingTL, Size paddingBR) + { + + computeGradient_0(nativeObj, img.nativeObj, grad.nativeObj, angleOfs.nativeObj, paddingTL.width, paddingTL.height, paddingBR.width, paddingBR.height); + + return; + } + + //javadoc: HOGDescriptor::computeGradient(img, grad, angleOfs) + public void computeGradient(Mat img, Mat grad, Mat angleOfs) + { + + computeGradient_1(nativeObj, img.nativeObj, grad.nativeObj, angleOfs.nativeObj); + + return; + } + + + // + // C++: void detect(Mat img, vector_Point& foundLocations, vector_double& weights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), vector_Point searchLocations = std::vector()) + // + + //javadoc: HOGDescriptor::detect(img, foundLocations, weights, hitThreshold, winStride, padding, searchLocations) + public void detect(Mat img, MatOfPoint foundLocations, MatOfDouble weights, double hitThreshold, Size winStride, Size padding, MatOfPoint searchLocations) + { + Mat foundLocations_mat = foundLocations; + Mat weights_mat = weights; + Mat searchLocations_mat = searchLocations; + detect_0(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, weights_mat.nativeObj, hitThreshold, winStride.width, winStride.height, padding.width, padding.height, searchLocations_mat.nativeObj); + + return; + } + + //javadoc: HOGDescriptor::detect(img, foundLocations, weights) + public void detect(Mat img, MatOfPoint foundLocations, MatOfDouble weights) + { + Mat foundLocations_mat = foundLocations; + Mat weights_mat = weights; + detect_1(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, weights_mat.nativeObj); + + return; + } + + + // + // C++: void detectMultiScale(Mat img, vector_Rect& foundLocations, vector_double& foundWeights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), double scale = 1.05, double finalThreshold = 2.0, bool useMeanshiftGrouping = false) + // + + //javadoc: HOGDescriptor::detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride, padding, scale, finalThreshold, useMeanshiftGrouping) + public void detectMultiScale(Mat img, MatOfRect foundLocations, MatOfDouble foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping) + { + Mat foundLocations_mat = foundLocations; + Mat foundWeights_mat = foundWeights; + detectMultiScale_0(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, foundWeights_mat.nativeObj, hitThreshold, winStride.width, winStride.height, padding.width, padding.height, scale, finalThreshold, useMeanshiftGrouping); + + return; + } + + //javadoc: HOGDescriptor::detectMultiScale(img, foundLocations, foundWeights) + public void detectMultiScale(Mat img, MatOfRect foundLocations, MatOfDouble foundWeights) + { + Mat foundLocations_mat = foundLocations; + Mat foundWeights_mat = foundWeights; + detectMultiScale_1(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, foundWeights_mat.nativeObj); + + return; + } + + + // + // C++: void save(String filename, String objname = String()) + // + + //javadoc: HOGDescriptor::save(filename, objname) + public void save(String filename, String objname) + { + + save_0(nativeObj, filename, objname); + + return; + } + + //javadoc: HOGDescriptor::save(filename) + public void save(String filename) + { + + save_1(nativeObj, filename); + + return; + } + + + // + // C++: void setSVMDetector(Mat _svmdetector) + // + + //javadoc: HOGDescriptor::setSVMDetector(_svmdetector) + public void setSVMDetector(Mat _svmdetector) + { + + setSVMDetector_0(nativeObj, _svmdetector.nativeObj); + + return; + } + + + // + // C++: Size HOGDescriptor::winSize + // + + //javadoc: HOGDescriptor::get_winSize() + public Size get_winSize() + { + + Size retVal = new Size(get_winSize_0(nativeObj)); + + return retVal; + } + + + // + // C++: Size HOGDescriptor::blockSize + // + + //javadoc: HOGDescriptor::get_blockSize() + public Size get_blockSize() + { + + Size retVal = new Size(get_blockSize_0(nativeObj)); + + return retVal; + } + + + // + // C++: Size HOGDescriptor::blockStride + // + + //javadoc: HOGDescriptor::get_blockStride() + public Size get_blockStride() + { + + Size retVal = new Size(get_blockStride_0(nativeObj)); + + return retVal; + } + + + // + // C++: Size HOGDescriptor::cellSize + // + + //javadoc: HOGDescriptor::get_cellSize() + public Size get_cellSize() + { + + Size retVal = new Size(get_cellSize_0(nativeObj)); + + return retVal; + } + + + // + // C++: int HOGDescriptor::nbins + // + + //javadoc: HOGDescriptor::get_nbins() + public int get_nbins() + { + + int retVal = get_nbins_0(nativeObj); + + return retVal; + } + + + // + // C++: int HOGDescriptor::derivAperture + // + + //javadoc: HOGDescriptor::get_derivAperture() + public int get_derivAperture() + { + + int retVal = get_derivAperture_0(nativeObj); + + return retVal; + } + + + // + // C++: double HOGDescriptor::winSigma + // + + //javadoc: HOGDescriptor::get_winSigma() + public double get_winSigma() + { + + double retVal = get_winSigma_0(nativeObj); + + return retVal; + } + + + // + // C++: int HOGDescriptor::histogramNormType + // + + //javadoc: HOGDescriptor::get_histogramNormType() + public int get_histogramNormType() + { + + int retVal = get_histogramNormType_0(nativeObj); + + return retVal; + } + + + // + // C++: double HOGDescriptor::L2HysThreshold + // + + //javadoc: HOGDescriptor::get_L2HysThreshold() + public double get_L2HysThreshold() + { + + double retVal = get_L2HysThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: bool HOGDescriptor::gammaCorrection + // + + //javadoc: HOGDescriptor::get_gammaCorrection() + public boolean get_gammaCorrection() + { + + boolean retVal = get_gammaCorrection_0(nativeObj); + + return retVal; + } + + + // + // C++: vector_float HOGDescriptor::svmDetector + // + + //javadoc: HOGDescriptor::get_svmDetector() + public MatOfFloat get_svmDetector() + { + + MatOfFloat retVal = MatOfFloat.fromNativeAddr(get_svmDetector_0(nativeObj)); + + return retVal; + } + + + // + // C++: int HOGDescriptor::nlevels + // + + //javadoc: HOGDescriptor::get_nlevels() + public int get_nlevels() + { + + int retVal = get_nlevels_0(nativeObj); + + return retVal; + } + + + // + // C++: bool HOGDescriptor::signedGradient + // + + //javadoc: HOGDescriptor::get_signedGradient() + public boolean get_signedGradient() + { + + boolean retVal = get_signedGradient_0(nativeObj); + + return retVal; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture = 1, double _winSigma = -1, int _histogramNormType = HOGDescriptor::L2Hys, double _L2HysThreshold = 0.2, bool _gammaCorrection = false, int _nlevels = HOGDescriptor::DEFAULT_NLEVELS, bool _signedGradient = false) + private static native long HOGDescriptor_0(double _winSize_width, double _winSize_height, double _blockSize_width, double _blockSize_height, double _blockStride_width, double _blockStride_height, double _cellSize_width, double _cellSize_height, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, boolean _gammaCorrection, int _nlevels, boolean _signedGradient); + private static native long HOGDescriptor_1(double _winSize_width, double _winSize_height, double _blockSize_width, double _blockSize_height, double _blockStride_width, double _blockStride_height, double _cellSize_width, double _cellSize_height, int _nbins); + + // C++: HOGDescriptor(String filename) + private static native long HOGDescriptor_2(String filename); + + // C++: HOGDescriptor() + private static native long HOGDescriptor_3(); + + // C++: bool checkDetectorSize() + private static native boolean checkDetectorSize_0(long nativeObj); + + // C++: bool load(String filename, String objname = String()) + private static native boolean load_0(long nativeObj, String filename, String objname); + private static native boolean load_1(long nativeObj, String filename); + + // C++: double getWinSigma() + private static native double getWinSigma_0(long nativeObj); + + // C++: size_t getDescriptorSize() + private static native long getDescriptorSize_0(long nativeObj); + + // C++: static vector_float getDaimlerPeopleDetector() + private static native long getDaimlerPeopleDetector_0(); + + // C++: static vector_float getDefaultPeopleDetector() + private static native long getDefaultPeopleDetector_0(); + + // C++: void compute(Mat img, vector_float& descriptors, Size winStride = Size(), Size padding = Size(), vector_Point locations = std::vector()) + private static native void compute_0(long nativeObj, long img_nativeObj, long descriptors_mat_nativeObj, double winStride_width, double winStride_height, double padding_width, double padding_height, long locations_mat_nativeObj); + private static native void compute_1(long nativeObj, long img_nativeObj, long descriptors_mat_nativeObj); + + // C++: void computeGradient(Mat img, Mat& grad, Mat& angleOfs, Size paddingTL = Size(), Size paddingBR = Size()) + private static native void computeGradient_0(long nativeObj, long img_nativeObj, long grad_nativeObj, long angleOfs_nativeObj, double paddingTL_width, double paddingTL_height, double paddingBR_width, double paddingBR_height); + private static native void computeGradient_1(long nativeObj, long img_nativeObj, long grad_nativeObj, long angleOfs_nativeObj); + + // C++: void detect(Mat img, vector_Point& foundLocations, vector_double& weights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), vector_Point searchLocations = std::vector()) + private static native void detect_0(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long weights_mat_nativeObj, double hitThreshold, double winStride_width, double winStride_height, double padding_width, double padding_height, long searchLocations_mat_nativeObj); + private static native void detect_1(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long weights_mat_nativeObj); + + // C++: void detectMultiScale(Mat img, vector_Rect& foundLocations, vector_double& foundWeights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), double scale = 1.05, double finalThreshold = 2.0, bool useMeanshiftGrouping = false) + private static native void detectMultiScale_0(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long foundWeights_mat_nativeObj, double hitThreshold, double winStride_width, double winStride_height, double padding_width, double padding_height, double scale, double finalThreshold, boolean useMeanshiftGrouping); + private static native void detectMultiScale_1(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long foundWeights_mat_nativeObj); + + // C++: void save(String filename, String objname = String()) + private static native void save_0(long nativeObj, String filename, String objname); + private static native void save_1(long nativeObj, String filename); + + // C++: void setSVMDetector(Mat _svmdetector) + private static native void setSVMDetector_0(long nativeObj, long _svmdetector_nativeObj); + + // C++: Size HOGDescriptor::winSize + private static native double[] get_winSize_0(long nativeObj); + + // C++: Size HOGDescriptor::blockSize + private static native double[] get_blockSize_0(long nativeObj); + + // C++: Size HOGDescriptor::blockStride + private static native double[] get_blockStride_0(long nativeObj); + + // C++: Size HOGDescriptor::cellSize + private static native double[] get_cellSize_0(long nativeObj); + + // C++: int HOGDescriptor::nbins + private static native int get_nbins_0(long nativeObj); + + // C++: int HOGDescriptor::derivAperture + private static native int get_derivAperture_0(long nativeObj); + + // C++: double HOGDescriptor::winSigma + private static native double get_winSigma_0(long nativeObj); + + // C++: int HOGDescriptor::histogramNormType + private static native int get_histogramNormType_0(long nativeObj); + + // C++: double HOGDescriptor::L2HysThreshold + private static native double get_L2HysThreshold_0(long nativeObj); + + // C++: bool HOGDescriptor::gammaCorrection + private static native boolean get_gammaCorrection_0(long nativeObj); + + // C++: vector_float HOGDescriptor::svmDetector + private static native long get_svmDetector_0(long nativeObj); + + // C++: int HOGDescriptor::nlevels + private static native int get_nlevels_0(long nativeObj); + + // C++: bool HOGDescriptor::signedGradient + private static native boolean get_signedGradient_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/objdetect/Objdetect.java b/openCVLibrary330/src/main/java/org/opencv/objdetect/Objdetect.java new file mode 100644 index 00000000000..5c55d9244d2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/objdetect/Objdetect.java @@ -0,0 +1,54 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.objdetect; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfInt; +import org.opencv.core.MatOfRect; +import org.opencv.utils.Converters; + +public class Objdetect { + + public static final int + CASCADE_DO_CANNY_PRUNING = 1, + CASCADE_SCALE_IMAGE = 2, + CASCADE_FIND_BIGGEST_OBJECT = 4, + CASCADE_DO_ROUGH_SEARCH = 8; + + + // + // C++: void groupRectangles(vector_Rect& rectList, vector_int& weights, int groupThreshold, double eps = 0.2) + // + + //javadoc: groupRectangles(rectList, weights, groupThreshold, eps) + public static void groupRectangles(MatOfRect rectList, MatOfInt weights, int groupThreshold, double eps) + { + Mat rectList_mat = rectList; + Mat weights_mat = weights; + groupRectangles_0(rectList_mat.nativeObj, weights_mat.nativeObj, groupThreshold, eps); + + return; + } + + //javadoc: groupRectangles(rectList, weights, groupThreshold) + public static void groupRectangles(MatOfRect rectList, MatOfInt weights, int groupThreshold) + { + Mat rectList_mat = rectList; + Mat weights_mat = weights; + groupRectangles_1(rectList_mat.nativeObj, weights_mat.nativeObj, groupThreshold); + + return; + } + + + + + // C++: void groupRectangles(vector_Rect& rectList, vector_int& weights, int groupThreshold, double eps = 0.2) + private static native void groupRectangles_0(long rectList_mat_nativeObj, long weights_mat_nativeObj, int groupThreshold, double eps); + private static native void groupRectangles_1(long rectList_mat_nativeObj, long weights_mat_nativeObj, int groupThreshold); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/osgi/OpenCVInterface.java b/openCVLibrary330/src/main/java/org/opencv/osgi/OpenCVInterface.java new file mode 100644 index 00000000000..83ffee1a1d0 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/osgi/OpenCVInterface.java @@ -0,0 +1,8 @@ +package org.opencv.osgi; + +/** + * Dummy interface to allow some integration testing within OSGi implementation. + */ +public interface OpenCVInterface +{ +} diff --git a/openCVLibrary330/src/main/java/org/opencv/osgi/OpenCVNativeLoader.java b/openCVLibrary330/src/main/java/org/opencv/osgi/OpenCVNativeLoader.java new file mode 100644 index 00000000000..b2ccc676ba5 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/osgi/OpenCVNativeLoader.java @@ -0,0 +1,18 @@ +package org.opencv.osgi; + +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * This class is intended to provide a convenient way to load OpenCV's native + * library from the Java bundle. If Blueprint is enabled in the OSGi container + * this class will be instantiated automatically and the init() method called + * loading the native library. + */ +public class OpenCVNativeLoader implements OpenCVInterface { + + public void init() { + System.loadLibrary("opencv_java3"); + Logger.getLogger("org.opencv.osgi").log(Level.INFO, "Successfully loaded OpenCV native library."); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/AlignExposures.java b/openCVLibrary330/src/main/java/org/opencv/photo/AlignExposures.java new file mode 100644 index 00000000000..e9b64e73e6d --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/AlignExposures.java @@ -0,0 +1,48 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class AlignExposures +//javadoc: AlignExposures +public class AlignExposures extends Algorithm { + + protected AlignExposures(long addr) { super(addr); } + + + // + // C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response) + // + + //javadoc: AlignExposures::process(src, dst, times, response) + public void process(List src, List dst, Mat times, Mat response) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + Mat dst_mat = Converters.vector_Mat_to_Mat(dst); + process_0(nativeObj, src_mat.nativeObj, dst_mat.nativeObj, times.nativeObj, response.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_mat_nativeObj, long times_nativeObj, long response_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/AlignMTB.java b/openCVLibrary330/src/main/java/org/opencv/photo/AlignMTB.java new file mode 100644 index 00000000000..38695b07351 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/AlignMTB.java @@ -0,0 +1,219 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.Point; +import org.opencv.utils.Converters; + +// C++: class AlignMTB +//javadoc: AlignMTB +public class AlignMTB extends AlignExposures { + + protected AlignMTB(long addr) { super(addr); } + + + // + // C++: Point calculateShift(Mat img0, Mat img1) + // + + //javadoc: AlignMTB::calculateShift(img0, img1) + public Point calculateShift(Mat img0, Mat img1) + { + + Point retVal = new Point(calculateShift_0(nativeObj, img0.nativeObj, img1.nativeObj)); + + return retVal; + } + + + // + // C++: bool getCut() + // + + //javadoc: AlignMTB::getCut() + public boolean getCut() + { + + boolean retVal = getCut_0(nativeObj); + + return retVal; + } + + + // + // C++: int getExcludeRange() + // + + //javadoc: AlignMTB::getExcludeRange() + public int getExcludeRange() + { + + int retVal = getExcludeRange_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxBits() + // + + //javadoc: AlignMTB::getMaxBits() + public int getMaxBits() + { + + int retVal = getMaxBits_0(nativeObj); + + return retVal; + } + + + // + // C++: void computeBitmaps(Mat img, Mat& tb, Mat& eb) + // + + //javadoc: AlignMTB::computeBitmaps(img, tb, eb) + public void computeBitmaps(Mat img, Mat tb, Mat eb) + { + + computeBitmaps_0(nativeObj, img.nativeObj, tb.nativeObj, eb.nativeObj); + + return; + } + + + // + // C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response) + // + + //javadoc: AlignMTB::process(src, dst, times, response) + public void process(List src, List dst, Mat times, Mat response) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + Mat dst_mat = Converters.vector_Mat_to_Mat(dst); + process_0(nativeObj, src_mat.nativeObj, dst_mat.nativeObj, times.nativeObj, response.nativeObj); + + return; + } + + + // + // C++: void process(vector_Mat src, vector_Mat dst) + // + + //javadoc: AlignMTB::process(src, dst) + public void process(List src, List dst) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + Mat dst_mat = Converters.vector_Mat_to_Mat(dst); + process_1(nativeObj, src_mat.nativeObj, dst_mat.nativeObj); + + return; + } + + + // + // C++: void setCut(bool value) + // + + //javadoc: AlignMTB::setCut(value) + public void setCut(boolean value) + { + + setCut_0(nativeObj, value); + + return; + } + + + // + // C++: void setExcludeRange(int exclude_range) + // + + //javadoc: AlignMTB::setExcludeRange(exclude_range) + public void setExcludeRange(int exclude_range) + { + + setExcludeRange_0(nativeObj, exclude_range); + + return; + } + + + // + // C++: void setMaxBits(int max_bits) + // + + //javadoc: AlignMTB::setMaxBits(max_bits) + public void setMaxBits(int max_bits) + { + + setMaxBits_0(nativeObj, max_bits); + + return; + } + + + // + // C++: void shiftMat(Mat src, Mat& dst, Point shift) + // + + //javadoc: AlignMTB::shiftMat(src, dst, shift) + public void shiftMat(Mat src, Mat dst, Point shift) + { + + shiftMat_0(nativeObj, src.nativeObj, dst.nativeObj, shift.x, shift.y); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Point calculateShift(Mat img0, Mat img1) + private static native double[] calculateShift_0(long nativeObj, long img0_nativeObj, long img1_nativeObj); + + // C++: bool getCut() + private static native boolean getCut_0(long nativeObj); + + // C++: int getExcludeRange() + private static native int getExcludeRange_0(long nativeObj); + + // C++: int getMaxBits() + private static native int getMaxBits_0(long nativeObj); + + // C++: void computeBitmaps(Mat img, Mat& tb, Mat& eb) + private static native void computeBitmaps_0(long nativeObj, long img_nativeObj, long tb_nativeObj, long eb_nativeObj); + + // C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_mat_nativeObj, long times_nativeObj, long response_nativeObj); + + // C++: void process(vector_Mat src, vector_Mat dst) + private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_mat_nativeObj); + + // C++: void setCut(bool value) + private static native void setCut_0(long nativeObj, boolean value); + + // C++: void setExcludeRange(int exclude_range) + private static native void setExcludeRange_0(long nativeObj, int exclude_range); + + // C++: void setMaxBits(int max_bits) + private static native void setMaxBits_0(long nativeObj, int max_bits); + + // C++: void shiftMat(Mat src, Mat& dst, Point shift) + private static native void shiftMat_0(long nativeObj, long src_nativeObj, long dst_nativeObj, double shift_x, double shift_y); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateCRF.java b/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateCRF.java new file mode 100644 index 00000000000..127307823a5 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateCRF.java @@ -0,0 +1,47 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class CalibrateCRF +//javadoc: CalibrateCRF +public class CalibrateCRF extends Algorithm { + + protected CalibrateCRF(long addr) { super(addr); } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times) + // + + //javadoc: CalibrateCRF::process(src, dst, times) + public void process(List src, Mat dst, Mat times) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void process(vector_Mat src, Mat& dst, Mat times) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateDebevec.java b/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateDebevec.java new file mode 100644 index 00000000000..45a3af68b35 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateDebevec.java @@ -0,0 +1,128 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + + + +// C++: class CalibrateDebevec +//javadoc: CalibrateDebevec +public class CalibrateDebevec extends CalibrateCRF { + + protected CalibrateDebevec(long addr) { super(addr); } + + + // + // C++: bool getRandom() + // + + //javadoc: CalibrateDebevec::getRandom() + public boolean getRandom() + { + + boolean retVal = getRandom_0(nativeObj); + + return retVal; + } + + + // + // C++: float getLambda() + // + + //javadoc: CalibrateDebevec::getLambda() + public float getLambda() + { + + float retVal = getLambda_0(nativeObj); + + return retVal; + } + + + // + // C++: int getSamples() + // + + //javadoc: CalibrateDebevec::getSamples() + public int getSamples() + { + + int retVal = getSamples_0(nativeObj); + + return retVal; + } + + + // + // C++: void setLambda(float lambda) + // + + //javadoc: CalibrateDebevec::setLambda(lambda) + public void setLambda(float lambda) + { + + setLambda_0(nativeObj, lambda); + + return; + } + + + // + // C++: void setRandom(bool random) + // + + //javadoc: CalibrateDebevec::setRandom(random) + public void setRandom(boolean random) + { + + setRandom_0(nativeObj, random); + + return; + } + + + // + // C++: void setSamples(int samples) + // + + //javadoc: CalibrateDebevec::setSamples(samples) + public void setSamples(int samples) + { + + setSamples_0(nativeObj, samples); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: bool getRandom() + private static native boolean getRandom_0(long nativeObj); + + // C++: float getLambda() + private static native float getLambda_0(long nativeObj); + + // C++: int getSamples() + private static native int getSamples_0(long nativeObj); + + // C++: void setLambda(float lambda) + private static native void setLambda_0(long nativeObj, float lambda); + + // C++: void setRandom(bool random) + private static native void setRandom_0(long nativeObj, boolean random); + + // C++: void setSamples(int samples) + private static native void setSamples_0(long nativeObj, int samples); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateRobertson.java b/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateRobertson.java new file mode 100644 index 00000000000..4d2956ac590 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/CalibrateRobertson.java @@ -0,0 +1,111 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import org.opencv.core.Mat; + +// C++: class CalibrateRobertson +//javadoc: CalibrateRobertson +public class CalibrateRobertson extends CalibrateCRF { + + protected CalibrateRobertson(long addr) { super(addr); } + + + // + // C++: Mat getRadiance() + // + + //javadoc: CalibrateRobertson::getRadiance() + public Mat getRadiance() + { + + Mat retVal = new Mat(getRadiance_0(nativeObj)); + + return retVal; + } + + + // + // C++: float getThreshold() + // + + //javadoc: CalibrateRobertson::getThreshold() + public float getThreshold() + { + + float retVal = getThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxIter() + // + + //javadoc: CalibrateRobertson::getMaxIter() + public int getMaxIter() + { + + int retVal = getMaxIter_0(nativeObj); + + return retVal; + } + + + // + // C++: void setMaxIter(int max_iter) + // + + //javadoc: CalibrateRobertson::setMaxIter(max_iter) + public void setMaxIter(int max_iter) + { + + setMaxIter_0(nativeObj, max_iter); + + return; + } + + + // + // C++: void setThreshold(float threshold) + // + + //javadoc: CalibrateRobertson::setThreshold(threshold) + public void setThreshold(float threshold) + { + + setThreshold_0(nativeObj, threshold); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: Mat getRadiance() + private static native long getRadiance_0(long nativeObj); + + // C++: float getThreshold() + private static native float getThreshold_0(long nativeObj); + + // C++: int getMaxIter() + private static native int getMaxIter_0(long nativeObj); + + // C++: void setMaxIter(int max_iter) + private static native void setMaxIter_0(long nativeObj, int max_iter); + + // C++: void setThreshold(float threshold) + private static native void setThreshold_0(long nativeObj, float threshold); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/MergeDebevec.java b/openCVLibrary330/src/main/java/org/opencv/photo/MergeDebevec.java new file mode 100644 index 00000000000..f540c8808ee --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/MergeDebevec.java @@ -0,0 +1,63 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class MergeDebevec +//javadoc: MergeDebevec +public class MergeDebevec extends MergeExposures { + + protected MergeDebevec(long addr) { super(addr); } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + // + + //javadoc: MergeDebevec::process(src, dst, times, response) + public void process(List src, Mat dst, Mat times, Mat response) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj); + + return; + } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times) + // + + //javadoc: MergeDebevec::process(src, dst, times) + public void process(List src, Mat dst, Mat times) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_1(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj); + + // C++: void process(vector_Mat src, Mat& dst, Mat times) + private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/MergeExposures.java b/openCVLibrary330/src/main/java/org/opencv/photo/MergeExposures.java new file mode 100644 index 00000000000..558dfcc8f90 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/MergeExposures.java @@ -0,0 +1,47 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class MergeExposures +//javadoc: MergeExposures +public class MergeExposures extends Algorithm { + + protected MergeExposures(long addr) { super(addr); } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + // + + //javadoc: MergeExposures::process(src, dst, times, response) + public void process(List src, Mat dst, Mat times, Mat response) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/MergeMertens.java b/openCVLibrary330/src/main/java/org/opencv/photo/MergeMertens.java new file mode 100644 index 00000000000..895c084a69e --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/MergeMertens.java @@ -0,0 +1,165 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class MergeMertens +//javadoc: MergeMertens +public class MergeMertens extends MergeExposures { + + protected MergeMertens(long addr) { super(addr); } + + + // + // C++: float getContrastWeight() + // + + //javadoc: MergeMertens::getContrastWeight() + public float getContrastWeight() + { + + float retVal = getContrastWeight_0(nativeObj); + + return retVal; + } + + + // + // C++: float getExposureWeight() + // + + //javadoc: MergeMertens::getExposureWeight() + public float getExposureWeight() + { + + float retVal = getExposureWeight_0(nativeObj); + + return retVal; + } + + + // + // C++: float getSaturationWeight() + // + + //javadoc: MergeMertens::getSaturationWeight() + public float getSaturationWeight() + { + + float retVal = getSaturationWeight_0(nativeObj); + + return retVal; + } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + // + + //javadoc: MergeMertens::process(src, dst, times, response) + public void process(List src, Mat dst, Mat times, Mat response) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj); + + return; + } + + + // + // C++: void process(vector_Mat src, Mat& dst) + // + + //javadoc: MergeMertens::process(src, dst) + public void process(List src, Mat dst) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_1(nativeObj, src_mat.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void setContrastWeight(float contrast_weiht) + // + + //javadoc: MergeMertens::setContrastWeight(contrast_weiht) + public void setContrastWeight(float contrast_weiht) + { + + setContrastWeight_0(nativeObj, contrast_weiht); + + return; + } + + + // + // C++: void setExposureWeight(float exposure_weight) + // + + //javadoc: MergeMertens::setExposureWeight(exposure_weight) + public void setExposureWeight(float exposure_weight) + { + + setExposureWeight_0(nativeObj, exposure_weight); + + return; + } + + + // + // C++: void setSaturationWeight(float saturation_weight) + // + + //javadoc: MergeMertens::setSaturationWeight(saturation_weight) + public void setSaturationWeight(float saturation_weight) + { + + setSaturationWeight_0(nativeObj, saturation_weight); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: float getContrastWeight() + private static native float getContrastWeight_0(long nativeObj); + + // C++: float getExposureWeight() + private static native float getExposureWeight_0(long nativeObj); + + // C++: float getSaturationWeight() + private static native float getSaturationWeight_0(long nativeObj); + + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj); + + // C++: void process(vector_Mat src, Mat& dst) + private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_nativeObj); + + // C++: void setContrastWeight(float contrast_weiht) + private static native void setContrastWeight_0(long nativeObj, float contrast_weiht); + + // C++: void setExposureWeight(float exposure_weight) + private static native void setExposureWeight_0(long nativeObj, float exposure_weight); + + // C++: void setSaturationWeight(float saturation_weight) + private static native void setSaturationWeight_0(long nativeObj, float saturation_weight); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/MergeRobertson.java b/openCVLibrary330/src/main/java/org/opencv/photo/MergeRobertson.java new file mode 100644 index 00000000000..86308b61859 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/MergeRobertson.java @@ -0,0 +1,63 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.utils.Converters; + +// C++: class MergeRobertson +//javadoc: MergeRobertson +public class MergeRobertson extends MergeExposures { + + protected MergeRobertson(long addr) { super(addr); } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + // + + //javadoc: MergeRobertson::process(src, dst, times, response) + public void process(List src, Mat dst, Mat times, Mat response) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj); + + return; + } + + + // + // C++: void process(vector_Mat src, Mat& dst, Mat times) + // + + //javadoc: MergeRobertson::process(src, dst, times) + public void process(List src, Mat dst, Mat times) + { + Mat src_mat = Converters.vector_Mat_to_Mat(src); + process_1(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response) + private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj); + + // C++: void process(vector_Mat src, Mat& dst, Mat times) + private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/Photo.java b/openCVLibrary330/src/main/java/org/opencv/photo/Photo.java new file mode 100644 index 00000000000..a76ed173420 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/Photo.java @@ -0,0 +1,742 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfFloat; +import org.opencv.core.Point; +import org.opencv.utils.Converters; + +public class Photo { + + private static final int + CV_INPAINT_NS = 0, + CV_INPAINT_TELEA = 1; + + + public static final int + INPAINT_NS = 0, + INPAINT_TELEA = 1, + NORMAL_CLONE = 1, + MIXED_CLONE = 2, + MONOCHROME_TRANSFER = 3, + RECURS_FILTER = 1, + NORMCONV_FILTER = 2, + LDR_SIZE = 256; + + + // + // C++: Ptr_AlignMTB createAlignMTB(int max_bits = 6, int exclude_range = 4, bool cut = true) + // + + //javadoc: createAlignMTB(max_bits, exclude_range, cut) + public static AlignMTB createAlignMTB(int max_bits, int exclude_range, boolean cut) + { + + AlignMTB retVal = new AlignMTB(createAlignMTB_0(max_bits, exclude_range, cut)); + + return retVal; + } + + //javadoc: createAlignMTB() + public static AlignMTB createAlignMTB() + { + + AlignMTB retVal = new AlignMTB(createAlignMTB_1()); + + return retVal; + } + + + // + // C++: Ptr_CalibrateDebevec createCalibrateDebevec(int samples = 70, float lambda = 10.0f, bool random = false) + // + + //javadoc: createCalibrateDebevec(samples, lambda, random) + public static CalibrateDebevec createCalibrateDebevec(int samples, float lambda, boolean random) + { + + CalibrateDebevec retVal = new CalibrateDebevec(createCalibrateDebevec_0(samples, lambda, random)); + + return retVal; + } + + //javadoc: createCalibrateDebevec() + public static CalibrateDebevec createCalibrateDebevec() + { + + CalibrateDebevec retVal = new CalibrateDebevec(createCalibrateDebevec_1()); + + return retVal; + } + + + // + // C++: Ptr_CalibrateRobertson createCalibrateRobertson(int max_iter = 30, float threshold = 0.01f) + // + + //javadoc: createCalibrateRobertson(max_iter, threshold) + public static CalibrateRobertson createCalibrateRobertson(int max_iter, float threshold) + { + + CalibrateRobertson retVal = new CalibrateRobertson(createCalibrateRobertson_0(max_iter, threshold)); + + return retVal; + } + + //javadoc: createCalibrateRobertson() + public static CalibrateRobertson createCalibrateRobertson() + { + + CalibrateRobertson retVal = new CalibrateRobertson(createCalibrateRobertson_1()); + + return retVal; + } + + + // + // C++: Ptr_MergeDebevec createMergeDebevec() + // + + //javadoc: createMergeDebevec() + public static MergeDebevec createMergeDebevec() + { + + MergeDebevec retVal = new MergeDebevec(createMergeDebevec_0()); + + return retVal; + } + + + // + // C++: Ptr_MergeMertens createMergeMertens(float contrast_weight = 1.0f, float saturation_weight = 1.0f, float exposure_weight = 0.0f) + // + + //javadoc: createMergeMertens(contrast_weight, saturation_weight, exposure_weight) + public static MergeMertens createMergeMertens(float contrast_weight, float saturation_weight, float exposure_weight) + { + + MergeMertens retVal = new MergeMertens(createMergeMertens_0(contrast_weight, saturation_weight, exposure_weight)); + + return retVal; + } + + //javadoc: createMergeMertens() + public static MergeMertens createMergeMertens() + { + + MergeMertens retVal = new MergeMertens(createMergeMertens_1()); + + return retVal; + } + + + // + // C++: Ptr_MergeRobertson createMergeRobertson() + // + + //javadoc: createMergeRobertson() + public static MergeRobertson createMergeRobertson() + { + + MergeRobertson retVal = new MergeRobertson(createMergeRobertson_0()); + + return retVal; + } + + + // + // C++: Ptr_Tonemap createTonemap(float gamma = 1.0f) + // + + //javadoc: createTonemap(gamma) + public static Tonemap createTonemap(float gamma) + { + + Tonemap retVal = new Tonemap(createTonemap_0(gamma)); + + return retVal; + } + + //javadoc: createTonemap() + public static Tonemap createTonemap() + { + + Tonemap retVal = new Tonemap(createTonemap_1()); + + return retVal; + } + + + // + // C++: Ptr_TonemapDrago createTonemapDrago(float gamma = 1.0f, float saturation = 1.0f, float bias = 0.85f) + // + + //javadoc: createTonemapDrago(gamma, saturation, bias) + public static TonemapDrago createTonemapDrago(float gamma, float saturation, float bias) + { + + TonemapDrago retVal = new TonemapDrago(createTonemapDrago_0(gamma, saturation, bias)); + + return retVal; + } + + //javadoc: createTonemapDrago() + public static TonemapDrago createTonemapDrago() + { + + TonemapDrago retVal = new TonemapDrago(createTonemapDrago_1()); + + return retVal; + } + + + // + // C++: Ptr_TonemapDurand createTonemapDurand(float gamma = 1.0f, float contrast = 4.0f, float saturation = 1.0f, float sigma_space = 2.0f, float sigma_color = 2.0f) + // + + //javadoc: createTonemapDurand(gamma, contrast, saturation, sigma_space, sigma_color) + public static TonemapDurand createTonemapDurand(float gamma, float contrast, float saturation, float sigma_space, float sigma_color) + { + + TonemapDurand retVal = new TonemapDurand(createTonemapDurand_0(gamma, contrast, saturation, sigma_space, sigma_color)); + + return retVal; + } + + //javadoc: createTonemapDurand() + public static TonemapDurand createTonemapDurand() + { + + TonemapDurand retVal = new TonemapDurand(createTonemapDurand_1()); + + return retVal; + } + + + // + // C++: Ptr_TonemapMantiuk createTonemapMantiuk(float gamma = 1.0f, float scale = 0.7f, float saturation = 1.0f) + // + + //javadoc: createTonemapMantiuk(gamma, scale, saturation) + public static TonemapMantiuk createTonemapMantiuk(float gamma, float scale, float saturation) + { + + TonemapMantiuk retVal = new TonemapMantiuk(createTonemapMantiuk_0(gamma, scale, saturation)); + + return retVal; + } + + //javadoc: createTonemapMantiuk() + public static TonemapMantiuk createTonemapMantiuk() + { + + TonemapMantiuk retVal = new TonemapMantiuk(createTonemapMantiuk_1()); + + return retVal; + } + + + // + // C++: Ptr_TonemapReinhard createTonemapReinhard(float gamma = 1.0f, float intensity = 0.0f, float light_adapt = 1.0f, float color_adapt = 0.0f) + // + + //javadoc: createTonemapReinhard(gamma, intensity, light_adapt, color_adapt) + public static TonemapReinhard createTonemapReinhard(float gamma, float intensity, float light_adapt, float color_adapt) + { + + TonemapReinhard retVal = new TonemapReinhard(createTonemapReinhard_0(gamma, intensity, light_adapt, color_adapt)); + + return retVal; + } + + //javadoc: createTonemapReinhard() + public static TonemapReinhard createTonemapReinhard() + { + + TonemapReinhard retVal = new TonemapReinhard(createTonemapReinhard_1()); + + return retVal; + } + + + // + // C++: void colorChange(Mat src, Mat mask, Mat& dst, float red_mul = 1.0f, float green_mul = 1.0f, float blue_mul = 1.0f) + // + + //javadoc: colorChange(src, mask, dst, red_mul, green_mul, blue_mul) + public static void colorChange(Mat src, Mat mask, Mat dst, float red_mul, float green_mul, float blue_mul) + { + + colorChange_0(src.nativeObj, mask.nativeObj, dst.nativeObj, red_mul, green_mul, blue_mul); + + return; + } + + //javadoc: colorChange(src, mask, dst) + public static void colorChange(Mat src, Mat mask, Mat dst) + { + + colorChange_1(src.nativeObj, mask.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void decolor(Mat src, Mat& grayscale, Mat& color_boost) + // + + //javadoc: decolor(src, grayscale, color_boost) + public static void decolor(Mat src, Mat grayscale, Mat color_boost) + { + + decolor_0(src.nativeObj, grayscale.nativeObj, color_boost.nativeObj); + + return; + } + + + // + // C++: void denoise_TVL1(vector_Mat observations, Mat result, double lambda = 1.0, int niters = 30) + // + + //javadoc: denoise_TVL1(observations, result, lambda, niters) + public static void denoise_TVL1(List observations, Mat result, double lambda, int niters) + { + Mat observations_mat = Converters.vector_Mat_to_Mat(observations); + denoise_TVL1_0(observations_mat.nativeObj, result.nativeObj, lambda, niters); + + return; + } + + //javadoc: denoise_TVL1(observations, result) + public static void denoise_TVL1(List observations, Mat result) + { + Mat observations_mat = Converters.vector_Mat_to_Mat(observations); + denoise_TVL1_1(observations_mat.nativeObj, result.nativeObj); + + return; + } + + + // + // C++: void detailEnhance(Mat src, Mat& dst, float sigma_s = 10, float sigma_r = 0.15f) + // + + //javadoc: detailEnhance(src, dst, sigma_s, sigma_r) + public static void detailEnhance(Mat src, Mat dst, float sigma_s, float sigma_r) + { + + detailEnhance_0(src.nativeObj, dst.nativeObj, sigma_s, sigma_r); + + return; + } + + //javadoc: detailEnhance(src, dst) + public static void detailEnhance(Mat src, Mat dst) + { + + detailEnhance_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void edgePreservingFilter(Mat src, Mat& dst, int flags = 1, float sigma_s = 60, float sigma_r = 0.4f) + // + + //javadoc: edgePreservingFilter(src, dst, flags, sigma_s, sigma_r) + public static void edgePreservingFilter(Mat src, Mat dst, int flags, float sigma_s, float sigma_r) + { + + edgePreservingFilter_0(src.nativeObj, dst.nativeObj, flags, sigma_s, sigma_r); + + return; + } + + //javadoc: edgePreservingFilter(src, dst) + public static void edgePreservingFilter(Mat src, Mat dst) + { + + edgePreservingFilter_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void fastNlMeansDenoising(Mat src, Mat& dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21) + // + + //javadoc: fastNlMeansDenoising(src, dst, h, templateWindowSize, searchWindowSize) + public static void fastNlMeansDenoising(Mat src, Mat dst, float h, int templateWindowSize, int searchWindowSize) + { + + fastNlMeansDenoising_0(src.nativeObj, dst.nativeObj, h, templateWindowSize, searchWindowSize); + + return; + } + + //javadoc: fastNlMeansDenoising(src, dst) + public static void fastNlMeansDenoising(Mat src, Mat dst) + { + + fastNlMeansDenoising_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void fastNlMeansDenoising(Mat src, Mat& dst, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2) + // + + //javadoc: fastNlMeansDenoising(src, dst, h, templateWindowSize, searchWindowSize, normType) + public static void fastNlMeansDenoising(Mat src, Mat dst, MatOfFloat h, int templateWindowSize, int searchWindowSize, int normType) + { + Mat h_mat = h; + fastNlMeansDenoising_2(src.nativeObj, dst.nativeObj, h_mat.nativeObj, templateWindowSize, searchWindowSize, normType); + + return; + } + + //javadoc: fastNlMeansDenoising(src, dst, h) + public static void fastNlMeansDenoising(Mat src, Mat dst, MatOfFloat h) + { + Mat h_mat = h; + fastNlMeansDenoising_3(src.nativeObj, dst.nativeObj, h_mat.nativeObj); + + return; + } + + + // + // C++: void fastNlMeansDenoisingColored(Mat src, Mat& dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21) + // + + //javadoc: fastNlMeansDenoisingColored(src, dst, h, hColor, templateWindowSize, searchWindowSize) + public static void fastNlMeansDenoisingColored(Mat src, Mat dst, float h, float hColor, int templateWindowSize, int searchWindowSize) + { + + fastNlMeansDenoisingColored_0(src.nativeObj, dst.nativeObj, h, hColor, templateWindowSize, searchWindowSize); + + return; + } + + //javadoc: fastNlMeansDenoisingColored(src, dst) + public static void fastNlMeansDenoisingColored(Mat src, Mat dst) + { + + fastNlMeansDenoisingColored_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void fastNlMeansDenoisingColoredMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21) + // + + //javadoc: fastNlMeansDenoisingColoredMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h, hColor, templateWindowSize, searchWindowSize) + public static void fastNlMeansDenoisingColoredMulti(List srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize) + { + Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs); + fastNlMeansDenoisingColoredMulti_0(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h, hColor, templateWindowSize, searchWindowSize); + + return; + } + + //javadoc: fastNlMeansDenoisingColoredMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize) + public static void fastNlMeansDenoisingColoredMulti(List srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize) + { + Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs); + fastNlMeansDenoisingColoredMulti_1(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize); + + return; + } + + + // + // C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21) + // + + //javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize) + public static void fastNlMeansDenoisingMulti(List srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize) + { + Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs); + fastNlMeansDenoisingMulti_0(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize); + + return; + } + + //javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize) + public static void fastNlMeansDenoisingMulti(List srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize) + { + Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs); + fastNlMeansDenoisingMulti_1(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize); + + return; + } + + + // + // C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2) + // + + //javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize, normType) + public static void fastNlMeansDenoisingMulti(List srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h, int templateWindowSize, int searchWindowSize, int normType) + { + Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs); + Mat h_mat = h; + fastNlMeansDenoisingMulti_2(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h_mat.nativeObj, templateWindowSize, searchWindowSize, normType); + + return; + } + + //javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h) + public static void fastNlMeansDenoisingMulti(List srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h) + { + Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs); + Mat h_mat = h; + fastNlMeansDenoisingMulti_3(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h_mat.nativeObj); + + return; + } + + + // + // C++: void illuminationChange(Mat src, Mat mask, Mat& dst, float alpha = 0.2f, float beta = 0.4f) + // + + //javadoc: illuminationChange(src, mask, dst, alpha, beta) + public static void illuminationChange(Mat src, Mat mask, Mat dst, float alpha, float beta) + { + + illuminationChange_0(src.nativeObj, mask.nativeObj, dst.nativeObj, alpha, beta); + + return; + } + + //javadoc: illuminationChange(src, mask, dst) + public static void illuminationChange(Mat src, Mat mask, Mat dst) + { + + illuminationChange_1(src.nativeObj, mask.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void inpaint(Mat src, Mat inpaintMask, Mat& dst, double inpaintRadius, int flags) + // + + //javadoc: inpaint(src, inpaintMask, dst, inpaintRadius, flags) + public static void inpaint(Mat src, Mat inpaintMask, Mat dst, double inpaintRadius, int flags) + { + + inpaint_0(src.nativeObj, inpaintMask.nativeObj, dst.nativeObj, inpaintRadius, flags); + + return; + } + + + // + // C++: void pencilSketch(Mat src, Mat& dst1, Mat& dst2, float sigma_s = 60, float sigma_r = 0.07f, float shade_factor = 0.02f) + // + + //javadoc: pencilSketch(src, dst1, dst2, sigma_s, sigma_r, shade_factor) + public static void pencilSketch(Mat src, Mat dst1, Mat dst2, float sigma_s, float sigma_r, float shade_factor) + { + + pencilSketch_0(src.nativeObj, dst1.nativeObj, dst2.nativeObj, sigma_s, sigma_r, shade_factor); + + return; + } + + //javadoc: pencilSketch(src, dst1, dst2) + public static void pencilSketch(Mat src, Mat dst1, Mat dst2) + { + + pencilSketch_1(src.nativeObj, dst1.nativeObj, dst2.nativeObj); + + return; + } + + + // + // C++: void seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat& blend, int flags) + // + + //javadoc: seamlessClone(src, dst, mask, p, blend, flags) + public static void seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat blend, int flags) + { + + seamlessClone_0(src.nativeObj, dst.nativeObj, mask.nativeObj, p.x, p.y, blend.nativeObj, flags); + + return; + } + + + // + // C++: void stylization(Mat src, Mat& dst, float sigma_s = 60, float sigma_r = 0.45f) + // + + //javadoc: stylization(src, dst, sigma_s, sigma_r) + public static void stylization(Mat src, Mat dst, float sigma_s, float sigma_r) + { + + stylization_0(src.nativeObj, dst.nativeObj, sigma_s, sigma_r); + + return; + } + + //javadoc: stylization(src, dst) + public static void stylization(Mat src, Mat dst) + { + + stylization_1(src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void textureFlattening(Mat src, Mat mask, Mat& dst, float low_threshold = 30, float high_threshold = 45, int kernel_size = 3) + // + + //javadoc: textureFlattening(src, mask, dst, low_threshold, high_threshold, kernel_size) + public static void textureFlattening(Mat src, Mat mask, Mat dst, float low_threshold, float high_threshold, int kernel_size) + { + + textureFlattening_0(src.nativeObj, mask.nativeObj, dst.nativeObj, low_threshold, high_threshold, kernel_size); + + return; + } + + //javadoc: textureFlattening(src, mask, dst) + public static void textureFlattening(Mat src, Mat mask, Mat dst) + { + + textureFlattening_1(src.nativeObj, mask.nativeObj, dst.nativeObj); + + return; + } + + + + + // C++: Ptr_AlignMTB createAlignMTB(int max_bits = 6, int exclude_range = 4, bool cut = true) + private static native long createAlignMTB_0(int max_bits, int exclude_range, boolean cut); + private static native long createAlignMTB_1(); + + // C++: Ptr_CalibrateDebevec createCalibrateDebevec(int samples = 70, float lambda = 10.0f, bool random = false) + private static native long createCalibrateDebevec_0(int samples, float lambda, boolean random); + private static native long createCalibrateDebevec_1(); + + // C++: Ptr_CalibrateRobertson createCalibrateRobertson(int max_iter = 30, float threshold = 0.01f) + private static native long createCalibrateRobertson_0(int max_iter, float threshold); + private static native long createCalibrateRobertson_1(); + + // C++: Ptr_MergeDebevec createMergeDebevec() + private static native long createMergeDebevec_0(); + + // C++: Ptr_MergeMertens createMergeMertens(float contrast_weight = 1.0f, float saturation_weight = 1.0f, float exposure_weight = 0.0f) + private static native long createMergeMertens_0(float contrast_weight, float saturation_weight, float exposure_weight); + private static native long createMergeMertens_1(); + + // C++: Ptr_MergeRobertson createMergeRobertson() + private static native long createMergeRobertson_0(); + + // C++: Ptr_Tonemap createTonemap(float gamma = 1.0f) + private static native long createTonemap_0(float gamma); + private static native long createTonemap_1(); + + // C++: Ptr_TonemapDrago createTonemapDrago(float gamma = 1.0f, float saturation = 1.0f, float bias = 0.85f) + private static native long createTonemapDrago_0(float gamma, float saturation, float bias); + private static native long createTonemapDrago_1(); + + // C++: Ptr_TonemapDurand createTonemapDurand(float gamma = 1.0f, float contrast = 4.0f, float saturation = 1.0f, float sigma_space = 2.0f, float sigma_color = 2.0f) + private static native long createTonemapDurand_0(float gamma, float contrast, float saturation, float sigma_space, float sigma_color); + private static native long createTonemapDurand_1(); + + // C++: Ptr_TonemapMantiuk createTonemapMantiuk(float gamma = 1.0f, float scale = 0.7f, float saturation = 1.0f) + private static native long createTonemapMantiuk_0(float gamma, float scale, float saturation); + private static native long createTonemapMantiuk_1(); + + // C++: Ptr_TonemapReinhard createTonemapReinhard(float gamma = 1.0f, float intensity = 0.0f, float light_adapt = 1.0f, float color_adapt = 0.0f) + private static native long createTonemapReinhard_0(float gamma, float intensity, float light_adapt, float color_adapt); + private static native long createTonemapReinhard_1(); + + // C++: void colorChange(Mat src, Mat mask, Mat& dst, float red_mul = 1.0f, float green_mul = 1.0f, float blue_mul = 1.0f) + private static native void colorChange_0(long src_nativeObj, long mask_nativeObj, long dst_nativeObj, float red_mul, float green_mul, float blue_mul); + private static native void colorChange_1(long src_nativeObj, long mask_nativeObj, long dst_nativeObj); + + // C++: void decolor(Mat src, Mat& grayscale, Mat& color_boost) + private static native void decolor_0(long src_nativeObj, long grayscale_nativeObj, long color_boost_nativeObj); + + // C++: void denoise_TVL1(vector_Mat observations, Mat result, double lambda = 1.0, int niters = 30) + private static native void denoise_TVL1_0(long observations_mat_nativeObj, long result_nativeObj, double lambda, int niters); + private static native void denoise_TVL1_1(long observations_mat_nativeObj, long result_nativeObj); + + // C++: void detailEnhance(Mat src, Mat& dst, float sigma_s = 10, float sigma_r = 0.15f) + private static native void detailEnhance_0(long src_nativeObj, long dst_nativeObj, float sigma_s, float sigma_r); + private static native void detailEnhance_1(long src_nativeObj, long dst_nativeObj); + + // C++: void edgePreservingFilter(Mat src, Mat& dst, int flags = 1, float sigma_s = 60, float sigma_r = 0.4f) + private static native void edgePreservingFilter_0(long src_nativeObj, long dst_nativeObj, int flags, float sigma_s, float sigma_r); + private static native void edgePreservingFilter_1(long src_nativeObj, long dst_nativeObj); + + // C++: void fastNlMeansDenoising(Mat src, Mat& dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21) + private static native void fastNlMeansDenoising_0(long src_nativeObj, long dst_nativeObj, float h, int templateWindowSize, int searchWindowSize); + private static native void fastNlMeansDenoising_1(long src_nativeObj, long dst_nativeObj); + + // C++: void fastNlMeansDenoising(Mat src, Mat& dst, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2) + private static native void fastNlMeansDenoising_2(long src_nativeObj, long dst_nativeObj, long h_mat_nativeObj, int templateWindowSize, int searchWindowSize, int normType); + private static native void fastNlMeansDenoising_3(long src_nativeObj, long dst_nativeObj, long h_mat_nativeObj); + + // C++: void fastNlMeansDenoisingColored(Mat src, Mat& dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21) + private static native void fastNlMeansDenoisingColored_0(long src_nativeObj, long dst_nativeObj, float h, float hColor, int templateWindowSize, int searchWindowSize); + private static native void fastNlMeansDenoisingColored_1(long src_nativeObj, long dst_nativeObj); + + // C++: void fastNlMeansDenoisingColoredMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21) + private static native void fastNlMeansDenoisingColoredMulti_0(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize); + private static native void fastNlMeansDenoisingColoredMulti_1(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize); + + // C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21) + private static native void fastNlMeansDenoisingMulti_0(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize); + private static native void fastNlMeansDenoisingMulti_1(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize); + + // C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2) + private static native void fastNlMeansDenoisingMulti_2(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, long h_mat_nativeObj, int templateWindowSize, int searchWindowSize, int normType); + private static native void fastNlMeansDenoisingMulti_3(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, long h_mat_nativeObj); + + // C++: void illuminationChange(Mat src, Mat mask, Mat& dst, float alpha = 0.2f, float beta = 0.4f) + private static native void illuminationChange_0(long src_nativeObj, long mask_nativeObj, long dst_nativeObj, float alpha, float beta); + private static native void illuminationChange_1(long src_nativeObj, long mask_nativeObj, long dst_nativeObj); + + // C++: void inpaint(Mat src, Mat inpaintMask, Mat& dst, double inpaintRadius, int flags) + private static native void inpaint_0(long src_nativeObj, long inpaintMask_nativeObj, long dst_nativeObj, double inpaintRadius, int flags); + + // C++: void pencilSketch(Mat src, Mat& dst1, Mat& dst2, float sigma_s = 60, float sigma_r = 0.07f, float shade_factor = 0.02f) + private static native void pencilSketch_0(long src_nativeObj, long dst1_nativeObj, long dst2_nativeObj, float sigma_s, float sigma_r, float shade_factor); + private static native void pencilSketch_1(long src_nativeObj, long dst1_nativeObj, long dst2_nativeObj); + + // C++: void seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat& blend, int flags) + private static native void seamlessClone_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj, double p_x, double p_y, long blend_nativeObj, int flags); + + // C++: void stylization(Mat src, Mat& dst, float sigma_s = 60, float sigma_r = 0.45f) + private static native void stylization_0(long src_nativeObj, long dst_nativeObj, float sigma_s, float sigma_r); + private static native void stylization_1(long src_nativeObj, long dst_nativeObj); + + // C++: void textureFlattening(Mat src, Mat mask, Mat& dst, float low_threshold = 30, float high_threshold = 45, int kernel_size = 3) + private static native void textureFlattening_0(long src_nativeObj, long mask_nativeObj, long dst_nativeObj, float low_threshold, float high_threshold, int kernel_size); + private static native void textureFlattening_1(long src_nativeObj, long mask_nativeObj, long dst_nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/Tonemap.java b/openCVLibrary330/src/main/java/org/opencv/photo/Tonemap.java new file mode 100644 index 00000000000..ca58ef4d837 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/Tonemap.java @@ -0,0 +1,78 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; + +// C++: class Tonemap +//javadoc: Tonemap +public class Tonemap extends Algorithm { + + protected Tonemap(long addr) { super(addr); } + + + // + // C++: float getGamma() + // + + //javadoc: Tonemap::getGamma() + public float getGamma() + { + + float retVal = getGamma_0(nativeObj); + + return retVal; + } + + + // + // C++: void process(Mat src, Mat& dst) + // + + //javadoc: Tonemap::process(src, dst) + public void process(Mat src, Mat dst) + { + + process_0(nativeObj, src.nativeObj, dst.nativeObj); + + return; + } + + + // + // C++: void setGamma(float gamma) + // + + //javadoc: Tonemap::setGamma(gamma) + public void setGamma(float gamma) + { + + setGamma_0(nativeObj, gamma); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: float getGamma() + private static native float getGamma_0(long nativeObj); + + // C++: void process(Mat src, Mat& dst) + private static native void process_0(long nativeObj, long src_nativeObj, long dst_nativeObj); + + // C++: void setGamma(float gamma) + private static native void setGamma_0(long nativeObj, float gamma); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/TonemapDrago.java b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapDrago.java new file mode 100644 index 00000000000..32d1a9d9742 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapDrago.java @@ -0,0 +1,94 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + + + +// C++: class TonemapDrago +//javadoc: TonemapDrago +public class TonemapDrago extends Tonemap { + + protected TonemapDrago(long addr) { super(addr); } + + + // + // C++: float getBias() + // + + //javadoc: TonemapDrago::getBias() + public float getBias() + { + + float retVal = getBias_0(nativeObj); + + return retVal; + } + + + // + // C++: float getSaturation() + // + + //javadoc: TonemapDrago::getSaturation() + public float getSaturation() + { + + float retVal = getSaturation_0(nativeObj); + + return retVal; + } + + + // + // C++: void setBias(float bias) + // + + //javadoc: TonemapDrago::setBias(bias) + public void setBias(float bias) + { + + setBias_0(nativeObj, bias); + + return; + } + + + // + // C++: void setSaturation(float saturation) + // + + //javadoc: TonemapDrago::setSaturation(saturation) + public void setSaturation(float saturation) + { + + setSaturation_0(nativeObj, saturation); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: float getBias() + private static native float getBias_0(long nativeObj); + + // C++: float getSaturation() + private static native float getSaturation_0(long nativeObj); + + // C++: void setBias(float bias) + private static native void setBias_0(long nativeObj, float bias); + + // C++: void setSaturation(float saturation) + private static native void setSaturation_0(long nativeObj, float saturation); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/TonemapDurand.java b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapDurand.java new file mode 100644 index 00000000000..71e48a0aad6 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapDurand.java @@ -0,0 +1,162 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + + + +// C++: class TonemapDurand +//javadoc: TonemapDurand +public class TonemapDurand extends Tonemap { + + protected TonemapDurand(long addr) { super(addr); } + + + // + // C++: float getContrast() + // + + //javadoc: TonemapDurand::getContrast() + public float getContrast() + { + + float retVal = getContrast_0(nativeObj); + + return retVal; + } + + + // + // C++: float getSaturation() + // + + //javadoc: TonemapDurand::getSaturation() + public float getSaturation() + { + + float retVal = getSaturation_0(nativeObj); + + return retVal; + } + + + // + // C++: float getSigmaColor() + // + + //javadoc: TonemapDurand::getSigmaColor() + public float getSigmaColor() + { + + float retVal = getSigmaColor_0(nativeObj); + + return retVal; + } + + + // + // C++: float getSigmaSpace() + // + + //javadoc: TonemapDurand::getSigmaSpace() + public float getSigmaSpace() + { + + float retVal = getSigmaSpace_0(nativeObj); + + return retVal; + } + + + // + // C++: void setContrast(float contrast) + // + + //javadoc: TonemapDurand::setContrast(contrast) + public void setContrast(float contrast) + { + + setContrast_0(nativeObj, contrast); + + return; + } + + + // + // C++: void setSaturation(float saturation) + // + + //javadoc: TonemapDurand::setSaturation(saturation) + public void setSaturation(float saturation) + { + + setSaturation_0(nativeObj, saturation); + + return; + } + + + // + // C++: void setSigmaColor(float sigma_color) + // + + //javadoc: TonemapDurand::setSigmaColor(sigma_color) + public void setSigmaColor(float sigma_color) + { + + setSigmaColor_0(nativeObj, sigma_color); + + return; + } + + + // + // C++: void setSigmaSpace(float sigma_space) + // + + //javadoc: TonemapDurand::setSigmaSpace(sigma_space) + public void setSigmaSpace(float sigma_space) + { + + setSigmaSpace_0(nativeObj, sigma_space); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: float getContrast() + private static native float getContrast_0(long nativeObj); + + // C++: float getSaturation() + private static native float getSaturation_0(long nativeObj); + + // C++: float getSigmaColor() + private static native float getSigmaColor_0(long nativeObj); + + // C++: float getSigmaSpace() + private static native float getSigmaSpace_0(long nativeObj); + + // C++: void setContrast(float contrast) + private static native void setContrast_0(long nativeObj, float contrast); + + // C++: void setSaturation(float saturation) + private static native void setSaturation_0(long nativeObj, float saturation); + + // C++: void setSigmaColor(float sigma_color) + private static native void setSigmaColor_0(long nativeObj, float sigma_color); + + // C++: void setSigmaSpace(float sigma_space) + private static native void setSigmaSpace_0(long nativeObj, float sigma_space); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/TonemapMantiuk.java b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapMantiuk.java new file mode 100644 index 00000000000..a626aaaff58 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapMantiuk.java @@ -0,0 +1,94 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + + + +// C++: class TonemapMantiuk +//javadoc: TonemapMantiuk +public class TonemapMantiuk extends Tonemap { + + protected TonemapMantiuk(long addr) { super(addr); } + + + // + // C++: float getSaturation() + // + + //javadoc: TonemapMantiuk::getSaturation() + public float getSaturation() + { + + float retVal = getSaturation_0(nativeObj); + + return retVal; + } + + + // + // C++: float getScale() + // + + //javadoc: TonemapMantiuk::getScale() + public float getScale() + { + + float retVal = getScale_0(nativeObj); + + return retVal; + } + + + // + // C++: void setSaturation(float saturation) + // + + //javadoc: TonemapMantiuk::setSaturation(saturation) + public void setSaturation(float saturation) + { + + setSaturation_0(nativeObj, saturation); + + return; + } + + + // + // C++: void setScale(float scale) + // + + //javadoc: TonemapMantiuk::setScale(scale) + public void setScale(float scale) + { + + setScale_0(nativeObj, scale); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: float getSaturation() + private static native float getSaturation_0(long nativeObj); + + // C++: float getScale() + private static native float getScale_0(long nativeObj); + + // C++: void setSaturation(float saturation) + private static native void setSaturation_0(long nativeObj, float saturation); + + // C++: void setScale(float scale) + private static native void setScale_0(long nativeObj, float scale); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/photo/TonemapReinhard.java b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapReinhard.java new file mode 100644 index 00000000000..340b1468bb8 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/photo/TonemapReinhard.java @@ -0,0 +1,128 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.photo; + + + +// C++: class TonemapReinhard +//javadoc: TonemapReinhard +public class TonemapReinhard extends Tonemap { + + protected TonemapReinhard(long addr) { super(addr); } + + + // + // C++: float getColorAdaptation() + // + + //javadoc: TonemapReinhard::getColorAdaptation() + public float getColorAdaptation() + { + + float retVal = getColorAdaptation_0(nativeObj); + + return retVal; + } + + + // + // C++: float getIntensity() + // + + //javadoc: TonemapReinhard::getIntensity() + public float getIntensity() + { + + float retVal = getIntensity_0(nativeObj); + + return retVal; + } + + + // + // C++: float getLightAdaptation() + // + + //javadoc: TonemapReinhard::getLightAdaptation() + public float getLightAdaptation() + { + + float retVal = getLightAdaptation_0(nativeObj); + + return retVal; + } + + + // + // C++: void setColorAdaptation(float color_adapt) + // + + //javadoc: TonemapReinhard::setColorAdaptation(color_adapt) + public void setColorAdaptation(float color_adapt) + { + + setColorAdaptation_0(nativeObj, color_adapt); + + return; + } + + + // + // C++: void setIntensity(float intensity) + // + + //javadoc: TonemapReinhard::setIntensity(intensity) + public void setIntensity(float intensity) + { + + setIntensity_0(nativeObj, intensity); + + return; + } + + + // + // C++: void setLightAdaptation(float light_adapt) + // + + //javadoc: TonemapReinhard::setLightAdaptation(light_adapt) + public void setLightAdaptation(float light_adapt) + { + + setLightAdaptation_0(nativeObj, light_adapt); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: float getColorAdaptation() + private static native float getColorAdaptation_0(long nativeObj); + + // C++: float getIntensity() + private static native float getIntensity_0(long nativeObj); + + // C++: float getLightAdaptation() + private static native float getLightAdaptation_0(long nativeObj); + + // C++: void setColorAdaptation(float color_adapt) + private static native void setColorAdaptation_0(long nativeObj, float color_adapt); + + // C++: void setIntensity(float intensity) + private static native void setIntensity_0(long nativeObj, float intensity); + + // C++: void setLightAdaptation(float light_adapt) + private static native void setLightAdaptation_0(long nativeObj, float light_adapt); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/utils/Converters.java b/openCVLibrary330/src/main/java/org/opencv/utils/Converters.java new file mode 100644 index 00000000000..c0575a66656 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/utils/Converters.java @@ -0,0 +1,773 @@ +package org.opencv.utils; + +import java.util.ArrayList; +import java.util.List; + +import org.opencv.core.CvType; +import org.opencv.core.Mat; +import org.opencv.core.MatOfByte; +import org.opencv.core.MatOfDMatch; +import org.opencv.core.MatOfKeyPoint; +import org.opencv.core.MatOfPoint; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.MatOfPoint3f; +import org.opencv.core.Point; +import org.opencv.core.Point3; +import org.opencv.core.Rect; +import org.opencv.core.Rect2d; +import org.opencv.core.DMatch; +import org.opencv.core.KeyPoint; + +public class Converters { + + public static Mat vector_Point_to_Mat(List pts) { + return vector_Point_to_Mat(pts, CvType.CV_32S); + } + + public static Mat vector_Point2f_to_Mat(List pts) { + return vector_Point_to_Mat(pts, CvType.CV_32F); + } + + public static Mat vector_Point2d_to_Mat(List pts) { + return vector_Point_to_Mat(pts, CvType.CV_64F); + } + + public static Mat vector_Point_to_Mat(List pts, int typeDepth) { + Mat res; + int count = (pts != null) ? pts.size() : 0; + if (count > 0) { + switch (typeDepth) { + case CvType.CV_32S: { + res = new Mat(count, 1, CvType.CV_32SC2); + int[] buff = new int[count * 2]; + for (int i = 0; i < count; i++) { + Point p = pts.get(i); + buff[i * 2] = (int) p.x; + buff[i * 2 + 1] = (int) p.y; + } + res.put(0, 0, buff); + } + break; + + case CvType.CV_32F: { + res = new Mat(count, 1, CvType.CV_32FC2); + float[] buff = new float[count * 2]; + for (int i = 0; i < count; i++) { + Point p = pts.get(i); + buff[i * 2] = (float) p.x; + buff[i * 2 + 1] = (float) p.y; + } + res.put(0, 0, buff); + } + break; + + case CvType.CV_64F: { + res = new Mat(count, 1, CvType.CV_64FC2); + double[] buff = new double[count * 2]; + for (int i = 0; i < count; i++) { + Point p = pts.get(i); + buff[i * 2] = p.x; + buff[i * 2 + 1] = p.y; + } + res.put(0, 0, buff); + } + break; + + default: + throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F"); + } + } else { + res = new Mat(); + } + return res; + } + + public static Mat vector_Point3i_to_Mat(List pts) { + return vector_Point3_to_Mat(pts, CvType.CV_32S); + } + + public static Mat vector_Point3f_to_Mat(List pts) { + return vector_Point3_to_Mat(pts, CvType.CV_32F); + } + + public static Mat vector_Point3d_to_Mat(List pts) { + return vector_Point3_to_Mat(pts, CvType.CV_64F); + } + + public static Mat vector_Point3_to_Mat(List pts, int typeDepth) { + Mat res; + int count = (pts != null) ? pts.size() : 0; + if (count > 0) { + switch (typeDepth) { + case CvType.CV_32S: { + res = new Mat(count, 1, CvType.CV_32SC3); + int[] buff = new int[count * 3]; + for (int i = 0; i < count; i++) { + Point3 p = pts.get(i); + buff[i * 3] = (int) p.x; + buff[i * 3 + 1] = (int) p.y; + buff[i * 3 + 2] = (int) p.z; + } + res.put(0, 0, buff); + } + break; + + case CvType.CV_32F: { + res = new Mat(count, 1, CvType.CV_32FC3); + float[] buff = new float[count * 3]; + for (int i = 0; i < count; i++) { + Point3 p = pts.get(i); + buff[i * 3] = (float) p.x; + buff[i * 3 + 1] = (float) p.y; + buff[i * 3 + 2] = (float) p.z; + } + res.put(0, 0, buff); + } + break; + + case CvType.CV_64F: { + res = new Mat(count, 1, CvType.CV_64FC3); + double[] buff = new double[count * 3]; + for (int i = 0; i < count; i++) { + Point3 p = pts.get(i); + buff[i * 3] = p.x; + buff[i * 3 + 1] = p.y; + buff[i * 3 + 2] = p.z; + } + res.put(0, 0, buff); + } + break; + + default: + throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F"); + } + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_Point2f(Mat m, List pts) { + Mat_to_vector_Point(m, pts); + } + + public static void Mat_to_vector_Point2d(Mat m, List pts) { + Mat_to_vector_Point(m, pts); + } + + public static void Mat_to_vector_Point(Mat m, List pts) { + if (pts == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + int count = m.rows(); + int type = m.type(); + if (m.cols() != 1) + throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m); + + pts.clear(); + if (type == CvType.CV_32SC2) { + int[] buff = new int[2 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + pts.add(new Point(buff[i * 2], buff[i * 2 + 1])); + } + } else if (type == CvType.CV_32FC2) { + float[] buff = new float[2 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + pts.add(new Point(buff[i * 2], buff[i * 2 + 1])); + } + } else if (type == CvType.CV_64FC2) { + double[] buff = new double[2 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + pts.add(new Point(buff[i * 2], buff[i * 2 + 1])); + } + } else { + throw new java.lang.IllegalArgumentException( + "Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m); + } + } + + public static void Mat_to_vector_Point3i(Mat m, List pts) { + Mat_to_vector_Point3(m, pts); + } + + public static void Mat_to_vector_Point3f(Mat m, List pts) { + Mat_to_vector_Point3(m, pts); + } + + public static void Mat_to_vector_Point3d(Mat m, List pts) { + Mat_to_vector_Point3(m, pts); + } + + public static void Mat_to_vector_Point3(Mat m, List pts) { + if (pts == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + int count = m.rows(); + int type = m.type(); + if (m.cols() != 1) + throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m); + + pts.clear(); + if (type == CvType.CV_32SC3) { + int[] buff = new int[3 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2])); + } + } else if (type == CvType.CV_32FC3) { + float[] buff = new float[3 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2])); + } + } else if (type == CvType.CV_64FC3) { + double[] buff = new double[3 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2])); + } + } else { + throw new java.lang.IllegalArgumentException( + "Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m); + } + } + + public static Mat vector_Mat_to_Mat(List mats) { + Mat res; + int count = (mats != null) ? mats.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_32SC2); + int[] buff = new int[count * 2]; + for (int i = 0; i < count; i++) { + long addr = mats.get(i).nativeObj; + buff[i * 2] = (int) (addr >> 32); + buff[i * 2 + 1] = (int) (addr & 0xffffffff); + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_Mat(Mat m, List mats) { + if (mats == null) + throw new java.lang.IllegalArgumentException("mats == null"); + int count = m.rows(); + if (CvType.CV_32SC2 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_32SC2 != m.type() || m.cols()!=1\n" + m); + + mats.clear(); + int[] buff = new int[count * 2]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + long addr = (((long) buff[i * 2]) << 32) | (((long) buff[i * 2 + 1]) & 0xffffffffL); + mats.add(new Mat(addr)); + } + } + + public static Mat vector_float_to_Mat(List fs) { + Mat res; + int count = (fs != null) ? fs.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_32FC1); + float[] buff = new float[count]; + for (int i = 0; i < count; i++) { + float f = fs.get(i); + buff[i] = f; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_float(Mat m, List fs) { + if (fs == null) + throw new java.lang.IllegalArgumentException("fs == null"); + int count = m.rows(); + if (CvType.CV_32FC1 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_32FC1 != m.type() || m.cols()!=1\n" + m); + + fs.clear(); + float[] buff = new float[count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + fs.add(buff[i]); + } + } + + public static Mat vector_uchar_to_Mat(List bs) { + Mat res; + int count = (bs != null) ? bs.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_8UC1); + byte[] buff = new byte[count]; + for (int i = 0; i < count; i++) { + byte b = bs.get(i); + buff[i] = b; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_uchar(Mat m, List us) { + if (us == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + int count = m.rows(); + if (CvType.CV_8UC1 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_8UC1 != m.type() || m.cols()!=1\n" + m); + + us.clear(); + byte[] buff = new byte[count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + us.add(buff[i]); + } + } + + public static Mat vector_char_to_Mat(List bs) { + Mat res; + int count = (bs != null) ? bs.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_8SC1); + byte[] buff = new byte[count]; + for (int i = 0; i < count; i++) { + byte b = bs.get(i); + buff[i] = b; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static Mat vector_int_to_Mat(List is) { + Mat res; + int count = (is != null) ? is.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_32SC1); + int[] buff = new int[count]; + for (int i = 0; i < count; i++) { + int v = is.get(i); + buff[i] = v; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_int(Mat m, List is) { + if (is == null) + throw new java.lang.IllegalArgumentException("is == null"); + int count = m.rows(); + if (CvType.CV_32SC1 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_32SC1 != m.type() || m.cols()!=1\n" + m); + + is.clear(); + int[] buff = new int[count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + is.add(buff[i]); + } + } + + public static void Mat_to_vector_char(Mat m, List bs) { + if (bs == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + int count = m.rows(); + if (CvType.CV_8SC1 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_8SC1 != m.type() || m.cols()!=1\n" + m); + + bs.clear(); + byte[] buff = new byte[count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + bs.add(buff[i]); + } + } + + public static Mat vector_Rect_to_Mat(List rs) { + Mat res; + int count = (rs != null) ? rs.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_32SC4); + int[] buff = new int[4 * count]; + for (int i = 0; i < count; i++) { + Rect r = rs.get(i); + buff[4 * i] = r.x; + buff[4 * i + 1] = r.y; + buff[4 * i + 2] = r.width; + buff[4 * i + 3] = r.height; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_Rect(Mat m, List rs) { + if (rs == null) + throw new java.lang.IllegalArgumentException("rs == null"); + int count = m.rows(); + if (CvType.CV_32SC4 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_32SC4 != m.type() || m.rows()!=1\n" + m); + + rs.clear(); + int[] buff = new int[4 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + rs.add(new Rect(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3])); + } + } + + public static Mat vector_Rect2d_to_Mat(List rs) { + Mat res; + int count = (rs != null) ? rs.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_64FC4); + double[] buff = new double[4 * count]; + for (int i = 0; i < count; i++) { + Rect2d r = rs.get(i); + buff[4 * i] = r.x; + buff[4 * i + 1] = r.y; + buff[4 * i + 2] = r.width; + buff[4 * i + 3] = r.height; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_Rect2d(Mat m, List rs) { + if (rs == null) + throw new java.lang.IllegalArgumentException("rs == null"); + int count = m.rows(); + if (CvType.CV_64FC4 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_64FC4 != m.type() || m.rows()!=1\n" + m); + + rs.clear(); + double[] buff = new double[4 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + rs.add(new Rect2d(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3])); + } + } + + public static Mat vector_KeyPoint_to_Mat(List kps) { + Mat res; + int count = (kps != null) ? kps.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_64FC(7)); + double[] buff = new double[count * 7]; + for (int i = 0; i < count; i++) { + KeyPoint kp = kps.get(i); + buff[7 * i] = kp.pt.x; + buff[7 * i + 1] = kp.pt.y; + buff[7 * i + 2] = kp.size; + buff[7 * i + 3] = kp.angle; + buff[7 * i + 4] = kp.response; + buff[7 * i + 5] = kp.octave; + buff[7 * i + 6] = kp.class_id; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_KeyPoint(Mat m, List kps) { + if (kps == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + int count = m.rows(); + if (CvType.CV_64FC(7) != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_64FC(7) != m.type() || m.cols()!=1\n" + m); + + kps.clear(); + double[] buff = new double[7 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + kps.add(new KeyPoint((float) buff[7 * i], (float) buff[7 * i + 1], (float) buff[7 * i + 2], (float) buff[7 * i + 3], + (float) buff[7 * i + 4], (int) buff[7 * i + 5], (int) buff[7 * i + 6])); + } + } + + // vector_vector_Point + public static Mat vector_vector_Point_to_Mat(List pts, List mats) { + Mat res; + int lCount = (pts != null) ? pts.size() : 0; + if (lCount > 0) { + for (MatOfPoint vpt : pts) + mats.add(vpt); + res = vector_Mat_to_Mat(mats); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_vector_Point(Mat m, List pts) { + if (pts == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + + if (m == null) + throw new java.lang.IllegalArgumentException("Input Mat can't be null"); + + List mats = new ArrayList(m.rows()); + Mat_to_vector_Mat(m, mats); + for (Mat mi : mats) { + MatOfPoint pt = new MatOfPoint(mi); + pts.add(pt); + mi.release(); + } + mats.clear(); + } + + // vector_vector_Point2f + public static void Mat_to_vector_vector_Point2f(Mat m, List pts) { + if (pts == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + + if (m == null) + throw new java.lang.IllegalArgumentException("Input Mat can't be null"); + + List mats = new ArrayList(m.rows()); + Mat_to_vector_Mat(m, mats); + for (Mat mi : mats) { + MatOfPoint2f pt = new MatOfPoint2f(mi); + pts.add(pt); + mi.release(); + } + mats.clear(); + } + + // vector_vector_Point2f + public static Mat vector_vector_Point2f_to_Mat(List pts, List mats) { + Mat res; + int lCount = (pts != null) ? pts.size() : 0; + if (lCount > 0) { + for (MatOfPoint2f vpt : pts) + mats.add(vpt); + res = vector_Mat_to_Mat(mats); + } else { + res = new Mat(); + } + return res; + } + + // vector_vector_Point3f + public static void Mat_to_vector_vector_Point3f(Mat m, List pts) { + if (pts == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + + if (m == null) + throw new java.lang.IllegalArgumentException("Input Mat can't be null"); + + List mats = new ArrayList(m.rows()); + Mat_to_vector_Mat(m, mats); + for (Mat mi : mats) { + MatOfPoint3f pt = new MatOfPoint3f(mi); + pts.add(pt); + mi.release(); + } + mats.clear(); + } + + // vector_vector_Point3f + public static Mat vector_vector_Point3f_to_Mat(List pts, List mats) { + Mat res; + int lCount = (pts != null) ? pts.size() : 0; + if (lCount > 0) { + for (MatOfPoint3f vpt : pts) + mats.add(vpt); + res = vector_Mat_to_Mat(mats); + } else { + res = new Mat(); + } + return res; + } + + // vector_vector_KeyPoint + public static Mat vector_vector_KeyPoint_to_Mat(List kps, List mats) { + Mat res; + int lCount = (kps != null) ? kps.size() : 0; + if (lCount > 0) { + for (MatOfKeyPoint vkp : kps) + mats.add(vkp); + res = vector_Mat_to_Mat(mats); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_vector_KeyPoint(Mat m, List kps) { + if (kps == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + + if (m == null) + throw new java.lang.IllegalArgumentException("Input Mat can't be null"); + + List mats = new ArrayList(m.rows()); + Mat_to_vector_Mat(m, mats); + for (Mat mi : mats) { + MatOfKeyPoint vkp = new MatOfKeyPoint(mi); + kps.add(vkp); + mi.release(); + } + mats.clear(); + } + + public static Mat vector_double_to_Mat(List ds) { + Mat res; + int count = (ds != null) ? ds.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_64FC1); + double[] buff = new double[count]; + for (int i = 0; i < count; i++) { + double v = ds.get(i); + buff[i] = v; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_double(Mat m, List ds) { + if (ds == null) + throw new java.lang.IllegalArgumentException("ds == null"); + int count = m.rows(); + if (CvType.CV_64FC1 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_64FC1 != m.type() || m.cols()!=1\n" + m); + + ds.clear(); + double[] buff = new double[count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + ds.add(buff[i]); + } + } + + public static Mat vector_DMatch_to_Mat(List matches) { + Mat res; + int count = (matches != null) ? matches.size() : 0; + if (count > 0) { + res = new Mat(count, 1, CvType.CV_64FC4); + double[] buff = new double[count * 4]; + for (int i = 0; i < count; i++) { + DMatch m = matches.get(i); + buff[4 * i] = m.queryIdx; + buff[4 * i + 1] = m.trainIdx; + buff[4 * i + 2] = m.imgIdx; + buff[4 * i + 3] = m.distance; + } + res.put(0, 0, buff); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_DMatch(Mat m, List matches) { + if (matches == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + int count = m.rows(); + if (CvType.CV_64FC4 != m.type() || m.cols() != 1) + throw new java.lang.IllegalArgumentException( + "CvType.CV_64FC4 != m.type() || m.cols()!=1\n" + m); + + matches.clear(); + double[] buff = new double[4 * count]; + m.get(0, 0, buff); + for (int i = 0; i < count; i++) { + matches.add(new DMatch((int) buff[4 * i], (int) buff[4 * i + 1], (int) buff[4 * i + 2], (float) buff[4 * i + 3])); + } + } + + // vector_vector_DMatch + public static Mat vector_vector_DMatch_to_Mat(List lvdm, List mats) { + Mat res; + int lCount = (lvdm != null) ? lvdm.size() : 0; + if (lCount > 0) { + for (MatOfDMatch vdm : lvdm) + mats.add(vdm); + res = vector_Mat_to_Mat(mats); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_vector_DMatch(Mat m, List lvdm) { + if (lvdm == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + + if (m == null) + throw new java.lang.IllegalArgumentException("Input Mat can't be null"); + + List mats = new ArrayList(m.rows()); + Mat_to_vector_Mat(m, mats); + lvdm.clear(); + for (Mat mi : mats) { + MatOfDMatch vdm = new MatOfDMatch(mi); + lvdm.add(vdm); + mi.release(); + } + mats.clear(); + } + + // vector_vector_char + public static Mat vector_vector_char_to_Mat(List lvb, List mats) { + Mat res; + int lCount = (lvb != null) ? lvb.size() : 0; + if (lCount > 0) { + for (MatOfByte vb : lvb) + mats.add(vb); + res = vector_Mat_to_Mat(mats); + } else { + res = new Mat(); + } + return res; + } + + public static void Mat_to_vector_vector_char(Mat m, List> llb) { + if (llb == null) + throw new java.lang.IllegalArgumentException("Output List can't be null"); + + if (m == null) + throw new java.lang.IllegalArgumentException("Input Mat can't be null"); + + List mats = new ArrayList(m.rows()); + Mat_to_vector_Mat(m, mats); + for (Mat mi : mats) { + List lb = new ArrayList(); + Mat_to_vector_char(mi, lb); + llb.add(lb); + mi.release(); + } + mats.clear(); + } +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractor.java b/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractor.java new file mode 100644 index 00000000000..581ce6635fd --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractor.java @@ -0,0 +1,71 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; + +// C++: class BackgroundSubtractor +//javadoc: BackgroundSubtractor +public class BackgroundSubtractor extends Algorithm { + + protected BackgroundSubtractor(long addr) { super(addr); } + + + // + // C++: void apply(Mat image, Mat& fgmask, double learningRate = -1) + // + + //javadoc: BackgroundSubtractor::apply(image, fgmask, learningRate) + public void apply(Mat image, Mat fgmask, double learningRate) + { + + apply_0(nativeObj, image.nativeObj, fgmask.nativeObj, learningRate); + + return; + } + + //javadoc: BackgroundSubtractor::apply(image, fgmask) + public void apply(Mat image, Mat fgmask) + { + + apply_1(nativeObj, image.nativeObj, fgmask.nativeObj); + + return; + } + + + // + // C++: void getBackgroundImage(Mat& backgroundImage) + // + + //javadoc: BackgroundSubtractor::getBackgroundImage(backgroundImage) + public void getBackgroundImage(Mat backgroundImage) + { + + getBackgroundImage_0(nativeObj, backgroundImage.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void apply(Mat image, Mat& fgmask, double learningRate = -1) + private static native void apply_0(long nativeObj, long image_nativeObj, long fgmask_nativeObj, double learningRate); + private static native void apply_1(long nativeObj, long image_nativeObj, long fgmask_nativeObj); + + // C++: void getBackgroundImage(Mat& backgroundImage) + private static native void getBackgroundImage_0(long nativeObj, long backgroundImage_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractorKNN.java b/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractorKNN.java new file mode 100644 index 00000000000..8ac2a6d64f3 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractorKNN.java @@ -0,0 +1,264 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + + + +// C++: class BackgroundSubtractorKNN +//javadoc: BackgroundSubtractorKNN +public class BackgroundSubtractorKNN extends BackgroundSubtractor { + + protected BackgroundSubtractorKNN(long addr) { super(addr); } + + + // + // C++: bool getDetectShadows() + // + + //javadoc: BackgroundSubtractorKNN::getDetectShadows() + public boolean getDetectShadows() + { + + boolean retVal = getDetectShadows_0(nativeObj); + + return retVal; + } + + + // + // C++: double getDist2Threshold() + // + + //javadoc: BackgroundSubtractorKNN::getDist2Threshold() + public double getDist2Threshold() + { + + double retVal = getDist2Threshold_0(nativeObj); + + return retVal; + } + + + // + // C++: double getShadowThreshold() + // + + //javadoc: BackgroundSubtractorKNN::getShadowThreshold() + public double getShadowThreshold() + { + + double retVal = getShadowThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getHistory() + // + + //javadoc: BackgroundSubtractorKNN::getHistory() + public int getHistory() + { + + int retVal = getHistory_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNSamples() + // + + //javadoc: BackgroundSubtractorKNN::getNSamples() + public int getNSamples() + { + + int retVal = getNSamples_0(nativeObj); + + return retVal; + } + + + // + // C++: int getShadowValue() + // + + //javadoc: BackgroundSubtractorKNN::getShadowValue() + public int getShadowValue() + { + + int retVal = getShadowValue_0(nativeObj); + + return retVal; + } + + + // + // C++: int getkNNSamples() + // + + //javadoc: BackgroundSubtractorKNN::getkNNSamples() + public int getkNNSamples() + { + + int retVal = getkNNSamples_0(nativeObj); + + return retVal; + } + + + // + // C++: void setDetectShadows(bool detectShadows) + // + + //javadoc: BackgroundSubtractorKNN::setDetectShadows(detectShadows) + public void setDetectShadows(boolean detectShadows) + { + + setDetectShadows_0(nativeObj, detectShadows); + + return; + } + + + // + // C++: void setDist2Threshold(double _dist2Threshold) + // + + //javadoc: BackgroundSubtractorKNN::setDist2Threshold(_dist2Threshold) + public void setDist2Threshold(double _dist2Threshold) + { + + setDist2Threshold_0(nativeObj, _dist2Threshold); + + return; + } + + + // + // C++: void setHistory(int history) + // + + //javadoc: BackgroundSubtractorKNN::setHistory(history) + public void setHistory(int history) + { + + setHistory_0(nativeObj, history); + + return; + } + + + // + // C++: void setNSamples(int _nN) + // + + //javadoc: BackgroundSubtractorKNN::setNSamples(_nN) + public void setNSamples(int _nN) + { + + setNSamples_0(nativeObj, _nN); + + return; + } + + + // + // C++: void setShadowThreshold(double threshold) + // + + //javadoc: BackgroundSubtractorKNN::setShadowThreshold(threshold) + public void setShadowThreshold(double threshold) + { + + setShadowThreshold_0(nativeObj, threshold); + + return; + } + + + // + // C++: void setShadowValue(int value) + // + + //javadoc: BackgroundSubtractorKNN::setShadowValue(value) + public void setShadowValue(int value) + { + + setShadowValue_0(nativeObj, value); + + return; + } + + + // + // C++: void setkNNSamples(int _nkNN) + // + + //javadoc: BackgroundSubtractorKNN::setkNNSamples(_nkNN) + public void setkNNSamples(int _nkNN) + { + + setkNNSamples_0(nativeObj, _nkNN); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: bool getDetectShadows() + private static native boolean getDetectShadows_0(long nativeObj); + + // C++: double getDist2Threshold() + private static native double getDist2Threshold_0(long nativeObj); + + // C++: double getShadowThreshold() + private static native double getShadowThreshold_0(long nativeObj); + + // C++: int getHistory() + private static native int getHistory_0(long nativeObj); + + // C++: int getNSamples() + private static native int getNSamples_0(long nativeObj); + + // C++: int getShadowValue() + private static native int getShadowValue_0(long nativeObj); + + // C++: int getkNNSamples() + private static native int getkNNSamples_0(long nativeObj); + + // C++: void setDetectShadows(bool detectShadows) + private static native void setDetectShadows_0(long nativeObj, boolean detectShadows); + + // C++: void setDist2Threshold(double _dist2Threshold) + private static native void setDist2Threshold_0(long nativeObj, double _dist2Threshold); + + // C++: void setHistory(int history) + private static native void setHistory_0(long nativeObj, int history); + + // C++: void setNSamples(int _nN) + private static native void setNSamples_0(long nativeObj, int _nN); + + // C++: void setShadowThreshold(double threshold) + private static native void setShadowThreshold_0(long nativeObj, double threshold); + + // C++: void setShadowValue(int value) + private static native void setShadowValue_0(long nativeObj, int value); + + // C++: void setkNNSamples(int _nkNN) + private static native void setkNNSamples_0(long nativeObj, int _nkNN); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractorMOG2.java b/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractorMOG2.java new file mode 100644 index 00000000000..dd8ad4e6840 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/BackgroundSubtractorMOG2.java @@ -0,0 +1,461 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import org.opencv.core.Mat; + +// C++: class BackgroundSubtractorMOG2 +//javadoc: BackgroundSubtractorMOG2 +public class BackgroundSubtractorMOG2 extends BackgroundSubtractor { + + protected BackgroundSubtractorMOG2(long addr) { super(addr); } + + + // + // C++: bool getDetectShadows() + // + + //javadoc: BackgroundSubtractorMOG2::getDetectShadows() + public boolean getDetectShadows() + { + + boolean retVal = getDetectShadows_0(nativeObj); + + return retVal; + } + + + // + // C++: double getBackgroundRatio() + // + + //javadoc: BackgroundSubtractorMOG2::getBackgroundRatio() + public double getBackgroundRatio() + { + + double retVal = getBackgroundRatio_0(nativeObj); + + return retVal; + } + + + // + // C++: double getComplexityReductionThreshold() + // + + //javadoc: BackgroundSubtractorMOG2::getComplexityReductionThreshold() + public double getComplexityReductionThreshold() + { + + double retVal = getComplexityReductionThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: double getShadowThreshold() + // + + //javadoc: BackgroundSubtractorMOG2::getShadowThreshold() + public double getShadowThreshold() + { + + double retVal = getShadowThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: double getVarInit() + // + + //javadoc: BackgroundSubtractorMOG2::getVarInit() + public double getVarInit() + { + + double retVal = getVarInit_0(nativeObj); + + return retVal; + } + + + // + // C++: double getVarMax() + // + + //javadoc: BackgroundSubtractorMOG2::getVarMax() + public double getVarMax() + { + + double retVal = getVarMax_0(nativeObj); + + return retVal; + } + + + // + // C++: double getVarMin() + // + + //javadoc: BackgroundSubtractorMOG2::getVarMin() + public double getVarMin() + { + + double retVal = getVarMin_0(nativeObj); + + return retVal; + } + + + // + // C++: double getVarThreshold() + // + + //javadoc: BackgroundSubtractorMOG2::getVarThreshold() + public double getVarThreshold() + { + + double retVal = getVarThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: double getVarThresholdGen() + // + + //javadoc: BackgroundSubtractorMOG2::getVarThresholdGen() + public double getVarThresholdGen() + { + + double retVal = getVarThresholdGen_0(nativeObj); + + return retVal; + } + + + // + // C++: int getHistory() + // + + //javadoc: BackgroundSubtractorMOG2::getHistory() + public int getHistory() + { + + int retVal = getHistory_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNMixtures() + // + + //javadoc: BackgroundSubtractorMOG2::getNMixtures() + public int getNMixtures() + { + + int retVal = getNMixtures_0(nativeObj); + + return retVal; + } + + + // + // C++: int getShadowValue() + // + + //javadoc: BackgroundSubtractorMOG2::getShadowValue() + public int getShadowValue() + { + + int retVal = getShadowValue_0(nativeObj); + + return retVal; + } + + + // + // C++: void apply(Mat image, Mat& fgmask, double learningRate = -1) + // + + //javadoc: BackgroundSubtractorMOG2::apply(image, fgmask, learningRate) + public void apply(Mat image, Mat fgmask, double learningRate) + { + + apply_0(nativeObj, image.nativeObj, fgmask.nativeObj, learningRate); + + return; + } + + //javadoc: BackgroundSubtractorMOG2::apply(image, fgmask) + public void apply(Mat image, Mat fgmask) + { + + apply_1(nativeObj, image.nativeObj, fgmask.nativeObj); + + return; + } + + + // + // C++: void setBackgroundRatio(double ratio) + // + + //javadoc: BackgroundSubtractorMOG2::setBackgroundRatio(ratio) + public void setBackgroundRatio(double ratio) + { + + setBackgroundRatio_0(nativeObj, ratio); + + return; + } + + + // + // C++: void setComplexityReductionThreshold(double ct) + // + + //javadoc: BackgroundSubtractorMOG2::setComplexityReductionThreshold(ct) + public void setComplexityReductionThreshold(double ct) + { + + setComplexityReductionThreshold_0(nativeObj, ct); + + return; + } + + + // + // C++: void setDetectShadows(bool detectShadows) + // + + //javadoc: BackgroundSubtractorMOG2::setDetectShadows(detectShadows) + public void setDetectShadows(boolean detectShadows) + { + + setDetectShadows_0(nativeObj, detectShadows); + + return; + } + + + // + // C++: void setHistory(int history) + // + + //javadoc: BackgroundSubtractorMOG2::setHistory(history) + public void setHistory(int history) + { + + setHistory_0(nativeObj, history); + + return; + } + + + // + // C++: void setNMixtures(int nmixtures) + // + + //javadoc: BackgroundSubtractorMOG2::setNMixtures(nmixtures) + public void setNMixtures(int nmixtures) + { + + setNMixtures_0(nativeObj, nmixtures); + + return; + } + + + // + // C++: void setShadowThreshold(double threshold) + // + + //javadoc: BackgroundSubtractorMOG2::setShadowThreshold(threshold) + public void setShadowThreshold(double threshold) + { + + setShadowThreshold_0(nativeObj, threshold); + + return; + } + + + // + // C++: void setShadowValue(int value) + // + + //javadoc: BackgroundSubtractorMOG2::setShadowValue(value) + public void setShadowValue(int value) + { + + setShadowValue_0(nativeObj, value); + + return; + } + + + // + // C++: void setVarInit(double varInit) + // + + //javadoc: BackgroundSubtractorMOG2::setVarInit(varInit) + public void setVarInit(double varInit) + { + + setVarInit_0(nativeObj, varInit); + + return; + } + + + // + // C++: void setVarMax(double varMax) + // + + //javadoc: BackgroundSubtractorMOG2::setVarMax(varMax) + public void setVarMax(double varMax) + { + + setVarMax_0(nativeObj, varMax); + + return; + } + + + // + // C++: void setVarMin(double varMin) + // + + //javadoc: BackgroundSubtractorMOG2::setVarMin(varMin) + public void setVarMin(double varMin) + { + + setVarMin_0(nativeObj, varMin); + + return; + } + + + // + // C++: void setVarThreshold(double varThreshold) + // + + //javadoc: BackgroundSubtractorMOG2::setVarThreshold(varThreshold) + public void setVarThreshold(double varThreshold) + { + + setVarThreshold_0(nativeObj, varThreshold); + + return; + } + + + // + // C++: void setVarThresholdGen(double varThresholdGen) + // + + //javadoc: BackgroundSubtractorMOG2::setVarThresholdGen(varThresholdGen) + public void setVarThresholdGen(double varThresholdGen) + { + + setVarThresholdGen_0(nativeObj, varThresholdGen); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: bool getDetectShadows() + private static native boolean getDetectShadows_0(long nativeObj); + + // C++: double getBackgroundRatio() + private static native double getBackgroundRatio_0(long nativeObj); + + // C++: double getComplexityReductionThreshold() + private static native double getComplexityReductionThreshold_0(long nativeObj); + + // C++: double getShadowThreshold() + private static native double getShadowThreshold_0(long nativeObj); + + // C++: double getVarInit() + private static native double getVarInit_0(long nativeObj); + + // C++: double getVarMax() + private static native double getVarMax_0(long nativeObj); + + // C++: double getVarMin() + private static native double getVarMin_0(long nativeObj); + + // C++: double getVarThreshold() + private static native double getVarThreshold_0(long nativeObj); + + // C++: double getVarThresholdGen() + private static native double getVarThresholdGen_0(long nativeObj); + + // C++: int getHistory() + private static native int getHistory_0(long nativeObj); + + // C++: int getNMixtures() + private static native int getNMixtures_0(long nativeObj); + + // C++: int getShadowValue() + private static native int getShadowValue_0(long nativeObj); + + // C++: void apply(Mat image, Mat& fgmask, double learningRate = -1) + private static native void apply_0(long nativeObj, long image_nativeObj, long fgmask_nativeObj, double learningRate); + private static native void apply_1(long nativeObj, long image_nativeObj, long fgmask_nativeObj); + + // C++: void setBackgroundRatio(double ratio) + private static native void setBackgroundRatio_0(long nativeObj, double ratio); + + // C++: void setComplexityReductionThreshold(double ct) + private static native void setComplexityReductionThreshold_0(long nativeObj, double ct); + + // C++: void setDetectShadows(bool detectShadows) + private static native void setDetectShadows_0(long nativeObj, boolean detectShadows); + + // C++: void setHistory(int history) + private static native void setHistory_0(long nativeObj, int history); + + // C++: void setNMixtures(int nmixtures) + private static native void setNMixtures_0(long nativeObj, int nmixtures); + + // C++: void setShadowThreshold(double threshold) + private static native void setShadowThreshold_0(long nativeObj, double threshold); + + // C++: void setShadowValue(int value) + private static native void setShadowValue_0(long nativeObj, int value); + + // C++: void setVarInit(double varInit) + private static native void setVarInit_0(long nativeObj, double varInit); + + // C++: void setVarMax(double varMax) + private static native void setVarMax_0(long nativeObj, double varMax); + + // C++: void setVarMin(double varMin) + private static native void setVarMin_0(long nativeObj, double varMin); + + // C++: void setVarThreshold(double varThreshold) + private static native void setVarThreshold_0(long nativeObj, double varThreshold); + + // C++: void setVarThresholdGen(double varThresholdGen) + private static native void setVarThresholdGen_0(long nativeObj, double varThresholdGen); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/DenseOpticalFlow.java b/openCVLibrary330/src/main/java/org/opencv/video/DenseOpticalFlow.java new file mode 100644 index 00000000000..7639671b4de --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/DenseOpticalFlow.java @@ -0,0 +1,61 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; + +// C++: class DenseOpticalFlow +//javadoc: DenseOpticalFlow +public class DenseOpticalFlow extends Algorithm { + + protected DenseOpticalFlow(long addr) { super(addr); } + + + // + // C++: void calc(Mat I0, Mat I1, Mat& flow) + // + + //javadoc: DenseOpticalFlow::calc(I0, I1, flow) + public void calc(Mat I0, Mat I1, Mat flow) + { + + calc_0(nativeObj, I0.nativeObj, I1.nativeObj, flow.nativeObj); + + return; + } + + + // + // C++: void collectGarbage() + // + + //javadoc: DenseOpticalFlow::collectGarbage() + public void collectGarbage() + { + + collectGarbage_0(nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void calc(Mat I0, Mat I1, Mat& flow) + private static native void calc_0(long nativeObj, long I0_nativeObj, long I1_nativeObj, long flow_nativeObj); + + // C++: void collectGarbage() + private static native void collectGarbage_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/DualTVL1OpticalFlow.java b/openCVLibrary330/src/main/java/org/opencv/video/DualTVL1OpticalFlow.java new file mode 100644 index 00000000000..2bb45769f81 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/DualTVL1OpticalFlow.java @@ -0,0 +1,461 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + + + +// C++: class DualTVL1OpticalFlow +//javadoc: DualTVL1OpticalFlow +public class DualTVL1OpticalFlow extends DenseOpticalFlow { + + protected DualTVL1OpticalFlow(long addr) { super(addr); } + + + // + // C++: static Ptr_DualTVL1OpticalFlow create(double tau = 0.25, double lambda = 0.15, double theta = 0.3, int nscales = 5, int warps = 5, double epsilon = 0.01, int innnerIterations = 30, int outerIterations = 10, double scaleStep = 0.8, double gamma = 0.0, int medianFiltering = 5, bool useInitialFlow = false) + // + + //javadoc: DualTVL1OpticalFlow::create(tau, lambda, theta, nscales, warps, epsilon, innnerIterations, outerIterations, scaleStep, gamma, medianFiltering, useInitialFlow) + public static DualTVL1OpticalFlow create(double tau, double lambda, double theta, int nscales, int warps, double epsilon, int innnerIterations, int outerIterations, double scaleStep, double gamma, int medianFiltering, boolean useInitialFlow) + { + + DualTVL1OpticalFlow retVal = new DualTVL1OpticalFlow(create_0(tau, lambda, theta, nscales, warps, epsilon, innnerIterations, outerIterations, scaleStep, gamma, medianFiltering, useInitialFlow)); + + return retVal; + } + + //javadoc: DualTVL1OpticalFlow::create() + public static DualTVL1OpticalFlow create() + { + + DualTVL1OpticalFlow retVal = new DualTVL1OpticalFlow(create_1()); + + return retVal; + } + + + // + // C++: bool getUseInitialFlow() + // + + //javadoc: DualTVL1OpticalFlow::getUseInitialFlow() + public boolean getUseInitialFlow() + { + + boolean retVal = getUseInitialFlow_0(nativeObj); + + return retVal; + } + + + // + // C++: double getEpsilon() + // + + //javadoc: DualTVL1OpticalFlow::getEpsilon() + public double getEpsilon() + { + + double retVal = getEpsilon_0(nativeObj); + + return retVal; + } + + + // + // C++: double getGamma() + // + + //javadoc: DualTVL1OpticalFlow::getGamma() + public double getGamma() + { + + double retVal = getGamma_0(nativeObj); + + return retVal; + } + + + // + // C++: double getLambda() + // + + //javadoc: DualTVL1OpticalFlow::getLambda() + public double getLambda() + { + + double retVal = getLambda_0(nativeObj); + + return retVal; + } + + + // + // C++: double getScaleStep() + // + + //javadoc: DualTVL1OpticalFlow::getScaleStep() + public double getScaleStep() + { + + double retVal = getScaleStep_0(nativeObj); + + return retVal; + } + + + // + // C++: double getTau() + // + + //javadoc: DualTVL1OpticalFlow::getTau() + public double getTau() + { + + double retVal = getTau_0(nativeObj); + + return retVal; + } + + + // + // C++: double getTheta() + // + + //javadoc: DualTVL1OpticalFlow::getTheta() + public double getTheta() + { + + double retVal = getTheta_0(nativeObj); + + return retVal; + } + + + // + // C++: int getInnerIterations() + // + + //javadoc: DualTVL1OpticalFlow::getInnerIterations() + public int getInnerIterations() + { + + int retVal = getInnerIterations_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMedianFiltering() + // + + //javadoc: DualTVL1OpticalFlow::getMedianFiltering() + public int getMedianFiltering() + { + + int retVal = getMedianFiltering_0(nativeObj); + + return retVal; + } + + + // + // C++: int getOuterIterations() + // + + //javadoc: DualTVL1OpticalFlow::getOuterIterations() + public int getOuterIterations() + { + + int retVal = getOuterIterations_0(nativeObj); + + return retVal; + } + + + // + // C++: int getScalesNumber() + // + + //javadoc: DualTVL1OpticalFlow::getScalesNumber() + public int getScalesNumber() + { + + int retVal = getScalesNumber_0(nativeObj); + + return retVal; + } + + + // + // C++: int getWarpingsNumber() + // + + //javadoc: DualTVL1OpticalFlow::getWarpingsNumber() + public int getWarpingsNumber() + { + + int retVal = getWarpingsNumber_0(nativeObj); + + return retVal; + } + + + // + // C++: void setEpsilon(double val) + // + + //javadoc: DualTVL1OpticalFlow::setEpsilon(val) + public void setEpsilon(double val) + { + + setEpsilon_0(nativeObj, val); + + return; + } + + + // + // C++: void setGamma(double val) + // + + //javadoc: DualTVL1OpticalFlow::setGamma(val) + public void setGamma(double val) + { + + setGamma_0(nativeObj, val); + + return; + } + + + // + // C++: void setInnerIterations(int val) + // + + //javadoc: DualTVL1OpticalFlow::setInnerIterations(val) + public void setInnerIterations(int val) + { + + setInnerIterations_0(nativeObj, val); + + return; + } + + + // + // C++: void setLambda(double val) + // + + //javadoc: DualTVL1OpticalFlow::setLambda(val) + public void setLambda(double val) + { + + setLambda_0(nativeObj, val); + + return; + } + + + // + // C++: void setMedianFiltering(int val) + // + + //javadoc: DualTVL1OpticalFlow::setMedianFiltering(val) + public void setMedianFiltering(int val) + { + + setMedianFiltering_0(nativeObj, val); + + return; + } + + + // + // C++: void setOuterIterations(int val) + // + + //javadoc: DualTVL1OpticalFlow::setOuterIterations(val) + public void setOuterIterations(int val) + { + + setOuterIterations_0(nativeObj, val); + + return; + } + + + // + // C++: void setScaleStep(double val) + // + + //javadoc: DualTVL1OpticalFlow::setScaleStep(val) + public void setScaleStep(double val) + { + + setScaleStep_0(nativeObj, val); + + return; + } + + + // + // C++: void setScalesNumber(int val) + // + + //javadoc: DualTVL1OpticalFlow::setScalesNumber(val) + public void setScalesNumber(int val) + { + + setScalesNumber_0(nativeObj, val); + + return; + } + + + // + // C++: void setTau(double val) + // + + //javadoc: DualTVL1OpticalFlow::setTau(val) + public void setTau(double val) + { + + setTau_0(nativeObj, val); + + return; + } + + + // + // C++: void setTheta(double val) + // + + //javadoc: DualTVL1OpticalFlow::setTheta(val) + public void setTheta(double val) + { + + setTheta_0(nativeObj, val); + + return; + } + + + // + // C++: void setUseInitialFlow(bool val) + // + + //javadoc: DualTVL1OpticalFlow::setUseInitialFlow(val) + public void setUseInitialFlow(boolean val) + { + + setUseInitialFlow_0(nativeObj, val); + + return; + } + + + // + // C++: void setWarpingsNumber(int val) + // + + //javadoc: DualTVL1OpticalFlow::setWarpingsNumber(val) + public void setWarpingsNumber(int val) + { + + setWarpingsNumber_0(nativeObj, val); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_DualTVL1OpticalFlow create(double tau = 0.25, double lambda = 0.15, double theta = 0.3, int nscales = 5, int warps = 5, double epsilon = 0.01, int innnerIterations = 30, int outerIterations = 10, double scaleStep = 0.8, double gamma = 0.0, int medianFiltering = 5, bool useInitialFlow = false) + private static native long create_0(double tau, double lambda, double theta, int nscales, int warps, double epsilon, int innnerIterations, int outerIterations, double scaleStep, double gamma, int medianFiltering, boolean useInitialFlow); + private static native long create_1(); + + // C++: bool getUseInitialFlow() + private static native boolean getUseInitialFlow_0(long nativeObj); + + // C++: double getEpsilon() + private static native double getEpsilon_0(long nativeObj); + + // C++: double getGamma() + private static native double getGamma_0(long nativeObj); + + // C++: double getLambda() + private static native double getLambda_0(long nativeObj); + + // C++: double getScaleStep() + private static native double getScaleStep_0(long nativeObj); + + // C++: double getTau() + private static native double getTau_0(long nativeObj); + + // C++: double getTheta() + private static native double getTheta_0(long nativeObj); + + // C++: int getInnerIterations() + private static native int getInnerIterations_0(long nativeObj); + + // C++: int getMedianFiltering() + private static native int getMedianFiltering_0(long nativeObj); + + // C++: int getOuterIterations() + private static native int getOuterIterations_0(long nativeObj); + + // C++: int getScalesNumber() + private static native int getScalesNumber_0(long nativeObj); + + // C++: int getWarpingsNumber() + private static native int getWarpingsNumber_0(long nativeObj); + + // C++: void setEpsilon(double val) + private static native void setEpsilon_0(long nativeObj, double val); + + // C++: void setGamma(double val) + private static native void setGamma_0(long nativeObj, double val); + + // C++: void setInnerIterations(int val) + private static native void setInnerIterations_0(long nativeObj, int val); + + // C++: void setLambda(double val) + private static native void setLambda_0(long nativeObj, double val); + + // C++: void setMedianFiltering(int val) + private static native void setMedianFiltering_0(long nativeObj, int val); + + // C++: void setOuterIterations(int val) + private static native void setOuterIterations_0(long nativeObj, int val); + + // C++: void setScaleStep(double val) + private static native void setScaleStep_0(long nativeObj, double val); + + // C++: void setScalesNumber(int val) + private static native void setScalesNumber_0(long nativeObj, int val); + + // C++: void setTau(double val) + private static native void setTau_0(long nativeObj, double val); + + // C++: void setTheta(double val) + private static native void setTheta_0(long nativeObj, double val); + + // C++: void setUseInitialFlow(bool val) + private static native void setUseInitialFlow_0(long nativeObj, boolean val); + + // C++: void setWarpingsNumber(int val) + private static native void setWarpingsNumber_0(long nativeObj, int val); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/FarnebackOpticalFlow.java b/openCVLibrary330/src/main/java/org/opencv/video/FarnebackOpticalFlow.java new file mode 100644 index 00000000000..0b109c2806c --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/FarnebackOpticalFlow.java @@ -0,0 +1,325 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + + + +// C++: class FarnebackOpticalFlow +//javadoc: FarnebackOpticalFlow +public class FarnebackOpticalFlow extends DenseOpticalFlow { + + protected FarnebackOpticalFlow(long addr) { super(addr); } + + + // + // C++: static Ptr_FarnebackOpticalFlow create(int numLevels = 5, double pyrScale = 0.5, bool fastPyramids = false, int winSize = 13, int numIters = 10, int polyN = 5, double polySigma = 1.1, int flags = 0) + // + + //javadoc: FarnebackOpticalFlow::create(numLevels, pyrScale, fastPyramids, winSize, numIters, polyN, polySigma, flags) + public static FarnebackOpticalFlow create(int numLevels, double pyrScale, boolean fastPyramids, int winSize, int numIters, int polyN, double polySigma, int flags) + { + + FarnebackOpticalFlow retVal = new FarnebackOpticalFlow(create_0(numLevels, pyrScale, fastPyramids, winSize, numIters, polyN, polySigma, flags)); + + return retVal; + } + + //javadoc: FarnebackOpticalFlow::create() + public static FarnebackOpticalFlow create() + { + + FarnebackOpticalFlow retVal = new FarnebackOpticalFlow(create_1()); + + return retVal; + } + + + // + // C++: bool getFastPyramids() + // + + //javadoc: FarnebackOpticalFlow::getFastPyramids() + public boolean getFastPyramids() + { + + boolean retVal = getFastPyramids_0(nativeObj); + + return retVal; + } + + + // + // C++: double getPolySigma() + // + + //javadoc: FarnebackOpticalFlow::getPolySigma() + public double getPolySigma() + { + + double retVal = getPolySigma_0(nativeObj); + + return retVal; + } + + + // + // C++: double getPyrScale() + // + + //javadoc: FarnebackOpticalFlow::getPyrScale() + public double getPyrScale() + { + + double retVal = getPyrScale_0(nativeObj); + + return retVal; + } + + + // + // C++: int getFlags() + // + + //javadoc: FarnebackOpticalFlow::getFlags() + public int getFlags() + { + + int retVal = getFlags_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNumIters() + // + + //javadoc: FarnebackOpticalFlow::getNumIters() + public int getNumIters() + { + + int retVal = getNumIters_0(nativeObj); + + return retVal; + } + + + // + // C++: int getNumLevels() + // + + //javadoc: FarnebackOpticalFlow::getNumLevels() + public int getNumLevels() + { + + int retVal = getNumLevels_0(nativeObj); + + return retVal; + } + + + // + // C++: int getPolyN() + // + + //javadoc: FarnebackOpticalFlow::getPolyN() + public int getPolyN() + { + + int retVal = getPolyN_0(nativeObj); + + return retVal; + } + + + // + // C++: int getWinSize() + // + + //javadoc: FarnebackOpticalFlow::getWinSize() + public int getWinSize() + { + + int retVal = getWinSize_0(nativeObj); + + return retVal; + } + + + // + // C++: void setFastPyramids(bool fastPyramids) + // + + //javadoc: FarnebackOpticalFlow::setFastPyramids(fastPyramids) + public void setFastPyramids(boolean fastPyramids) + { + + setFastPyramids_0(nativeObj, fastPyramids); + + return; + } + + + // + // C++: void setFlags(int flags) + // + + //javadoc: FarnebackOpticalFlow::setFlags(flags) + public void setFlags(int flags) + { + + setFlags_0(nativeObj, flags); + + return; + } + + + // + // C++: void setNumIters(int numIters) + // + + //javadoc: FarnebackOpticalFlow::setNumIters(numIters) + public void setNumIters(int numIters) + { + + setNumIters_0(nativeObj, numIters); + + return; + } + + + // + // C++: void setNumLevels(int numLevels) + // + + //javadoc: FarnebackOpticalFlow::setNumLevels(numLevels) + public void setNumLevels(int numLevels) + { + + setNumLevels_0(nativeObj, numLevels); + + return; + } + + + // + // C++: void setPolyN(int polyN) + // + + //javadoc: FarnebackOpticalFlow::setPolyN(polyN) + public void setPolyN(int polyN) + { + + setPolyN_0(nativeObj, polyN); + + return; + } + + + // + // C++: void setPolySigma(double polySigma) + // + + //javadoc: FarnebackOpticalFlow::setPolySigma(polySigma) + public void setPolySigma(double polySigma) + { + + setPolySigma_0(nativeObj, polySigma); + + return; + } + + + // + // C++: void setPyrScale(double pyrScale) + // + + //javadoc: FarnebackOpticalFlow::setPyrScale(pyrScale) + public void setPyrScale(double pyrScale) + { + + setPyrScale_0(nativeObj, pyrScale); + + return; + } + + + // + // C++: void setWinSize(int winSize) + // + + //javadoc: FarnebackOpticalFlow::setWinSize(winSize) + public void setWinSize(int winSize) + { + + setWinSize_0(nativeObj, winSize); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_FarnebackOpticalFlow create(int numLevels = 5, double pyrScale = 0.5, bool fastPyramids = false, int winSize = 13, int numIters = 10, int polyN = 5, double polySigma = 1.1, int flags = 0) + private static native long create_0(int numLevels, double pyrScale, boolean fastPyramids, int winSize, int numIters, int polyN, double polySigma, int flags); + private static native long create_1(); + + // C++: bool getFastPyramids() + private static native boolean getFastPyramids_0(long nativeObj); + + // C++: double getPolySigma() + private static native double getPolySigma_0(long nativeObj); + + // C++: double getPyrScale() + private static native double getPyrScale_0(long nativeObj); + + // C++: int getFlags() + private static native int getFlags_0(long nativeObj); + + // C++: int getNumIters() + private static native int getNumIters_0(long nativeObj); + + // C++: int getNumLevels() + private static native int getNumLevels_0(long nativeObj); + + // C++: int getPolyN() + private static native int getPolyN_0(long nativeObj); + + // C++: int getWinSize() + private static native int getWinSize_0(long nativeObj); + + // C++: void setFastPyramids(bool fastPyramids) + private static native void setFastPyramids_0(long nativeObj, boolean fastPyramids); + + // C++: void setFlags(int flags) + private static native void setFlags_0(long nativeObj, int flags); + + // C++: void setNumIters(int numIters) + private static native void setNumIters_0(long nativeObj, int numIters); + + // C++: void setNumLevels(int numLevels) + private static native void setNumLevels_0(long nativeObj, int numLevels); + + // C++: void setPolyN(int polyN) + private static native void setPolyN_0(long nativeObj, int polyN); + + // C++: void setPolySigma(double polySigma) + private static native void setPolySigma_0(long nativeObj, double polySigma); + + // C++: void setPyrScale(double pyrScale) + private static native void setPyrScale_0(long nativeObj, double pyrScale); + + // C++: void setWinSize(int winSize) + private static native void setWinSize_0(long nativeObj, int winSize); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/KalmanFilter.java b/openCVLibrary330/src/main/java/org/opencv/video/KalmanFilter.java new file mode 100644 index 00000000000..6865f1a3bdd --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/KalmanFilter.java @@ -0,0 +1,456 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import org.opencv.core.Mat; + +// C++: class KalmanFilter +//javadoc: KalmanFilter +public class KalmanFilter { + + protected final long nativeObj; + protected KalmanFilter(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: KalmanFilter(int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F) + // + + //javadoc: KalmanFilter::KalmanFilter(dynamParams, measureParams, controlParams, type) + public KalmanFilter(int dynamParams, int measureParams, int controlParams, int type) + { + + nativeObj = KalmanFilter_0(dynamParams, measureParams, controlParams, type); + + return; + } + + //javadoc: KalmanFilter::KalmanFilter(dynamParams, measureParams) + public KalmanFilter(int dynamParams, int measureParams) + { + + nativeObj = KalmanFilter_1(dynamParams, measureParams); + + return; + } + + + // + // C++: KalmanFilter() + // + + //javadoc: KalmanFilter::KalmanFilter() + public KalmanFilter() + { + + nativeObj = KalmanFilter_2(); + + return; + } + + + // + // C++: Mat correct(Mat measurement) + // + + //javadoc: KalmanFilter::correct(measurement) + public Mat correct(Mat measurement) + { + + Mat retVal = new Mat(correct_0(nativeObj, measurement.nativeObj)); + + return retVal; + } + + + // + // C++: Mat predict(Mat control = Mat()) + // + + //javadoc: KalmanFilter::predict(control) + public Mat predict(Mat control) + { + + Mat retVal = new Mat(predict_0(nativeObj, control.nativeObj)); + + return retVal; + } + + //javadoc: KalmanFilter::predict() + public Mat predict() + { + + Mat retVal = new Mat(predict_1(nativeObj)); + + return retVal; + } + + + // + // C++: Mat KalmanFilter::statePre + // + + //javadoc: KalmanFilter::get_statePre() + public Mat get_statePre() + { + + Mat retVal = new Mat(get_statePre_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::statePre + // + + //javadoc: KalmanFilter::set_statePre(statePre) + public void set_statePre(Mat statePre) + { + + set_statePre_0(nativeObj, statePre.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::statePost + // + + //javadoc: KalmanFilter::get_statePost() + public Mat get_statePost() + { + + Mat retVal = new Mat(get_statePost_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::statePost + // + + //javadoc: KalmanFilter::set_statePost(statePost) + public void set_statePost(Mat statePost) + { + + set_statePost_0(nativeObj, statePost.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::transitionMatrix + // + + //javadoc: KalmanFilter::get_transitionMatrix() + public Mat get_transitionMatrix() + { + + Mat retVal = new Mat(get_transitionMatrix_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::transitionMatrix + // + + //javadoc: KalmanFilter::set_transitionMatrix(transitionMatrix) + public void set_transitionMatrix(Mat transitionMatrix) + { + + set_transitionMatrix_0(nativeObj, transitionMatrix.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::controlMatrix + // + + //javadoc: KalmanFilter::get_controlMatrix() + public Mat get_controlMatrix() + { + + Mat retVal = new Mat(get_controlMatrix_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::controlMatrix + // + + //javadoc: KalmanFilter::set_controlMatrix(controlMatrix) + public void set_controlMatrix(Mat controlMatrix) + { + + set_controlMatrix_0(nativeObj, controlMatrix.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::measurementMatrix + // + + //javadoc: KalmanFilter::get_measurementMatrix() + public Mat get_measurementMatrix() + { + + Mat retVal = new Mat(get_measurementMatrix_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::measurementMatrix + // + + //javadoc: KalmanFilter::set_measurementMatrix(measurementMatrix) + public void set_measurementMatrix(Mat measurementMatrix) + { + + set_measurementMatrix_0(nativeObj, measurementMatrix.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::processNoiseCov + // + + //javadoc: KalmanFilter::get_processNoiseCov() + public Mat get_processNoiseCov() + { + + Mat retVal = new Mat(get_processNoiseCov_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::processNoiseCov + // + + //javadoc: KalmanFilter::set_processNoiseCov(processNoiseCov) + public void set_processNoiseCov(Mat processNoiseCov) + { + + set_processNoiseCov_0(nativeObj, processNoiseCov.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::measurementNoiseCov + // + + //javadoc: KalmanFilter::get_measurementNoiseCov() + public Mat get_measurementNoiseCov() + { + + Mat retVal = new Mat(get_measurementNoiseCov_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::measurementNoiseCov + // + + //javadoc: KalmanFilter::set_measurementNoiseCov(measurementNoiseCov) + public void set_measurementNoiseCov(Mat measurementNoiseCov) + { + + set_measurementNoiseCov_0(nativeObj, measurementNoiseCov.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::errorCovPre + // + + //javadoc: KalmanFilter::get_errorCovPre() + public Mat get_errorCovPre() + { + + Mat retVal = new Mat(get_errorCovPre_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::errorCovPre + // + + //javadoc: KalmanFilter::set_errorCovPre(errorCovPre) + public void set_errorCovPre(Mat errorCovPre) + { + + set_errorCovPre_0(nativeObj, errorCovPre.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::gain + // + + //javadoc: KalmanFilter::get_gain() + public Mat get_gain() + { + + Mat retVal = new Mat(get_gain_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::gain + // + + //javadoc: KalmanFilter::set_gain(gain) + public void set_gain(Mat gain) + { + + set_gain_0(nativeObj, gain.nativeObj); + + return; + } + + + // + // C++: Mat KalmanFilter::errorCovPost + // + + //javadoc: KalmanFilter::get_errorCovPost() + public Mat get_errorCovPost() + { + + Mat retVal = new Mat(get_errorCovPost_0(nativeObj)); + + return retVal; + } + + + // + // C++: void KalmanFilter::errorCovPost + // + + //javadoc: KalmanFilter::set_errorCovPost(errorCovPost) + public void set_errorCovPost(Mat errorCovPost) + { + + set_errorCovPost_0(nativeObj, errorCovPost.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: KalmanFilter(int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F) + private static native long KalmanFilter_0(int dynamParams, int measureParams, int controlParams, int type); + private static native long KalmanFilter_1(int dynamParams, int measureParams); + + // C++: KalmanFilter() + private static native long KalmanFilter_2(); + + // C++: Mat correct(Mat measurement) + private static native long correct_0(long nativeObj, long measurement_nativeObj); + + // C++: Mat predict(Mat control = Mat()) + private static native long predict_0(long nativeObj, long control_nativeObj); + private static native long predict_1(long nativeObj); + + // C++: Mat KalmanFilter::statePre + private static native long get_statePre_0(long nativeObj); + + // C++: void KalmanFilter::statePre + private static native void set_statePre_0(long nativeObj, long statePre_nativeObj); + + // C++: Mat KalmanFilter::statePost + private static native long get_statePost_0(long nativeObj); + + // C++: void KalmanFilter::statePost + private static native void set_statePost_0(long nativeObj, long statePost_nativeObj); + + // C++: Mat KalmanFilter::transitionMatrix + private static native long get_transitionMatrix_0(long nativeObj); + + // C++: void KalmanFilter::transitionMatrix + private static native void set_transitionMatrix_0(long nativeObj, long transitionMatrix_nativeObj); + + // C++: Mat KalmanFilter::controlMatrix + private static native long get_controlMatrix_0(long nativeObj); + + // C++: void KalmanFilter::controlMatrix + private static native void set_controlMatrix_0(long nativeObj, long controlMatrix_nativeObj); + + // C++: Mat KalmanFilter::measurementMatrix + private static native long get_measurementMatrix_0(long nativeObj); + + // C++: void KalmanFilter::measurementMatrix + private static native void set_measurementMatrix_0(long nativeObj, long measurementMatrix_nativeObj); + + // C++: Mat KalmanFilter::processNoiseCov + private static native long get_processNoiseCov_0(long nativeObj); + + // C++: void KalmanFilter::processNoiseCov + private static native void set_processNoiseCov_0(long nativeObj, long processNoiseCov_nativeObj); + + // C++: Mat KalmanFilter::measurementNoiseCov + private static native long get_measurementNoiseCov_0(long nativeObj); + + // C++: void KalmanFilter::measurementNoiseCov + private static native void set_measurementNoiseCov_0(long nativeObj, long measurementNoiseCov_nativeObj); + + // C++: Mat KalmanFilter::errorCovPre + private static native long get_errorCovPre_0(long nativeObj); + + // C++: void KalmanFilter::errorCovPre + private static native void set_errorCovPre_0(long nativeObj, long errorCovPre_nativeObj); + + // C++: Mat KalmanFilter::gain + private static native long get_gain_0(long nativeObj); + + // C++: void KalmanFilter::gain + private static native void set_gain_0(long nativeObj, long gain_nativeObj); + + // C++: Mat KalmanFilter::errorCovPost + private static native long get_errorCovPost_0(long nativeObj); + + // C++: void KalmanFilter::errorCovPost + private static native void set_errorCovPost_0(long nativeObj, long errorCovPost_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/SparseOpticalFlow.java b/openCVLibrary330/src/main/java/org/opencv/video/SparseOpticalFlow.java new file mode 100644 index 00000000000..6c7dc383545 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/SparseOpticalFlow.java @@ -0,0 +1,54 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import org.opencv.core.Algorithm; +import org.opencv.core.Mat; + +// C++: class SparseOpticalFlow +//javadoc: SparseOpticalFlow +public class SparseOpticalFlow extends Algorithm { + + protected SparseOpticalFlow(long addr) { super(addr); } + + + // + // C++: void calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat& nextPts, Mat& status, Mat& err = cv::Mat()) + // + + //javadoc: SparseOpticalFlow::calc(prevImg, nextImg, prevPts, nextPts, status, err) + public void calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status, Mat err) + { + + calc_0(nativeObj, prevImg.nativeObj, nextImg.nativeObj, prevPts.nativeObj, nextPts.nativeObj, status.nativeObj, err.nativeObj); + + return; + } + + //javadoc: SparseOpticalFlow::calc(prevImg, nextImg, prevPts, nextPts, status) + public void calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status) + { + + calc_1(nativeObj, prevImg.nativeObj, nextImg.nativeObj, prevPts.nativeObj, nextPts.nativeObj, status.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: void calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat& nextPts, Mat& status, Mat& err = cv::Mat()) + private static native void calc_0(long nativeObj, long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_nativeObj, long nextPts_nativeObj, long status_nativeObj, long err_nativeObj); + private static native void calc_1(long nativeObj, long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_nativeObj, long nextPts_nativeObj, long status_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/SparsePyrLKOpticalFlow.java b/openCVLibrary330/src/main/java/org/opencv/video/SparsePyrLKOpticalFlow.java new file mode 100644 index 00000000000..758eea55954 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/SparsePyrLKOpticalFlow.java @@ -0,0 +1,224 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import org.opencv.core.Size; +import org.opencv.core.TermCriteria; + +// C++: class SparsePyrLKOpticalFlow +//javadoc: SparsePyrLKOpticalFlow +public class SparsePyrLKOpticalFlow extends SparseOpticalFlow { + + protected SparsePyrLKOpticalFlow(long addr) { super(addr); } + + + // + // C++: static Ptr_SparsePyrLKOpticalFlow create(Size winSize = Size(21, 21), int maxLevel = 3, TermCriteria crit = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4) + // + + //javadoc: SparsePyrLKOpticalFlow::create(winSize, maxLevel, crit, flags, minEigThreshold) + public static SparsePyrLKOpticalFlow create(Size winSize, int maxLevel, TermCriteria crit, int flags, double minEigThreshold) + { + + SparsePyrLKOpticalFlow retVal = new SparsePyrLKOpticalFlow(create_0(winSize.width, winSize.height, maxLevel, crit.type, crit.maxCount, crit.epsilon, flags, minEigThreshold)); + + return retVal; + } + + //javadoc: SparsePyrLKOpticalFlow::create() + public static SparsePyrLKOpticalFlow create() + { + + SparsePyrLKOpticalFlow retVal = new SparsePyrLKOpticalFlow(create_1()); + + return retVal; + } + + + // + // C++: Size getWinSize() + // + + //javadoc: SparsePyrLKOpticalFlow::getWinSize() + public Size getWinSize() + { + + Size retVal = new Size(getWinSize_0(nativeObj)); + + return retVal; + } + + + // + // C++: TermCriteria getTermCriteria() + // + + //javadoc: SparsePyrLKOpticalFlow::getTermCriteria() + public TermCriteria getTermCriteria() + { + + TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj)); + + return retVal; + } + + + // + // C++: double getMinEigThreshold() + // + + //javadoc: SparsePyrLKOpticalFlow::getMinEigThreshold() + public double getMinEigThreshold() + { + + double retVal = getMinEigThreshold_0(nativeObj); + + return retVal; + } + + + // + // C++: int getFlags() + // + + //javadoc: SparsePyrLKOpticalFlow::getFlags() + public int getFlags() + { + + int retVal = getFlags_0(nativeObj); + + return retVal; + } + + + // + // C++: int getMaxLevel() + // + + //javadoc: SparsePyrLKOpticalFlow::getMaxLevel() + public int getMaxLevel() + { + + int retVal = getMaxLevel_0(nativeObj); + + return retVal; + } + + + // + // C++: void setFlags(int flags) + // + + //javadoc: SparsePyrLKOpticalFlow::setFlags(flags) + public void setFlags(int flags) + { + + setFlags_0(nativeObj, flags); + + return; + } + + + // + // C++: void setMaxLevel(int maxLevel) + // + + //javadoc: SparsePyrLKOpticalFlow::setMaxLevel(maxLevel) + public void setMaxLevel(int maxLevel) + { + + setMaxLevel_0(nativeObj, maxLevel); + + return; + } + + + // + // C++: void setMinEigThreshold(double minEigThreshold) + // + + //javadoc: SparsePyrLKOpticalFlow::setMinEigThreshold(minEigThreshold) + public void setMinEigThreshold(double minEigThreshold) + { + + setMinEigThreshold_0(nativeObj, minEigThreshold); + + return; + } + + + // + // C++: void setTermCriteria(TermCriteria crit) + // + + //javadoc: SparsePyrLKOpticalFlow::setTermCriteria(crit) + public void setTermCriteria(TermCriteria crit) + { + + setTermCriteria_0(nativeObj, crit.type, crit.maxCount, crit.epsilon); + + return; + } + + + // + // C++: void setWinSize(Size winSize) + // + + //javadoc: SparsePyrLKOpticalFlow::setWinSize(winSize) + public void setWinSize(Size winSize) + { + + setWinSize_0(nativeObj, winSize.width, winSize.height); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: static Ptr_SparsePyrLKOpticalFlow create(Size winSize = Size(21, 21), int maxLevel = 3, TermCriteria crit = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4) + private static native long create_0(double winSize_width, double winSize_height, int maxLevel, int crit_type, int crit_maxCount, double crit_epsilon, int flags, double minEigThreshold); + private static native long create_1(); + + // C++: Size getWinSize() + private static native double[] getWinSize_0(long nativeObj); + + // C++: TermCriteria getTermCriteria() + private static native double[] getTermCriteria_0(long nativeObj); + + // C++: double getMinEigThreshold() + private static native double getMinEigThreshold_0(long nativeObj); + + // C++: int getFlags() + private static native int getFlags_0(long nativeObj); + + // C++: int getMaxLevel() + private static native int getMaxLevel_0(long nativeObj); + + // C++: void setFlags(int flags) + private static native void setFlags_0(long nativeObj, int flags); + + // C++: void setMaxLevel(int maxLevel) + private static native void setMaxLevel_0(long nativeObj, int maxLevel); + + // C++: void setMinEigThreshold(double minEigThreshold) + private static native void setMinEigThreshold_0(long nativeObj, double minEigThreshold); + + // C++: void setTermCriteria(TermCriteria crit) + private static native void setTermCriteria_0(long nativeObj, int crit_type, int crit_maxCount, double crit_epsilon); + + // C++: void setWinSize(Size winSize) + private static native void setWinSize_0(long nativeObj, double winSize_width, double winSize_height); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/video/Video.java b/openCVLibrary330/src/main/java/org/opencv/video/Video.java new file mode 100644 index 00000000000..f46f498db37 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/video/Video.java @@ -0,0 +1,289 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.video; + +import java.util.ArrayList; +import java.util.List; +import org.opencv.core.Mat; +import org.opencv.core.MatOfByte; +import org.opencv.core.MatOfFloat; +import org.opencv.core.MatOfPoint2f; +import org.opencv.core.Rect; +import org.opencv.core.RotatedRect; +import org.opencv.core.Size; +import org.opencv.core.TermCriteria; +import org.opencv.utils.Converters; + +public class Video { + + private static final int + CV_LKFLOW_INITIAL_GUESSES = 4, + CV_LKFLOW_GET_MIN_EIGENVALS = 8; + + + public static final int + OPTFLOW_USE_INITIAL_FLOW = 4, + OPTFLOW_LK_GET_MIN_EIGENVALS = 8, + OPTFLOW_FARNEBACK_GAUSSIAN = 256, + MOTION_TRANSLATION = 0, + MOTION_EUCLIDEAN = 1, + MOTION_AFFINE = 2, + MOTION_HOMOGRAPHY = 3; + + + // + // C++: Mat estimateRigidTransform(Mat src, Mat dst, bool fullAffine) + // + + //javadoc: estimateRigidTransform(src, dst, fullAffine) + public static Mat estimateRigidTransform(Mat src, Mat dst, boolean fullAffine) + { + + Mat retVal = new Mat(estimateRigidTransform_0(src.nativeObj, dst.nativeObj, fullAffine)); + + return retVal; + } + + + // + // C++: Ptr_BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history = 500, double dist2Threshold = 400.0, bool detectShadows = true) + // + + //javadoc: createBackgroundSubtractorKNN(history, dist2Threshold, detectShadows) + public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history, double dist2Threshold, boolean detectShadows) + { + + BackgroundSubtractorKNN retVal = new BackgroundSubtractorKNN(createBackgroundSubtractorKNN_0(history, dist2Threshold, detectShadows)); + + return retVal; + } + + //javadoc: createBackgroundSubtractorKNN() + public static BackgroundSubtractorKNN createBackgroundSubtractorKNN() + { + + BackgroundSubtractorKNN retVal = new BackgroundSubtractorKNN(createBackgroundSubtractorKNN_1()); + + return retVal; + } + + + // + // C++: Ptr_BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history = 500, double varThreshold = 16, bool detectShadows = true) + // + + //javadoc: createBackgroundSubtractorMOG2(history, varThreshold, detectShadows) + public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history, double varThreshold, boolean detectShadows) + { + + BackgroundSubtractorMOG2 retVal = new BackgroundSubtractorMOG2(createBackgroundSubtractorMOG2_0(history, varThreshold, detectShadows)); + + return retVal; + } + + //javadoc: createBackgroundSubtractorMOG2() + public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2() + { + + BackgroundSubtractorMOG2 retVal = new BackgroundSubtractorMOG2(createBackgroundSubtractorMOG2_1()); + + return retVal; + } + + + // + // C++: Ptr_DualTVL1OpticalFlow createOptFlow_DualTVL1() + // + + //javadoc: createOptFlow_DualTVL1() + public static DualTVL1OpticalFlow createOptFlow_DualTVL1() + { + + DualTVL1OpticalFlow retVal = new DualTVL1OpticalFlow(createOptFlow_DualTVL1_0()); + + return retVal; + } + + + // + // C++: RotatedRect CamShift(Mat probImage, Rect& window, TermCriteria criteria) + // + + //javadoc: CamShift(probImage, window, criteria) + public static RotatedRect CamShift(Mat probImage, Rect window, TermCriteria criteria) + { + double[] window_out = new double[4]; + RotatedRect retVal = new RotatedRect(CamShift_0(probImage.nativeObj, window.x, window.y, window.width, window.height, window_out, criteria.type, criteria.maxCount, criteria.epsilon)); + if(window!=null){ window.x = (int)window_out[0]; window.y = (int)window_out[1]; window.width = (int)window_out[2]; window.height = (int)window_out[3]; } + return retVal; + } + + + // + // C++: double findTransformECC(Mat templateImage, Mat inputImage, Mat& warpMatrix, int motionType = MOTION_AFFINE, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001), Mat inputMask = Mat()) + // + + //javadoc: findTransformECC(templateImage, inputImage, warpMatrix, motionType, criteria, inputMask) + public static double findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix, int motionType, TermCriteria criteria, Mat inputMask) + { + + double retVal = findTransformECC_0(templateImage.nativeObj, inputImage.nativeObj, warpMatrix.nativeObj, motionType, criteria.type, criteria.maxCount, criteria.epsilon, inputMask.nativeObj); + + return retVal; + } + + //javadoc: findTransformECC(templateImage, inputImage, warpMatrix, motionType) + public static double findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix, int motionType) + { + + double retVal = findTransformECC_1(templateImage.nativeObj, inputImage.nativeObj, warpMatrix.nativeObj, motionType); + + return retVal; + } + + //javadoc: findTransformECC(templateImage, inputImage, warpMatrix) + public static double findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix) + { + + double retVal = findTransformECC_2(templateImage.nativeObj, inputImage.nativeObj, warpMatrix.nativeObj); + + return retVal; + } + + + // + // C++: int buildOpticalFlowPyramid(Mat img, vector_Mat& pyramid, Size winSize, int maxLevel, bool withDerivatives = true, int pyrBorder = BORDER_REFLECT_101, int derivBorder = BORDER_CONSTANT, bool tryReuseInputImage = true) + // + + //javadoc: buildOpticalFlowPyramid(img, pyramid, winSize, maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage) + public static int buildOpticalFlowPyramid(Mat img, List pyramid, Size winSize, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage) + { + Mat pyramid_mat = new Mat(); + int retVal = buildOpticalFlowPyramid_0(img.nativeObj, pyramid_mat.nativeObj, winSize.width, winSize.height, maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage); + Converters.Mat_to_vector_Mat(pyramid_mat, pyramid); + pyramid_mat.release(); + return retVal; + } + + //javadoc: buildOpticalFlowPyramid(img, pyramid, winSize, maxLevel) + public static int buildOpticalFlowPyramid(Mat img, List pyramid, Size winSize, int maxLevel) + { + Mat pyramid_mat = new Mat(); + int retVal = buildOpticalFlowPyramid_1(img.nativeObj, pyramid_mat.nativeObj, winSize.width, winSize.height, maxLevel); + Converters.Mat_to_vector_Mat(pyramid_mat, pyramid); + pyramid_mat.release(); + return retVal; + } + + + // + // C++: int meanShift(Mat probImage, Rect& window, TermCriteria criteria) + // + + //javadoc: meanShift(probImage, window, criteria) + public static int meanShift(Mat probImage, Rect window, TermCriteria criteria) + { + double[] window_out = new double[4]; + int retVal = meanShift_0(probImage.nativeObj, window.x, window.y, window.width, window.height, window_out, criteria.type, criteria.maxCount, criteria.epsilon); + if(window!=null){ window.x = (int)window_out[0]; window.y = (int)window_out[1]; window.width = (int)window_out[2]; window.height = (int)window_out[3]; } + return retVal; + } + + + // + // C++: void calcOpticalFlowFarneback(Mat prev, Mat next, Mat& flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) + // + + //javadoc: calcOpticalFlowFarneback(prev, next, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags) + public static void calcOpticalFlowFarneback(Mat prev, Mat next, Mat flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) + { + + calcOpticalFlowFarneback_0(prev.nativeObj, next.nativeObj, flow.nativeObj, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags); + + return; + } + + + // + // C++: void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, vector_Point2f prevPts, vector_Point2f& nextPts, vector_uchar& status, vector_float& err, Size winSize = Size(21,21), int maxLevel = 3, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4) + // + + //javadoc: calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err, winSize, maxLevel, criteria, flags, minEigThreshold) + public static void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, MatOfPoint2f prevPts, MatOfPoint2f nextPts, MatOfByte status, MatOfFloat err, Size winSize, int maxLevel, TermCriteria criteria, int flags, double minEigThreshold) + { + Mat prevPts_mat = prevPts; + Mat nextPts_mat = nextPts; + Mat status_mat = status; + Mat err_mat = err; + calcOpticalFlowPyrLK_0(prevImg.nativeObj, nextImg.nativeObj, prevPts_mat.nativeObj, nextPts_mat.nativeObj, status_mat.nativeObj, err_mat.nativeObj, winSize.width, winSize.height, maxLevel, criteria.type, criteria.maxCount, criteria.epsilon, flags, minEigThreshold); + + return; + } + + //javadoc: calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err, winSize, maxLevel) + public static void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, MatOfPoint2f prevPts, MatOfPoint2f nextPts, MatOfByte status, MatOfFloat err, Size winSize, int maxLevel) + { + Mat prevPts_mat = prevPts; + Mat nextPts_mat = nextPts; + Mat status_mat = status; + Mat err_mat = err; + calcOpticalFlowPyrLK_1(prevImg.nativeObj, nextImg.nativeObj, prevPts_mat.nativeObj, nextPts_mat.nativeObj, status_mat.nativeObj, err_mat.nativeObj, winSize.width, winSize.height, maxLevel); + + return; + } + + //javadoc: calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err) + public static void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, MatOfPoint2f prevPts, MatOfPoint2f nextPts, MatOfByte status, MatOfFloat err) + { + Mat prevPts_mat = prevPts; + Mat nextPts_mat = nextPts; + Mat status_mat = status; + Mat err_mat = err; + calcOpticalFlowPyrLK_2(prevImg.nativeObj, nextImg.nativeObj, prevPts_mat.nativeObj, nextPts_mat.nativeObj, status_mat.nativeObj, err_mat.nativeObj); + + return; + } + + + + + // C++: Mat estimateRigidTransform(Mat src, Mat dst, bool fullAffine) + private static native long estimateRigidTransform_0(long src_nativeObj, long dst_nativeObj, boolean fullAffine); + + // C++: Ptr_BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history = 500, double dist2Threshold = 400.0, bool detectShadows = true) + private static native long createBackgroundSubtractorKNN_0(int history, double dist2Threshold, boolean detectShadows); + private static native long createBackgroundSubtractorKNN_1(); + + // C++: Ptr_BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history = 500, double varThreshold = 16, bool detectShadows = true) + private static native long createBackgroundSubtractorMOG2_0(int history, double varThreshold, boolean detectShadows); + private static native long createBackgroundSubtractorMOG2_1(); + + // C++: Ptr_DualTVL1OpticalFlow createOptFlow_DualTVL1() + private static native long createOptFlow_DualTVL1_0(); + + // C++: RotatedRect CamShift(Mat probImage, Rect& window, TermCriteria criteria) + private static native double[] CamShift_0(long probImage_nativeObj, int window_x, int window_y, int window_width, int window_height, double[] window_out, int criteria_type, int criteria_maxCount, double criteria_epsilon); + + // C++: double findTransformECC(Mat templateImage, Mat inputImage, Mat& warpMatrix, int motionType = MOTION_AFFINE, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001), Mat inputMask = Mat()) + private static native double findTransformECC_0(long templateImage_nativeObj, long inputImage_nativeObj, long warpMatrix_nativeObj, int motionType, int criteria_type, int criteria_maxCount, double criteria_epsilon, long inputMask_nativeObj); + private static native double findTransformECC_1(long templateImage_nativeObj, long inputImage_nativeObj, long warpMatrix_nativeObj, int motionType); + private static native double findTransformECC_2(long templateImage_nativeObj, long inputImage_nativeObj, long warpMatrix_nativeObj); + + // C++: int buildOpticalFlowPyramid(Mat img, vector_Mat& pyramid, Size winSize, int maxLevel, bool withDerivatives = true, int pyrBorder = BORDER_REFLECT_101, int derivBorder = BORDER_CONSTANT, bool tryReuseInputImage = true) + private static native int buildOpticalFlowPyramid_0(long img_nativeObj, long pyramid_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage); + private static native int buildOpticalFlowPyramid_1(long img_nativeObj, long pyramid_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel); + + // C++: int meanShift(Mat probImage, Rect& window, TermCriteria criteria) + private static native int meanShift_0(long probImage_nativeObj, int window_x, int window_y, int window_width, int window_height, double[] window_out, int criteria_type, int criteria_maxCount, double criteria_epsilon); + + // C++: void calcOpticalFlowFarneback(Mat prev, Mat next, Mat& flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) + private static native void calcOpticalFlowFarneback_0(long prev_nativeObj, long next_nativeObj, long flow_nativeObj, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags); + + // C++: void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, vector_Point2f prevPts, vector_Point2f& nextPts, vector_uchar& status, vector_float& err, Size winSize = Size(21,21), int maxLevel = 3, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4) + private static native void calcOpticalFlowPyrLK_0(long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_mat_nativeObj, long nextPts_mat_nativeObj, long status_mat_nativeObj, long err_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel, int criteria_type, int criteria_maxCount, double criteria_epsilon, int flags, double minEigThreshold); + private static native void calcOpticalFlowPyrLK_1(long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_mat_nativeObj, long nextPts_mat_nativeObj, long status_mat_nativeObj, long err_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel); + private static native void calcOpticalFlowPyrLK_2(long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_mat_nativeObj, long nextPts_mat_nativeObj, long status_mat_nativeObj, long err_mat_nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/videoio/VideoCapture.java b/openCVLibrary330/src/main/java/org/opencv/videoio/VideoCapture.java new file mode 100644 index 00000000000..eb4911e91c2 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/videoio/VideoCapture.java @@ -0,0 +1,294 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.videoio; + +import java.lang.String; +import org.opencv.core.Mat; + +// C++: class VideoCapture +//javadoc: VideoCapture +public class VideoCapture { + + protected final long nativeObj; + protected VideoCapture(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: VideoCapture(String filename, int apiPreference) + // + + //javadoc: VideoCapture::VideoCapture(filename, apiPreference) + public VideoCapture(String filename, int apiPreference) + { + + nativeObj = VideoCapture_0(filename, apiPreference); + + return; + } + + + // + // C++: VideoCapture(String filename) + // + + //javadoc: VideoCapture::VideoCapture(filename) + public VideoCapture(String filename) + { + + nativeObj = VideoCapture_1(filename); + + return; + } + + + // + // C++: VideoCapture(int index) + // + + //javadoc: VideoCapture::VideoCapture(index) + public VideoCapture(int index) + { + + nativeObj = VideoCapture_2(index); + + return; + } + + + // + // C++: VideoCapture() + // + + //javadoc: VideoCapture::VideoCapture() + public VideoCapture() + { + + nativeObj = VideoCapture_3(); + + return; + } + + + // + // C++: bool grab() + // + + //javadoc: VideoCapture::grab() + public boolean grab() + { + + boolean retVal = grab_0(nativeObj); + + return retVal; + } + + + // + // C++: bool isOpened() + // + + //javadoc: VideoCapture::isOpened() + public boolean isOpened() + { + + boolean retVal = isOpened_0(nativeObj); + + return retVal; + } + + + // + // C++: bool open(String filename, int apiPreference) + // + + //javadoc: VideoCapture::open(filename, apiPreference) + public boolean open(String filename, int apiPreference) + { + + boolean retVal = open_0(nativeObj, filename, apiPreference); + + return retVal; + } + + + // + // C++: bool open(String filename) + // + + //javadoc: VideoCapture::open(filename) + public boolean open(String filename) + { + + boolean retVal = open_1(nativeObj, filename); + + return retVal; + } + + + // + // C++: bool open(int cameraNum, int apiPreference) + // + + //javadoc: VideoCapture::open(cameraNum, apiPreference) + public boolean open(int cameraNum, int apiPreference) + { + + boolean retVal = open_2(nativeObj, cameraNum, apiPreference); + + return retVal; + } + + + // + // C++: bool open(int index) + // + + //javadoc: VideoCapture::open(index) + public boolean open(int index) + { + + boolean retVal = open_3(nativeObj, index); + + return retVal; + } + + + // + // C++: bool read(Mat& image) + // + + //javadoc: VideoCapture::read(image) + public boolean read(Mat image) + { + + boolean retVal = read_0(nativeObj, image.nativeObj); + + return retVal; + } + + + // + // C++: bool retrieve(Mat& image, int flag = 0) + // + + //javadoc: VideoCapture::retrieve(image, flag) + public boolean retrieve(Mat image, int flag) + { + + boolean retVal = retrieve_0(nativeObj, image.nativeObj, flag); + + return retVal; + } + + //javadoc: VideoCapture::retrieve(image) + public boolean retrieve(Mat image) + { + + boolean retVal = retrieve_1(nativeObj, image.nativeObj); + + return retVal; + } + + + // + // C++: bool set(int propId, double value) + // + + //javadoc: VideoCapture::set(propId, value) + public boolean set(int propId, double value) + { + + boolean retVal = set_0(nativeObj, propId, value); + + return retVal; + } + + + // + // C++: double get(int propId) + // + + //javadoc: VideoCapture::get(propId) + public double get(int propId) + { + + double retVal = get_0(nativeObj, propId); + + return retVal; + } + + + // + // C++: void release() + // + + //javadoc: VideoCapture::release() + public void release() + { + + release_0(nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: VideoCapture(String filename, int apiPreference) + private static native long VideoCapture_0(String filename, int apiPreference); + + // C++: VideoCapture(String filename) + private static native long VideoCapture_1(String filename); + + // C++: VideoCapture(int index) + private static native long VideoCapture_2(int index); + + // C++: VideoCapture() + private static native long VideoCapture_3(); + + // C++: bool grab() + private static native boolean grab_0(long nativeObj); + + // C++: bool isOpened() + private static native boolean isOpened_0(long nativeObj); + + // C++: bool open(String filename, int apiPreference) + private static native boolean open_0(long nativeObj, String filename, int apiPreference); + + // C++: bool open(String filename) + private static native boolean open_1(long nativeObj, String filename); + + // C++: bool open(int cameraNum, int apiPreference) + private static native boolean open_2(long nativeObj, int cameraNum, int apiPreference); + + // C++: bool open(int index) + private static native boolean open_3(long nativeObj, int index); + + // C++: bool read(Mat& image) + private static native boolean read_0(long nativeObj, long image_nativeObj); + + // C++: bool retrieve(Mat& image, int flag = 0) + private static native boolean retrieve_0(long nativeObj, long image_nativeObj, int flag); + private static native boolean retrieve_1(long nativeObj, long image_nativeObj); + + // C++: bool set(int propId, double value) + private static native boolean set_0(long nativeObj, int propId, double value); + + // C++: double get(int propId) + private static native double get_0(long nativeObj, int propId); + + // C++: void release() + private static native void release_0(long nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/videoio/VideoWriter.java b/openCVLibrary330/src/main/java/org/opencv/videoio/VideoWriter.java new file mode 100644 index 00000000000..5f14a80db65 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/videoio/VideoWriter.java @@ -0,0 +1,257 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.videoio; + +import java.lang.String; +import org.opencv.core.Mat; +import org.opencv.core.Size; + +// C++: class VideoWriter +//javadoc: VideoWriter +public class VideoWriter { + + protected final long nativeObj; + protected VideoWriter(long addr) { nativeObj = addr; } + + public long getNativeObjAddr() { return nativeObj; } + + // + // C++: VideoWriter(String filename, int apiPreference, int fourcc, double fps, Size frameSize, bool isColor = true) + // + + //javadoc: VideoWriter::VideoWriter(filename, apiPreference, fourcc, fps, frameSize, isColor) + public VideoWriter(String filename, int apiPreference, int fourcc, double fps, Size frameSize, boolean isColor) + { + + nativeObj = VideoWriter_0(filename, apiPreference, fourcc, fps, frameSize.width, frameSize.height, isColor); + + return; + } + + //javadoc: VideoWriter::VideoWriter(filename, apiPreference, fourcc, fps, frameSize) + public VideoWriter(String filename, int apiPreference, int fourcc, double fps, Size frameSize) + { + + nativeObj = VideoWriter_1(filename, apiPreference, fourcc, fps, frameSize.width, frameSize.height); + + return; + } + + + // + // C++: VideoWriter(String filename, int fourcc, double fps, Size frameSize, bool isColor = true) + // + + //javadoc: VideoWriter::VideoWriter(filename, fourcc, fps, frameSize, isColor) + public VideoWriter(String filename, int fourcc, double fps, Size frameSize, boolean isColor) + { + + nativeObj = VideoWriter_2(filename, fourcc, fps, frameSize.width, frameSize.height, isColor); + + return; + } + + //javadoc: VideoWriter::VideoWriter(filename, fourcc, fps, frameSize) + public VideoWriter(String filename, int fourcc, double fps, Size frameSize) + { + + nativeObj = VideoWriter_3(filename, fourcc, fps, frameSize.width, frameSize.height); + + return; + } + + + // + // C++: VideoWriter() + // + + //javadoc: VideoWriter::VideoWriter() + public VideoWriter() + { + + nativeObj = VideoWriter_4(); + + return; + } + + + // + // C++: bool isOpened() + // + + //javadoc: VideoWriter::isOpened() + public boolean isOpened() + { + + boolean retVal = isOpened_0(nativeObj); + + return retVal; + } + + + // + // C++: bool open(String filename, int apiPreference, int fourcc, double fps, Size frameSize, bool isColor = true) + // + + //javadoc: VideoWriter::open(filename, apiPreference, fourcc, fps, frameSize, isColor) + public boolean open(String filename, int apiPreference, int fourcc, double fps, Size frameSize, boolean isColor) + { + + boolean retVal = open_0(nativeObj, filename, apiPreference, fourcc, fps, frameSize.width, frameSize.height, isColor); + + return retVal; + } + + //javadoc: VideoWriter::open(filename, apiPreference, fourcc, fps, frameSize) + public boolean open(String filename, int apiPreference, int fourcc, double fps, Size frameSize) + { + + boolean retVal = open_1(nativeObj, filename, apiPreference, fourcc, fps, frameSize.width, frameSize.height); + + return retVal; + } + + + // + // C++: bool open(String filename, int fourcc, double fps, Size frameSize, bool isColor = true) + // + + //javadoc: VideoWriter::open(filename, fourcc, fps, frameSize, isColor) + public boolean open(String filename, int fourcc, double fps, Size frameSize, boolean isColor) + { + + boolean retVal = open_2(nativeObj, filename, fourcc, fps, frameSize.width, frameSize.height, isColor); + + return retVal; + } + + //javadoc: VideoWriter::open(filename, fourcc, fps, frameSize) + public boolean open(String filename, int fourcc, double fps, Size frameSize) + { + + boolean retVal = open_3(nativeObj, filename, fourcc, fps, frameSize.width, frameSize.height); + + return retVal; + } + + + // + // C++: bool set(int propId, double value) + // + + //javadoc: VideoWriter::set(propId, value) + public boolean set(int propId, double value) + { + + boolean retVal = set_0(nativeObj, propId, value); + + return retVal; + } + + + // + // C++: double get(int propId) + // + + //javadoc: VideoWriter::get(propId) + public double get(int propId) + { + + double retVal = get_0(nativeObj, propId); + + return retVal; + } + + + // + // C++: static int fourcc(char c1, char c2, char c3, char c4) + // + + //javadoc: VideoWriter::fourcc(c1, c2, c3, c4) + public static int fourcc(char c1, char c2, char c3, char c4) + { + + int retVal = fourcc_0(c1, c2, c3, c4); + + return retVal; + } + + + // + // C++: void release() + // + + //javadoc: VideoWriter::release() + public void release() + { + + release_0(nativeObj); + + return; + } + + + // + // C++: void write(Mat image) + // + + //javadoc: VideoWriter::write(image) + public void write(Mat image) + { + + write_0(nativeObj, image.nativeObj); + + return; + } + + + @Override + protected void finalize() throws Throwable { + delete(nativeObj); + } + + + + // C++: VideoWriter(String filename, int apiPreference, int fourcc, double fps, Size frameSize, bool isColor = true) + private static native long VideoWriter_0(String filename, int apiPreference, int fourcc, double fps, double frameSize_width, double frameSize_height, boolean isColor); + private static native long VideoWriter_1(String filename, int apiPreference, int fourcc, double fps, double frameSize_width, double frameSize_height); + + // C++: VideoWriter(String filename, int fourcc, double fps, Size frameSize, bool isColor = true) + private static native long VideoWriter_2(String filename, int fourcc, double fps, double frameSize_width, double frameSize_height, boolean isColor); + private static native long VideoWriter_3(String filename, int fourcc, double fps, double frameSize_width, double frameSize_height); + + // C++: VideoWriter() + private static native long VideoWriter_4(); + + // C++: bool isOpened() + private static native boolean isOpened_0(long nativeObj); + + // C++: bool open(String filename, int apiPreference, int fourcc, double fps, Size frameSize, bool isColor = true) + private static native boolean open_0(long nativeObj, String filename, int apiPreference, int fourcc, double fps, double frameSize_width, double frameSize_height, boolean isColor); + private static native boolean open_1(long nativeObj, String filename, int apiPreference, int fourcc, double fps, double frameSize_width, double frameSize_height); + + // C++: bool open(String filename, int fourcc, double fps, Size frameSize, bool isColor = true) + private static native boolean open_2(long nativeObj, String filename, int fourcc, double fps, double frameSize_width, double frameSize_height, boolean isColor); + private static native boolean open_3(long nativeObj, String filename, int fourcc, double fps, double frameSize_width, double frameSize_height); + + // C++: bool set(int propId, double value) + private static native boolean set_0(long nativeObj, int propId, double value); + + // C++: double get(int propId) + private static native double get_0(long nativeObj, int propId); + + // C++: static int fourcc(char c1, char c2, char c3, char c4) + private static native int fourcc_0(char c1, char c2, char c3, char c4); + + // C++: void release() + private static native void release_0(long nativeObj); + + // C++: void write(Mat image) + private static native void write_0(long nativeObj, long image_nativeObj); + + // native support for java finalize() + private static native void delete(long nativeObj); + +} diff --git a/openCVLibrary330/src/main/java/org/opencv/videoio/Videoio.java b/openCVLibrary330/src/main/java/org/opencv/videoio/Videoio.java new file mode 100644 index 00000000000..42e64752e82 --- /dev/null +++ b/openCVLibrary330/src/main/java/org/opencv/videoio/Videoio.java @@ -0,0 +1,678 @@ + +// +// This file is auto-generated. Please don't modify it! +// +package org.opencv.videoio; + + + +public class Videoio { + + public static final int + CV_CAP_ANY = 0, + CV_CAP_MIL = 100, + CV_CAP_VFW = 200, + CV_CAP_V4L = 200, + CV_CAP_V4L2 = 200, + CV_CAP_FIREWARE = 300, + CV_CAP_FIREWIRE = 300, + CV_CAP_IEEE1394 = 300, + CV_CAP_DC1394 = 300, + CV_CAP_CMU1394 = 300, + CV_CAP_STEREO = 400, + CV_CAP_TYZX = 400, + CV_TYZX_LEFT = 400, + CV_TYZX_RIGHT = 401, + CV_TYZX_COLOR = 402, + CV_TYZX_Z = 403, + CV_CAP_QT = 500, + CV_CAP_UNICAP = 600, + CV_CAP_DSHOW = 700, + CV_CAP_MSMF = 1400, + CV_CAP_PVAPI = 800, + CV_CAP_OPENNI = 900, + CV_CAP_OPENNI_ASUS = 910, + CV_CAP_ANDROID = 1000, + CV_CAP_ANDROID_BACK = CV_CAP_ANDROID+99, + CV_CAP_ANDROID_FRONT = CV_CAP_ANDROID+98, + CV_CAP_XIAPI = 1100, + CV_CAP_AVFOUNDATION = 1200, + CV_CAP_GIGANETIX = 1300, + CV_CAP_INTELPERC = 1500, + CV_CAP_OPENNI2 = 1600, + CV_CAP_GPHOTO2 = 1700, + CV_CAP_GSTREAMER = 1800, + CV_CAP_FFMPEG = 1900, + CV_CAP_IMAGES = 2000, + CV_CAP_ARAVIS = 2100, + CV_CAP_PROP_DC1394_OFF = -4, + CV_CAP_PROP_DC1394_MODE_MANUAL = -3, + CV_CAP_PROP_DC1394_MODE_AUTO = -2, + CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1, + CV_CAP_PROP_POS_MSEC = 0, + CV_CAP_PROP_POS_FRAMES = 1, + CV_CAP_PROP_POS_AVI_RATIO = 2, + CV_CAP_PROP_FRAME_WIDTH = 3, + CV_CAP_PROP_FRAME_HEIGHT = 4, + CV_CAP_PROP_FPS = 5, + CV_CAP_PROP_FOURCC = 6, + CV_CAP_PROP_FRAME_COUNT = 7, + CV_CAP_PROP_FORMAT = 8, + CV_CAP_PROP_MODE = 9, + CV_CAP_PROP_BRIGHTNESS = 10, + CV_CAP_PROP_CONTRAST = 11, + CV_CAP_PROP_SATURATION = 12, + CV_CAP_PROP_HUE = 13, + CV_CAP_PROP_GAIN = 14, + CV_CAP_PROP_EXPOSURE = 15, + CV_CAP_PROP_CONVERT_RGB = 16, + CV_CAP_PROP_WHITE_BALANCE_BLUE_U = 17, + CV_CAP_PROP_RECTIFICATION = 18, + CV_CAP_PROP_MONOCHROME = 19, + CV_CAP_PROP_SHARPNESS = 20, + CV_CAP_PROP_AUTO_EXPOSURE = 21, + CV_CAP_PROP_GAMMA = 22, + CV_CAP_PROP_TEMPERATURE = 23, + CV_CAP_PROP_TRIGGER = 24, + CV_CAP_PROP_TRIGGER_DELAY = 25, + CV_CAP_PROP_WHITE_BALANCE_RED_V = 26, + CV_CAP_PROP_ZOOM = 27, + CV_CAP_PROP_FOCUS = 28, + CV_CAP_PROP_GUID = 29, + CV_CAP_PROP_ISO_SPEED = 30, + CV_CAP_PROP_MAX_DC1394 = 31, + CV_CAP_PROP_BACKLIGHT = 32, + CV_CAP_PROP_PAN = 33, + CV_CAP_PROP_TILT = 34, + CV_CAP_PROP_ROLL = 35, + CV_CAP_PROP_IRIS = 36, + CV_CAP_PROP_SETTINGS = 37, + CV_CAP_PROP_BUFFERSIZE = 38, + CV_CAP_PROP_AUTOFOCUS = 39, + CV_CAP_PROP_SAR_NUM = 40, + CV_CAP_PROP_SAR_DEN = 41, + CV_CAP_PROP_AUTOGRAB = 1024, + CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING = 1025, + CV_CAP_PROP_PREVIEW_FORMAT = 1026, + CV_CAP_OPENNI_DEPTH_GENERATOR = 1 << 31, + CV_CAP_OPENNI_IMAGE_GENERATOR = 1 << 30, + CV_CAP_OPENNI_IR_GENERATOR = 1 << 29, + CV_CAP_OPENNI_GENERATORS_MASK = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_OPENNI_IR_GENERATOR, + CV_CAP_PROP_OPENNI_OUTPUT_MODE = 100, + CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, + CV_CAP_PROP_OPENNI_BASELINE = 102, + CV_CAP_PROP_OPENNI_FOCAL_LENGTH = 103, + CV_CAP_PROP_OPENNI_REGISTRATION = 104, + CV_CAP_PROP_OPENNI_REGISTRATION_ON = CV_CAP_PROP_OPENNI_REGISTRATION, + CV_CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105, + CV_CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106, + CV_CAP_PROP_OPENNI_CIRCLE_BUFFER = 107, + CV_CAP_PROP_OPENNI_MAX_TIME_DURATION = 108, + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT = 109, + CV_CAP_PROP_OPENNI2_SYNC = 110, + CV_CAP_PROP_OPENNI2_MIRROR = 111, + CV_CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT, + CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_OUTPUT_MODE, + CV_CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT, + CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_BASELINE, + CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_FOCAL_LENGTH, + CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION, + CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION, + CV_CAP_OPENNI_IR_GENERATOR_PRESENT = CV_CAP_OPENNI_IR_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT, + CV_CAP_GSTREAMER_QUEUE_LENGTH = 200, + CV_CAP_PROP_PVAPI_MULTICASTIP = 300, + CV_CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, + CV_CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302, + CV_CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303, + CV_CAP_PROP_PVAPI_BINNINGX = 304, + CV_CAP_PROP_PVAPI_BINNINGY = 305, + CV_CAP_PROP_PVAPI_PIXELFORMAT = 306, + CV_CAP_PROP_XI_DOWNSAMPLING = 400, + CV_CAP_PROP_XI_DATA_FORMAT = 401, + CV_CAP_PROP_XI_OFFSET_X = 402, + CV_CAP_PROP_XI_OFFSET_Y = 403, + CV_CAP_PROP_XI_TRG_SOURCE = 404, + CV_CAP_PROP_XI_TRG_SOFTWARE = 405, + CV_CAP_PROP_XI_GPI_SELECTOR = 406, + CV_CAP_PROP_XI_GPI_MODE = 407, + CV_CAP_PROP_XI_GPI_LEVEL = 408, + CV_CAP_PROP_XI_GPO_SELECTOR = 409, + CV_CAP_PROP_XI_GPO_MODE = 410, + CV_CAP_PROP_XI_LED_SELECTOR = 411, + CV_CAP_PROP_XI_LED_MODE = 412, + CV_CAP_PROP_XI_MANUAL_WB = 413, + CV_CAP_PROP_XI_AUTO_WB = 414, + CV_CAP_PROP_XI_AEAG = 415, + CV_CAP_PROP_XI_EXP_PRIORITY = 416, + CV_CAP_PROP_XI_AE_MAX_LIMIT = 417, + CV_CAP_PROP_XI_AG_MAX_LIMIT = 418, + CV_CAP_PROP_XI_AEAG_LEVEL = 419, + CV_CAP_PROP_XI_TIMEOUT = 420, + CV_CAP_PROP_XI_EXPOSURE = 421, + CV_CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422, + CV_CAP_PROP_XI_GAIN_SELECTOR = 423, + CV_CAP_PROP_XI_GAIN = 424, + CV_CAP_PROP_XI_DOWNSAMPLING_TYPE = 426, + CV_CAP_PROP_XI_BINNING_SELECTOR = 427, + CV_CAP_PROP_XI_BINNING_VERTICAL = 428, + CV_CAP_PROP_XI_BINNING_HORIZONTAL = 429, + CV_CAP_PROP_XI_BINNING_PATTERN = 430, + CV_CAP_PROP_XI_DECIMATION_SELECTOR = 431, + CV_CAP_PROP_XI_DECIMATION_VERTICAL = 432, + CV_CAP_PROP_XI_DECIMATION_HORIZONTAL = 433, + CV_CAP_PROP_XI_DECIMATION_PATTERN = 434, + CV_CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587, + CV_CAP_PROP_XI_TEST_PATTERN = 588, + CV_CAP_PROP_XI_IMAGE_DATA_FORMAT = 435, + CV_CAP_PROP_XI_SHUTTER_TYPE = 436, + CV_CAP_PROP_XI_SENSOR_TAPS = 437, + CV_CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439, + CV_CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440, + CV_CAP_PROP_XI_AEAG_ROI_WIDTH = 441, + CV_CAP_PROP_XI_AEAG_ROI_HEIGHT = 442, + CV_CAP_PROP_XI_BPC = 445, + CV_CAP_PROP_XI_WB_KR = 448, + CV_CAP_PROP_XI_WB_KG = 449, + CV_CAP_PROP_XI_WB_KB = 450, + CV_CAP_PROP_XI_WIDTH = 451, + CV_CAP_PROP_XI_HEIGHT = 452, + CV_CAP_PROP_XI_REGION_SELECTOR = 589, + CV_CAP_PROP_XI_REGION_MODE = 595, + CV_CAP_PROP_XI_LIMIT_BANDWIDTH = 459, + CV_CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460, + CV_CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461, + CV_CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462, + CV_CAP_PROP_XI_OUTPUT_DATA_PACKING = 463, + CV_CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464, + CV_CAP_PROP_XI_IS_COOLED = 465, + CV_CAP_PROP_XI_COOLING = 466, + CV_CAP_PROP_XI_TARGET_TEMP = 467, + CV_CAP_PROP_XI_CHIP_TEMP = 468, + CV_CAP_PROP_XI_HOUS_TEMP = 469, + CV_CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590, + CV_CAP_PROP_XI_SENSOR_BOARD_TEMP = 596, + CV_CAP_PROP_XI_CMS = 470, + CV_CAP_PROP_XI_APPLY_CMS = 471, + CV_CAP_PROP_XI_IMAGE_IS_COLOR = 474, + CV_CAP_PROP_XI_COLOR_FILTER_ARRAY = 475, + CV_CAP_PROP_XI_GAMMAY = 476, + CV_CAP_PROP_XI_GAMMAC = 477, + CV_CAP_PROP_XI_SHARPNESS = 478, + CV_CAP_PROP_XI_CC_MATRIX_00 = 479, + CV_CAP_PROP_XI_CC_MATRIX_01 = 480, + CV_CAP_PROP_XI_CC_MATRIX_02 = 481, + CV_CAP_PROP_XI_CC_MATRIX_03 = 482, + CV_CAP_PROP_XI_CC_MATRIX_10 = 483, + CV_CAP_PROP_XI_CC_MATRIX_11 = 484, + CV_CAP_PROP_XI_CC_MATRIX_12 = 485, + CV_CAP_PROP_XI_CC_MATRIX_13 = 486, + CV_CAP_PROP_XI_CC_MATRIX_20 = 487, + CV_CAP_PROP_XI_CC_MATRIX_21 = 488, + CV_CAP_PROP_XI_CC_MATRIX_22 = 489, + CV_CAP_PROP_XI_CC_MATRIX_23 = 490, + CV_CAP_PROP_XI_CC_MATRIX_30 = 491, + CV_CAP_PROP_XI_CC_MATRIX_31 = 492, + CV_CAP_PROP_XI_CC_MATRIX_32 = 493, + CV_CAP_PROP_XI_CC_MATRIX_33 = 494, + CV_CAP_PROP_XI_DEFAULT_CC_MATRIX = 495, + CV_CAP_PROP_XI_TRG_SELECTOR = 498, + CV_CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499, + CV_CAP_PROP_XI_DEBOUNCE_EN = 507, + CV_CAP_PROP_XI_DEBOUNCE_T0 = 508, + CV_CAP_PROP_XI_DEBOUNCE_T1 = 509, + CV_CAP_PROP_XI_DEBOUNCE_POL = 510, + CV_CAP_PROP_XI_LENS_MODE = 511, + CV_CAP_PROP_XI_LENS_APERTURE_VALUE = 512, + CV_CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513, + CV_CAP_PROP_XI_LENS_FOCUS_MOVE = 514, + CV_CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515, + CV_CAP_PROP_XI_LENS_FOCAL_LENGTH = 516, + CV_CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517, + CV_CAP_PROP_XI_LENS_FEATURE = 518, + CV_CAP_PROP_XI_DEVICE_MODEL_ID = 521, + CV_CAP_PROP_XI_DEVICE_SN = 522, + CV_CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529, + CV_CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530, + CV_CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531, + CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532, + CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533, + CV_CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534, + CV_CAP_PROP_XI_FRAMERATE = 535, + CV_CAP_PROP_XI_COUNTER_SELECTOR = 536, + CV_CAP_PROP_XI_COUNTER_VALUE = 537, + CV_CAP_PROP_XI_ACQ_TIMING_MODE = 538, + CV_CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539, + CV_CAP_PROP_XI_BUFFER_POLICY = 540, + CV_CAP_PROP_XI_LUT_EN = 541, + CV_CAP_PROP_XI_LUT_INDEX = 542, + CV_CAP_PROP_XI_LUT_VALUE = 543, + CV_CAP_PROP_XI_TRG_DELAY = 544, + CV_CAP_PROP_XI_TS_RST_MODE = 545, + CV_CAP_PROP_XI_TS_RST_SOURCE = 546, + CV_CAP_PROP_XI_IS_DEVICE_EXIST = 547, + CV_CAP_PROP_XI_ACQ_BUFFER_SIZE = 548, + CV_CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549, + CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550, + CV_CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551, + CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552, + CV_CAP_PROP_XI_RECENT_FRAME = 553, + CV_CAP_PROP_XI_DEVICE_RESET = 554, + CV_CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555, + CV_CAP_PROP_XI_ROW_FPN_CORRECTION = 591, + CV_CAP_PROP_XI_SENSOR_MODE = 558, + CV_CAP_PROP_XI_HDR = 559, + CV_CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560, + CV_CAP_PROP_XI_HDR_T1 = 561, + CV_CAP_PROP_XI_HDR_T2 = 562, + CV_CAP_PROP_XI_KNEEPOINT1 = 563, + CV_CAP_PROP_XI_KNEEPOINT2 = 564, + CV_CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565, + CV_CAP_PROP_XI_HW_REVISION = 571, + CV_CAP_PROP_XI_DEBUG_LEVEL = 572, + CV_CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573, + CV_CAP_PROP_XI_FFS_FILE_ID = 594, + CV_CAP_PROP_XI_FFS_FILE_SIZE = 580, + CV_CAP_PROP_XI_FREE_FFS_SIZE = 581, + CV_CAP_PROP_XI_USED_FFS_SIZE = 582, + CV_CAP_PROP_XI_FFS_ACCESS_KEY = 583, + CV_CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585, + CV_CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586, + CV_CAP_PROP_ANDROID_FLASH_MODE = 8001, + CV_CAP_PROP_ANDROID_FOCUS_MODE = 8002, + CV_CAP_PROP_ANDROID_WHITE_BALANCE = 8003, + CV_CAP_PROP_ANDROID_ANTIBANDING = 8004, + CV_CAP_PROP_ANDROID_FOCAL_LENGTH = 8005, + CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR = 8006, + CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007, + CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR = 8008, + CV_CAP_PROP_ANDROID_EXPOSE_LOCK = 8009, + CV_CAP_PROP_ANDROID_WHITEBALANCE_LOCK = 8010, + CV_CAP_PROP_IOS_DEVICE_FOCUS = 9001, + CV_CAP_PROP_IOS_DEVICE_EXPOSURE = 9002, + CV_CAP_PROP_IOS_DEVICE_FLASH = 9003, + CV_CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004, + CV_CAP_PROP_IOS_DEVICE_TORCH = 9005, + CV_CAP_PROP_GIGA_FRAME_OFFSET_X = 10001, + CV_CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002, + CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003, + CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004, + CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005, + CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006, + CV_CAP_PROP_INTELPERC_PROFILE_COUNT = 11001, + CV_CAP_PROP_INTELPERC_PROFILE_IDX = 11002, + CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003, + CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004, + CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005, + CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006, + CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007, + CV_CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29, + CV_CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28, + CV_CAP_INTELPERC_GENERATORS_MASK = CV_CAP_INTELPERC_DEPTH_GENERATOR + CV_CAP_INTELPERC_IMAGE_GENERATOR, + CV_CAP_MODE_BGR = 0, + CV_CAP_MODE_RGB = 1, + CV_CAP_MODE_GRAY = 2, + CV_CAP_MODE_YUYV = 3, + CV_CAP_OPENNI_DEPTH_MAP = 0, + CV_CAP_OPENNI_POINT_CLOUD_MAP = 1, + CV_CAP_OPENNI_DISPARITY_MAP = 2, + CV_CAP_OPENNI_DISPARITY_MAP_32F = 3, + CV_CAP_OPENNI_VALID_DEPTH_MASK = 4, + CV_CAP_OPENNI_BGR_IMAGE = 5, + CV_CAP_OPENNI_GRAY_IMAGE = 6, + CV_CAP_OPENNI_IR_IMAGE = 7, + CV_CAP_OPENNI_VGA_30HZ = 0, + CV_CAP_OPENNI_SXGA_15HZ = 1, + CV_CAP_OPENNI_SXGA_30HZ = 2, + CV_CAP_OPENNI_QVGA_30HZ = 3, + CV_CAP_OPENNI_QVGA_60HZ = 4, + CV_CAP_INTELPERC_DEPTH_MAP = 0, + CV_CAP_INTELPERC_UVDEPTH_MAP = 1, + CV_CAP_INTELPERC_IR_MAP = 2, + CV_CAP_INTELPERC_IMAGE = 3, + CV_CAP_PROP_GPHOTO2_PREVIEW = 17001, + CV_CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002, + CV_CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003, + CV_CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004, + CV_CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005, + CV_CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006, + CV_CAP_PROP_SPEED = 17007, + CV_CAP_PROP_APERTURE = 17008, + CV_CAP_PROP_EXPOSUREPROGRAM = 17009, + CV_CAP_PROP_VIEWFINDER = 17010, + CAP_ANY = 0, + CAP_VFW = 200, + CAP_V4L = 200, + CAP_V4L2 = CAP_V4L, + CAP_FIREWIRE = 300, + CAP_FIREWARE = CAP_FIREWIRE, + CAP_IEEE1394 = CAP_FIREWIRE, + CAP_DC1394 = CAP_FIREWIRE, + CAP_CMU1394 = CAP_FIREWIRE, + CAP_QT = 500, + CAP_UNICAP = 600, + CAP_DSHOW = 700, + CAP_PVAPI = 800, + CAP_OPENNI = 900, + CAP_OPENNI_ASUS = 910, + CAP_ANDROID = 1000, + CAP_XIAPI = 1100, + CAP_AVFOUNDATION = 1200, + CAP_GIGANETIX = 1300, + CAP_MSMF = 1400, + CAP_WINRT = 1410, + CAP_INTELPERC = 1500, + CAP_OPENNI2 = 1600, + CAP_OPENNI2_ASUS = 1610, + CAP_GPHOTO2 = 1700, + CAP_GSTREAMER = 1800, + CAP_FFMPEG = 1900, + CAP_IMAGES = 2000, + CAP_ARAVIS = 2100, + CAP_OPENCV_MJPEG = 2200, + CAP_INTEL_MFX = 2300, + CAP_PROP_POS_MSEC = 0, + CAP_PROP_POS_FRAMES = 1, + CAP_PROP_POS_AVI_RATIO = 2, + CAP_PROP_FRAME_WIDTH = 3, + CAP_PROP_FRAME_HEIGHT = 4, + CAP_PROP_FPS = 5, + CAP_PROP_FOURCC = 6, + CAP_PROP_FRAME_COUNT = 7, + CAP_PROP_FORMAT = 8, + CAP_PROP_MODE = 9, + CAP_PROP_BRIGHTNESS = 10, + CAP_PROP_CONTRAST = 11, + CAP_PROP_SATURATION = 12, + CAP_PROP_HUE = 13, + CAP_PROP_GAIN = 14, + CAP_PROP_EXPOSURE = 15, + CAP_PROP_CONVERT_RGB = 16, + CAP_PROP_WHITE_BALANCE_BLUE_U = 17, + CAP_PROP_RECTIFICATION = 18, + CAP_PROP_MONOCHROME = 19, + CAP_PROP_SHARPNESS = 20, + CAP_PROP_AUTO_EXPOSURE = 21, + CAP_PROP_GAMMA = 22, + CAP_PROP_TEMPERATURE = 23, + CAP_PROP_TRIGGER = 24, + CAP_PROP_TRIGGER_DELAY = 25, + CAP_PROP_WHITE_BALANCE_RED_V = 26, + CAP_PROP_ZOOM = 27, + CAP_PROP_FOCUS = 28, + CAP_PROP_GUID = 29, + CAP_PROP_ISO_SPEED = 30, + CAP_PROP_BACKLIGHT = 32, + CAP_PROP_PAN = 33, + CAP_PROP_TILT = 34, + CAP_PROP_ROLL = 35, + CAP_PROP_IRIS = 36, + CAP_PROP_SETTINGS = 37, + CAP_PROP_BUFFERSIZE = 38, + CAP_PROP_AUTOFOCUS = 39, + CAP_MODE_BGR = 0, + CAP_MODE_RGB = 1, + CAP_MODE_GRAY = 2, + CAP_MODE_YUYV = 3, + VIDEOWRITER_PROP_QUALITY = 1, + VIDEOWRITER_PROP_FRAMEBYTES = 2, + VIDEOWRITER_PROP_NSTRIPES = 3, + CAP_PROP_DC1394_OFF = -4, + CAP_PROP_DC1394_MODE_MANUAL = -3, + CAP_PROP_DC1394_MODE_AUTO = -2, + CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1, + CAP_PROP_DC1394_MAX = 31, + CAP_OPENNI_DEPTH_GENERATOR = 1 << 31, + CAP_OPENNI_IMAGE_GENERATOR = 1 << 30, + CAP_OPENNI_IR_GENERATOR = 1 << 29, + CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR, + CAP_PROP_OPENNI_OUTPUT_MODE = 100, + CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, + CAP_PROP_OPENNI_BASELINE = 102, + CAP_PROP_OPENNI_FOCAL_LENGTH = 103, + CAP_PROP_OPENNI_REGISTRATION = 104, + CAP_PROP_OPENNI_REGISTRATION_ON = CAP_PROP_OPENNI_REGISTRATION, + CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105, + CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106, + CAP_PROP_OPENNI_CIRCLE_BUFFER = 107, + CAP_PROP_OPENNI_MAX_TIME_DURATION = 108, + CAP_PROP_OPENNI_GENERATOR_PRESENT = 109, + CAP_PROP_OPENNI2_SYNC = 110, + CAP_PROP_OPENNI2_MIRROR = 111, + CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT, + CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE, + CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT, + CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE, + CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH, + CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION, + CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION, + CAP_OPENNI_IR_GENERATOR_PRESENT = CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT, + CAP_OPENNI_DEPTH_MAP = 0, + CAP_OPENNI_POINT_CLOUD_MAP = 1, + CAP_OPENNI_DISPARITY_MAP = 2, + CAP_OPENNI_DISPARITY_MAP_32F = 3, + CAP_OPENNI_VALID_DEPTH_MASK = 4, + CAP_OPENNI_BGR_IMAGE = 5, + CAP_OPENNI_GRAY_IMAGE = 6, + CAP_OPENNI_IR_IMAGE = 7, + CAP_OPENNI_VGA_30HZ = 0, + CAP_OPENNI_SXGA_15HZ = 1, + CAP_OPENNI_SXGA_30HZ = 2, + CAP_OPENNI_QVGA_30HZ = 3, + CAP_OPENNI_QVGA_60HZ = 4, + CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200, + CAP_PROP_PVAPI_MULTICASTIP = 300, + CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, + CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302, + CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303, + CAP_PROP_PVAPI_BINNINGX = 304, + CAP_PROP_PVAPI_BINNINGY = 305, + CAP_PROP_PVAPI_PIXELFORMAT = 306, + CAP_PVAPI_FSTRIGMODE_FREERUN = 0, + CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1, + CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2, + CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3, + CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4, + CAP_PVAPI_DECIMATION_OFF = 1, + CAP_PVAPI_DECIMATION_2OUTOF4 = 2, + CAP_PVAPI_DECIMATION_2OUTOF8 = 4, + CAP_PVAPI_DECIMATION_2OUTOF16 = 8, + CAP_PVAPI_PIXELFORMAT_MONO8 = 1, + CAP_PVAPI_PIXELFORMAT_MONO16 = 2, + CAP_PVAPI_PIXELFORMAT_BAYER8 = 3, + CAP_PVAPI_PIXELFORMAT_BAYER16 = 4, + CAP_PVAPI_PIXELFORMAT_RGB24 = 5, + CAP_PVAPI_PIXELFORMAT_BGR24 = 6, + CAP_PVAPI_PIXELFORMAT_RGBA32 = 7, + CAP_PVAPI_PIXELFORMAT_BGRA32 = 8, + CAP_PROP_XI_DOWNSAMPLING = 400, + CAP_PROP_XI_DATA_FORMAT = 401, + CAP_PROP_XI_OFFSET_X = 402, + CAP_PROP_XI_OFFSET_Y = 403, + CAP_PROP_XI_TRG_SOURCE = 404, + CAP_PROP_XI_TRG_SOFTWARE = 405, + CAP_PROP_XI_GPI_SELECTOR = 406, + CAP_PROP_XI_GPI_MODE = 407, + CAP_PROP_XI_GPI_LEVEL = 408, + CAP_PROP_XI_GPO_SELECTOR = 409, + CAP_PROP_XI_GPO_MODE = 410, + CAP_PROP_XI_LED_SELECTOR = 411, + CAP_PROP_XI_LED_MODE = 412, + CAP_PROP_XI_MANUAL_WB = 413, + CAP_PROP_XI_AUTO_WB = 414, + CAP_PROP_XI_AEAG = 415, + CAP_PROP_XI_EXP_PRIORITY = 416, + CAP_PROP_XI_AE_MAX_LIMIT = 417, + CAP_PROP_XI_AG_MAX_LIMIT = 418, + CAP_PROP_XI_AEAG_LEVEL = 419, + CAP_PROP_XI_TIMEOUT = 420, + CAP_PROP_XI_EXPOSURE = 421, + CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422, + CAP_PROP_XI_GAIN_SELECTOR = 423, + CAP_PROP_XI_GAIN = 424, + CAP_PROP_XI_DOWNSAMPLING_TYPE = 426, + CAP_PROP_XI_BINNING_SELECTOR = 427, + CAP_PROP_XI_BINNING_VERTICAL = 428, + CAP_PROP_XI_BINNING_HORIZONTAL = 429, + CAP_PROP_XI_BINNING_PATTERN = 430, + CAP_PROP_XI_DECIMATION_SELECTOR = 431, + CAP_PROP_XI_DECIMATION_VERTICAL = 432, + CAP_PROP_XI_DECIMATION_HORIZONTAL = 433, + CAP_PROP_XI_DECIMATION_PATTERN = 434, + CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587, + CAP_PROP_XI_TEST_PATTERN = 588, + CAP_PROP_XI_IMAGE_DATA_FORMAT = 435, + CAP_PROP_XI_SHUTTER_TYPE = 436, + CAP_PROP_XI_SENSOR_TAPS = 437, + CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439, + CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440, + CAP_PROP_XI_AEAG_ROI_WIDTH = 441, + CAP_PROP_XI_AEAG_ROI_HEIGHT = 442, + CAP_PROP_XI_BPC = 445, + CAP_PROP_XI_WB_KR = 448, + CAP_PROP_XI_WB_KG = 449, + CAP_PROP_XI_WB_KB = 450, + CAP_PROP_XI_WIDTH = 451, + CAP_PROP_XI_HEIGHT = 452, + CAP_PROP_XI_REGION_SELECTOR = 589, + CAP_PROP_XI_REGION_MODE = 595, + CAP_PROP_XI_LIMIT_BANDWIDTH = 459, + CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460, + CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461, + CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462, + CAP_PROP_XI_OUTPUT_DATA_PACKING = 463, + CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464, + CAP_PROP_XI_IS_COOLED = 465, + CAP_PROP_XI_COOLING = 466, + CAP_PROP_XI_TARGET_TEMP = 467, + CAP_PROP_XI_CHIP_TEMP = 468, + CAP_PROP_XI_HOUS_TEMP = 469, + CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590, + CAP_PROP_XI_SENSOR_BOARD_TEMP = 596, + CAP_PROP_XI_CMS = 470, + CAP_PROP_XI_APPLY_CMS = 471, + CAP_PROP_XI_IMAGE_IS_COLOR = 474, + CAP_PROP_XI_COLOR_FILTER_ARRAY = 475, + CAP_PROP_XI_GAMMAY = 476, + CAP_PROP_XI_GAMMAC = 477, + CAP_PROP_XI_SHARPNESS = 478, + CAP_PROP_XI_CC_MATRIX_00 = 479, + CAP_PROP_XI_CC_MATRIX_01 = 480, + CAP_PROP_XI_CC_MATRIX_02 = 481, + CAP_PROP_XI_CC_MATRIX_03 = 482, + CAP_PROP_XI_CC_MATRIX_10 = 483, + CAP_PROP_XI_CC_MATRIX_11 = 484, + CAP_PROP_XI_CC_MATRIX_12 = 485, + CAP_PROP_XI_CC_MATRIX_13 = 486, + CAP_PROP_XI_CC_MATRIX_20 = 487, + CAP_PROP_XI_CC_MATRIX_21 = 488, + CAP_PROP_XI_CC_MATRIX_22 = 489, + CAP_PROP_XI_CC_MATRIX_23 = 490, + CAP_PROP_XI_CC_MATRIX_30 = 491, + CAP_PROP_XI_CC_MATRIX_31 = 492, + CAP_PROP_XI_CC_MATRIX_32 = 493, + CAP_PROP_XI_CC_MATRIX_33 = 494, + CAP_PROP_XI_DEFAULT_CC_MATRIX = 495, + CAP_PROP_XI_TRG_SELECTOR = 498, + CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499, + CAP_PROP_XI_DEBOUNCE_EN = 507, + CAP_PROP_XI_DEBOUNCE_T0 = 508, + CAP_PROP_XI_DEBOUNCE_T1 = 509, + CAP_PROP_XI_DEBOUNCE_POL = 510, + CAP_PROP_XI_LENS_MODE = 511, + CAP_PROP_XI_LENS_APERTURE_VALUE = 512, + CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513, + CAP_PROP_XI_LENS_FOCUS_MOVE = 514, + CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515, + CAP_PROP_XI_LENS_FOCAL_LENGTH = 516, + CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517, + CAP_PROP_XI_LENS_FEATURE = 518, + CAP_PROP_XI_DEVICE_MODEL_ID = 521, + CAP_PROP_XI_DEVICE_SN = 522, + CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529, + CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530, + CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531, + CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532, + CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533, + CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534, + CAP_PROP_XI_FRAMERATE = 535, + CAP_PROP_XI_COUNTER_SELECTOR = 536, + CAP_PROP_XI_COUNTER_VALUE = 537, + CAP_PROP_XI_ACQ_TIMING_MODE = 538, + CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539, + CAP_PROP_XI_BUFFER_POLICY = 540, + CAP_PROP_XI_LUT_EN = 541, + CAP_PROP_XI_LUT_INDEX = 542, + CAP_PROP_XI_LUT_VALUE = 543, + CAP_PROP_XI_TRG_DELAY = 544, + CAP_PROP_XI_TS_RST_MODE = 545, + CAP_PROP_XI_TS_RST_SOURCE = 546, + CAP_PROP_XI_IS_DEVICE_EXIST = 547, + CAP_PROP_XI_ACQ_BUFFER_SIZE = 548, + CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549, + CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550, + CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551, + CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552, + CAP_PROP_XI_RECENT_FRAME = 553, + CAP_PROP_XI_DEVICE_RESET = 554, + CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555, + CAP_PROP_XI_ROW_FPN_CORRECTION = 591, + CAP_PROP_XI_SENSOR_MODE = 558, + CAP_PROP_XI_HDR = 559, + CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560, + CAP_PROP_XI_HDR_T1 = 561, + CAP_PROP_XI_HDR_T2 = 562, + CAP_PROP_XI_KNEEPOINT1 = 563, + CAP_PROP_XI_KNEEPOINT2 = 564, + CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565, + CAP_PROP_XI_HW_REVISION = 571, + CAP_PROP_XI_DEBUG_LEVEL = 572, + CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573, + CAP_PROP_XI_FFS_FILE_ID = 594, + CAP_PROP_XI_FFS_FILE_SIZE = 580, + CAP_PROP_XI_FREE_FFS_SIZE = 581, + CAP_PROP_XI_USED_FFS_SIZE = 582, + CAP_PROP_XI_FFS_ACCESS_KEY = 583, + CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585, + CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586, + CAP_PROP_IOS_DEVICE_FOCUS = 9001, + CAP_PROP_IOS_DEVICE_EXPOSURE = 9002, + CAP_PROP_IOS_DEVICE_FLASH = 9003, + CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004, + CAP_PROP_IOS_DEVICE_TORCH = 9005, + CAP_PROP_GIGA_FRAME_OFFSET_X = 10001, + CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002, + CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003, + CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004, + CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005, + CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006, + CAP_PROP_INTELPERC_PROFILE_COUNT = 11001, + CAP_PROP_INTELPERC_PROFILE_IDX = 11002, + CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003, + CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004, + CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005, + CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006, + CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007, + CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29, + CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28, + CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR, + CAP_INTELPERC_DEPTH_MAP = 0, + CAP_INTELPERC_UVDEPTH_MAP = 1, + CAP_INTELPERC_IR_MAP = 2, + CAP_INTELPERC_IMAGE = 3, + CAP_PROP_GPHOTO2_PREVIEW = 17001, + CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002, + CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003, + CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004, + CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005, + CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006, + CAP_PROP_SPEED = 17007, + CAP_PROP_APERTURE = 17008, + CAP_PROP_EXPOSUREPROGRAM = 17009, + CAP_PROP_VIEWFINDER = 17010, + CAP_PROP_IMAGES_BASE = 18000, + CAP_PROP_IMAGES_LAST = 19000; + + + + +} diff --git a/openCVLibrary330/src/main/res/values/attrs.xml b/openCVLibrary330/src/main/res/values/attrs.xml new file mode 100644 index 00000000000..6902621f66b --- /dev/null +++ b/openCVLibrary330/src/main/res/values/attrs.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/settings.gradle b/settings.gradle index 9e2cfb3b4b0..044f98690f5 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,3 @@ -include ':FtcRobotController' +include ':FtcRobotController', ':DogeCV' include ':TeamCode' +include ':openCVLibrary330'