diff --git a/lib/javacv-bin/CHANGELOG.md b/lib/javacv-bin/CHANGELOG.md new file mode 100644 index 0000000..11da337 --- /dev/null +++ b/lib/javacv-bin/CHANGELOG.md @@ -0,0 +1,473 @@ + +### October 25, 2015 version 1.1 + * Make `FrameConverter` for images return `null` when `Frame.image == null` ([issue #249](https://github.com/bytedeco/javacv/issues/249)) + * Add `FFmpegLogCallback` to redirect easily to Java log messages from FFmpeg + * Upgrade all Maven dependencies and plugins to latest versions, thus bumping minimum requirements to Java SE 7, Android 4.0, and Maven 3.0 + * Fix broken `FFmpegFrameGrabber.grabImage()` after `setTimestamp()` ([issue #236](https://github.com/bytedeco/javacv/issues/236)) + * Add `FFmpegFrameGrabber.grabSamples()` to grab only audio samples, and ignore video frames ([issue #235](https://github.com/bytedeco/javacv/issues/235)) + * Fix broken `setVideoCodecName()` and `setAudioCodecName()` for `FFmpegFrameRecorder` ([issue #229](https://github.com/bytedeco/javacv/issues/229)) + * Remove `FaceRecognition.java` sample, which requires the deprecated `opencv_legacy` module ([issue #200](https://github.com/bytedeco/javacv/issues/200)) + * Fix potential crash in `ObjectFinder` with FLANN ([issue #210](https://github.com/bytedeco/javacv/issues/210)) + * Add `FFmpegFrameFilter` to let users process `Frame` images with `libavfilter` easily ([issue #164](https://github.com/bytedeco/javacv/issues/164)) + * Add `FaceRecognizerInVideo.java` sample that does a combo of face detection and recognition ([issue #203](https://github.com/bytedeco/javacv/issues/203)) + * Return `AVStream.r_frame_rate` when `AVStream.avg_frame_rate` is invalid in `FFmpegFrameGrabber.getFrameRate()` ([issue #292](https://code.google.com/p/javacv/issues/detail?id=292)) + * Update some samples to make them work with OpenCV 3.0 + * Add new convenience `FFmpegFrameRecorder.record(Frame frame, int pixelFormat)` method ([issue #181](https://github.com/bytedeco/javacv/issues/181)) + * Let `Java2DFrameConverter.copy()` from `ByteBuffer` with 4 channels to `BufferedImage.TYPE_INT_RGB`, among others, also taking into account the `flipChannels` argument ([issue #181](https://github.com/bytedeco/javacv/issues/181)) + +### July 11, 2015 version 1.0 + * Offer the Apache License, Version 2.0, as a new choice of license, in addition to the GPLv2 with Classpath exception + * Upgrade support to OpenCV 3.0.0 + * Upgrade supported FFmpeg API to the 2.7 release branch + * Switch descriptor used by `ObjectFinder` from SURF to AKAZE + * Let users get resized images from `FFmpegFrameGrabber` by calling `setImageWidth()` and `setImageHeight()` before `start()` + * Add check for supported display size in the `RecordActivity` sample ([pull #153](https://github.com/bytedeco/javacv/pull/153)) + * Clarify the semantics of `FrameConverter` ([issue #150](https://github.com/bytedeco/javacv/issues/150)) + * Fix `FFmpegFrameRecorder` not saving the last few frames, especially when encoding with x264 ([issue #50](https://github.com/bytedeco/javacv/issues/50)) + * Add `FrameConverterTest` and fix a couple of bugs uncovered by it + * Make `Frame implements Indexable` for easy and efficient access to image pixels + * Fix `AbstractMethodError` thrown from `OpenCVFrameConverter` on some versions of the JDK ([issue #143](https://github.com/bytedeco/javacv/issues/143)) + * Add `FFmpegFrameGrabber.grabImage()` method to restore the functionality previously provided by `IplImage grab()` ([issue #116](https://github.com/bytedeco/javacv/issues/116)) + * Give users of `FFmpegFrameGrabber` and `FFmpegFrameRecorder` access to more options and metadata ([issue #132](https://github.com/bytedeco/javacv/issues/132)) + * Add the ability to specify from which video and audio streams `FFmpegFrameGrabber` should grab from ([issue #135](https://github.com/bytedeco/javacv/issues/135)) + * Fix `Java2DFrameConverter` when used with `BufferedImage.TYPE_INT_RGB` or other types based on `int` ([issue #140](https://github.com/bytedeco/javacv/issues/140)) + * Add new `WebcamAndMicrophoneCapture` sample ([pull #131](https://github.com/bytedeco/javacv/pull/131)) + * Add `aspectRatio` property to `FrameGrabber` and `FrameRecorder`, to be able to use pixel aspect ratios other than 1.0 ([issue #90](https://github.com/bytedeco/javacv/issues/90)) + +### April 4, 2015 version 0.11 + * Upgrade support to OpenCV 2.4.11 + * Upgrade supported FFmpeg API to the 2.6 release branch + * Add new `Square` sample, thanks to Geir Ruud + * Add `AndroidFrameConverter`, `Java2DFrameConverter` and `OpenCVFrameConverter`, and use them to refactor `Frame`, `CanvasFrame`, `FrameGrabber`, and `FrameRecorder` in a way to help users avoid coupling with Android, Java 2D, or OpenCV ([issue #84](https://github.com/bytedeco/javacv/issues/84)) + * Fix `Demo` class in the `README.md` file ([issue #102](https://github.com/bytedeco/javacv/issues/102)) + * Add new `ColoredObjectTrack` sample ([pull #99](https://github.com/bytedeco/javacv/pull/99)) + * Add `option` property to `FFmpegFrameGrabber` to let users set such things as "analyzeduration", "probesize", or "list_devices" + * Fix "AVFrame.format is not set" and "AVFrame.width or height is not set" warning messages ([issue #76](https://github.com/bytedeco/javacv/issues/76)) + +### December 23, 2014 version 0.10 + * Upgrade support to OpenCV 2.4.10 + * Upgrade supported FFmpeg API to the 2.5 release branch + * Fix `time_base` warnings displayed by `FFmpegFrameRecorder` ([issue #75](https://github.com/bytedeco/javacv/issues/75)) + * Add new `TemplateMatching` sample, thanks to Waldemar Neto + * Update instructions in the `README.md` file for manual installation in Android Studio + * Replace deprecated `CvMat` and `IplImage` functionality used in the `Demo` class with new `Indexer` API, and provide sample `pom.xml` file for Maven + * Make `FFmpegFrameGrabber.getFrameRate()` return `AVStream.avg_frame_rate` instead of `r_frame_rate` ([issue #63](https://github.com/bytedeco/javacv/issues/63)) + * Disable DocLint, which prevents the build from succeeding on Java 8 ([issue bytedeco/javacpp#5](https://github.com/bytedeco/javacpp/issues/5)) + * Add `FlyCapture2FrameGrabber` with cross-platform support of FlyCapture2 ([pull #45](https://github.com/bytedeco/javacv/pull/45)) + * Fix issue that would prevent `CanvasFrame` from working on Mac OS X with recent versions of the JDK ([issue #39](https://github.com/bytedeco/javacv/issues/39) and [issue #314](http://code.google.com/p/javacv/issues/detail?id=314)) + * Upgrade `RecordActivity` sample with a continuous record loop, thanks to Federico Sendra and Juan Manuel Sobral + * Make `FrameGrabber.createDefault()` throw an exception on unsupported input, instead of returning a cryptic `null` ([issue #30](https://github.com/bytedeco/javacv/issues/30)) + * Add `videoCodec`, `videoBitrate`, `audioCodec`, and `audioBitrate` properties to `FrameGrabber` + * Work around `avcodec` and `avdevice` not loading properly for `FFmpegFrameGrabber` and `FFmpegFrameRecorder` ([issue #24](https://github.com/bytedeco/javacv/issues/24)) + * Do key frame detection in `FFmpegFrameRecorder` based on `AVPacket`, not `AVPicture` ([pull #20](https://github.com/bytedeco/javacv/pull/20)) + +### July 27, 2014 version 0.9 + * Remove `platform` property from `pom.xml`, replaced with the `platform.dependency` one in JavaCPP Presets ([issue #10](https://github.com/bytedeco/javacv/issues/10)) + * Add new `RLSA` sample, thanks to Nicholas Woodward ([issue #469](http://code.google.com/p/javacv/issues/detail?id=469)) + * Fix a timestamp rounding issue in `FFmpegFrameGrabber` that causes `setFrameNumber()` to sometimes pick the wrong frame if FPS is not a proper divisor of 1000000 ([issue #5](https://github.com/bytedeco/javacv/issues/5)) + * Increase the flexibility of the `pom.xml` file by making it possible to specify a custom version of JavaCPP + * Add missing dependencies for JogAmp in the `pom.xml` file ([issue #2](https://github.com/bytedeco/javacv/issues/2)) + * Add new `OpenCVFaceRecognizer` sample, thanks to Petter Christian Bjelland + * Add new `OpticalFlowDense` sample, thanks to Dawit Gebreyohannes ([issue #468](http://code.google.com/p/javacv/issues/detail?id=468)) + * Make it easier to try out the `FaceRecognition.java` sample ([issue #1](https://github.com/bytedeco/javacv/issues/1)) + +### April 28, 2014 version 0.8 + * Move from Google Code to GitHub as main source code repository + * Upgrade support to OpenCV 2.4.9 + * Upgrade supported FFmpeg API to the 2.2 release branch + * Fix `FFmpegFrameRecorder` not refreshing the resampler when the format of samples changes (issue #465) + * Rename the `com.googlecode.javacv.cpp` package to `org.bytedeco.javacpp`, and `com.googlecode.javacv` to `org.bytedeco.javacv` + * Removed old NetBeans project files that cause a conflict when trying to open as a Maven project (issue #210) + * Adjusted the samples a bit because of small changes in the API with the move to the JavaCPP Presets + * Fixed `ObjectFinder` not working with recent versions of OpenCV, especially on Android (issue #214) + * Added new `FrameRecorder.gopSize` property to let users set a desired GOP size instead of the default one of 12 + * `FFmpegFrameGrabber` now takes into account calls to `setPixelFormat()` (issue #429), but does not enforce it + * Added a `Frame.audioChannels` field for resampling purposes in `FFmpegFrameRecorder` (issue #388) + * In `FFmpegFrameRecorder`, fixed audio encoding with the Vorbis codec (issue #428) and the WebM container (issue #435), and other audio related things + * Added missing `allocateArray()` constructors to `CameraParams` and `MatchesInfo` (issue #421) + * Fixed errors such as "jniopencv_nonfree.dll: Can't find dependent libraries" by adding the `opencv_ocl` module as dependency + * Added support to seek in audio-only streams with `FFmpegFrameGrabber.setTimestamp()` (issue #417) + * Fixed potential thread concurrency issues and crash in the `stopRecording()` and `onDestroy()` methods of the `RecordActivity` sample, thanks to Jacob Duron + * To capture the last frame of a video file, reverted `FFmpegFrameGrabber.setTimestamp()` to its previous behavior (issue #413) + * Updated `samples/FaceApplet.jnlp` to make it work with JDK/JRE 7u45 + +### January 6, 2014 version 0.7 + * Upgraded support to OpenCV 2.4.8 + * Upgraded supported FFmpeg API to the 2.1 release branch + * Updated `freenect` to reflect the latest changes of OpenKinect's master branch + * Updated `videoInput` to reflect the latest changes in the "update2013" branch + * Added `Frame.opaque` field to give access to the raw `AVFrame` in the case of `FFmpegFrameGrabber` (issue #399) + * Added new `FFmpegFrameGrabber.grabKeyFrame()` method to grab key frames (I-frames) directly (issue #312) + * `VideoInputFrameGrabber` now uses 640x480 as default image size to prevent "videoInput.getPixels() Error: Could not get pixels." + * Fixed `FFmpegFrameGrabber.setTimestamp()` not working for streams with audio (issue #398) + * Fixed wrong `haarcascade_frontalface_alt.xml` file getting downloaded by the `Demo` class (issue #402) + * Added a `Frame.sampleRate` field to allow audio samples to be resampled by `FFmpegFrameRecorder` (issue #388) + * Incorporated `IPCameraFrameGrabber` from Greg Perry (issue #384) + * Fixed thread safety issues with FFmpeg in `FFmpegFrameGrabber` and `FFmpegFrameRecorder` (issue #377) + * Fixed memory leak in the `MotionDetector.java` sample file (issue #372) + * New `videoCodecName` and `audioCodecName` properties to allow users of `FFmpegFrameRecorder` to use codecs such as "libx264rgb" (issue #369) + +### September 15, 2013 version 0.6 + * Upgraded supported FFmpeg API to the 2.0 release branch (with Java interface files now based on code automatically produced by [JavaCPP Presets](https://github.com/bytedeco/javacpp-presets)) + * Fixed `FFmpegFrameGrabber.getFrameNumber()` + * Upgraded support to OpenCV 2.4.6 + * Fixed callbacks when used with custom class loaders such as with Web containers + * Upgraded to ARToolKitPlus 2.3.0 (issue #234) + * Fixed drawing issues with `MarkerDetector.draw()` + * Fixed `FFmpegFrameGrabber.getTimestamp()` not returning values for audio frames (issue #328) + * Added new `Frame.keyFrame` field returned by `FFmpegFrameGrabber.grabFrame()` to know when a grabbed frame is a key frame or not (issue #312) + * Worked around problem in `samples/RecordActivity.java` that would happen when trying to record a frame with an invalid timestamp (issue #313) + * Fixed potential resource leak that could occur after `FFmpegFrameRecorder` throwing an `Exception` + * Fixed `FFmpegFrameGrabber` not returning the last few frames of video streams (issue #315) + * Fixed wrong dependencies of OpenCV preventing correct loading (issue #304) + * Renamed `FrameRecorder.record(Buffer[] samples)` to a cleaner `record(Buffer ... samples)` (issue #303) + * Fixed `FFmpegFrameRecorder` not flushing buffers on `stop()` (issue #302) + +### April 7, 2013 version 0.5 + * Upgraded support to OpenCV 2.4.5 + * Upgraded supported FFmpeg API to the 1.2 release branch + * New methods `FFmpegFrameRecorder.setVideoOption()` and `setAudioOption()` generalize the way to set arbitrary codec options, such as "profile", "preset", "tune", etc. used by the x264 codec + * Included better format guessing inside `FFmpegFrameRecorder` for protocols like RTP + * Added support for planar audio formats to `FFmpegFrameGrabber` and `FFmpegFrameRecorder`, as required by newer versions of FFmpeg for at least MP3 and AAC + * Enhanced `FFmpegFrameRecorder` by making it use the closest supported frame rate for the given codec instead of failing + * To support variable bitrate (VBR) encoding, appended new `videoQuality` and `audioQuality` properties to `FFmpegFrameRecorder`, which usually have an effective range of [0, 51] and overrides the `videoBitrate` and `audioBitrate` properties + +### March 3, 2013 version 0.4 + * Upgraded support to OpenCV 2.4.4 + * `CanvasFrame.waitKey(-1)` does not wait anymore and returns the last `KeyEvent` dispatched since the last call to it + * Upgraded supported FFmpeg API to the 1.1 release branch + * Fixed bug in `FaceRecognition.java` sample (issue #276) + * Included `Sobel()`, `Scharr()`, `Laplacian()`, and `Canny()` from `opencv_imgproc` whose equivalent functions in the C API have missing parameters + * Extended `OpenKinectFrameGrabber` with `setDepthFormat()` and `setVideoFormat()` methods to be able to set both formats independently (issue #273) + * Fixed `Blender.blend()` having its `@OutputMat` incorrectly annotated as `@InputMat` (issue #272) + * Added new `RecordActivity.java` Android sample from Shawn Van Every and Qianliang Zhang + * Added missing `allocate()` methods for `FunctionPointer` in `AVIOContext` and others, which prevented these FFmpeg callbacks from functioning + * Fixed infinite loop in `FrameGrabber.Array.grab()` (as used by ProCamCalib in the case of stereo cameras, issue #262) when `FrameGrabber.getTimestamp()` returns an invalid negative value (as with `opencv_highgui`) or when using different types of (unsynchronized) `FrameGrabber` together + * Fixed `cvQueryHistValue_1D()` and other functions that use a raw `CvArr` object + * Fixed problem when subclassing `CanvasFrame` + +### November 4, 2012 version 0.3 + * Upgraded support to OpenCV 2.4.3 (issue #233) + * Fixed functions like `Algorithm.getMat()` and `HOGDescriptor.getDefaultPeopleDetector()` returning `null` instead of the expected data + * Implemented better, more transparent, handling of `cv::Ptr` + * When allocating an empty `IplImage`, `CvMat`, `CvBGCodeBookModel`, etc. its memory content now gets zeroed out, giving OpenCV a better chance of displaying an error message instead of crashing + * Upgraded supported FFmpeg API to the 1.0 release branch + * Appended to `StringVector` and `MatVector` new convenient bulk constructors and `put()` methods taking arrays of `String`, `IplImage`, `CvMat`, etc. + * Included new `Blobs` module from David Grossman and the corresponding `BlobDemo` sample + * Added missing `opencv_core.partition()` function (issue #144) + * Fixed up the samples a bit (issue #229 and issue #230) + * Switched the majority of `@Adapter` annotations to more concise ones like `@StdVector` as allowed by new capabilities of JavaCPP + * Fixed `FFmpegFrameGrabber.getLengthInFrames()` and `OpenCVFrameGrabber.getLengthInTime()` (issue #231 and issue #236) + * Enhanced `FFmpegFrameRecorder` to support conversion between audio sample formats (for the experimental AAC encoder among other things) and to let two different threads call `record(samples)` and `record(image)` simultaneously, plus a couple of other features like `setFrameNumber()`, which lets users skip image frames (achieving variable frame rate) + * Added a `javacpp.skip` property to `pom.xml`, such that a command like `mvn package -Pall -Djavacpp.skip=true` only recompiles the Java source files, but also added `platform.root` and `compiler.path` properties, which map directly to JavaCPP's for convenience + +### July 21, 2012 version 0.2 + * Provided new `javacv-linux-arm.jar` build thanks to Jeremy Nicola (issue #184) + * Additional default properties inside `pom.xml` make it easier to build JavaCV from source (issue #202), calling `mvn package` now succeeds with only OpenCV and a C++ compiler for JavaCPP + * Made a few minor updates for OpenCV 2.4.2 + * New `Pointer.limit` property of JavaCPP can now be used to get the `size` of an output parameter, and to specify the maximum `size` on input as well + * Upgraded supported FFmpeg API to the 0.11 release branch + * Added audio support to `FFmpegFrameGrabber` (call `grabFrame()` instead of `grab()`) and `FFmpegFrameRecorder` (call `setAudioChannels()` before `start()`, and `record(Frame)` instead of `record(IplImage)`) (issue #160) + * Gave better default `FFmpegFrameRecorder` settings to H.263, MPEG-4, etc. codecs and fixed H.264 encoding with libx264 (issue #160) + * Refined the `FaceApplet` sample + * Fixed `FlannBasedMatcher` constructor, `FaceRecognizer.train()`, and `Stitcher.stitch()/composePanorama()` (issue #211) + * Fixed `CanvasFrame` sometimes blanking out under Windows and maybe Linux (issue #212) + +### May 27, 2012 version 0.1 + * Started using version numbers, friendly to tools like Maven, and placing packages in a sort of [Maven repository](http://maven2.javacv.googlecode.com/git/) + * JavaCV can now extract and load native dependent libraries such as `libopencv_core.so.2.4`, `libopencv_core.2.4.dylib`, `opencv_core240.dll`, etc. from Java resources placed inside the `com.googlecode.javacv.cpp.` package (i.e.: under the `/com/googlecode/javacv/cpp//` directory of a JAR file in the classpath) (issue #146) + * Included new `FaceApplet` sample to demonstrate [How to use JavaCV in an applet](http://code.google.com/p/javacv/wiki/HowToMakeAnApplet) + * Added handy `IplImage.asCvMat()` and `CvMat.asIplImage()` conversion methods + * Fixed a few small things with `OpenCVFrameGrabber`, `opencv_contrib`, `opencv_legacy`, and `opencv_stitching` + +### May 12, 2012 + * Upgraded support to OpenCV 2.4.0 (issue #187) + * Moved the source code repository to Git + * Added `pom.xml` file for Maven support and changed the directory structure of the source code to match Maven's standard directory layout + * Made it easier to create one massive statically linked native library by passing something like "-Xcompiler -Wl,-static -o javacv" as command line options to JavaCPP, usually from inside `build.xml` or `pom.xml` (issue #146) + * Fixed missing parameter from `CvANN_MLP.create()` + * Added methods `cvCalcCovarMatrixEx()`, `cvEigenDecomposite()`, and `cvEigenProjection()` taking an `IplImage[]` as argument for convenience + * `VideoInputFrameGrabber.start()` now accepts a `connection` argument such as `VI_COMPOSITE` to support analog cameras and what not + * Fixed `FaceRecognition` sample (issue #188) + * Added a few convenience methods to avoid the need to create empty `CvAttrList` + +### March 29, 2012 + * Added missing array allocators and `position()` methods to `KDTree.Node`, `DefaultRngAuto`, `CvAffinePose`, `KeyPoint`, `BaseKeypoint`, `ReferenceTrees`, `DMatch`, `*.Params`, `CvFuzzy*`, `Octree.Node`, `CvDefParam`, `Cv*Blob*`, `Cv*Track*`, `CvDrawShape`, `CvVectors`, `CvParamGrid`, `Cv*Params`, `CvSVM*`, `CvPair16u32s`, `CvDTree*` `CvTrainTestSplit`, `CvMLData`, `FeatureEvaluator`, and `*DataMatrixCode` + * Increased versatility of `IplImage.createFrom()`, `copyFrom()`, `copyTo()`, `getBufferedImage()` by providing a `flipChannels` parameter, whose effect was previously mistakenly forced onto four-channel images of byte values only (issue #163) + * Fixed a couple of things with `CvMat.get()/put()` (issue #167) + * In addition to an `IplImage`, we may now specify the pixel format of the data when calling `FFmpegFrameRecorder.record()`, but otherwise when `IplImage.nChannels == 2`, it assumes `PIX_FMT_NV21`, allowing for easy and efficient encoding of data captured from the camera on Android (issue #160), image objects we can also convert to RGB using `cvCvtColor()` with `CV_YUV420sp2BGR` + * Fixed seeking capabilities of `FFmpegFrameGrabber` (issue #162) and added `getLengthInFrames()` and `getLengthInTime()` methods to query the duration of streams, when known + * Enhanced `IplImage.clone()` and `create*Compatible()` with cloning of their `BufferedImage` to make it easier to keep color components in the right order (issue #163) + * Refactored `FrameGrabber` and `FrameRecorder` a bit to accommodate new `createDefault(...)` and `create(String className, ...)` factory methods, offering to users an easier selection method to work around limitations of some APIs (issue #70) + * Adjusted `GNImageAligner`, `ProCamTransformer`, etc. to support alignment of only the projector display on textureless surface planes + * Renamed a few more `Settings` properties to reflect better their meanings + +### February 18, 2012 + * Added `GLCanvasFrame` to show OpenGL renderbuffers on screen, plus a new factory method `JavaCVCL.createCLGLImageFrom()` to create compatible ones from `IplImage` objects, as well as more user-friendly `getGLContext()`, `getGL()` and `getGL2()` methods + * Fixed various things of the original `CanvasFrame`, and `JavaCV.createCLImage()` and `createIplImage()`, also appending `From` to their names + * New `createPinnedBuffer()` and `createPinnedIplImage()` factory methods in `JavaCVCL` to allocate page-locked memory for faster CPU<->GPU transfers, but it does not seem to work for OpenCL image objects, only linear buffer objects :( + * Fixed and enhanced `GNImageAlignerCL` and `ProjectorDevice` (its `useOpenGL` property) to support fully OpenCL and OpenGL acceleration + * Refactored `Parallel` a bit so that we may set the number of threads it uses via its static `numThreads` property or the "com.googlecode.javacv.numthreads" system property, which defaults to `Parallel.getNumCores() = Runtime.getRuntime().availableProcessors()` + * Cleaned up and renamed some methods in `JavaCV`, while adding `boundingRect()`, functionally similar to `cvBoundingRect`, but better adapted to compute a properly aligned and padded ROI + * Inserted a couple of missing `allocate()` inside `opencv_flann` + * Updated `ObjectFinder` with a `Settings.useFLANN` property to let it use FLANN via OpenCV + * Cleaned up and optimized `HandMouse` + * `CanvasFrame`, `FrameGrabber`, `FrameRecorder`, and `ProjectiveDevice` objects now throw `Exception` objects of a nested class instead of the too generic `java.lang.Exception` one + * Moved parallel execution of `cvkernels.multiWarpColorTransform()`, modifying `ImageTransformer` classes, from `GNImageAligner` into `cvkernels`, which now also supports other image types than `float` + * Renamed some `Settings` properties here and there to correct typos and reflect better their meanings + * Updated `freenect` to reflect the latest changes of OpenKinect's master branch + * FFmpeg and other libraries did not work under Android when compiled with the latest NDK, r7 (issue #147): Fixed in JavaCPP + * Moved `IplImage.timestamp` to `FrameGrabber`, also adding a `frameNumber` property, both allowing to seek within streams too + * Removed `triggerFlushSize` property from `CameraDevice` and `FrameGrabber`, instead relying on the `numBuffers` property to decide the required size of a buffer flush + * Corrected the logic behind `FFmpegFrameGrabber.getFrameRate()` and `getTimestamp()` (issue #151) + * Created a `BufferRing` class for convenient circular rings of large buffers that require manual release of resources, such as OpenCL memory + * Added a few more useful methods to `FrameGrabber`, including `restart()`, `flush()`, and `delayedGrab()` (to be used in conjunction with `getDelayedTime()` and `getDelayedImage()`) + * Inserted `cvLoadImageBGRA()` and `cvLoadImageRGBA()` methods into `opencv_highgui` to load color images compatible with OpenCL more easily + * `JavaCvErrorCallback` now outputs messages to `Logger` instead of `System.err` + * Defined `VI_COM_MULTI_THREADED` for `videoInput`, allowing it to run on multiple threads if needed + +### January 8, 2012 + * JavaCV should now have an easier time automatically finding libraries inside standard directories such as `/usr/local/lib/`, `/opt/local/lib/`, and `C:\opencv\`, even when they are not part of the system configuration or PATH (issue #127) + * Renamed `set()` and `fill()` methods to `put()` inside `CvPoint*` classes, for better naming consistency + * Renamed `FrameGrabber.ColorMode` to `ImageMode` and its `BGR` value to `COLOR` to reflect the fact that a `FrameGrabber` instance can return color images in some arbitrary format, but added a new `pixelFormat` property to let users know or specify the exact pixel format desired, such as `PIX_FMT_BGR24`, etc. in the case of `FFmpegFrameGrabber` + * After `FFmpegFrameGrabber.start()`, the `format`, `imageWidth`, `imageHeight`, and `frameRate` properties switch to their effective values + * Added new `FrameGrabber.sensorPattern` property to obtain the Bayer filter layout of raw data from `DC1394FrameGrabber` and `FlyCaptureFrameGrabber` + * Readded to `KDTree`, `Index`, and `HOGDescriptor` some functions with `FloatPointer` and `IntPointer` arguments that were mistakenly removed when OpenCV switched to using `cv::InputArray` and `cv::OutputArray` parameter types (issue #134) + * Renamed `ProjectiveGainBiasTransformer` to `ProjectiveColorTransformer` + * Added a few classes to do some processing using OpenCL and OpenGL: `JavaCVCL`, `GNImageAlignerCL`, `ProjectiveTransformerCL`, `ProjectiveColorTransformerCL`, and `ProCamTransformerCL` with some other related files + * Renamed `Parallel.numCores` to the more conventional `Parallel.NUM_CORES` + * Added new `FaceRecognition.java` sample from Stephen L. Reed + * Inserted a couple of missing calls to `Loader.load()` (issue #142) + * Improved hacks for `Loader.load()` in JavaCPP make JavaCV work on Android 4.0 + * New `PS3EyeFrameGrabber` from Jiri Masa can now grab images using the SDK from Code Laboratories + +### October 1, 2011 + * Fixed `DC1394FrameGrabber` and `FlyCaptureFrameGrabber` to behave as expected with all Bayer/Raw/Mono/RGB/YUV cameras modes (within the limits of libdc1394 and PGR FlyCapture) (issue #91) + * Fixed regression of `IplImage.copyFrom()` and `createFrom()` with `BufferedImage` objects of `SinglePixelPackedSampleModel` (issue #102) + * C++ functions using `std::vector` objects as output parameters now work on Windows Vista and Windows 7 as well + +### August 20, 2011 + * Upgraded support to OpenCV 2.3.1 + * An output argument of type `cv::Mat` or `cv::OutputArray` returned with a size 0 now correctly sets `CvArr.address = 0` + * Fixed `IplImage.createFrom()` and `copyFrom()` when called on objects returned by `BufferedImage.getSubimage()` + * Added missing allocator to `CvRNG` + * `OpenCVFrameGrabber` now detects when CV_CAP_PROP_POS_MSEC is broken and gives up calling `cvGetCaptureProperty()` + * New `OpenKinectFrameGrabber.grabDepth()` and `grabVideo()` methods to capture "depth" and "video" simultaneously, regardless of the mode + +### July 5, 2011 + * Upgraded support to OpenCV 2.3.0 + * Fixed `OpenKinectFrameGrabber`, which can now also capture depth images when `setFormat("depth")` is called before `start()` + * Fixed `CvMatArray` and `IplImageArray` as well as histogram related functions + * Fixed `FFmpegFrameGrabber`, and `FFmpegFrameRecorder` now works on Android also + * Fixed calls, such as `opencv_flann.Index.knnSearch()`, that require a `MatAdapter` or an `ArrayAdapter` for output + +### June 10, 2011 + * New `freenect` wrapper and corresponding `OpenKinectFrameGrabber` to capture from Microsoft's Kinect stereo camera using OpenKinect + * JavaCV now exposes all C++ functions and classes of OpenCV not covered by the C API + * Fixed various erroneous declarations and calls, including those due to changes in JavaCPP + +### May 11, 2011 + * Removed `CvMat` object pooling in favor of more efficient `ThreadLocal` objects created by `CvMat.createThreadLocal()` + * Changed `Marker.getCenter()` back to the centroid, because it has better noise averaging properties and gives in practice more accurate results than the actual center + * Added hack to `OpenCVFrameGrabber.start()` to wait for `cvRetrieveFrame()` to return something else than `null` under Mac OS X + * FFmpeg now works properly on Windows and Android (issue #63) with newer binaries + * New `videoInputLib` wrapper and corresponding `VideoInputFrameGrabber` to capture using DirectShow, useful under Windows 7 where OpenCV and FFmpeg can fail to capture using Video for Windows (issue #58) + * `GeometricCalibrator` now reports the maximum errors in addition to the average (RMS) errors + +### April 7, 2011 + * Added a `format` property to `CameraDevice`, `FrameGrabber`, and `FrameRecorder`, mostly useful for `FFmpegFrameGrabber`, where interesting values include "dv1394", "mjpeg", "video4linux2", "vfwcap", and "x11grab" + * `OpenCVFrameRecorder` now uses `CV_FOURCC_PROMPT` under Windows as default since `CV_FOURCC_DEFAULT` crashes (issue #49) + * Added hack to make sure the temporarily extracted library files get properly deleted under Windows + * JavaCPP now loads classes more lazily + * Fixed most occurences of `UnsatisfiedLinkError` (issue #54), but some corner cases may require a call to `Loader.load()` on the class one wishes to use + * Added (rudimentary) outlier detection and modified zero threshold handling in the image alignment framework + * New `JavaCV.hysteresisThreshold()` feature + * New `HandMouse` functionality, which depends on the image alignment framework + * Fixed `ProjectiveDevice.distort()`, which mistakenly undistorted images instead + * New `HoughLines` sample thanks to Jeremy Nicola + +### February 19, 2011 + * Switched from JNA to JavaCPP, which has a lower overhead and supports C++, bringing hope that future versions of JavaCV will support features of OpenCV available only through the C++ API + * Consequently, the syntax of various operations have changed a bit, but the transition should not be too painful + * As a happier consequence, this also fixes the problem with SSE instructions on 32-bit x86 (issue #36) + * Also, JavaCPP does not have any limitations or performance issues with large data structures (issue #10 and issue #14) + * Added support for OpenCV 2.2 (issue #42), but dropped support for all previous versions + * Added samples provided by users (issue #1, issue #45, and issue #46) + * Added deinterlace setting to `FFmpegFrameGrabber` having it call `avpicture_deinterlace()` (issue #38) + * Enhanced a few things of the image alignment algorithm + * Tried to fix image format conversion inside `FlyCaptureFrameGrabber`, but this is going to require more careful debugging + * Fixed and added various other things I forget + +### December 2, 2010 + * Now works on Android with the Dalvik VM (for more details, please refer to the FacePreview sample available on the download page) + * Added more hacks to `CanvasFrame` in the hope to make it behave better outside the EDT + * Made clearer the error messages thrown from `FrameGrabber` objects, when `start()` may not have been called + * Fixed version specific declarations of `CvStereoBMState` and related functions + * Fixed conditions that could crash `cvkernels` + +### November 4, 2010 + * Renamed the package namespace to `com.googlecode.javacv`, which makes more sense now that JavaCV has been well anchored at Google Code for more than a year, piggybacking on the unique and easy-to-remember domain name + * Included new FFmpeg wrapper classes `avutil`, `avcodec`, `avformat`, `avdevice`, `avfilter`, `postprocess`, and `swscale`, eliminating the need of the separate FFmpeg-Java package + * `CanvasFrame` now redraws its `Canvas` after the user resizes the `Frame` + * Fixed the `Error` thrown when calling `CanvasFrame.showImage()` from the EDT + * Added check to `DC1394FrameGrabber` so that a "Failed to initialize libdc1394" does not crash the JVM + * `FFmpegFrameGrabber` does not crash anymore when forgetting to call `start()` before a `grab()` or `trigger()` + * `FrameGrabber` now selects the default grabber a bit better + * Made sweeping changes (for the better, but still not finalized) to `GNImageAligner`, `ProjectiveTransformer`, `ProjectiveGainBiasTransformer`, and `ProCamTransformer`... + * Added to `JavaCV` more methods related to transformation of planes: `perspectiveTransform()`, `getPlaneParameters()`, `getPerspectiveTransform()`, and `HtoRt()`, as well as `ProjectiveDevice.getFrontoParallelH()` + * Added a static `autoSynch` flag to all `Structure` classes of `cxcore`, `cv`, and `cvaux`, which you may set to `false` prior to the return of things like big and heavy `CvSeq` to make them load faster and to avoid stack overflows, but accessing fields will then require manual calls to `readField()` and `writeField()` (issue #10 and #14) + * Added missing `ByValue` subclasses to `CvSeq`, `CvSet`, `CvContourTree`, and `CvChain`... Any others missing? + * Fixed `Exception` thrown from `cvCreateHist()` under JNA 3.2.7 (issue #26) + * Enhanced `CvMat.put()`, which now supports setting submatrices + * Improved inside `IplImage` the support of `BufferedImage`, especially those using a `DirectColorModel` (issue #23) + * Fixed crash in `cvkernels` when color transformation `X` is `null` + +### July 30, 2010 + * Fixed crash that would occur in `CanvasFrame` for some video drivers + * `FFmpegFrameGrabber` now supports other input formats (devices), such as `x11grab` that can be used for screencasting + * Added `JavaCV.median()` function, and `JavaCV.fractalTriangleWave()` now respects image ROI + * Fixed background subtraction in `cvaux` + * Fixed crash inside the code for direct alignment caused by the ROI getting set outside the image plane + * Added `deltaScale` and `tryToFixPlane` to `GNImageAligner.Settings` (the first used in `ImageTransformer.Parameters` as increment, randomly selected forward or backward, for finite difference), which sometimes help to jump over local minima + +### May 30, 2010 + * Removed redundant `CvMemStorage.clearMem()` method, use `cvClearMemStorage()` + * Fixed the sample `Test2` class that did not work under Windows + * Fixed corruption by the `cvkernels` `transformer` at the borders + * Modified `CanvasFrame` constructors and added a `gamma` argument used by `showImage(IplImage)` + * `CanvasFrame` now lets users resize the frame, while displayed images are stretched to fit the new size + * Renamed `CanvasFrame.acquireGraphics()` to `createGraphics()` for consistency + * When `FlyCaptureFrameGrabber` cannot set fastest speed, it now safely fails by setting any supported speed + * Added a new `Parallel.loop()` method that can use more threads than the number of CPU cores detected + * Added new `numThreads` property to `GNImageAligner` and fixed a few minor inconsistencies as well + * Fixed incorrect `Java.HnToRt()`, and added a few `norm()` and `randn()` methods + * For functions with `float[]` and `double[]` arguments in `cvaux` and `cv`, added complementary `FloatBuffer` and `DoubleBuffer` declarations + * Fixed loading problems with `cvaux` + * Fixed and enhanced histogram, back projection, and other CAMSHIFT related functionality + * Added code for `CvRNG` + * Added "/opt/local/lib/" and "/opt/local/lib64/" (standard on Mac OS X) to the default list of search paths for OpenCV + * Added `CvScalar.getVal()` and `CvIntScalar.getVal()`, which simply return the `val` field, convenient for Scala where `val` is a reserved word + * Fixed the construction of `IplImage` from a `Pointer` + * Removed incorrect cases when an `IplImage` gets converted to a `BufferedImage.TYPE_CUSTOM` + * Made `CvArr.PointerByReference` a bit more consistent and general + +### April 16, 2010 + * Modified `IplImage`, `FrameGrabber`, and `CanvasFrame` to get better default behavior of gamma correction + * Fixed `cv.CvHistogram` and related histogram functions + * `CameraDevice.Settings.triggerFlushSize` now defaults to 5 (only affects `OpenCVFrameGrabber` and `FFmpegFrameGrabber`) + * Replaced `LMImageAligner` by `GNImageAligner`, a more appropriate name for Gauss-Newton with `lineSearch` + * Fixed a few things related with `ProjectiveDevice.Settings` + +### April 8, 2010 + * Added support for OpenCV 2.1 + +### April 5, 2010 + * Fixed up `clone()` methods to avoid the need to cast + * Removed the `fullScreen` argument from `CanvasFrame` constructors, which will now switch to full-screen mode only when a `screenNumber` is explicitly passed + * Renamed `FrameGrabber.ColorMode.GRAYSCALE` to `GRAY` + * Replaced deprecated functions from `FFmpegFrameGrabber` and `FFmpegFrameRecorder` + * `FFmpegFrameGrabber` can now resize images + +### March 21, 2010 + * Added new classes and methods used by ProCamTracker: `cvkernels`, `JavaCV.fractalTriangleWave()`, `ImageAligner`, `LMImageAligner`, `ImageTransformer`, `ProjectiveTransformer`, `ProjectiveGainBiasTransformer`, `ProCamTransformer`, and `ReflectanceInitializer` + * `CameraDevice.Settings` has a new `deviceFile` property (used by a `FrameGrabber`), which brings up a file dialog for some `PropertyEditor`s + * Moved in `CameraSettings`, `ProjectorSettings`, and `FrameGrabber.PropertyEditor` from the `procamcalib` package + * Added to `CameraDevice.Settings` and `FrameGrabber` a `triggerFlushSize` property to indicate the number of buffers to flush on `trigger()` to compensate for cheap cameras that keep old images in memory indefinitely + * Changed the type of `CameraDevice.Settings.deviceNumber` to `Integer` so we may set it to `null` + * Fixed and enhanced `CanvasFrame.showImage()` methods a bit + * In `triggerMode` `DC1394FrameGrabber` now tries to use a real software trigger and only falls back to one-shot mode on error + * Fixed array constructors of `IplImage.PointerByReference()` and `CvImgObsInfo.PointerByReference()` + * Added `CvPoint.fillArray()` methods to reuse preallocated arrays and changed `createArray()` a bit as well + * Fixed and enhanced all `IplImage.copy*()` methods, including new support for ROIs and subimages, which affects `create*()` and `getBufferedImage()` methods as well + * Updated `Marker` to support different size and spacing in X and Y + * Added `Settings` to `ObjectFinder` + * Fixed distortion problem in `ProjectiveDevice` and `ProCamColorCalibrator` with OpenCV 1.1pre1 + * Split `ProjectiveDevice.Settings` into `ProjectiveDevice.CalibrationSettings` (for applications like ProCamCalib) and `ProjectiveDevice.CalibratedSettings` (for applications like ProCamTracker) + * Renamed `gamma` to `responseGamma` in `ProjectiveDevice`, and moved previous `nominalDistance` parameter to `Settings` + * Added `ProjectiveDevice.rescale()` to rescale calibration parameters when switching a device to a new image size + * `ProjectiveDevice.undistort()` and `distort()` can now `useFixedPointMaps` of OpenCV + * `ProjectiveDevice` and its subclasses now `throw new Exception()` if the `parameterFile` cannot be read + +### February 13, 2010 + * Relicensed JavaCV under the GPLv2 with Classpath exception (see LICENSE.txt). Please note that if your application links with code that needs ARToolKitPlus, for example, it will become subject to the full GPL, without Classpath exception + * Added `devicePath` setting to `CameraDevice` that works with `FFmpegFrameGrabber`, `OpenCVFrameGrabber`, and other `FrameGrabber` with a String constructor + * Added "C:/OpenCV2.0/bin/release/" to the directory list to search for OpenCV DLLs + * Moved `cvFindHomography()`, `cvFindExtrinsicCameraParams2()`, `cvReprojectImageTo3D()`, `cvSaveImage()`, and `cvRetrieveFrame()` to version specific classes since their number of arguments differ with the version of OpenCV + * Enhanced `CvMat.put(CvMat mat)` to work better even when the matrices are not actually compatible + * Added new `IplImage` factory methods `createCompatible(IplImage image)`, `createIfNotCompatible(IplImage image, IplImage template)`, and `createFrom(BufferedImage image)` + * Fixed `distortionCoeffs` corruption that might occur in `ProjectiveDevice` + +### January 3, 2010 + * Added wrapper for the `cvaux` module of OpenCV + * Added abstract `FrameRecorder` class and a `OpenCVFrameRecorder` class + * Fixed read() problem that might occur within Pointer constructors + * Running `java -jar javacv.jar` now displays version information + +### December 22, 2009 + * Fixed `CanvasFrame` from getting stuck in a maximized window + * Removed all `setAutoWrite(false)` from `cxcore` now that the bug appears fixed in JNA + * Added `FFmpegFrameGrabber` and `FFmpegFrameRecorder` to easily record live footage and grab back offline into JavaCV + +### November 24, 2009 + * Added more convenient constructors and factory methods for `CvPoint*`, `CvSize*`, `CvRect`, `CvTermCriteria`, `CvSlice`, and `CvAttrList` + * Added _R2_ correlation coefficient field to `ProjectiveDevice` + * Enhanced and fixed color conversion spaghetti code in `FlyCaptureFrameGrabber` + * Fixed the `CvHaarFeature` Structure + * Renamed `CvIntScalar` factory methods to match with `CvScalar` + * Enhanced and fixed some problems with gamma correction in `IplImage` + * Added a `highgui.CV_FOURCC()` method that takes chars as parameter + * Moved `MarkedPlane.drawMarkers()` to `Marker.draw()` for better code reuse + * Added `MarkedPlane.getTotalWarp()` with a "useCenters" parameter + * Changed default values of `MarkerDetector.binarizationKWhiteMarkers` to 1.0 and `ProjectorDevice.brightnessBackground` to 0.0 + * Fixed issue with image width and memory alignment in `MarkerDetector` + * `Marker.getCenter()` now computes the actual physical center instead of the centroid + * `OpenCVFrameGrabber.getDeviceDescriptions()` now throws `UnsupportedOperationException` + * Added support in `OpenCVFrameGrabber` to grab frames from video files + * Added `ProjectiveDevice.getRectifyingHomography()` method + * Added `JavaCvErrorCallback` to easily catch errors of OpenCV in Java + +### October 19, 2009 + * Moved the functionality of `CvMatPool` to the `CvMat.take()` and `.pool()` methods + * Added color calibration for projector-camera systems (`ProCamColorCalibrator`) + * Updated `DC1394FrameGrabber` to handle more conversion use cases automatically + * Fixed `CvIntScalar` to mirror `CvScalar` + +### October 14, 2009 + * Change of plan: JavaCV now works with any of OpenCV 1.0, 1.1pre1, or 2.0! Version specific functionality is enclosed in subclasses, e.g., the class `cv.v20` can access everything from the `cv` module of OpenCV 2.0 + * Added a few missing functions and adjusted some mappings to make them closer to the C API + * Added a few more helper methods to `CvPoint*` + * Added temporary storage to `ObjectFinder` to plug the memory leak + +### October 2, 2009 + * Fixed problem when loading distortion coefficients with `ProjectiveDevice` + * Added automatic read and write for functions with arrays of `Structure` or `PointerByReference` + * Added to `cv.java` a few missing functions related to calibration + * Fixed up a bit helper methods for `CvPoint*`, `CvScalar`, `CvRect`, `CvBox2D`, `CvMat`, `IplImage`, `CvMemStorage`, `CvSeq`, and `CvSeqBlock` + * Added `CvMatPool` to `MarkedPlane` and `Marker` + * Added a few new `distort()` methods to `ProjectiveDevice` + * Last version to support OpenCV 1.1pre1: Future version will require OpenCV 2.0 + +### August 27, 2009 + * `IplImage` now flips the buffer on copy if necessary + * Added needed Pointer constructor for `CvSURFPoint` and `CvConvexityDefect` + * Cleaned up a bit the messy Buffers in `CvMat` + +### August 26, 2009 + * Added `get*Buffer()` functions to `IplImage` + * Added more options for gamma correction in `IplImage` and `ProjectiveDevice` + * Further cleaned up the namespace and constructors of `ProjectiveDevices` + * `CanvasFrame.waitKey()` now only checks `KeyEvent.KEY_PRESSED` + * Added `CvMatPool` to avoid recreating matrices + * Moved `CvScalar` functions to `cxcore` + +### August 19, 2009 + * Switched to using `import static` for relief from namespace hell + * Fixed color channel reversal of Bayer images in `DC1394FrameGrabber` + +### August 11, 2009 +Initial release + + +Acknowledgments +--------------- +This project was conceived at the [Okutomi & Tanaka Laboratory](http://www.ok.ctrl.titech.ac.jp/), Tokyo Institute of Technology, where I was supported for my doctoral research program by a generous scholarship from the Ministry of Education, Culture, Sports, Science and Technology (MEXT) of the Japanese Government. I extend my gratitude further to all who have reported bugs, donated code, or made suggestions for improvements (details above)! diff --git a/lib/javacv-bin/LICENSE.txt b/lib/javacv-bin/LICENSE.txt new file mode 100644 index 0000000..c513065 --- /dev/null +++ b/lib/javacv-bin/LICENSE.txt @@ -0,0 +1,572 @@ +You may use this work under the terms of either the Apache License, +Version 2.0, or the GNU General Public License (GPL), either version 2, +or any later version, with "Classpath" exception (details below). + +You don't have to do anything special to choose one license or the other +and you don't have to notify anyone which license you are using. You are +free to use this work in any project (even commercial projects) as long +as the copyright header is left intact. + +=============================================================================== + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +=============================================================================== + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. + + +"CLASSPATH" EXCEPTION TO THE GPL + + Linking this library statically or dynamically with other modules is making + a combined work based on this library. Thus, the terms and conditions of + the GNU General Public License cover the whole combination. + + As a special exception, the copyright holders of this library give you + permission to link this library with independent modules to produce an + executable, regardless of the license terms of these independent modules, + and to copy and distribute the resulting executable under terms of your + choice, provided that you also meet, for each linked independent module, + the terms and conditions of the license of that module. An independent + module is a module which is not derived from or based on this library. If + you modify this library, you may extend this exception to your version of + the library, but you are not obligated to do so. If you do not wish to do + so, delete this exception statement from your version. diff --git a/lib/javacv-bin/README.md b/lib/javacv-bin/README.md new file mode 100644 index 0000000..9699327 --- /dev/null +++ b/lib/javacv-bin/README.md @@ -0,0 +1,293 @@ +JavaCV +====== + +Introduction +------------ +JavaCV uses wrappers from the [JavaCPP Presets](https://github.com/bytedeco/javacpp-presets) of commonly used libraries by researchers in the field of computer vision ([OpenCV](http://opencv.org/), [FFmpeg](http://ffmpeg.org/), [libdc1394](http://damien.douxchamps.net/ieee1394/libdc1394/), [PGR FlyCapture](http://www.ptgrey.com/products/pgrflycapture/), [OpenKinect](http://openkinect.org/), [videoInput](http://muonics.net/school/spring05/videoInput/), [ARToolKitPlus](http://studierstube.icg.tugraz.at/handheld_ar/artoolkitplus.php), and [flandmark](http://cmp.felk.cvut.cz/~uricamic/flandmark/)), and provides utility classes to make their functionality easier to use on the Java platform, including Android. + +JavaCV also comes with hardware accelerated full-screen image display (`CanvasFrame` and `GLCanvasFrame`), easy-to-use methods to execute code in parallel on multiple cores (`Parallel`), user-friendly geometric and color calibration of cameras and projectors (`GeometricCalibrator`, `ProCamGeometricCalibrator`, `ProCamColorCalibrator`), detection and matching of feature points (`ObjectFinder`), a set of classes that implement direct image alignment of projector-camera systems (mainly `GNImageAligner`, `ProjectiveTransformer`, `ProjectiveColorTransformer`, `ProCamTransformer`, and `ReflectanceInitializer`), a blob analysis package (`Blobs`), as well as miscellaneous functionality in the `JavaCV` class. Some of these classes also have an OpenCL and OpenGL counterpart, their names ending with `CL` or starting with `GL`, i.e.: `JavaCVCL`, `GLCanvasFrame`, etc. + +To learn how to use the API, since documentation currently lacks, please refer to the [Sample Usage](#sample-usage) section below as well as the [sample programs](https://github.com/bytedeco/javacv/tree/master/samples/), including two for Android (`FacePreview.java` and `RecordActivity.java`), also found in the `samples` directory. You may also find it useful to refer to the source code of [ProCamCalib](https://github.com/bytedeco/procamcalib) and [ProCamTracker](https://github.com/bytedeco/procamtracker) as well as [examples ported from OpenCV2 Cookbook](https://github.com/bytedeco/javacv-examples/) and the associated [wiki pages](https://github.com/bytedeco/javacv-examples/blob/master/OpenCV2_Cookbook). + +Please keep me informed of any updates or fixes you make to the code so that I may integrate them into the next release. Thank you! And feel free to ask questions on [the mailing list](http://groups.google.com/group/javacv) if you encounter any problems with the software! I am sure it is far from perfect... + + +Downloads +--------- +To install manually the JAR files, obtain the following archives and follow the instructions in the [Manual Installation](#manual-installation) section below. + + * JavaCV 1.1 binary archive [javacv-1.1-bin.zip](http://search.maven.org/remotecontent?filepath=org/bytedeco/javacv/1.1/javacv-1.1-bin.zip) (140 MB) + * JavaCV 1.1 source archive [javacv-1.1-src.zip](http://search.maven.org/remotecontent?filepath=org/bytedeco/javacv/1.1/javacv-1.1-src.zip) (415 KB) + +The binary archive contains builds for Android, Linux, Mac OS X, and Windows. The JAR files for specific child modules or platforms can also be obtained individually from the [Maven Central Repository](http://search.maven.org/#search|ga|1|bytedeco). + + +We can also have everything downloaded and installed automatically with: + + * Maven (inside the `pom.xml` file) +```xml + + org.bytedeco + javacv + 1.1 + +``` + + * Gradle (inside the `build.gradle` file) +```groovy + dependencies { + compile group: 'org.bytedeco', name: 'javacv', version: '1.1' + } +``` + + * sbt (inside the `build.sbt` file) +```scala + classpathTypes += "maven-plugin" + libraryDependencies += "org.bytedeco" % "javacv" % "1.1" +``` + +Additionally, we need to either set the `platform` system property (via the `-D` command line option) to something like `android-arm`, or set the `platform.dependencies` one to `true` to get all the binaries for Android, Linux, Mac OS X, and Windows. **On build systems where this does not work, we need to add the platform-specific artifacts manually.** + + +Required Software +----------------- +To use JavaCV, you will first need to download and install the following software: + + * An implementation of Java SE 7 or newer: + * OpenJDK http://openjdk.java.net/install/ or + * Sun JDK http://www.oracle.com/technetwork/java/javase/downloads/ or + * IBM JDK http://www.ibm.com/developerworks/java/jdk/ + +Further, although not always required, some functionality of JavaCV also relies on: + + * CL Eye Platform SDK (Windows only) http://codelaboratories.com/downloads/ + * Android SDK API 14 or newer http://developer.android.com/sdk/ + * JOCL and JOGL from JogAmp http://jogamp.org/ + +Finally, please make sure everything has the same bitness: **32-bit and 64-bit modules do not mix under any circumstances**. + + +Manual Installation +------------------- +Simply put all the desired JAR files (`opencv*.jar`, `ffmpeg*.jar`, etc.), in addition to `javacpp.jar` and `javacv.jar`, somewhere in your class path. Here are some more specific instructions for common cases: + +NetBeans (Java SE 7 or newer): + + 1. In the Projects window, right-click the Libraries node of your project, and select "Add JAR/Folder...". + 2. Locate the JAR files, select them, and click OK. + +Eclipse (Java SE 7 or newer): + + 1. Navigate to Project > Properties > Java Build Path > Libraries and click "Add External JARs...". + 2. Locate the JAR files, select them, and click OK. + +IntelliJ IDEA (Android 4.0 or newer): + + 1. Follow the instructions on this page: http://developer.android.com/training/basics/firstapp/ + 2. Copy all the JAR files into the `app/libs` subdirectory. + 3. Navigate to File > Project Structure > app > Dependencies, click `+`, and select "2 File dependency". + 4. Select all the JAR files from the `libs` subdirectory. + +After that, the wrapper classes for OpenCV and FFmpeg, for example, can automatically access all of their C/C++ APIs: + + * [OpenCV documentation](http://docs.opencv.org/master/) + * [FFmpeg documentation](http://ffmpeg.org/doxygen/trunk/) + + +Sample Usage +------------ +The class definitions are basically ports to Java of the original header files in C/C++, and I deliberately decided to keep as much of the original syntax as possible. For example, here is a method that tries to load an image file, smooth it, and save it back to disk: + +```java +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; + +public class Smoother { + public static void smooth(String filename) { + IplImage image = cvLoadImage(filename); + if (image != null) { + cvSmooth(image, image); + cvSaveImage(filename, image); + cvReleaseImage(image); + } + } +} +``` + +JavaCV also comes with helper classes and methods on top of OpenCV and FFmpeg to facilitate their integration to the Java platform. Here is a small demo program demonstrating the most frequently useful parts: + +```java +import java.io.File; +import java.net.URL; +import org.bytedeco.javacv.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.indexer.*; +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_calib3d.*; +import static org.bytedeco.javacpp.opencv_objdetect.*; + +public class Demo { + public static void main(String[] args) throws Exception { + String classifierName = null; + if (args.length > 0) { + classifierName = args[0]; + } else { + URL url = new URL("https://raw.github.com/Itseez/opencv/2.4.0/data/haarcascades/haarcascade_frontalface_alt.xml"); + File file = Loader.extractResource(url, null, "classifier", ".xml"); + file.deleteOnExit(); + classifierName = file.getAbsolutePath(); + } + + // Preload the opencv_objdetect module to work around a known bug. + Loader.load(opencv_objdetect.class); + + // We can "cast" Pointer objects by instantiating a new object of the desired class. + CvHaarClassifierCascade classifier = new CvHaarClassifierCascade(cvLoad(classifierName)); + if (classifier.isNull()) { + System.err.println("Error loading classifier file \"" + classifierName + "\"."); + System.exit(1); + } + + // The available FrameGrabber classes include OpenCVFrameGrabber (opencv_videoio), + // DC1394FrameGrabber, FlyCaptureFrameGrabber, OpenKinectFrameGrabber, + // PS3EyeFrameGrabber, VideoInputFrameGrabber, and FFmpegFrameGrabber. + FrameGrabber grabber = FrameGrabber.createDefault(0); + grabber.start(); + + // CanvasFrame, FrameGrabber, and FrameRecorder use Frame objects to communicate image data. + // We need a FrameConverter to interface with other APIs (Android, Java 2D, or OpenCV). + OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage(); + + // FAQ about IplImage and Mat objects from OpenCV: + // - For custom raw processing of data, createBuffer() returns an NIO direct + // buffer wrapped around the memory pointed by imageData, and under Android we can + // also use that Buffer with Bitmap.copyPixelsFromBuffer() and copyPixelsToBuffer(). + // - To get a BufferedImage from an IplImage, or vice versa, we can chain calls to + // Java2DFrameConverter and OpenCVFrameConverter, one after the other. + // - Java2DFrameConverter also has static copy() methods that we can use to transfer + // data more directly between BufferedImage and IplImage or Mat via Frame objects. + IplImage grabbedImage = converter.convert(grabber.grab()); + int width = grabbedImage.width(); + int height = grabbedImage.height(); + IplImage grayImage = IplImage.create(width, height, IPL_DEPTH_8U, 1); + IplImage rotatedImage = grabbedImage.clone(); + + // Objects allocated with a create*() or clone() factory method are automatically released + // by the garbage collector, but may still be explicitly released by calling release(). + // You shall NOT call cvReleaseImage(), cvReleaseMemStorage(), etc. on objects allocated this way. + CvMemStorage storage = CvMemStorage.create(); + + // The OpenCVFrameRecorder class simply uses the CvVideoWriter of opencv_videoio, + // but FFmpegFrameRecorder also exists as a more versatile alternative. + FrameRecorder recorder = FrameRecorder.createDefault("output.avi", width, height); + recorder.start(); + + // CanvasFrame is a JFrame containing a Canvas component, which is hardware accelerated. + // It can also switch into full-screen mode when called with a screenNumber. + // We should also specify the relative monitor/camera response for proper gamma correction. + CanvasFrame frame = new CanvasFrame("Some Title", CanvasFrame.getDefaultGamma()/grabber.getGamma()); + + // Let's create some random 3D rotation... + CvMat randomR = CvMat.create(3, 3), randomAxis = CvMat.create(3, 1); + // We can easily and efficiently access the elements of matrices and images + // through an Indexer object with the set of get() and put() methods. + DoubleIndexer Ridx = randomR.createIndexer(), axisIdx = randomAxis.createIndexer(); + axisIdx.put(0, (Math.random()-0.5)/4, (Math.random()-0.5)/4, (Math.random()-0.5)/4); + cvRodrigues2(randomAxis, randomR, null); + double f = (width + height)/2.0; Ridx.put(0, 2, Ridx.get(0, 2)*f); + Ridx.put(1, 2, Ridx.get(1, 2)*f); + Ridx.put(2, 0, Ridx.get(2, 0)/f); Ridx.put(2, 1, Ridx.get(2, 1)/f); + System.out.println(Ridx); + + // We can allocate native arrays using constructors taking an integer as argument. + CvPoint hatPoints = new CvPoint(3); + + while (frame.isVisible() && (grabbedImage = converter.convert(grabber.grab())) != null) { + cvClearMemStorage(storage); + + // Let's try to detect some faces! but we need a grayscale image... + cvCvtColor(grabbedImage, grayImage, CV_BGR2GRAY); + CvSeq faces = cvHaarDetectObjects(grayImage, classifier, storage, + 1.1, 3, CV_HAAR_FIND_BIGGEST_OBJECT | CV_HAAR_DO_ROUGH_SEARCH); + int total = faces.total(); + for (int i = 0; i < total; i++) { + CvRect r = new CvRect(cvGetSeqElem(faces, i)); + int x = r.x(), y = r.y(), w = r.width(), h = r.height(); + cvRectangle(grabbedImage, cvPoint(x, y), cvPoint(x+w, y+h), CvScalar.RED, 1, CV_AA, 0); + + // To access or pass as argument the elements of a native array, call position() before. + hatPoints.position(0).x(x-w/10) .y(y-h/10); + hatPoints.position(1).x(x+w*11/10).y(y-h/10); + hatPoints.position(2).x(x+w/2) .y(y-h/2); + cvFillConvexPoly(grabbedImage, hatPoints.position(0), 3, CvScalar.GREEN, CV_AA, 0); + } + + // Let's find some contours! but first some thresholding... + cvThreshold(grayImage, grayImage, 64, 255, CV_THRESH_BINARY); + + // To check if an output argument is null we may call either isNull() or equals(null). + CvSeq contour = new CvSeq(null); + cvFindContours(grayImage, storage, contour, Loader.sizeof(CvContour.class), + CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); + while (contour != null && !contour.isNull()) { + if (contour.elem_size() > 0) { + CvSeq points = cvApproxPoly(contour, Loader.sizeof(CvContour.class), + storage, CV_POLY_APPROX_DP, cvContourPerimeter(contour)*0.02, 0); + cvDrawContours(grabbedImage, points, CvScalar.BLUE, CvScalar.BLUE, -1, 1, CV_AA); + } + contour = contour.h_next(); + } + + cvWarpPerspective(grabbedImage, rotatedImage, randomR); + + Frame rotatedFrame = converter.convert(rotatedImage); + frame.showImage(rotatedFrame); + recorder.record(rotatedFrame); + } + frame.dispose(); + recorder.stop(); + grabber.stop(); + } +} +``` + +Furthermore, after creating a `pom.xml` file with the following content: +```xml + + 4.0.0 + org.bytedeco.javacv + demo + 1.1 + + + org.bytedeco + javacv + 1.1 + + + +``` + +And by placing the source code above in `src/main/java/Demo.java`, we can use the following command to have everything first installed automatically and then executed by Maven: +```bash + $ mvn package exec:java -Dexec.mainClass=Demo +``` + + +Build Instructions +------------------ +If the binary files available above are not enough for your needs, you might need to rebuild them from the source code. To this end, the project files were created for: + + * Maven 3.x http://maven.apache.org/download.html + * JavaCPP 1.1 https://github.com/bytedeco/javacpp + * JavaCPP Presets 1.1 https://github.com/bytedeco/javacpp-presets + +Once installed, simply call the usual `mvn install` command for JavaCPP, its Presets, and JavaCV. By default, no other dependencies than a C++ compiler for JavaCPP are required. Please refer to the comments inside the `pom.xml` files for further details. + + +---- +Project lead: Samuel Audet [samuel.audet `at` gmail.com](mailto:samuel.audet at gmail.com) +Developer site: https://github.com/bytedeco/javacv +Discussion group: http://groups.google.com/group/javacv diff --git a/lib/javacv-bin/artoolkitplus-android-arm.jar b/lib/javacv-bin/artoolkitplus-android-arm.jar new file mode 100644 index 0000000..caf4786 Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-android-arm.jar differ diff --git a/lib/javacv-bin/artoolkitplus-android-x86.jar b/lib/javacv-bin/artoolkitplus-android-x86.jar new file mode 100644 index 0000000..7ea780b Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-android-x86.jar differ diff --git a/lib/javacv-bin/artoolkitplus-linux-x86.jar b/lib/javacv-bin/artoolkitplus-linux-x86.jar new file mode 100644 index 0000000..ede2912 Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-linux-x86.jar differ diff --git a/lib/javacv-bin/artoolkitplus-linux-x86_64.jar b/lib/javacv-bin/artoolkitplus-linux-x86_64.jar new file mode 100644 index 0000000..082c2cf Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-linux-x86_64.jar differ diff --git a/lib/javacv-bin/artoolkitplus-macosx-x86_64.jar b/lib/javacv-bin/artoolkitplus-macosx-x86_64.jar new file mode 100644 index 0000000..72fc5f1 Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-macosx-x86_64.jar differ diff --git a/lib/javacv-bin/artoolkitplus-windows-x86.jar b/lib/javacv-bin/artoolkitplus-windows-x86.jar new file mode 100644 index 0000000..e3b5e14 Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-windows-x86.jar differ diff --git a/lib/javacv-bin/artoolkitplus-windows-x86_64.jar b/lib/javacv-bin/artoolkitplus-windows-x86_64.jar new file mode 100644 index 0000000..b6f1ca2 Binary files /dev/null and b/lib/javacv-bin/artoolkitplus-windows-x86_64.jar differ diff --git a/lib/javacv-bin/artoolkitplus.jar b/lib/javacv-bin/artoolkitplus.jar new file mode 100644 index 0000000..54bccf5 Binary files /dev/null and b/lib/javacv-bin/artoolkitplus.jar differ diff --git a/lib/javacv-bin/ffmpeg-android-arm.jar b/lib/javacv-bin/ffmpeg-android-arm.jar new file mode 100644 index 0000000..35870a6 Binary files /dev/null and b/lib/javacv-bin/ffmpeg-android-arm.jar differ diff --git a/lib/javacv-bin/ffmpeg-android-x86.jar b/lib/javacv-bin/ffmpeg-android-x86.jar new file mode 100644 index 0000000..f16eed8 Binary files /dev/null and b/lib/javacv-bin/ffmpeg-android-x86.jar differ diff --git a/lib/javacv-bin/ffmpeg-linux-x86.jar b/lib/javacv-bin/ffmpeg-linux-x86.jar new file mode 100644 index 0000000..334fc7a Binary files /dev/null and b/lib/javacv-bin/ffmpeg-linux-x86.jar differ diff --git a/lib/javacv-bin/ffmpeg-linux-x86_64.jar b/lib/javacv-bin/ffmpeg-linux-x86_64.jar new file mode 100644 index 0000000..0e0119b Binary files /dev/null and b/lib/javacv-bin/ffmpeg-linux-x86_64.jar differ diff --git a/lib/javacv-bin/ffmpeg-macosx-x86_64.jar b/lib/javacv-bin/ffmpeg-macosx-x86_64.jar new file mode 100644 index 0000000..2a031b2 Binary files /dev/null and b/lib/javacv-bin/ffmpeg-macosx-x86_64.jar differ diff --git a/lib/javacv-bin/ffmpeg-windows-x86.jar b/lib/javacv-bin/ffmpeg-windows-x86.jar new file mode 100644 index 0000000..c37ecb5 Binary files /dev/null and b/lib/javacv-bin/ffmpeg-windows-x86.jar differ diff --git a/lib/javacv-bin/ffmpeg-windows-x86_64.jar b/lib/javacv-bin/ffmpeg-windows-x86_64.jar new file mode 100644 index 0000000..26da09b Binary files /dev/null and b/lib/javacv-bin/ffmpeg-windows-x86_64.jar differ diff --git a/lib/javacv-bin/ffmpeg.jar b/lib/javacv-bin/ffmpeg.jar new file mode 100644 index 0000000..c583499 Binary files /dev/null and b/lib/javacv-bin/ffmpeg.jar differ diff --git a/lib/javacv-bin/flandmark-android-arm.jar b/lib/javacv-bin/flandmark-android-arm.jar new file mode 100644 index 0000000..eb2bbb1 Binary files /dev/null and b/lib/javacv-bin/flandmark-android-arm.jar differ diff --git a/lib/javacv-bin/flandmark-android-x86.jar b/lib/javacv-bin/flandmark-android-x86.jar new file mode 100644 index 0000000..a2a4d25 Binary files /dev/null and b/lib/javacv-bin/flandmark-android-x86.jar differ diff --git a/lib/javacv-bin/flandmark-linux-x86.jar b/lib/javacv-bin/flandmark-linux-x86.jar new file mode 100644 index 0000000..f7e3ef5 Binary files /dev/null and b/lib/javacv-bin/flandmark-linux-x86.jar differ diff --git a/lib/javacv-bin/flandmark-linux-x86_64.jar b/lib/javacv-bin/flandmark-linux-x86_64.jar new file mode 100644 index 0000000..b2a9a4a Binary files /dev/null and b/lib/javacv-bin/flandmark-linux-x86_64.jar differ diff --git a/lib/javacv-bin/flandmark-macosx-x86_64.jar b/lib/javacv-bin/flandmark-macosx-x86_64.jar new file mode 100644 index 0000000..8053265 Binary files /dev/null and b/lib/javacv-bin/flandmark-macosx-x86_64.jar differ diff --git a/lib/javacv-bin/flandmark-windows-x86.jar b/lib/javacv-bin/flandmark-windows-x86.jar new file mode 100644 index 0000000..f868692 Binary files /dev/null and b/lib/javacv-bin/flandmark-windows-x86.jar differ diff --git a/lib/javacv-bin/flandmark-windows-x86_64.jar b/lib/javacv-bin/flandmark-windows-x86_64.jar new file mode 100644 index 0000000..62f6af6 Binary files /dev/null and b/lib/javacv-bin/flandmark-windows-x86_64.jar differ diff --git a/lib/javacv-bin/flandmark.jar b/lib/javacv-bin/flandmark.jar new file mode 100644 index 0000000..efe306c Binary files /dev/null and b/lib/javacv-bin/flandmark.jar differ diff --git a/lib/javacv-bin/flycapture-linux-x86.jar b/lib/javacv-bin/flycapture-linux-x86.jar new file mode 100644 index 0000000..15aa390 Binary files /dev/null and b/lib/javacv-bin/flycapture-linux-x86.jar differ diff --git a/lib/javacv-bin/flycapture-linux-x86_64.jar b/lib/javacv-bin/flycapture-linux-x86_64.jar new file mode 100644 index 0000000..151645b Binary files /dev/null and b/lib/javacv-bin/flycapture-linux-x86_64.jar differ diff --git a/lib/javacv-bin/flycapture-windows-x86.jar b/lib/javacv-bin/flycapture-windows-x86.jar new file mode 100644 index 0000000..df0c061 Binary files /dev/null and b/lib/javacv-bin/flycapture-windows-x86.jar differ diff --git a/lib/javacv-bin/flycapture-windows-x86_64.jar b/lib/javacv-bin/flycapture-windows-x86_64.jar new file mode 100644 index 0000000..096ca07 Binary files /dev/null and b/lib/javacv-bin/flycapture-windows-x86_64.jar differ diff --git a/lib/javacv-bin/flycapture.jar b/lib/javacv-bin/flycapture.jar new file mode 100644 index 0000000..bf389de Binary files /dev/null and b/lib/javacv-bin/flycapture.jar differ diff --git a/lib/javacv-bin/javacpp.jar b/lib/javacv-bin/javacpp.jar new file mode 100644 index 0000000..114fc8f Binary files /dev/null and b/lib/javacv-bin/javacpp.jar differ diff --git a/lib/javacv-bin/javacv.jar b/lib/javacv-bin/javacv.jar new file mode 100644 index 0000000..1135b0a Binary files /dev/null and b/lib/javacv-bin/javacv.jar differ diff --git a/lib/javacv-bin/libdc1394-linux-x86.jar b/lib/javacv-bin/libdc1394-linux-x86.jar new file mode 100644 index 0000000..d91153c Binary files /dev/null and b/lib/javacv-bin/libdc1394-linux-x86.jar differ diff --git a/lib/javacv-bin/libdc1394-linux-x86_64.jar b/lib/javacv-bin/libdc1394-linux-x86_64.jar new file mode 100644 index 0000000..f8014ca Binary files /dev/null and b/lib/javacv-bin/libdc1394-linux-x86_64.jar differ diff --git a/lib/javacv-bin/libdc1394-macosx-x86_64.jar b/lib/javacv-bin/libdc1394-macosx-x86_64.jar new file mode 100644 index 0000000..ab04f91 Binary files /dev/null and b/lib/javacv-bin/libdc1394-macosx-x86_64.jar differ diff --git a/lib/javacv-bin/libdc1394.jar b/lib/javacv-bin/libdc1394.jar new file mode 100644 index 0000000..89cbe5a Binary files /dev/null and b/lib/javacv-bin/libdc1394.jar differ diff --git a/lib/javacv-bin/libfreenect-linux-x86.jar b/lib/javacv-bin/libfreenect-linux-x86.jar new file mode 100644 index 0000000..5f9f77d Binary files /dev/null and b/lib/javacv-bin/libfreenect-linux-x86.jar differ diff --git a/lib/javacv-bin/libfreenect-linux-x86_64.jar b/lib/javacv-bin/libfreenect-linux-x86_64.jar new file mode 100644 index 0000000..6c65f68 Binary files /dev/null and b/lib/javacv-bin/libfreenect-linux-x86_64.jar differ diff --git a/lib/javacv-bin/libfreenect-macosx-x86_64.jar b/lib/javacv-bin/libfreenect-macosx-x86_64.jar new file mode 100644 index 0000000..3812586 Binary files /dev/null and b/lib/javacv-bin/libfreenect-macosx-x86_64.jar differ diff --git a/lib/javacv-bin/libfreenect-windows-x86.jar b/lib/javacv-bin/libfreenect-windows-x86.jar new file mode 100644 index 0000000..1e23941 Binary files /dev/null and b/lib/javacv-bin/libfreenect-windows-x86.jar differ diff --git a/lib/javacv-bin/libfreenect-windows-x86_64.jar b/lib/javacv-bin/libfreenect-windows-x86_64.jar new file mode 100644 index 0000000..2d4b2d3 Binary files /dev/null and b/lib/javacv-bin/libfreenect-windows-x86_64.jar differ diff --git a/lib/javacv-bin/libfreenect.jar b/lib/javacv-bin/libfreenect.jar new file mode 100644 index 0000000..48a7a75 Binary files /dev/null and b/lib/javacv-bin/libfreenect.jar differ diff --git a/lib/javacv-bin/opencv-android-arm.jar b/lib/javacv-bin/opencv-android-arm.jar new file mode 100644 index 0000000..59b54cb Binary files /dev/null and b/lib/javacv-bin/opencv-android-arm.jar differ diff --git a/lib/javacv-bin/opencv-android-x86.jar b/lib/javacv-bin/opencv-android-x86.jar new file mode 100644 index 0000000..074b9df Binary files /dev/null and b/lib/javacv-bin/opencv-android-x86.jar differ diff --git a/lib/javacv-bin/opencv-linux-x86.jar b/lib/javacv-bin/opencv-linux-x86.jar new file mode 100644 index 0000000..b75d1b6 Binary files /dev/null and b/lib/javacv-bin/opencv-linux-x86.jar differ diff --git a/lib/javacv-bin/opencv-linux-x86_64.jar b/lib/javacv-bin/opencv-linux-x86_64.jar new file mode 100644 index 0000000..8f32f69 Binary files /dev/null and b/lib/javacv-bin/opencv-linux-x86_64.jar differ diff --git a/lib/javacv-bin/opencv-macosx-x86_64.jar b/lib/javacv-bin/opencv-macosx-x86_64.jar new file mode 100644 index 0000000..4436169 Binary files /dev/null and b/lib/javacv-bin/opencv-macosx-x86_64.jar differ diff --git a/lib/javacv-bin/opencv-windows-x86.jar b/lib/javacv-bin/opencv-windows-x86.jar new file mode 100644 index 0000000..a057abf Binary files /dev/null and b/lib/javacv-bin/opencv-windows-x86.jar differ diff --git a/lib/javacv-bin/opencv-windows-x86_64.jar b/lib/javacv-bin/opencv-windows-x86_64.jar new file mode 100644 index 0000000..0bfc678 Binary files /dev/null and b/lib/javacv-bin/opencv-windows-x86_64.jar differ diff --git a/lib/javacv-bin/opencv.jar b/lib/javacv-bin/opencv.jar new file mode 100644 index 0000000..376b369 Binary files /dev/null and b/lib/javacv-bin/opencv.jar differ diff --git a/lib/javacv-bin/samples/BlackBalls.jpg b/lib/javacv-bin/samples/BlackBalls.jpg new file mode 100644 index 0000000..88aa33b Binary files /dev/null and b/lib/javacv-bin/samples/BlackBalls.jpg differ diff --git a/lib/javacv-bin/samples/Blob1.jpg b/lib/javacv-bin/samples/Blob1.jpg new file mode 100644 index 0000000..4049dbe Binary files /dev/null and b/lib/javacv-bin/samples/Blob1.jpg differ diff --git a/lib/javacv-bin/samples/Blob2.jpg b/lib/javacv-bin/samples/Blob2.jpg new file mode 100644 index 0000000..5ca1c66 Binary files /dev/null and b/lib/javacv-bin/samples/Blob2.jpg differ diff --git a/lib/javacv-bin/samples/Blob3.jpg b/lib/javacv-bin/samples/Blob3.jpg new file mode 100644 index 0000000..e792a11 Binary files /dev/null and b/lib/javacv-bin/samples/Blob3.jpg differ diff --git a/lib/javacv-bin/samples/BlobDemo.java b/lib/javacv-bin/samples/BlobDemo.java new file mode 100644 index 0000000..6d6d244 --- /dev/null +++ b/lib/javacv-bin/samples/BlobDemo.java @@ -0,0 +1,271 @@ +import org.bytedeco.javacv.Blobs; +import org.bytedeco.javacv.CanvasFrame; +import org.bytedeco.javacv.OpenCVFrameConverter; + +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; + +/////////////////////////////////////////////////////////////////// +//* *// +//* As the author of this code, I place all of this code into *// +//* the public domain. Users can use it for any legal purpose. *// +//* *// +//* - Dave Grossman *// +//* *// +/////////////////////////////////////////////////////////////////// +public class BlobDemo +{ + public static void main(String[] args) + { + System.out.println("STARTING...\n"); + demo(); + System.out.println("ALL DONE"); + } + + public static void demo() + { + int MinArea = 6; + int ErodeCount =0; + int DilateCount = 0; + + IplImage RawImage = null; + + // Read an image. + for(int k = 0; k < 7; k++) + { + if(k == 0) { RawImage = cvLoadImage("BlackBalls.jpg"); MinArea = 250; ErodeCount = 0; DilateCount = 1; } + else if(k == 1) { RawImage = cvLoadImage("Shapes1.jpg"); MinArea = 6; ErodeCount = 0; DilateCount = 1; } + else if(k == 2) { RawImage = cvLoadImage("Shapes2.jpg"); MinArea = 250; ErodeCount = 0; DilateCount = 1; } + else if(k == 3) { RawImage = cvLoadImage("Blob1.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; } + else if(k == 4) { RawImage = cvLoadImage("Blob2.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; } + else if(k == 5) { RawImage = cvLoadImage("Blob3.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; } + else if(k == 6) { RawImage = cvLoadImage("Rice.jpg"); MinArea = 30; ErodeCount = 2; DilateCount = 1; } + //ShowImage(RawImage, "RawImage", 512); + + IplImage GrayImage = cvCreateImage(cvGetSize(RawImage), IPL_DEPTH_8U, 1); + cvCvtColor(RawImage, GrayImage, CV_BGR2GRAY); + //ShowImage(GrayImage, "GrayImage", 512); + + IplImage BWImage = cvCreateImage(cvGetSize(GrayImage), IPL_DEPTH_8U, 1); + cvThreshold(GrayImage, BWImage, 127, 255, CV_THRESH_BINARY); + //ShowImage(BWImage, "BWImage"); + + IplImage WorkingImage = cvCreateImage(cvGetSize(BWImage), IPL_DEPTH_8U, 1); + cvErode(BWImage, WorkingImage, null, ErodeCount); + cvDilate(WorkingImage, WorkingImage, null, DilateCount); + //ShowImage(WorkingImage, "WorkingImage", 512); + + //cvSaveImage("Working.jpg", WorkingImage); + //PrintGrayImage(WorkingImage, "WorkingImage"); + //BinaryHistogram(WorkingImage); + + Blobs Regions = new Blobs(); + Regions.BlobAnalysis( + WorkingImage, // image + -1, -1, // ROI start col, row + -1, -1, // ROI cols, rows + 1, // border (0 = black; 1 = white) + MinArea); // minarea + Regions.PrintRegionData(); + + for(int i = 1; i <= Blobs.MaxLabel; i++) + { + double [] Region = Blobs.RegionData[i]; + int Parent = (int) Region[Blobs.BLOBPARENT]; + int Color = (int) Region[Blobs.BLOBCOLOR]; + int MinX = (int) Region[Blobs.BLOBMINX]; + int MaxX = (int) Region[Blobs.BLOBMAXX]; + int MinY = (int) Region[Blobs.BLOBMINY]; + int MaxY = (int) Region[Blobs.BLOBMAXY]; + Highlight(RawImage, MinX, MinY, MaxX, MaxY, 1); + } + + ShowImage(RawImage, "RawImage", 512); + + cvReleaseImage(GrayImage); GrayImage = null; + cvReleaseImage(BWImage); BWImage = null; + cvReleaseImage(WorkingImage); WorkingImage = null; + } + cvReleaseImage(RawImage); RawImage = null; + } + + // Versions with 2, 3, and 4 parms respectively + public static void ShowImage(IplImage image, String caption) + { + CvMat mat = image.asCvMat(); + int width = mat.cols(); if(width < 1) width = 1; + int height = mat.rows(); if(height < 1) height = 1; + double aspect = 1.0 * width / height; + if(height < 128) { height = 128; width = (int) ( height * aspect ); } + if(width < 128) width = 128; + height = (int) ( width / aspect ); + ShowImage(image, caption, width, height); + } + public static void ShowImage(IplImage image, String caption, int size) + { + if(size < 128) size = 128; + CvMat mat = image.asCvMat(); + int width = mat.cols(); if(width < 1) width = 1; + int height = mat.rows(); if(height < 1) height = 1; + double aspect = 1.0 * width / height; + if(height != size) { height = size; width = (int) ( height * aspect ); } + if(width != size) width = size; + height = (int) ( width / aspect ); + ShowImage(image, caption, width, height); + } + public static void ShowImage(IplImage image, String caption, int width, int height) + { + CanvasFrame canvas = new CanvasFrame(caption, 1); // gamma=1 + canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); + canvas.setCanvasSize(width, height); + OpenCVFrameConverter converter = new OpenCVFrameConverter.ToIplImage(); + canvas.showImage(converter.convert(image)); + } + + public static void Highlight(IplImage image, int [] inVec) + { + Highlight(image, inVec[0], inVec[1], inVec[2], inVec[3], 1); + } + public static void Highlight(IplImage image, int [] inVec, int Thick) + { + Highlight(image, inVec[0], inVec[1], inVec[2], inVec[3], Thick); + } + public static void Highlight(IplImage image, int xMin, int yMin, int xMax, int yMax) + { + Highlight(image, xMin, yMin, xMax, yMax, 1); + } + public static void Highlight(IplImage image, int xMin, int yMin, int xMax, int yMax, int Thick) + { + CvPoint pt1 = cvPoint(xMin,yMin); + CvPoint pt2 = cvPoint(xMax,yMax); + CvScalar color = cvScalar(255,0,0,0); // blue [green] [red] + cvRectangle(image, pt1, pt2, color, Thick, 4, 0); + } + + public static void PrintGrayImage(IplImage image, String caption) + { + int size = 512; // impractical to print anything larger + CvMat mat = image.asCvMat(); + int cols = mat.cols(); if(cols < 1) cols = 1; + int rows = mat.rows(); if(rows < 1) rows = 1; + double aspect = 1.0 * cols / rows; + if(rows > size) { rows = size; cols = (int) ( rows * aspect ); } + if(cols > size) cols = size; + rows = (int) ( cols / aspect ); + PrintGrayImage(image, caption, 0, cols, 0, rows); + } + public static void PrintGrayImage(IplImage image, String caption, int MinX, int MaxX, int MinY, int MaxY) + { + int size = 512; // impractical to print anything larger + CvMat mat = image.asCvMat(); + int cols = mat.cols(); if(cols < 1) cols = 1; + int rows = mat.rows(); if(rows < 1) rows = 1; + + if(MinX < 0) MinX = 0; if(MinX > cols) MinX = cols; + if(MaxX < 0) MaxX = 0; if(MaxX > cols) MaxX = cols; + if(MinY < 0) MinY = 0; if(MinY > rows) MinY = rows; + if(MaxY < 0) MaxY = 0; if(MaxY > rows) MaxY = rows; + + System.out.println("\n" + caption); + System.out.print(" +"); + for(int icol = MinX; icol < MaxX; icol++) System.out.print("-"); + System.out.println("+"); + + for(int irow = MinY; irow < MaxY; irow++) + { + if(irow<10) System.out.print(" "); + if(irow<100) System.out.print(" "); + System.out.print(irow); + System.out.print("|"); + for(int icol = MinX; icol < MaxX; icol++) + { + int val = (int) mat.get(irow,icol); + String C = " "; + if(val == 0) C = "*"; + System.out.print(C); + } + System.out.println("|"); + } + System.out.print(" +"); + for(int icol = MinX; icol < MaxX; icol++) System.out.print("-"); + System.out.println("+"); + } + + public static void PrintImageProperties(IplImage image) + { + CvMat mat = image.asCvMat(); + int cols = mat.cols(); + int rows = mat.rows(); + int depth = mat.depth(); + System.out.println("ImageProperties for " + image + " : cols=" + cols + " rows=" + rows + " depth=" + depth); + } + + public static float BinaryHistogram(IplImage image) + { + CvScalar Sum = cvSum(image); + float WhitePixels = (float) ( Sum.getVal(0) / 255 ); + CvMat mat = image.asCvMat(); + float TotalPixels = mat.cols() * mat.rows(); + //float BlackPixels = TotalPixels - WhitePixels; + return WhitePixels / TotalPixels; + } + + // Counterclockwise small angle rotation by skewing - Does not stretch border pixels + public static IplImage SkewGrayImage(IplImage Src, double angle) // angle is in radians + { + //double radians = - Math.PI * angle / 360.0; // Half because skew is horizontal and vertical + double sin = - Math.sin(angle); + double AbsSin = Math.abs(sin); + + int nChannels = Src.nChannels(); + if(nChannels != 1) + { + System.out.println("ERROR: SkewGrayImage: Require 1 channel: nChannels=" + nChannels); + System.exit(1); + } + + CvMat SrcMat = Src.asCvMat(); + int SrcCols = SrcMat.cols(); + int SrcRows = SrcMat.rows(); + + double WidthSkew = AbsSin * SrcRows; + double HeightSkew = AbsSin * SrcCols; + + int DstCols = (int) ( SrcCols + WidthSkew ); + int DstRows = (int) ( SrcRows + HeightSkew ); + + CvMat DstMat = cvCreateMat(DstRows, DstCols, CV_8UC1); // Type matches IPL_DEPTH_8U + cvSetZero(DstMat); + cvNot(DstMat, DstMat); + + for(int irow = 0; irow < DstRows; irow++) + { + int dcol = (int) ( WidthSkew * irow / SrcRows ); + for(int icol = 0; icol < DstCols; icol++) + { + int drow = (int) ( HeightSkew - HeightSkew * icol / SrcCols ); + int jrow = irow - drow; + int jcol = icol - dcol; + if(jrow < 0 || jcol < 0 || jrow >= SrcRows || jcol >= SrcCols) DstMat.put(irow, icol, 255); + else DstMat.put(irow, icol, (int) SrcMat.get(jrow,jcol)); + } + } + + IplImage Dst = cvCreateImage(cvSize(DstCols, DstRows), IPL_DEPTH_8U, 1); + Dst = DstMat.asIplImage(); + return Dst; + } + + public static IplImage TransposeImage(IplImage SrcImage) + { + CvMat mat = SrcImage.asCvMat(); + int cols = mat.cols(); + int rows = mat.rows(); + IplImage DstImage = cvCreateImage(cvSize(rows, cols), IPL_DEPTH_8U, 1); + cvTranspose(SrcImage, DstImage); + cvFlip(DstImage,DstImage,1); + return DstImage; + } +} + diff --git a/lib/javacv-bin/samples/ColoredObjectTrack.java b/lib/javacv-bin/samples/ColoredObjectTrack.java new file mode 100644 index 0000000..b8efdd0 --- /dev/null +++ b/lib/javacv-bin/samples/ColoredObjectTrack.java @@ -0,0 +1,118 @@ +/* + * Just an example using the opencv to make a colored object tracking, + * i adpted this code to bytedeco/javacv, i think this will help some people. + * + * Waldemar + */ + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.image.BufferedImage; +import javax.swing.JPanel; +import org.bytedeco.javacv.CanvasFrame; +import org.bytedeco.javacv.FrameGrabber; +import org.bytedeco.javacv.Java2DFrameConverter; +import org.bytedeco.javacv.OpenCVFrameConverter; + +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; + +public class ColoredObjectTrack implements Runnable { + + public static void main(String[] args) { + ColoredObjectTrack cot = new ColoredObjectTrack(); + Thread th = new Thread(cot); + th.start(); + } + + final int INTERVAL = 10;// 1sec + final int CAMERA_NUM = 0; // Default camera for this time + + /** + * Correct the color range- it depends upon the object, camera quality, + * environment. + */ + static CvScalar rgba_min = cvScalar(0, 0, 130, 0);// RED wide dabur birko + static CvScalar rgba_max = cvScalar(80, 80, 255, 0); + + IplImage image; + CanvasFrame canvas = new CanvasFrame("Web Cam Live"); + CanvasFrame path = new CanvasFrame("Detection"); + int ii = 0; + JPanel jp = new JPanel(); + + public ColoredObjectTrack() { + canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); + path.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); + path.setContentPane(jp); + } + + @Override + public void run() { + try { + FrameGrabber grabber = FrameGrabber.createDefault(CAMERA_NUM); + OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage(); + grabber.start(); + IplImage img; + int posX = 0; + int posY = 0; + while (true) { + img = converter.convert(grabber.grab()); + if (img != null) { + // show image on window + cvFlip(img, img, 1);// l-r = 90_degrees_steps_anti_clockwise + canvas.showImage(converter.convert(img)); + IplImage detectThrs = getThresholdImage(img); + + CvMoments moments = new CvMoments(); + cvMoments(detectThrs, moments, 1); + double mom10 = cvGetSpatialMoment(moments, 1, 0); + double mom01 = cvGetSpatialMoment(moments, 0, 1); + double area = cvGetCentralMoment(moments, 0, 0); + posX = (int) (mom10 / area); + posY = (int) (mom01 / area); + // only if its a valid position + if (posX > 0 && posY > 0) { + paint(img, posX, posY); + } + } + // Thread.sleep(INTERVAL); + } + } catch (Exception e) { + } + } + + private void paint(IplImage img, int posX, int posY) { + Graphics g = jp.getGraphics(); + path.setSize(img.width(), img.height()); + // g.clearRect(0, 0, img.width(), img.height()); + g.setColor(Color.RED); + // g.fillOval(posX, posY, 20, 20); + g.drawOval(posX, posY, 20, 20); + System.out.println(posX + " , " + posY); + + } + + private IplImage getThresholdImage(IplImage orgImg) { + IplImage imgThreshold = cvCreateImage(cvGetSize(orgImg), 8, 1); + // + cvInRangeS(orgImg, rgba_min, rgba_max, imgThreshold);// red + + cvSmooth(imgThreshold, imgThreshold, CV_MEDIAN, 15,0,0,0); + cvSaveImage(++ii + "dsmthreshold.jpg", imgThreshold); + return imgThreshold; + } + + + public IplImage Equalize(BufferedImage bufferedimg) { + Java2DFrameConverter converter1 = new Java2DFrameConverter(); + OpenCVFrameConverter.ToIplImage converter2 = new OpenCVFrameConverter.ToIplImage(); + IplImage iploriginal = converter2.convert(converter1.convert(bufferedimg)); + IplImage srcimg = IplImage.create(iploriginal.width(), iploriginal.height(), IPL_DEPTH_8U, 1); + IplImage destimg = IplImage.create(iploriginal.width(), iploriginal.height(), IPL_DEPTH_8U, 1); + cvCvtColor(iploriginal, srcimg, CV_BGR2GRAY); + cvEqualizeHist(srcimg, destimg); + return destimg; + } +} diff --git a/lib/javacv-bin/samples/FaceApplet.html b/lib/javacv-bin/samples/FaceApplet.html new file mode 100644 index 0000000..dab5395 --- /dev/null +++ b/lib/javacv-bin/samples/FaceApplet.html @@ -0,0 +1,17 @@ + + + + FaceApplet + + + + +

FaceApplet

+ + + + diff --git a/lib/javacv-bin/samples/FaceApplet.java b/lib/javacv-bin/samples/FaceApplet.java new file mode 100644 index 0000000..1145a20 --- /dev/null +++ b/lib/javacv-bin/samples/FaceApplet.java @@ -0,0 +1,149 @@ +import java.applet.Applet; +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.opencv_objdetect; +import org.bytedeco.javacv.Frame; +import org.bytedeco.javacv.FrameGrabber; +import org.bytedeco.javacv.Java2DFrameConverter; +import org.bytedeco.javacv.OpenCVFrameConverter; +import org.bytedeco.javacv.OpenCVFrameGrabber; + +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_objdetect.*; + +/** + * + * @author Samuel Audet + */ +public class FaceApplet extends Applet implements Runnable { + + private CvHaarClassifierCascade classifier = null; + private CvMemStorage storage = null; + private FrameGrabber grabber = null; + private IplImage grabbedImage = null, grayImage = null, smallImage = null; + private CvSeq faces = null; + private boolean stop = false; + private Exception exception = null; + OpenCVFrameConverter.ToIplImage grabberConverter = new OpenCVFrameConverter.ToIplImage(); + Java2DFrameConverter paintConverter = new Java2DFrameConverter(); + + @Override public void init() { + try { + // Load the classifier file from Java resources. + String classiferName = "haarcascade_frontalface_alt.xml"; + File classifierFile = Loader.extractResource(classiferName, null, "classifier", ".xml"); + if (classifierFile == null || classifierFile.length() <= 0) { + throw new IOException("Could not extract \"" + classiferName + "\" from Java resources."); + } + + // Preload the opencv_objdetect module to work around a known bug. + Loader.load(opencv_objdetect.class); + classifier = new CvHaarClassifierCascade(cvLoad(classifierFile.getAbsolutePath())); + classifierFile.delete(); + if (classifier.isNull()) { + throw new IOException("Could not load the classifier file."); + } + + storage = CvMemStorage.create(); + } catch (Exception e) { + if (exception == null) { + exception = e; + repaint(); + } + } + } + + @Override public void start() { + try { + new Thread(this).start(); + } catch (Exception e) { + if (exception == null) { + exception = e; + repaint(); + } + } + } + + public void run() { + try { + try { + grabber = FrameGrabber.createDefault(0); + grabber.setImageWidth(getWidth()); + grabber.setImageHeight(getHeight()); + grabber.start(); + grabbedImage = grabberConverter.convert(grabber.grab()); + } catch (Exception e) { + if (grabber != null) grabber.release(); + grabber = new OpenCVFrameGrabber(0); + grabber.setImageWidth(getWidth()); + grabber.setImageHeight(getHeight()); + grabber.start(); + grabbedImage = grabberConverter.convert(grabber.grab()); + } + grayImage = IplImage.create(grabbedImage.width(), grabbedImage.height(), IPL_DEPTH_8U, 1); + smallImage = IplImage.create(grabbedImage.width()/4, grabbedImage.height()/4, IPL_DEPTH_8U, 1); + stop = false; + while (!stop && (grabbedImage = grabberConverter.convert(grabber.grab())) != null) { + if (faces == null) { + cvClearMemStorage(storage); + cvCvtColor(grabbedImage, grayImage, CV_BGR2GRAY); + cvResize(grayImage, smallImage, CV_INTER_AREA); + faces = cvHaarDetectObjects(smallImage, classifier, storage, 1.1, 3, CV_HAAR_DO_CANNY_PRUNING); + repaint(); + } + } + grabbedImage = grayImage = smallImage = null; + grabber.stop(); + grabber.release(); + grabber = null; + } catch (Exception e) { + if (exception == null) { + exception = e; + repaint(); + } + } + } + + @Override public void update(Graphics g) { + paint(g); + } + + @Override public void paint(Graphics g) { + if (grabbedImage != null) { + Frame frame = grabberConverter.convert(grabbedImage); + BufferedImage image = paintConverter.getBufferedImage(frame, 2.2/grabber.getGamma()); + Graphics2D g2 = image.createGraphics(); + if (faces != null) { + g2.setColor(Color.RED); + g2.setStroke(new BasicStroke(2)); + int total = faces.total(); + for (int i = 0; i < total; i++) { + CvRect r = new CvRect(cvGetSeqElem(faces, i)); + g2.drawRect(r.x()*4, r.y()*4, r.width()*4, r.height()*4); + } + faces = null; + } + g.drawImage(image, 0, 0, null); + } + if (exception != null) { + int y = 0, h = g.getFontMetrics().getHeight(); + g.drawString(exception.toString(), 5, y += h); + for (StackTraceElement e : exception.getStackTrace()) { + g.drawString(" at " + e.toString(), 5, y += h); + } + } + } + + @Override public void stop() { + stop = true; + } + + @Override public void destroy() { } +} diff --git a/lib/javacv-bin/samples/FaceApplet.jnlp b/lib/javacv-bin/samples/FaceApplet.jnlp new file mode 100644 index 0000000..f97f22a --- /dev/null +++ b/lib/javacv-bin/samples/FaceApplet.jnlp @@ -0,0 +1,16 @@ + + + + FaceApplet + Samuel Audet + + + + + + + + + + + diff --git a/lib/javacv-bin/samples/FacePreview.java b/lib/javacv-bin/samples/FacePreview.java new file mode 100644 index 0000000..118a5ee --- /dev/null +++ b/lib/javacv-bin/samples/FacePreview.java @@ -0,0 +1,294 @@ +/* + * Copyright (C) 2010,2011,2012 Samuel Audet + * + * FacePreview - A fusion of OpenCV's facedetect and Android's CameraPreview samples, + * with JavaCV + JavaCPP as the glue in between. + * + * This file was based on CameraPreview.java that came with the Samples for + * Android SDK API 8, revision 1 and contained the following copyright notice: + * + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * + * IMPORTANT - Make sure the AndroidManifest.xml file looks like this: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ + +package org.bytedeco.javacv.facepreview; + +import android.app.Activity; +import android.app.AlertDialog; +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.ImageFormat; +import android.graphics.Paint; +import android.hardware.Camera; +import android.hardware.Camera.Size; +import android.os.Bundle; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.View; +import android.view.Window; +import android.view.WindowManager; +import android.widget.FrameLayout; +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.List; +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.opencv_objdetect; + +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_objdetect.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; + +// ---------------------------------------------------------------------- + +public class FacePreview extends Activity { + private FrameLayout layout; + private FaceView faceView; + private Preview mPreview; + + @Override + protected void onCreate(Bundle savedInstanceState) { + // Hide the window title. + requestWindowFeature(Window.FEATURE_NO_TITLE); + + super.onCreate(savedInstanceState); + + getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN); + + // Create our Preview view and set it as the content of our activity. + try { + layout = new FrameLayout(this); + faceView = new FaceView(this); + mPreview = new Preview(this, faceView); + layout.addView(mPreview); + layout.addView(faceView); + setContentView(layout); + } catch (IOException e) { + e.printStackTrace(); + new AlertDialog.Builder(this).setMessage(e.getMessage()).create().show(); + } + } +} + +// ---------------------------------------------------------------------- + +class FaceView extends View implements Camera.PreviewCallback { + public static final int SUBSAMPLING_FACTOR = 4; + + private IplImage grayImage; + private CvHaarClassifierCascade classifier; + private CvMemStorage storage; + private CvSeq faces; + + public FaceView(FacePreview context) throws IOException { + super(context); + + // Load the classifier file from Java resources. + File classifierFile = Loader.extractResource(getClass(), + "/org/bytedeco/javacv/facepreview/haarcascade_frontalface_alt.xml", + context.getCacheDir(), "classifier", ".xml"); + if (classifierFile == null || classifierFile.length() <= 0) { + throw new IOException("Could not extract the classifier file from Java resource."); + } + + // Preload the opencv_objdetect module to work around a known bug. + Loader.load(opencv_objdetect.class); + classifier = new CvHaarClassifierCascade(cvLoad(classifierFile.getAbsolutePath())); + classifierFile.delete(); + if (classifier.isNull()) { + throw new IOException("Could not load the classifier file."); + } + storage = CvMemStorage.create(); + } + + public void onPreviewFrame(final byte[] data, final Camera camera) { + try { + Camera.Size size = camera.getParameters().getPreviewSize(); + processImage(data, size.width, size.height); + camera.addCallbackBuffer(data); + } catch (RuntimeException e) { + // The camera has probably just been released, ignore. + } + } + + protected void processImage(byte[] data, int width, int height) { + // First, downsample our image and convert it into a grayscale IplImage + int f = SUBSAMPLING_FACTOR; + if (grayImage == null || grayImage.width() != width/f || grayImage.height() != height/f) { + grayImage = IplImage.create(width/f, height/f, IPL_DEPTH_8U, 1); + } + int imageWidth = grayImage.width(); + int imageHeight = grayImage.height(); + int dataStride = f*width; + int imageStride = grayImage.widthStep(); + ByteBuffer imageBuffer = grayImage.getByteBuffer(); + for (int y = 0; y < imageHeight; y++) { + int dataLine = y*dataStride; + int imageLine = y*imageStride; + for (int x = 0; x < imageWidth; x++) { + imageBuffer.put(imageLine + x, data[dataLine + f*x]); + } + } + + cvClearMemStorage(storage); + faces = cvHaarDetectObjects(grayImage, classifier, storage, 1.1, 3, CV_HAAR_DO_CANNY_PRUNING); + postInvalidate(); + } + + @Override + protected void onDraw(Canvas canvas) { + Paint paint = new Paint(); + paint.setColor(Color.RED); + paint.setTextSize(20); + + String s = "FacePreview - This side up."; + float textWidth = paint.measureText(s); + canvas.drawText(s, (getWidth()-textWidth)/2, 20, paint); + + if (faces != null) { + paint.setStrokeWidth(2); + paint.setStyle(Paint.Style.STROKE); + float scaleX = (float)getWidth()/grayImage.width(); + float scaleY = (float)getHeight()/grayImage.height(); + int total = faces.total(); + for (int i = 0; i < total; i++) { + CvRect r = new CvRect(cvGetSeqElem(faces, i)); + int x = r.x(), y = r.y(), w = r.width(), h = r.height(); + canvas.drawRect(x*scaleX, y*scaleY, (x+w)*scaleX, (y+h)*scaleY, paint); + } + } + } +} + +// ---------------------------------------------------------------------- + +class Preview extends SurfaceView implements SurfaceHolder.Callback { + SurfaceHolder mHolder; + Camera mCamera; + Camera.PreviewCallback previewCallback; + + Preview(Context context, Camera.PreviewCallback previewCallback) { + super(context); + this.previewCallback = previewCallback; + + // Install a SurfaceHolder.Callback so we get notified when the + // underlying surface is created and destroyed. + mHolder = getHolder(); + mHolder.addCallback(this); + mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); + } + + public void surfaceCreated(SurfaceHolder holder) { + // The Surface has been created, acquire the camera and tell it where + // to draw. + mCamera = Camera.open(); + try { + mCamera.setPreviewDisplay(holder); + } catch (IOException exception) { + mCamera.release(); + mCamera = null; + // TODO: add more exception handling logic here + } + } + + public void surfaceDestroyed(SurfaceHolder holder) { + // Surface will be destroyed when we return, so stop the preview. + // Because the CameraDevice object is not a shared resource, it's very + // important to release it when the activity is paused. + mCamera.stopPreview(); + mCamera.release(); + mCamera = null; + } + + + private Size getOptimalPreviewSize(List sizes, int w, int h) { + final double ASPECT_TOLERANCE = 0.05; + double targetRatio = (double) w / h; + if (sizes == null) return null; + + Size optimalSize = null; + double minDiff = Double.MAX_VALUE; + + int targetHeight = h; + + // Try to find an size match aspect ratio and size + for (Size size : sizes) { + double ratio = (double) size.width / size.height; + if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue; + if (Math.abs(size.height - targetHeight) < minDiff) { + optimalSize = size; + minDiff = Math.abs(size.height - targetHeight); + } + } + + // Cannot find the one match the aspect ratio, ignore the requirement + if (optimalSize == null) { + minDiff = Double.MAX_VALUE; + for (Size size : sizes) { + if (Math.abs(size.height - targetHeight) < minDiff) { + optimalSize = size; + minDiff = Math.abs(size.height - targetHeight); + } + } + } + return optimalSize; + } + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + // Now that the size is known, set up the camera parameters and begin + // the preview. + Camera.Parameters parameters = mCamera.getParameters(); + + List sizes = parameters.getSupportedPreviewSizes(); + Size optimalSize = getOptimalPreviewSize(sizes, w, h); + parameters.setPreviewSize(optimalSize.width, optimalSize.height); + + mCamera.setParameters(parameters); + if (previewCallback != null) { + mCamera.setPreviewCallbackWithBuffer(previewCallback); + Camera.Size size = parameters.getPreviewSize(); + byte[] data = new byte[size.width*size.height* + ImageFormat.getBitsPerPixel(parameters.getPreviewFormat())/8]; + mCamera.addCallbackBuffer(data); + } + mCamera.startPreview(); + } + +} diff --git a/lib/javacv-bin/samples/FaceRecognizerInVideo.java b/lib/javacv-bin/samples/FaceRecognizerInVideo.java new file mode 100644 index 0000000..d883b22 --- /dev/null +++ b/lib/javacv-bin/samples/FaceRecognizerInVideo.java @@ -0,0 +1,104 @@ + +import java.io.File; + +import org.bytedeco.javacv.Frame; +import org.bytedeco.javacv.FrameGrabber.Exception; +import org.bytedeco.javacv.OpenCVFrameConverter; +import org.bytedeco.javacv.OpenCVFrameGrabber; + +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_face.*; +import static org.bytedeco.javacpp.opencv_highgui.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_objdetect.*; + +/** + * This is an example how to detect face in a video file with javacv + * @author Vincent He (chinadragon0515@gmail.com) + * + */ +public class FaceRecognizerInVideo { + + public static void main(String[] args) throws Exception { + + OpenCVFrameConverter.ToMat converterToMat = new OpenCVFrameConverter.ToMat(); + + if (args.length < 2) { + System.out.println("Two parameters are required to run this program, first parameter is the analized video and second parameter is the trained result for fisher faces."); + } + + String videoFileName = args[0]; + String trainedResult = args[1]; + + CascadeClassifier face_cascade = new CascadeClassifier( + "data\\haarcascade_frontalface_default.xml"); + FaceRecognizer lbphFaceRecognizer = createLBPHFaceRecognizer(); + lbphFaceRecognizer.load(trainedResult); + + File f = new File(videoFileName); + + OpenCVFrameGrabber grabber = null; + try { + grabber = OpenCVFrameGrabber.createDefault(f); + grabber.start(); + } catch (Exception e) { + System.err.println("Failed start the grabber."); + } + + Frame videoFrame = null; + Mat videoMat = new Mat(); + while (true) { + videoFrame = grabber.grab(); + videoMat = converterToMat.convert(videoFrame); + Mat videoMatGray = new Mat(); + // Convert the current frame to grayscale: + cvtColor(videoMat, videoMatGray, COLOR_BGRA2GRAY); + equalizeHist(videoMatGray, videoMatGray); + + Point p = new Point(); + RectVector faces = new RectVector(); + // Find the faces in the frame: + face_cascade.detectMultiScale(videoMatGray, faces); + + // At this point you have the position of the faces in + // faces. Now we'll get the faces, make a prediction and + // annotate it in the video. Cool or what? + for (int i = 0; i < faces.size(); i++) { + Rect face_i = faces.get(i); + + Mat face = new Mat(videoMatGray, face_i); + // If fisher face recognizer is used, the face need to be + // resized. + // resize(face, face_resized, new Size(im_width, im_height), + // 1.0, 1.0, INTER_CUBIC); + + // Now perform the prediction, see how easy that is: + int prediction = lbphFaceRecognizer.predict(face); + + // And finally write all we've found out to the original image! + // First of all draw a green rectangle around the detected face: + rectangle(videoMat, face_i, new Scalar(0, 255, 0, 1)); + + // Create the text we will annotate the box with: + String box_text = "Prediction = " + prediction; + // Calculate the position for annotated text (make sure we don't + // put illegal values in there): + int pos_x = Math.max(face_i.tl().x() - 10, 0); + int pos_y = Math.max(face_i.tl().y() - 10, 0); + // And now put it into the image: + putText(videoMat, box_text, new Point(pos_x, pos_y), + FONT_HERSHEY_PLAIN, 1.0, new Scalar(0, 255, 0, 2.0)); + } + // Show the result: + imshow("face_recognizer", videoMat); + + char key = (char) waitKey(20); + // Exit this loop on escape: + if (key == 27) { + destroyAllWindows(); + break; + } + } + } + +} diff --git a/lib/javacv-bin/samples/HoughLines.java b/lib/javacv-bin/samples/HoughLines.java new file mode 100644 index 0000000..7567020 --- /dev/null +++ b/lib/javacv-bin/samples/HoughLines.java @@ -0,0 +1,117 @@ +import javax.swing.JFrame; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacv.*; +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; + +/** + * C to Java translation of the houghlines.c sample provided in the c sample directory of OpenCV 2.1, + * using the JavaCV Java wrapper of OpenCV 2.2 developped by Samuel Audet. + * + * @author Jeremy Nicola + * jeremy.nicola@gmail.com + */ +public class HoughLines { + + /** + * usage: java HoughLines imageDir\imageName TransformType + */ + public static void main(String[] args) { + + String fileName = args.length >= 1 ? args[0] : "pic1.png"; // if no params provided, compute the defaut image + IplImage src = cvLoadImage(fileName, 0); + IplImage dst; + IplImage colorDst; + CvMemStorage storage = cvCreateMemStorage(0); + CvSeq lines = new CvSeq(); + + CanvasFrame source = new CanvasFrame("Source"); + CanvasFrame hough = new CanvasFrame("Hough"); + OpenCVFrameConverter.ToIplImage sourceConverter = new OpenCVFrameConverter.ToIplImage(); + OpenCVFrameConverter.ToIplImage houghConverter = new OpenCVFrameConverter.ToIplImage(); + if (src == null) { + System.out.println("Couldn't load source image."); + return; + } + + dst = cvCreateImage(cvGetSize(src), src.depth(), 1); + colorDst = cvCreateImage(cvGetSize(src), src.depth(), 3); + + cvCanny(src, dst, 50, 200, 3); + cvCvtColor(dst, colorDst, CV_GRAY2BGR); + + /* + * apply the probabilistic hough transform + * which returns for each line deteced two points ((x1, y1); (x2,y2)) + * defining the detected segment + */ + if (args.length == 2 && args[1].contentEquals("probabilistic")) { + System.out.println("Using the Probabilistic Hough Transform"); + lines = cvHoughLines2(dst, storage, CV_HOUGH_PROBABILISTIC, 1, Math.PI / 180, 40, 50, 10, 0, CV_PI); + for (int i = 0; i < lines.total(); i++) { + // Based on JavaCPP, the equivalent of the C code: + // CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i); + // CvPoint first=line[0], second=line[1] + // is: + Pointer line = cvGetSeqElem(lines, i); + CvPoint pt1 = new CvPoint(line).position(0); + CvPoint pt2 = new CvPoint(line).position(1); + + System.out.println("Line spotted: "); + System.out.println("\t pt1: " + pt1); + System.out.println("\t pt2: " + pt2); + cvLine(colorDst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0); // draw the segment on the image + } + } + /* + * Apply the multiscale hough transform which returns for each line two float parameters (rho, theta) + * rho: distance from the origin of the image to the line + * theta: angle between the x-axis and the normal line of the detected line + */ + else if(args.length==2 && args[1].contentEquals("multiscale")){ + System.out.println("Using the multiscale Hough Transform"); // + lines = cvHoughLines2(dst, storage, CV_HOUGH_MULTI_SCALE, 1, Math.PI / 180, 40, 1, 1, 0, CV_PI); + for (int i = 0; i < lines.total(); i++) { + CvPoint2D32f point = new CvPoint2D32f(cvGetSeqElem(lines, i)); + + float rho=point.x(); + float theta=point.y(); + + double a = Math.cos((double) theta), b = Math.sin((double) theta); + double x0 = a * rho, y0 = b * rho; + CvPoint pt1 = cvPoint((int) Math.round(x0 + 1000 * (-b)), (int) Math.round(y0 + 1000 * (a))), pt2 = cvPoint((int) Math.round(x0 - 1000 * (-b)), (int) Math.round(y0 - 1000 * (a))); + System.out.println("Line spoted: "); + System.out.println("\t rho= " + rho); + System.out.println("\t theta= " + theta); + cvLine(colorDst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0); + } + } + /* + * Default: apply the standard hough transform. Outputs: same as the multiscale output. + */ + else { + System.out.println("Using the Standard Hough Transform"); + lines = cvHoughLines2(dst, storage, CV_HOUGH_STANDARD, 1, Math.PI / 180, 90, 0, 0, 0, CV_PI); + for (int i = 0; i < lines.total(); i++) { + CvPoint2D32f point = new CvPoint2D32f(cvGetSeqElem(lines, i)); + + float rho=point.x(); + float theta=point.y(); + + double a = Math.cos((double) theta), b = Math.sin((double) theta); + double x0 = a * rho, y0 = b * rho; + CvPoint pt1 = cvPoint((int) Math.round(x0 + 1000 * (-b)), (int) Math.round(y0 + 1000 * (a))), pt2 = cvPoint((int) Math.round(x0 - 1000 * (-b)), (int) Math.round(y0 - 1000 * (a))); + System.out.println("Line spotted: "); + System.out.println("\t rho= " + rho); + System.out.println("\t theta= " + theta); + cvLine(colorDst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0); + } + } + source.showImage(sourceConverter.convert(src)); + hough.showImage(houghConverter.convert(colorDst)); + + source.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + hough.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } +} diff --git a/lib/javacv-bin/samples/MotionDetector.java b/lib/javacv-bin/samples/MotionDetector.java new file mode 100644 index 0000000..0f528e2 --- /dev/null +++ b/lib/javacv-bin/samples/MotionDetector.java @@ -0,0 +1,98 @@ +/* + * I developed some code for recognize motion detections with JavaCV. + * Actually, it works with an array of Rect, performing, every cicle, an + * intersection test with area of difference with the rect of interests + * (this array is callad "sa", stands for SizedArea). I hope could this + * helps someone. + * + * Feel free to ask about any question regarding the code above, cheers! + * + * Angelo Marchesin + */ + +import org.bytedeco.javacpp.*; +import org.bytedeco.javacv.*; +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; + +public class MotionDetector { + public static void main(String[] args) throws Exception { + OpenCVFrameGrabber grabber = new OpenCVFrameGrabber(0); + OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage(); + grabber.start(); + + IplImage frame = converter.convert(grabber.grab()); + IplImage image = null; + IplImage prevImage = null; + IplImage diff = null; + + CanvasFrame canvasFrame = new CanvasFrame("Some Title"); + canvasFrame.setCanvasSize(frame.width(), frame.height()); + + CvMemStorage storage = CvMemStorage.create(); + + while (canvasFrame.isVisible() && (frame = converter.convert(grabber.grab())) != null) { + cvClearMemStorage(storage); + + cvSmooth(frame, frame, CV_GAUSSIAN, 9, 9, 2, 2); + if (image == null) { + image = IplImage.create(frame.width(), frame.height(), IPL_DEPTH_8U, 1); + cvCvtColor(frame, image, CV_RGB2GRAY); + } else { + prevImage = IplImage.create(frame.width(), frame.height(), IPL_DEPTH_8U, 1); + prevImage = image; + image = IplImage.create(frame.width(), frame.height(), IPL_DEPTH_8U, 1); + cvCvtColor(frame, image, CV_RGB2GRAY); + } + + if (diff == null) { + diff = IplImage.create(frame.width(), frame.height(), IPL_DEPTH_8U, 1); + } + + if (prevImage != null) { + // perform ABS difference + cvAbsDiff(image, prevImage, diff); + // do some threshold for wipe away useless details + cvThreshold(diff, diff, 64, 255, CV_THRESH_BINARY); + + canvasFrame.showImage(converter.convert(diff)); + + // recognize contours + CvSeq contour = new CvSeq(null); + cvFindContours(diff, storage, contour, Loader.sizeof(CvContour.class), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); + + while (contour != null && !contour.isNull()) { + if (contour.elem_size() > 0) { + CvBox2D box = cvMinAreaRect2(contour, storage); + // test intersection + if (box != null) { + CvPoint2D32f center = box.center(); + CvSize2D32f size = box.size(); +/* for (int i = 0; i < sa.length; i++) { + if ((Math.abs(center.x - (sa[i].offsetX + sa[i].width / 2))) < ((size.width / 2) + (sa[i].width / 2)) && + (Math.abs(center.y - (sa[i].offsetY + sa[i].height / 2))) < ((size.height / 2) + (sa[i].height / 2))) { + + if (!alarmedZones.containsKey(i)) { + alarmedZones.put(i, true); + activeAlarms.put(i, 1); + } else { + activeAlarms.remove(i); + activeAlarms.put(i, 1); + } + System.out.println("Motion Detected in the area no: " + i + + " Located at points: (" + sa[i].x + ", " + sa[i].y+ ") -" + + " (" + (sa[i].x +sa[i].width) + ", " + + (sa[i].y+sa[i].height) + ")"); + } + } +*/ + } + } + contour = contour.h_next(); + } + } + } + grabber.stop(); + canvasFrame.dispose(); + } +} diff --git a/lib/javacv-bin/samples/OpenCVFaceRecognizer.java b/lib/javacv-bin/samples/OpenCVFaceRecognizer.java new file mode 100644 index 0000000..7a845e3 --- /dev/null +++ b/lib/javacv-bin/samples/OpenCVFaceRecognizer.java @@ -0,0 +1,78 @@ +import java.io.File; +import java.io.FilenameFilter; +import java.nio.IntBuffer; +import static org.bytedeco.javacpp.opencv_face.*; +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; + +/** + * I couldn't find any tutorial on how to perform face recognition using OpenCV and Java, + * so I decided to share a viable solution here. The solution is very inefficient in its + * current form as the training model is built at each run, however it shows what's needed + * to make it work. + * + * The class below takes two arguments: The path to the directory containing the training + * faces and the path to the image you want to classify. Not that all images has to be of + * the same size and that the faces already has to be cropped out of their original images + * (Take a look here http://fivedots.coe.psu.ac.th/~ad/jg/nui07/index.html if you haven't + * done the face detection yet). + * + * For the simplicity of this post, the class also requires that the training images have + * filename format: