Full Code of bytedeco/javacv for AI

master 47b4003c00b0 cached
131 files
1.9 MB
575.6k tokens
2320 symbols
1 requests
Download .txt
Showing preview only (2,071K chars total). Download the full file or copy to clipboard to get everything.
Repository: bytedeco/javacv
Branch: master
Commit: 47b4003c00b0
Files: 131
Total size: 1.9 MB

Directory structure:
gitextract_7jum8khe/

├── .github/
│   ├── FUNDING.yml
│   └── workflows/
│       └── javacv.yml
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── LICENSE.txt
├── README.md
├── platform/
│   ├── pom.xml
│   └── src/
│       ├── main/
│       │   ├── assembly/
│       │   │   ├── bin.xml
│       │   │   └── src.xml
│       │   └── java9/
│       │       └── module-info.java
│       └── test/
│           └── java/
│               └── org/
│                   └── bytedeco/
│                       └── javacv/
│                           ├── FrameConverterTest.java
│                           ├── FrameFilterTest.java
│                           ├── FrameGrabberChangingResolutionTest.java
│                           ├── FrameGrabberTest.java
│                           └── SeekableByteArrayOutputStreamTest.java
├── pom.xml
├── samples/
│   ├── AudioSplitMergeHelper.java
│   ├── BioInspiredRetina.java
│   ├── BlobDemo.java
│   ├── CaffeGooglenet.java
│   ├── ColoredObjectTrack.java
│   ├── DeepLearningFaceDetection.java
│   ├── DeinterlacedVideoPlayer.java
│   ├── Demo.java
│   ├── FFmpegStreamingTimeout.java
│   ├── FaceApplet.html
│   ├── FaceApplet.java
│   ├── FaceApplet.jnlp
│   ├── FacePreview.java
│   ├── FaceRecognizerInVideo.java
│   ├── HoughLines.java
│   ├── ImageSegmentation.java
│   ├── JavaFxPlayVideoAndAudio.java
│   ├── KazemiFacemarkExample.java
│   ├── LBFFacemarkExampleWithVideo.java
│   ├── MotionDetector.java
│   ├── OpenCVFaceRecognizer.java
│   ├── OpenCVFeatures2dSerialization.java
│   ├── OpticalFlowDense.java
│   ├── OpticalFlowTracker.java
│   ├── PacketRecorderTest.java
│   ├── PerspectiveWarpDemo.java
│   ├── PrincipalComponentAnalysis.java
│   ├── RLSA.java
│   ├── RealSense2DepthMeasuring.java
│   ├── RecordActivity.java
│   ├── Similarity.java
│   ├── Smoother.java
│   ├── Square.java
│   ├── TemplateMatching.java
│   ├── WebcamAndMicrophoneCapture.java
│   ├── YOLONet.java
│   ├── haarcascade_frontalface_alt2.xml
│   └── pom.xml
└── src/
    └── main/
        ├── java/
        │   ├── cl/
        │   │   └── eye/
        │   │       └── CLCamera.java
        │   └── org/
        │       └── bytedeco/
        │           └── javacv/
        │               ├── AndroidFrameConverter.java
        │               ├── BaseChildSettings.java
        │               ├── BaseSettings.java
        │               ├── Blobs.java
        │               ├── BufferRing.java
        │               ├── CameraDevice.java
        │               ├── CameraSettings.java
        │               ├── CanvasFrame.java
        │               ├── ColorCalibrator.java
        │               ├── DC1394FrameGrabber.java
        │               ├── FFmpegFrameFilter.java
        │               ├── FFmpegFrameGrabber.java
        │               ├── FFmpegFrameRecorder.java
        │               ├── FFmpegLockCallback.java
        │               ├── FFmpegLogCallback.java
        │               ├── FlyCapture2FrameGrabber.java
        │               ├── FlyCaptureFrameGrabber.java
        │               ├── Frame.java
        │               ├── FrameConverter.java
        │               ├── FrameFilter.java
        │               ├── FrameGrabber.java
        │               ├── FrameRecorder.java
        │               ├── GLCanvasFrame.java
        │               ├── GNImageAligner.java
        │               ├── GNImageAlignerCL.java
        │               ├── GeometricCalibrator.java
        │               ├── HandMouse.java
        │               ├── IPCameraFrameGrabber.java
        │               ├── ImageAligner.java
        │               ├── ImageAlignerCL.java
        │               ├── ImageTransformer.java
        │               ├── ImageTransformerCL.java
        │               ├── Java2DFrameConverter.java
        │               ├── Java2DFrameUtils.java
        │               ├── JavaCV.java
        │               ├── JavaCVCL.java
        │               ├── JavaCvErrorCallback.java
        │               ├── JavaFXFrameConverter.java
        │               ├── LeptonicaFrameConverter.java
        │               ├── LibgdxFrameConverter.java
        │               ├── MarkedPlane.java
        │               ├── Marker.java
        │               ├── MarkerDetector.java
        │               ├── ObjectFinder.java
        │               ├── OpenCVFrameConverter.java
        │               ├── OpenCVFrameGrabber.java
        │               ├── OpenCVFrameRecorder.java
        │               ├── OpenKinect2FrameGrabber.java
        │               ├── OpenKinectFrameGrabber.java
        │               ├── PS3EyeFrameGrabber.java
        │               ├── Parallel.java
        │               ├── ProCamColorCalibrator.java
        │               ├── ProCamGeometricCalibrator.java
        │               ├── ProCamTransformer.java
        │               ├── ProCamTransformerCL.java
        │               ├── ProjectiveColorTransformer.java
        │               ├── ProjectiveColorTransformerCL.java
        │               ├── ProjectiveDevice.java
        │               ├── ProjectiveTransformer.java
        │               ├── ProjectiveTransformerCL.java
        │               ├── ProjectorDevice.java
        │               ├── ProjectorSettings.java
        │               ├── RealSense2FrameGrabber.java
        │               ├── RealSenseFrameGrabber.java
        │               ├── ReflectanceInitializer.java
        │               ├── Seekable.java
        │               ├── SeekableByteArrayOutputStream.java
        │               ├── VideoInputFrameGrabber.java
        │               └── cvkernels.java
        ├── java9/
        │   └── module-info.java
        └── resources/
            └── org/
                └── bytedeco/
                    └── javacv/
                        ├── ImageTransformer.cl
                        ├── JavaCV.cl
                        ├── ProCamTransformer.cl
                        ├── ProjectiveColorTransformer.cl
                        └── ProjectiveTransformer.cl

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/FUNDING.yml
================================================
github: bytedeco


================================================
FILE: .github/workflows/javacv.yml
================================================
name: javacv
on: [push, pull_request, workflow_dispatch]
env:
  CI_DEPLOY_MODULE: .
  CI_DEPLOY_PLATFORM: ${{ github.job }}
  CI_DEPLOY_SETTINGS: ${{ secrets.CI_DEPLOY_SETTINGS }}
  CI_DEPLOY_USERNAME: ${{ secrets.CI_DEPLOY_USERNAME }}
  CI_DEPLOY_PASSWORD: ${{ secrets.CI_DEPLOY_PASSWORD }}
  STAGING_REPOSITORY: ${{ secrets.STAGING_REPOSITORY }}
jobs:
  linux-arm64:
    runs-on: ubuntu-22.04-arm
    steps:
      - uses: bytedeco/javacpp-presets/.github/actions/deploy-ubuntu@actions
      - uses: mxschmitt/action-tmate@v3
        if: ${{ github.event_name == 'workflow_dispatch' }}
  linux-x86_64:
    runs-on: ubuntu-22.04
    steps:
      - uses: bytedeco/javacpp-presets/.github/actions/deploy-ubuntu@actions
      - uses: mxschmitt/action-tmate@v3
        if: ${{ github.event_name == 'workflow_dispatch' }}
  macosx-arm64:
    runs-on: macos-15
    steps:
      - uses: bytedeco/javacpp-presets/.github/actions/deploy-macosx@actions
      - uses: mxschmitt/action-tmate@v3
        if: ${{ github.event_name == 'workflow_dispatch' }}
  macosx-x86_64:
    runs-on: macos-15-intel
    steps:
      - uses: bytedeco/javacpp-presets/.github/actions/deploy-macosx@actions
      - uses: mxschmitt/action-tmate@v3
        if: ${{ github.event_name == 'workflow_dispatch' }}
  windows-x86_64:
    runs-on: windows-2022
    steps:
      - uses: bytedeco/javacpp-presets/.github/actions/deploy-windows@actions
      - uses: mxschmitt/action-tmate@v3
        if: ${{ github.event_name == 'workflow_dispatch' }}
  platform:
    needs: [linux-x86_64, macosx-arm64, macosx-x86_64, windows-x86_64]
    runs-on: ubuntu-22.04
    steps:
      - uses: bytedeco/javacpp-presets/.github/actions/redeploy@actions


================================================
FILE: .gitignore
================================================
**/target/**

# Mac
.DS_Store

# Eclipse
.classpath
.project
.settings

# IntelliJ
*.iml
.idea


================================================
FILE: .travis.yml
================================================
dist: xenial
cache:
  directories:
    - $HOME/.m2/repository

before_install:
  - "echo '<settings><localRepository>${env.HOME}/.m2/repository</localRepository><servers><server><id>sonatype-nexus-snapshots</id><username>${env.CI_DEPLOY_USERNAME}</username><password>${env.CI_DEPLOY_PASSWORD}</password></server></servers></settings>' > $HOME/settings.xml"
  - "[[ $TRAVIS_PULL_REQUEST == 'false' ]] && export MAVEN_PHASE=deploy || export MAVEN_PHASE=install"

jobs:
  include:
    - os: linux
      arch: arm64
      language: java
      addons:
        apt:
          packages: openjdk-8-jdk openjfx maven
      env: PLATFORMS="linux-arm64"
      install:
        - export JAVA_HOME="/usr/lib/jvm/java-8-openjdk-arm64"
      script:
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml -f platform/pom.xml -Djavacpp.platform=linux-arm64 '-Dtest=!FrameGrabberTest#testFFmpegFrameGrabber'
    - os: linux
      arch: ppc64le
      language: java
      addons:
        apt:
          packages: openjdk-8-jdk openjfx maven
      env: PLATFORMS="linux-ppc64le"
      install:
        - export JAVA_HOME="/usr/lib/jvm/java-8-openjdk-ppc64el"
      script:
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml -f platform/pom.xml -Djavacpp.platform=linux-ppc64le
    - os: linux
      arch: amd64
      language: java
      addons:
        apt:
          packages: openjdk-8-jdk openjfx maven
      env: PLATFORMS="linux-x86_64"
      install:
        - export JAVA_HOME="/usr/lib/jvm/java-8-openjdk-amd64"
      script:
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml -f platform/pom.xml -Djavacpp.platform=linux-x86_64
    - os: osx
      osx_image: xcode12.2
      language: java
      env: PLATFORMS="macosx-x86_64"
      install:
        - brew update
        - brew install gpg1
        - brew tap AdoptOpenJDK/openjdk
        - brew install --cask adoptopenjdk8
        - export JAVA_HOME=$(/usr/libexec/java_home -v1.8)
      script:
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml
        - mvn clean $MAVEN_PHASE -B -V -U -s $HOME/settings.xml -f platform/pom.xml -Djavacpp.platform=macosx-x86_64 '-Dtest=!FrameGrabberTest#testFFmpegFrameGrabber'
    - os: windows
      language: bash
      env: PLATFORMS="windows-x86_64"
      install:
        - powershell Install-WindowsFeature Server-Media-Foundation
        - choco install jdk8 --params 'installdir=c:\\jdk8'
        - choco install maven --version=3.6.3
        - export JAVA_HOME="/c/jdk8/"
        - export PATH="$PATH:/c/ProgramData/chocolatey/lib/maven/apache-maven-3.6.3/bin/:/c/Program Files (x86)/Microsoft Visual Studio/2017/BuildTools/VC/Auxiliary/Build/"
      script:
        - cmd.exe //C 'vcvarsall.bat amd64 && mvn clean %MAVEN_PHASE% -B -V -U -s %HOME%/settings.xml'
        - cmd.exe //C 'vcvarsall.bat amd64 && mvn clean %MAVEN_PHASE% -B -V -U -s %HOME%/settings.xml -f platform/pom.xml -Djavacpp.platform=windows-x86_64 -Dtest=!FrameConverterTest#testOpenCV*'


================================================
FILE: CHANGELOG.md
================================================

 * Compile classes with `parameters` bumping minimum requirements to Java SE 8 and Android 7.0 ([issue bytedeco/javacpp-presets#1739](https://github.com/bytedeco/javacpp-presets/issues/1739))

### February 22, 2026 version 1.5.13
 * Call `Pointer.trimMemory()` on `FFmpegFrameGrabber/Filter/Recorder` close to reclaim system memory on Linux ([issue #2334](https://github.com/bytedeco/javacv/issues/2334))
 * Add `FrameRecorder.videoProfile` property ([pull #2361](https://github.com/bytedeco/javacv/pull/2361))
 * Upgrade dependencies for OpenBLAS 0.3.31, OpenCV 4.13.0, FFmpeg 8.0.1, Leptonica 1.87.0, Tesseract 5.5.2

### June 30, 2025 version 1.5.12
 * Add `LibgdxFrameConverter` to convert `Frame` to Libgdx `Pixmap` ([pull #2315](https://github.com/bytedeco/javacv/pull/2315))
 * Fix `FFmpegFrameRecorder` dropped frame issues with audio samples ([pull #2307](https://github.com/bytedeco/javacv/pull/2307))
 * Add `FrameFilter.videoFilterArgs/audioFilterArgs` properties to support multiple different inputs ([pull #2304](https://github.com/bytedeco/javacv/pull/2304))
 * Ensure `FFmpegFrameGrabber.start()` skips over streams with no codecs ([issue #2299](https://github.com/bytedeco/javacv/issues/2299))
 * Add `FFmpegLogCallback.logRejectedOptions()` for debugging purposes ([pull #2301](https://github.com/bytedeco/javacv/pull/2301))
 * Upgrade dependencies for OpenBLAS 0.3.30, OpenCV 4.11.0, FFmpeg 7.1.1, Tesseract 5.5.1

### November 16, 2024 version 1.5.11
 * Fix memory leak in `FFmpegFrameGrabber` when decoding from `InputStream` ([pull #2214](https://github.com/bytedeco/javacv/pull/2214))
 * Upgrade dependencies for OpenBLAS 0.3.28, OpenCV 4.10.0, FFmpeg 7.1, Leptonica 1.85.0, Tesseract 5.5.0

### January 29, 2024 version 1.5.10
 * Work around `swscale` bug in `FFmpegFrameGrabber` for images with unaligned width ([issue #1960](https://github.com/bytedeco/javacv/issues/1960))
 * Improve `FFmpegFrameGrabber.setTimestamp()` further for MPEG-TS streams ([pull #2144](https://github.com/bytedeco/javacv/pull/2144))
 * Fix `module-info.java` broken since last release ([issue bytedeco/javacpp-presets#1414](https://github.com/bytedeco/javacpp-presets/issues/1414))
 * Add new `AudioSplitMergeHelper` sample for processing raw audio frames ([pull #2052](https://github.com/bytedeco/javacv/pull/2052))
 * Upgrade dependencies for OpenBLAS 0.3.26, OpenCV 4.9.0, FFmpeg 6.1.1, Leptonica 1.84.1, Tesseract 5.3.4

### June 6, 2023 version 1.5.9
 * Add `FrameRecorder.videoSideData/audioSideData` properties and `FFmpegFrameRecorder.setDisplayRotation()` for convenience ([issue #1976](https://github.com/bytedeco/javacv/issues/1976))
 * Fix `FFmpegFrameGrabber.grab()` not returning audio frames buffered by the codec ([issue #1971](https://github.com/bytedeco/javacv/issues/1971))
 * Upgrade dependencies for OpenBLAS 0.3.23, OpenCV 4.7.0, FFmpeg 6.0 ([issue #1693](https://github.com/bytedeco/javacv/issues/1693)), librealsense2 2.53.1, Leptonica 1.83.0, Tesseract 5.3.1

### November 2, 2022 version 1.5.8
 * Override `FFmpegFrameGrabber.getVideoCodecName()/getAudioCodecName()` to return names of opened codecs ([pull #1901](https://github.com/bytedeco/javacv/pull/1901))
 * Add `FrameGrabber.videoDisposition/audioDisposition` properties to select streams by disposition ([pull #1879](https://github.com/bytedeco/javacv/pull/1879))
 * Work around `OpenKinect2FrameGrabber` failing when provided with a pipeline on some system ([pull #1886](https://github.com/bytedeco/javacv/pull/1886))
 * Fix `FFmpegFrameRecorder.record()` incorrectly flushing the video codec on data frames ([issue #1858](https://github.com/bytedeco/javacv/issues/1858))
 * Improve accuracy of `FFmpegFrameGrabber.setFrameNumber()` ([pull #1851](https://github.com/bytedeco/javacv/pull/1851))
 * Add `FrameGrabber.resetStartTime()` to allow `grabAtFrameRate()` after operations such as seeking ([pull #1846](https://github.com/bytedeco/javacv/pull/1846))
 * Add `FrameGrabber.videoSideData/audioSideData` properties and `FFmpegFrameGrabber.getDisplayRotation()` for convenience ([issue #1361](https://github.com/bytedeco/javacv/issues/1361))
 * Add to `FFmpegFrameGrabber` and `FFmpegFrameRecorder` constructors taking a `URL` for convenience and clarity
 * Fix incorrect call to `opencv_calib3d.stereoRectify()` in `ProjectiveDevice` ([issue #1802](https://github.com/bytedeco/javacv/issues/1802))
 * Retry after 10 ms when `av_read_frame()` returns `EAGAIN` in `FFmpegFrameGrabber.grabFrame()` ([issue #1784](https://github.com/bytedeco/javacv/issues/1784))
 * Append `frame_rate=%d/%d` input parameter in `FFmpegFrameFilter` as required by `xfade` ([issue #1776](https://github.com/bytedeco/javacv/issues/1776))
 * Update `FFmpegStreamingTimeout` sample to use `timeout` instead of `stimeout` for RTSP ([pull #1758](https://github.com/bytedeco/javacv/pull/1758))
 * Restore static calls to `FFmpegFrameGrabber.tryLoad()` and `FFmpegFrameRecorder.tryLoad()` ([issue #1756](https://github.com/bytedeco/javacv/issues/1756))
 * Enable by default on `RealSense2FrameGrabber.start()` all color, depth, and IR streams as `videoStream` ([pull #1750](https://github.com/bytedeco/javacv/pull/1750))
 * Upgrade dependencies for OpenBLAS 0.3.21, OpenCV 4.6.0, FFmpeg 5.1.2, Leptonica 1.82.0 ([pull #1791](https://github.com/bytedeco/javacv/pull/1791)), Tesseract 5.2.0

### February 11, 2022 version 1.5.7
 * Fix accuracy and latency issues with `FFmpegFrameGrabber.setVideoFrameNumber()` ([pull #1734](https://github.com/bytedeco/javacv/pull/1734))
 * Add new `Frame.pictType` field set to `I`, `P`, `B`, etc by `FFmpegFrameGrabber` ([pull #1730](https://github.com/bytedeco/javacv/pull/1730))
 * Set metadata for `AVFrame.opaque` in `FFmpegFrameGrabber` with call to `av_frame_copy_props()` ([issue #1729](https://github.com/bytedeco/javacv/issues/1729))
 * Add `charset` property to `FrameGrabber` and `FrameRecorder` to use for metadata from FFmpeg ([pull #1720](https://github.com/bytedeco/javacv/pull/1720))
 * Call `Frame.close()` on temporary clones in `Java2DFrameUtils` to prevent premature deallocations ([issue #1716](https://github.com/bytedeco/javacv/issues/1716))
 * Ignore errors from `avcodec_send_packet()` and `avcodec_receive_frame()` to emulate old API in `FFmpegFrameGrabber` ([issue #1679](https://github.com/bytedeco/javacv/issues/1679))
 * Upgrade dependencies for OpenBLAS 0.3.19, OpenCV 4.5.5, FFmpeg 5.0, librealsense2 2.50.0, Leptonica 1.82.0, Tesseract 5.0.1

### August 2, 2021 version 1.5.6
 * Enhance audio and video synchronization of `JavaFxPlayVideoAndAudio` sample ([pull #1662](https://github.com/bytedeco/javacv/pull/1662))
 * Add `FrameGrabber.grabAtFrameRate()` to simulate a device or stream when reading from files ([pull #1659](https://github.com/bytedeco/javacv/pull/1659))
 * Update `FFmpegFrameGrabber` and `FFmpegFrameRecorder` with new `avcodec` API ([issue #1498](https://github.com/bytedeco/javacv/issues/1498))
 * Add new `Similarity` sample with PSNR and MSSIM ([pull #1622](https://github.com/bytedeco/javacv/pull/1622))
 * Avoid crash in `FFmpegFrameRecorder.stop()` by moving `av_write_trailer()` out of `flush()` ([issue #1616](https://github.com/bytedeco/javacv/issues/1616))
 * Upgrade dependencies for OpenBLAS 0.3.17, OpenCV 4.5.3, FFmpeg 4.4, librealsense2 2.44.0, Leptonica 1.81.1

### March 8, 2021 version 1.5.5
 * Have `Frame` and `FrameConverter` implement `AutoCloseable` to release memory explicitly ([issue #1574](https://github.com/bytedeco/javacv/issues/1574))
 * Add new `YOLONet` sample for object detection ([pull #1595](https://github.com/bytedeco/javacv/pull/1595))
 * Fix crash on `FFmpegFrameGrabber.stop()` when in `ImageMode.RAW` ([issue #1568](https://github.com/bytedeco/javacv/issues/1568))
 * Let `FFmpegFrameRecorder.flush()` ignore errors from the encoder ([issue #1563](https://github.com/bytedeco/javacv/issues/1563))
 * Improve `FFmpegFrameGrabber.setTimestamp()` and fix `getAudioFrameRate()` ([pull #1559](https://github.com/bytedeco/javacv/pull/1559))
 * Fix frame rate and aspect ratio on `FFmpegFrameRecorder.start(AVFormatContext)` ([pull #1535](https://github.com/bytedeco/javacv/pull/1535))
 * Upgrade dependencies for OpenBLAS 0.3.13, OpenCV 4.5.1, FFmpeg 4.3.2, librealsense2 2.40.0
 * Update unit tests to use codecs available in FFmpeg under LGPL v3 ([pull bytedeco/javacpp-presets#950](https://github.com/bytedeco/javacpp-presets/pull/950))
 * Add `RealSense2FrameGrabber.tryLoad()` method and missing entries for librealsense2 ([issue bytedeco/procamcalib#25](https://github.com/bytedeco/procamcalib/issues/25))

### September 9, 2020 version 1.5.4
 * Fix error message thrown from `FFmpegFrameRecorder.start()` not containing filename ([pull #1492](https://github.com/bytedeco/javacv/pull/1492))
 * Fix `FFmpegFrameFilter.pull()` not returning audio/video frames without audio/video filtergraph ([issue #1466](https://github.com/bytedeco/javacv/issues/1466))
 * Update `OpenCVFrameConverter.convertToOrgOpenCvCoreMat()` with new API to set the stride ([issue #1460](https://github.com/bytedeco/javacv/issues/1460))
 * Fix memory leaks and reduce memory fragmentation in `FFmpegFrameGrabber` and `FFmpegFrameRecorder` ([issue #1366](https://github.com/bytedeco/javacv/issues/1366))
 * Use `PointerScope` in `FFmpegFrameFilter`, `FFmpegFrameGrabber`, and `FFmpegFrameRecorder` to deallocate quickly temporary buffers ([issue #1383](https://github.com/bytedeco/javacv/issues/1383))
 * Fix `FFmpegFrameFilter` by calling `String.format()` with `Locale.ROOT` ([pull #1441](https://github.com/bytedeco/javacv/pull/1441))
 * Increase thread safety of `FFmpegFrameFilter`, `FFmpegFrameGrabber`, and `FFmpegFrameRecorder` with `synchronized` methods ([issue #1434](https://github.com/bytedeco/javacv/issues/1434))
 * Upgrade dependencies for OpenBLAS 0.3.10, OpenCV 4.4.0, FFmpeg 4.3.1, and Leptonica 1.80.0

### April 14, 2020 version 1.5.3
 * Add `FFmpegFrameGrabber.start(boolean findStreamInfo)` parameter to minimize startup time ([issue #1376](https://github.com/bytedeco/javacv/issues/1376))
 * Let `FFmpegFrameGrabber.grab()` return non-audio/video streams as new `Frame.DATA` type ([pull #1378](https://github.com/bytedeco/javacv/pull/1378))
 * Fix crash in `FFmpegFrameRecorder.flush()` for HLS format and possibly others ([pull #1374](https://github.com/bytedeco/javacv/pull/1374))
 * Fix "Resetting to invalid mark" `IOException` thrown on `FFmpegFrameGrabber.release()` ([issue #911](https://github.com/bytedeco/javacv/issues/911))
 * Upgrade dependencies for OpenBLAS 0.3.9, OpenCV 4.3.0, FFmpeg 4.2.2, Leptonica 1.79.0, and Tesseract 4.1.1
 * Add `Seekable` and `SeekableByteArrayOutputStream` to be used with `FFmpegFrameRecorder` ([pull #1350](https://github.com/bytedeco/javacv/pull/1350))
 * Update `RealSense2FrameGrabber` with support for sensor options and fix for multiple devices ([pull #1348](https://github.com/bytedeco/javacv/pull/1348))

### November 5, 2019 version 1.5.2
 * Increase thread safety of `FFmpegFrameFilter`, `FFmpegFrameGrabber`, and `FFmpegFrameRecorder` with `volatile boolean started` flag ([pull #1325](https://github.com/bytedeco/javacv/pull/1325))
 * Let `FFmpegFrameFilter.push(null)` indicate EOF to audio filters as well ([issue #1315](https://github.com/bytedeco/javacv/issues/1315))
 * Add `RealSense2FrameGrabber` to capture images with librealsense2 ([pull #1316](https://github.com/bytedeco/javacv/pull/1316))
 * Disable seek function in `FFmpegFrameGrabber` when `maximumSize <= 0` ([issue #1304](https://github.com/bytedeco/javacv/issues/1304))
 * Use `Pointer.retainReference()` to prevent `PointerScope` from deallocating globally shared callback objects for FFmpeg
 * Fix `FFmpegFrameRecorder` failing to encode `float` samples in MP3 ([issue #1294](https://github.com/bytedeco/javacv/issues/1294))
 * Fix `OpenCVFrameConverter` error in `IPCameraFrameGrabber` ([pull #1278](https://github.com/bytedeco/javacv/pull/1278))
 * Allow setting properties for `OpenCVFrameGrabber` and `OpenCVFrameRecorder` with `setOption()` ([issue #1269](https://github.com/bytedeco/javacv/issues/1269))
 * Add missing `requires java.desktop` to `module-info.java` ([issue #1265](https://github.com/bytedeco/javacv/issues/1265))
 * Upgrade dependencies for OpenBLAS 0.3.7, OpenCV 4.1.2, FFmpeg 4.2.1, librealsense 1.12.4, and librealsense2 2.29.0

### July 9, 2019 version 1.5.1
 * Work around `swscale` bug in `FFmpegFrameGrabber` for images with unaligned width ([issue #845](https://github.com/bytedeco/javacv/issues/845))
 * Add support for `AVSEEK_SIZE` to `FFmpegFrameGrabber` as required by MPEG-TS ([issue #1234](https://github.com/bytedeco/javacv/issues/1234))
 * Throw exception on `start()` for already started `FFmpegFrameFilter`, `FFmpegFrameGrabber`, or `FFmpegFrameRecorder` ([issue #1233](https://github.com/bytedeco/javacv/issues/1233))
 * Add dependency on OpenBLAS/MKL, now used by OpenCV to accelerate some matrix operations
 * Upgrade dependencies for OpenCV 4.1.0, libdc1394 2.2.6, and Tesseract 4.1.0
 * Add support for `Frame.timestamp` to `FFmpegFrameFilter` ([issue #1177](https://github.com/bytedeco/javacv/issues/1177))

### April 11, 2019 version 1.5
 * Override methods in `FFmpegFrameGrabber` to get all metadata from streams ([issue #1180](https://github.com/bytedeco/javacv/issues/1180))
 * Fix sample rate in output of `FFmpegFrameRecorder` by setting deprecated `AVStream.codec.time_base` ([issue #1179](https://github.com/bytedeco/javacv/issues/1179))
 * Add `asetpts=N` to input of `FFmpegFrameFilter` to make filters like `afade` behave as expected ([issue #1171](https://github.com/bytedeco/javacv/issues/1171))
 * Use `AVFormat.format()` from `Frame.opaque` when available in `FFmpegFrameFilter` and `FFmpegFrameRecorder` ([issue #1173](https://github.com/bytedeco/javacv/issues/1173))
 * Enable multithreading for all codecs by default in `FFmpegFrameGrabber` and `FFmpegFrameRecorder` ([issue #1163](https://github.com/bytedeco/javacv/issues/1163))
 * Improve thread safety of `FFmpegFrameRecorder` and `Java2DFrameConverter` by relying less on `Buffer.position` ([pull #1166](https://github.com/bytedeco/javacv/pull/1166))
 * Use ModiTect to compile `module-info.java` with JDK 8 and preserve backward compatibility
 * Add `FFmpegFrameRecorder.closeOutputStream` and `FFmpegFrameGrabber.closeInputStream` properties to leave streams opened ([issue #1149](https://github.com/bytedeco/javacv/issues/1149))
 * Add `FFmpegFrameRecorder.flush()` method that does not release the stream ([issue #1149](https://github.com/bytedeco/javacv/issues/1149))
 * Readd `synchronized` blocks for `FFmpegFrameGrabber` and `FFmpegFrameRecorder`, but make unsafe methods public ([issue #1139](https://github.com/bytedeco/javacv/issues/1139))
 * Allocate native memory for `Frame` using `Pointer` to allow deallocation with `PointerScope` ([issue #1152](https://github.com/bytedeco/javacv/issues/1152))
 * Add `module-info.java` and depend on modularized JavaCPP Presets to comply with JPMS
 * Upgrade dependencies for FFmpeg 4.1.3, libfreenect 0.5.7, and Leptonica 1.78.0
 * Allow allocation of `Frame` images with custom strides
 * Take into account `Bitmap.getRowBytes()` in `AndroidFrameConverter.convert(Bitmap)` ([issue #1143](https://github.com/bytedeco/javacv/issues/1143))
 * Add `static { Loader.load(); }` in `LeptonicaFrameConverter` and `OpenCVFrameConverter` to prevent link errors ([issue #1128](https://github.com/bytedeco/javacv/issues/1128))

### January 11, 2019 version 1.4.4
 * Add `FFmpegFrameGrabber(InputStream, int)` constructor to set the maximum cache size used for seeking
 * Set `pts` and `dts` for `AVPacket` in `FFmpegFrameRecorder.recordPacket()` ([pull #1097](https://github.com/bytedeco/javacv/pull/1097))
 * Prevent premature deallocations with `LeptonicaFrameConverter` ([issue bytedeco/javacpp#272](https://github.com/bytedeco/javacpp/issues/272)) and `OpenCVFrameConverter.IplImage` ([issue #1101](https://github.com/bytedeco/javacv/issues/1101))
 * Fix `OpenCVFrameGrabber` from crashing when in `ImageMode.GRAY`
 * Add support for multiple inputs to `FFmpegFrameFilter` ([issue #955](https://github.com/bytedeco/javacv/issues/955))
 * Fix fps in output of `FFmpegFrameRecorder` by setting deprecated `AVStream.codec.time_base` ([issue #1069](https://github.com/bytedeco/javacv/issues/1069))
 * Fix memory leak in `FFmpegFrameRecorder` on `writePacket()` ([issue #1068](https://github.com/bytedeco/javacv/issues/1068))
 * Upgrade dependencies for OpenCV 4.0.1, FFmpeg 4.1, FlyCapture 2.13.3.31, Leptonica 1.77.0, and Tesseract 4.0.0

### October 15, 2018 version 1.4.3
 * Add `imageScalingFlags` property to `FrameGrabber` and `FrameRecorder`, with `SWS_BILINEAR` as default for FFmpeg ([issue #845](https://github.com/bytedeco/javacv/issues/845))
 * Add `OpenCVFrameConverter.ToOrgOpenCvCoreMat` to easily but efficiently get image data from official Java API of OpenCV ([issue bytedeco/javacpp#38](https://github.com/bytedeco/javacpp/issues/38))
 * Keep globally shared callback objects for FFmpeg out of `PointerScope` ([issue #911](https://github.com/bytedeco/javacv/issues/911))
 * Upgrade dependencies for OpenCV 3.4.3, FFmpeg 4.0.2, and Tesseract 4.0.0-rc2
 * Update the `Demo` class to use the C++ API of OpenCV ([issue #1042](https://github.com/bytedeco/javacv/issues/1042))
 * Add new `DeepLearningFaceDetection` ([pull #1041](https://github.com/bytedeco/javacv/pull/1041)) and `PerspectiveWarpDemo` ([pull #1066](https://github.com/bytedeco/javacv/pull/1066)) samples

### July 17, 2018 version 1.4.2
 * Allow `FFmpegFrameGrabber` to use accelerated decoders with `videoCodecName` and `audioCodecName` properties ([pull #948](https://github.com/bytedeco/javacv/pull/948))
 * Add new `KazemiFacemarkExample` and `LBFFacemarkExampleWithVideo` samples ([pull #1030](https://github.com/bytedeco/javacv/pull/1030))
 * Expose `apiPreference` constructor argument of `VideoCapture` to `OpenCVFrameGrabber` ([pull #1025](https://github.com/bytedeco/javacv/pull/1025))
 * Add `LeptonicaFrameConverter` to easily but efficiently pass image data to Tesseract ([issue bytedeco/javacpp-presets#224](https://github.com/bytedeco/javacpp-presets/issues/224))
 * Update `RecordActivity` to fix issue with pixel formats ([issue #979](https://github.com/bytedeco/javacv/issues/979))
 * Fix `FFmpegFrameFilter` to support negative strides returned by "vflip" ([pull #977](https://github.com/bytedeco/javacv/pull/977))
 * Fix `FFmpegFrameFilter` on Mac throwing "Resource temporarily unavailable" ([issue #974](https://github.com/bytedeco/javacv/issues/974))
 * Upgrade dependencies for OpenCV 3.4.2, FFmpeg 4.0.1 and Tesseract 4.0.0-beta.3
 * Add initial limited version of `JavaFXFrameConverter` ([pull #969](https://github.com/bytedeco/javacv/pull/969))
 * Revert default behavior of `FFmpegFrameGrabber.setTimestamp()` to previous version ([pull #949](https://github.com/bytedeco/javacv/pull/949))
 * Add support for audio frames to `FFmpegFrameFilter` ([issue #492](https://github.com/bytedeco/javacv/issues/492))
 * Add `setpts=N` to input of `FFmpegFrameFilter` to make `fade` and `overlay` filters behave as expected ([issue #667](https://github.com/bytedeco/javacv/issues/667))
 * Fix crash on `FFmpegFrameRecorder.stop()` when no audio samples are left to write

### March 29, 2018 version 1.4.1
 * Improve seeking and frame number estimates in `FFmpegFrameGrabber` ([pull #908](https://github.com/bytedeco/javacv/pull/908))
 * Add `maxBFrames`, `trellis`, and `maxDelay` properties to `FFmpegFrameRecorder` ([pull #939](https://github.com/bytedeco/javacv/pull/939))
 * Introduce `FFmpegFrameGrabber.maxDelay` property ([pull #938](https://github.com/bytedeco/javacv/pull/938))
 * Upgrade dependencies for OpenCV 3.4.1, FFmpeg 3.4.2
 * Allow enabling streams with `RealSenseFrameGrabber.setFormat()` for compatibility ([pull #922](https://github.com/bytedeco/javacv/pull/922))
 * Process audio frames after `FFmpegFrameGrabber.setTimestamp()` to avoid corrupted images ([issue #896](https://github.com/bytedeco/javacv/issues/896))
 * Fix `FFmpegFrameRecorder` not flushing all audio samples properly ([pull #886](https://github.com/bytedeco/javacv/pull/886))
 * Give access to pixel format, etc for images returned by `FFmpegFrameFilter.pull()` ([issue #887](https://github.com/bytedeco/javacv/issues/887))

### January 16, 2018 version 1.4
 * Decode audio frames on `FFmpegFrameGrabber.setTimestamp()` to avoid sync issues ([pull #871](https://github.com/bytedeco/javacv/pull/871))
 * Give access to options and metadata `Map` from `FrameGrabber` and `FrameRecorder` ([issue #858](https://github.com/bytedeco/javacv/issues/858))
 * Make `FFmpegFrameGrabber(InputStream)` and `FFmpegFrameRecorder(OutputStream)` thread-safe
 * Add new `OpenCVFeatures2dSerialization` sample ([pull #842](https://github.com/bytedeco/javacv/pull/842))
 * Upgrade dependencies for OpenCV 3.4.0, FFmpeg 3.4.1, librealsense 1.12.1
 * Fix potential audio read issue in `WebcamAndMicrophoneCapture` sample ([issue #826](https://github.com/bytedeco/javacv/issues/826))
 * Update `JavaFxPlayVideoAndAudio` sample to support `FrameGrabber.sampleMode` property ([issue #820](https://github.com/bytedeco/javacv/issues/820))
 * Set the `Frame.timestamp` field on `FFmpegFrameGrabber.grab()` ([pull #810](https://github.com/bytedeco/javacv/pull/810))
 * Fix image loading issue with the `CaffeGooglenet.java` sample ([pull #805](https://github.com/bytedeco/javacv/pull/805))
 * Prevent `FFmpegFrameGrabber.setTimestamp()` from going into an infinite loop ([issue #731](https://github.com/bytedeco/javacv/issues/731))
 * Fix `FFmpegFrameRecorder.record()` when called with `AV_PIX_FMT_NV21` ([pull #787](https://github.com/bytedeco/javacv/pull/787))
 * Add `FFmpegLockCallback` to use more efficient thread-safe mechanisms ([pull #770](https://github.com/bytedeco/javacv/pull/770))
 * Make `FFmpegFrameGrabber` support streams with changing resolution ([pull #769](https://github.com/bytedeco/javacv/pull/769))
 * Add new `DeinterlacedVideoPlayer` sample ([pull #757](https://github.com/bytedeco/javacv/pull/757))

### July 25, 2017 version 1.3.3
 * Fix `Java2DFrameConverter.cloneBufferedImage()` not copying the data ([pull #739](https://github.com/bytedeco/javacv/pull/739))
 * Make sure `OpenCVFrameConverter` always resets `Frame.opaque` even when `Pointer` is equal ([issue deeplearning4j/DataVec#316](https://github.com/deeplearning4j/DataVec/issues/316))
 * Fix `OutputStream` leak in `FFmpegFrameRecorder` ([pull #727](https://github.com/bytedeco/javacv/pull/727))
 * Synchronize on `FFmpegFrameRecorder.stop()` to avoid potential race conditions ([issue #700](https://github.com/bytedeco/javacv/issues/700))
 * Add `src/main/java/cl/eye/CLCamera.java` to remove build dependency on external module
 * Fix seeking issues with `FFmpegFrameGrabber(InputStream)` ([pull #703](https://github.com/bytedeco/javacv/pull/703))
 * Upgrade dependencies for FFmpeg 3.3.2, FlyCapture 2.11.3.121 ([pull bytedeco/javacpp-presets#424](https://github.com/bytedeco/javacpp-presets/pull/424))
 * Initialize the `avdevice` module for `FFmpegFrameRecorder` in the same way as with `FFmpegFrameGrabber`
 * Add `FrameGrabber.sampleMode` property and have `FFmpegFrameGrabber` convert audio samples to user-specified format ([issue #18](https://github.com/bytedeco/javacv/issues/18))
 * Add new `ImageSegmentation` ([pull #460](https://github.com/bytedeco/javacv/pull/460)) and `FFmpegStreamingTimeout` ([pull #712](https://github.com/bytedeco/javacv/pull/712)) samples
 * Fix up and add missing functionality to `FlyCapture2FrameGrabber` ([pull #655](https://github.com/bytedeco/javacv/pull/655))
 * Take `OpenCVFrameGrabber.setFormat()` value to set FOURCC of `VideoCapture` ([pull #651](https://github.com/bytedeco/javacv/pull/651))
 * Fix call to `FaceRecognizer.predict()` in samples ([issue #642](https://github.com/bytedeco/javacv/issues/642))

### March 13, 2017 version 1.3.2
 * Add `Java2DFrameUtils` to facilitate conversion between `Frame`, `BufferedImage`, `IplImage`, and `Mat`
 * Add new `JavaFxPlayVideoAndAudio` sample ([pull #618](https://github.com/bytedeco/javacv/pull/618))
 * Get rid of deprecated calls in `FFmpegFrameFilter`, `FFmpegFrameGrabber` and `FFmpegFrameRecorder` ([issue #607](https://github.com/bytedeco/javacv/issues/607))
 * Fix crash in `FFmpegFrameGrabber.restart()` ([issue #605](https://github.com/bytedeco/javacv/issues/605))
 * Upgrade dependencies for OpenCV 3.2.0, FFmpeg 3.2.1, libdc1394 2.2.5

### January 14, 2017 version 1.3.1
 * Let `FFmpegFrameRecorder` pass options to the protocol as well ([issue #598](https://github.com/bytedeco/javacv/issues/598))
 * Add `RealSenseFrameGrabber` and `OpenKinect2FrameGrabber` to `FrameGrabber.list` to have them loaded by default
 * Remove confusing and no longer useful profiles from the `pom.xml` file
 * Provide new `FFmpegFrameGrabber(InputStream)` and `FFmpegFrameRecorder(OutputStream)` constructors ([issue #95](https://github.com/bytedeco/javacv/issues/95))
 * Make `FrameFilter`, `FrameGrabber`, and `FrameRecorder` implement `Closeable` to let us try-with-resources
 * Fix potential crash when recording audio with `FFmpegFrameRecorder`
 * Add `OpenKinect2FrameGrabber` to capture images with libfreenect2 ([pull #584](https://github.com/bytedeco/javacv/pull/584))
 * Add `OpenKinectFrameGrabber.grabIR()` and stabilize `RealSenseFrameGrabber` ([pull #585](https://github.com/bytedeco/javacv/pull/585))

### December 7, 2016 version 1.3
 * Fix unnecessary memory allocation in `OpenCVFrameGrabber` ([pull #575](https://github.com/bytedeco/javacv/pull/575))
 * Add `FFmpegFrameFilter` to `RecordActivity` sample for Android ([pull #550](https://github.com/bytedeco/javacv/pull/550))
 * Introduce platform artifact for easier cross-platform builds and to avoid issues with some build systems ([issue #395](https://github.com/bytedeco/javacv/issues/395))
 * Add `RealSenseFrameGrabber` to capture images with librealsense ([pull #486](https://github.com/bytedeco/javacv/pull/486))
 * Add `BioInspiredRetina.java` sample for the `opencv_bioinspired` module ([pull #505](https://github.com/bytedeco/javacv/pull/505))
 * Update the `JavaCV` class with appropriate documentation comments ([issue #444](https://github.com/bytedeco/javacv/issues/444))
 * Fix Javadoc links for externally referenced classes
 * Fix seeking when calling `FFmpegFrameGrabber.setTimestamp()` on audio-only files
 * Add more appropriate default pixel formats for JPEG formats in `FFmpegFrameRecorder` ([issue #410](https://github.com/bytedeco/javacv/issues/410))

### May 15, 2016 version 1.2
 * Optimize `AndroidFrameConverter` a bit and add a test ([pull #379](https://github.com/bytedeco/javacv/pull/379))
 * Fix `DC1394FrameGrabber` on the Windows platform ([issue bytedeco/procamcalib#4](https://github.com/bytedeco/procamcalib/issues/4))
 * Support `AVPacket` in `FFmpegFrameGrabber` and `FFmpegFrameRecorder` to copy without re-encoding ([issue #93](https://github.com/bytedeco/javacv/issues/93))
 * Lower Maven prerequisite in the `pom.xml` file to 3.0 ([issue bytedeco/javacpp#93](https://github.com/bytedeco/javacpp/issues/93))
 * Add new `PrincipalComponentAnalysis` sample ([pull #373](https://github.com/bytedeco/javacv/pull/373))
 * Upgrade `OpenCVFrameRecorder` to use the new C++ `VideoWriter` API ([pull #370](https://github.com/bytedeco/javacv/pull/370))
 * Upgrade `OpenCVFrameGrabber` to use the new C++ `VideoCapture` API ([pull #361](https://github.com/bytedeco/javacv/pull/361))
 * Add `CaffeGooglenet.java` sample for the `opencv_dnn` module ([pull #341](https://github.com/bytedeco/javacv/pull/341))
 * Clean up `IPCameraFrameGrabber` and fix incorrectly reading some headers ([pull #323](https://github.com/bytedeco/javacv/pull/323), [pull #345](https://github.com/bytedeco/javacv/pull/345))
 * Fix swallowed `InterruptedException` and throw appropriate exception in `FrameGrabber.start()` ([issue #315](https://github.com/bytedeco/javacv/issues/315))
 * Fix `IPCameraFrameGrabber.stop()` not checking for null ([pull #300](https://github.com/bytedeco/javacv/pull/300))
 * Upgrade dependencies for OpenCV 3.1.0, FFmpeg 3.0.2, FlyCapture 2.9.3.43, libdc1394 2.2.4
 * Let users call `FFmpegFrameFilter.push(null)` to indicate EOF, as required by some filters like "palettegen" ([issue #287](https://github.com/bytedeco/javacv/issues/287))
 * Call `cvHaarDetectObjects()` with `CV_HAAR_FIND_BIGGEST_OBJECT | CV_HAAR_DO_ROUGH_SEARCH` instead of `CV_HAAR_DO_CANNY_PRUNING` in the face detection samples to get acceptable performance with OpenCV 3.0 ([issue #272](https://github.com/bytedeco/javacv/issues/272))
 * Change `WakeLock` for `keepScreenOn` in `AndroidManifest.xml` file and add `setPreviewDisplay()` call on `surfaceChanged()` event for the `RecordActivity` sample ([pull #269](https://github.com/bytedeco/javacv/pull/269), [pull #271](https://github.com/bytedeco/javacv/pull/271))

### 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.<platform.name>` package (i.e.: under the `/com/googlecode/javacv/cpp/<platform.name>/` 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)!


================================================
FILE: LICENSE.txt
================================================
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.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    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.

  <signature of Ty Coon>, 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.


================================================
FILE: README.md
================================================
JavaCV
======

[![Gitter](https://badges.gitter.im/bytedeco/javacv.svg)](https://gitter.im/bytedeco/javacv) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.bytedeco/javacv-platform/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.bytedeco/javacv-platform) [![Sonatype Nexus (Snapshots)](https://img.shields.io/nexus/s/https/oss.sonatype.org/org.bytedeco/javacv.svg)](http://bytedeco.org/builds/) [![Build Status](https://travis-ci.org/bytedeco/javacv.svg?branch=master)](https://travis-ci.org/bytedeco/javacv) <sup>Commercial support:</sup> [![xscode](https://img.shields.io/badge/Available%20on-xs%3Acode-blue?style=?style=plastic&logo=appveyor&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAAZQTFRF////////VXz1bAAAAAJ0Uk5T/wDltzBKAAAAlUlEQVR42uzXSwqAMAwE0Mn9L+3Ggtgkk35QwcnSJo9S+yGwM9DCooCbgn4YrJ4CIPUcQF7/XSBbx2TEz4sAZ2q1RAECBAiYBlCtvwN+KiYAlG7UDGj59MViT9hOwEqAhYCtAsUZvL6I6W8c2wcbd+LIWSCHSTeSAAECngN4xxIDSK9f4B9t377Wd7H5Nt7/Xz8eAgwAvesLRjYYPuUAAAAASUVORK5CYII=)](https://xscode.com/bytedeco/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/), [FlyCapture](https://www.flir.com/products/flycapture-sdk/), [Spinnaker](https://www.flir.com/products/spinnaker-sdk/), [OpenKinect](http://openkinect.org/), [librealsense](https://github.com/IntelRealSense/librealsense), [CL PS3 Eye Driver](https://codelaboratories.com/downloads/), [videoInput](http://muonics.net/school/spring05/videoInput/), [ARToolKitPlus](https://launchpad.net/artoolkitplus), [flandmark](https://github.com/uricamic/flandmark), [Leptonica](http://www.leptonica.org/), and [Tesseract](https://github.com/tesseract-ocr/tesseract)) 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/tree/master/OpenCV_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) or [the discussion forum](https://github.com/bytedeco/javacv/discussions) if you encounter any problems with the software! I am sure it is far from perfect...


Downloads
---------
Archives containing JAR files are available as [releases](https://github.com/bytedeco/javacv/releases). The binary archive contains builds for Android, iOS, 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).

To install manually the JAR files, follow the instructions in the [Manual Installation](#manual-installation) section below.

We can also have everything downloaded and installed automatically with:

 * Maven (inside the `pom.xml` file)
```xml
  <dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacv-platform</artifactId>
    <version>1.5.13</version>
  </dependency>
```

 * Gradle (inside the `build.gradle.kts` or `build.gradle` file)
```groovy
  dependencies {
    implementation("org.bytedeco:javacv-platform:1.5.13")
  }
```

 * Leiningen (inside the `project.clj` file)
```clojure
  :dependencies [
    [org.bytedeco/javacv-platform "1.5.13"]
  ]
```

 * sbt (inside the `build.sbt` file)
```scala
  libraryDependencies += "org.bytedeco" % "javacv-platform" % "1.5.13"
```

This downloads binaries for all platforms, but to get binaries for only one platform we can set the `javacpp.platform` system property (via the `-D` command line option) to something like `android-arm`, `linux-x86_64`, `macosx-x86_64`, `windows-x86_64`, etc. Please refer to the [README.md file of the JavaCPP Presets](https://github.com/bytedeco/javacpp-presets#downloads) for details. Another option available to Gradle users is [Gradle JavaCPP](https://github.com/bytedeco/gradle-javacpp), and similarly for Scala users there is [SBT-JavaCV](https://github.com/bytedeco/sbt-javacv).


Required Software
-----------------
To use JavaCV, you will first need to download and install the following software:

 * An implementation of Java SE 8 or newer:
   * OpenJDK  http://openjdk.java.net/install/  or
   * Oracle JDK  http://www.oracle.com/technetwork/java/javase/downloads/  or
   * IBM JDK  http://www.ibm.com/developerworks/java/jdk/  or
   * Microsoft JDK  https://www.microsoft.com/openjdk  etc

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 24 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 8 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 8 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.
 
Visual Studio Code (Java SE 8 or newer):

 1. Navigate to Java Projects > Referenced Libraries, and click `+`.
 2. Locate the JAR files, select them, and click OK.

IntelliJ IDEA (Android 7.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.
 5. In the AndroidManifest.xml add `android:extractNativeLibs="true"`

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 org.bytedeco.opencv.opencv_core.*;
import org.bytedeco.opencv.opencv_imgproc.*;
import static org.bytedeco.opencv.global.opencv_core.*;
import static org.bytedeco.opencv.global.opencv_imgproc.*;
import static org.bytedeco.opencv.global.opencv_imgcodecs.*;

public class Smoother {
    public static void smooth(String filename) {
        Mat image = imread(filename);
        if (image != null) {
            GaussianBlur(image, image, new Size(3, 3), 0);
            imwrite(filename, 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 org.bytedeco.opencv.opencv_core.*;
import org.bytedeco.opencv.opencv_imgproc.*;
import org.bytedeco.opencv.opencv_calib3d.*;
import org.bytedeco.opencv.opencv_objdetect.*;
import static org.bytedeco.opencv.global.opencv_core.*;
import static org.bytedeco.opencv.global.opencv_imgproc.*;
import static org.bytedeco.opencv.global.opencv_calib3d.*;
import static org.bytedeco.opencv.global.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/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt.xml");
            File file = Loader.cacheResource(url);
            classifierName = file.getAbsolutePath();
        }

        // We can "cast" Pointer objects by instantiating a new object of the desired class.
        CascadeClassifier classifier = new CascadeClassifier(classifierName);
        if (classifier == null) {
            System.err.println("Error loading classifier file \"" + classifierName + "\".");
            System.exit(1);
        }

        // The available FrameGrabber classes include OpenCVFrameGrabber (opencv_videoio),
        // DC1394FrameGrabber, FlyCapture2FrameGrabber, OpenKinectFrameGrabber, OpenKinect2FrameGrabber,
        // RealSenseFrameGrabber, RealSense2FrameGrabber, 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, JavaFX, Tesseract, OpenCV, etc).
        OpenCVFrameConverter.ToMat converter = new OpenCVFrameConverter.ToMat();

        // 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.
        Mat grabbedImage = converter.convert(grabber.grab());
        int height = grabbedImage.rows();
        int width = grabbedImage.cols();

        // Objects allocated with `new`, clone(), or a create*() factory method are automatically released
        // by the garbage collector, but may still be explicitly released by calling deallocate().
        // You shall NOT call cvReleaseImage(), cvReleaseMemStorage(), etc. on objects allocated this way.
        Mat grayImage = new Mat(height, width, CV_8UC1);
        Mat rotatedImage = grabbedImage.clone();

        // The OpenCVFrameRecorder class simply uses the VideoWriter 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...
        Mat randomR    = new Mat(3, 3, CV_64FC1),
            randomAxis = new Mat(3, 1, CV_64FC1);
        // 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);
        Rodrigues(randomAxis, randomR);
        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.
        Point hatPoints = new Point(3);

        while (frame.isVisible() && (grabbedImage = converter.convert(grabber.grab())) != null) {
            // Let's try to detect some faces! but we need a grayscale image...
            cvtColor(grabbedImage, grayImage, CV_BGR2GRAY);
            RectVector faces = new RectVector();
            classifier.detectMultiScale(grayImage, faces);
            long total = faces.size();
            for (long i = 0; i < total; i++) {
                Rect r = faces.get(i);
                int x = r.x(), y = r.y(), w = r.width(), h = r.height();
                rectangle(grabbedImage, new Point(x, y), new Point(x + w, y + h), Scalar.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 );
                fillConvexPoly(grabbedImage, hatPoints.position(0), 3, Scalar.GREEN, CV_AA, 0);
            }

            // Let's find some contours! but first some thresholding...
            threshold(grayImage, grayImage, 64, 255, CV_THRESH_BINARY);

            // To check if an output argument is null we may call either isNull() or equals(null).
            MatVector contours = new MatVector();
            findContours(grayImage, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
            long n = contours.size();
            for (long i = 0; i < n; i++) {
                Mat contour = contours.get(i);
                Mat points = new Mat();
                approxPolyDP(contour, points, arcLength(contour, true) * 0.02, true);
                drawContours(grabbedImage, new MatVector(points), -1, Scalar.BLUE);
            }

            warpPerspective(grabbedImage, rotatedImage, randomR, rotatedImage.size());

            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
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.bytedeco.javacv</groupId>
    <artifactId>demo</artifactId>
    <version>1.5.13</version>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>javacv-platform</artifactId>
            <version>1.5.13</version>
        </dependency>

        <!-- Additional dependencies required to use CUDA and cuDNN -->
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>opencv-platform-gpu</artifactId>
            <version>4.13.0-1.5.13</version>
        </dependency>

        <!-- Optional GPL builds with (almost) everything enabled -->
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>ffmpeg-platform-gpl</artifactId>
            <version>8.0.1-1.5.13</version>
        </dependency>
    </dependencies>
    <build>
        <sourceDirectory>.</sourceDirectory>
    </build>
</project>
```

And by placing the source code above in `Demo.java`, or similarly for other classes found in the [`samples`](samples), we can use the following command to have everything first installed automatically and then executed by Maven:
```bash
 $ mvn compile exec:java -Dexec.mainClass=Demo
```

**Note**: In case of errors, please make sure that the `artifactId` in the `pom.xml` file reads `javacv-platform`, not `javacv` only, for example. The artifact `javacv-platform` adds all the necessary binary dependencies.


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.5.13  https://github.com/bytedeco/javacpp
 * JavaCPP Presets 1.5.13  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.

Instead of building the native libraries manually, we can run `mvn install` for JavaCV only and rely on the snapshot artifacts from the CI builds:

 * http://bytedeco.org/builds/


----
Project lead: Samuel Audet [samuel.audet `at` gmail.com](mailto:samuel.audet&nbsp;at&nbsp;gmail.com)  
Developer site: https://github.com/bytedeco/javacv  
Discussion group: http://groups.google.com/group/javacv


================================================
FILE: platform/pom.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacpp-presets</artifactId>
    <version>1.5.14-SNAPSHOT</version>
    <relativePath></relativePath>
  </parent>

  <groupId>org.bytedeco</groupId>
  <artifactId>javacv-platform</artifactId>
  <name>JavaCV Platform</name>

  <properties>
    <javacpp.version>${project.version}</javacpp.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>javacv</artifactId>
      <version>${project.version}</version>
    </dependency>

    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>javacpp-platform</artifactId>
      <version>${javacpp.version}</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>openblas-platform</artifactId>
      <version>0.3.31-${javacpp.version}</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>opencv-platform</artifactId>
      <version>4.13.0-${javacpp.version}</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>ffmpeg-platform</artifactId>
      <version>8.0.1-${javacpp.version}</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>flycapture-platform</artifactId>
      <version>2.13.3.31-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>libdc1394-platform</artifactId>
      <version>2.2.6-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>libfreenect-platform</artifactId>
      <version>0.5.7-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>libfreenect2-platform</artifactId>
      <version>0.2.0-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>librealsense-platform</artifactId>
      <version>1.12.4-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>librealsense2-platform</artifactId>
      <version>2.53.1-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>videoinput-platform</artifactId>
      <version>0.200-1.5.9</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>artoolkitplus-platform</artifactId>
      <version>2.3.1-1.5.9</version>
    </dependency>
<!--    <dependency>-->
<!--      <groupId>org.bytedeco</groupId>-->
<!--      <artifactId>flandmark-platform</artifactId>-->
<!--      <version>1.07-1.5.8</version>-->
<!--    </dependency>-->
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>leptonica-platform</artifactId>
      <version>1.87.0-${javacpp.version}</version>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>tesseract-platform</artifactId>
      <version>5.5.2-${javacpp.version}</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>opencv-platform-gpu</artifactId>
      <version>4.13.0-${javacpp.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.bytedeco</groupId>
      <artifactId>ffmpeg-platform-gpl</artifactId>
      <version>8.0.1-${javacpp.version}</version>
      <scope>test</scope>
    </dependency>

  </dependencies>

  <repositories>
    <repository>
      <id>central-portal-snapshots</id>
      <name>Central Portal Snapshots</name>
      <url>https://central.sonatype.com/repository/maven-snapshots/</url>
      <releases>
        <enabled>false</enabled>
      </releases>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </repository>
  </repositories>

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.5.0</version>
        <executions>
          <execution>
            <id>default-jar</id>
            <configuration>
              <archive>
                <manifestEntries>
                  <Class-Path>javacv.jar javacpp-platform.jar openblas-platform.jar opencv-platform.jar ffmpeg-platform.jar flycapture-platform.jar libdc1394-platform.jar libfreenect-platform.jar libfreenect2-platform.jar librealsense-platform.jar librealsense2-platform.jar videoinput-platform.jar artoolkitplus-platform.jar flandmark-platform.jar leptonica-platform.jar tesseract-platform.jar</Class-Path>
                  <Name>org/bytedeco/javacv/</Name>
                </manifestEntries>
              </archive>
            </configuration>
          </execution>
          <execution>
            <id>empty-javadoc-jar</id>
            <goals>
              <goal>jar</goal>
            </goals>
            <configuration>
              <classifier>javadoc</classifier>
            </configuration>
          </execution>
          <execution>
            <id>empty-sources-jar</id>
            <goals>
              <goal>jar</goal>
            </goals>
            <configuration>
              <classifier>sources</classifier>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.moditect</groupId>
        <artifactId>moditect-maven-plugin</artifactId>
        <version>1.3.0</version>
        <configuration>
          <jvmVersion>9</jvmVersion>
          <overwriteExistingFiles>true</overwriteExistingFiles>
          <outputDirectory>${project.build.directory}</outputDirectory>
        </configuration>
        <executions>
          <execution>
            <id>add-module-infos</id>
            <phase>package</phase>
            <goals>
              <goal>add-module-info</goal>
            </goals>
            <configuration>
              <modules>
                <module>
                  <file>${project.build.directory}/${project.artifactId}.jar</file>
                  <moduleInfoFile>${project.basedir}/src/main/java9/module-info.java</moduleInfoFile>
                </module>
              </modules>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-dependency-plugin</artifactId>
        <version>3.10.0</version>
        <executions>
          <execution>
            <id>properties</id>
            <goals>
              <goal>properties</goal>
            </goals>
          </execution>
          <execution>
            <id>copy-dependencies</id>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}</outputDirectory>
              <stripVersion>true</stripVersion>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.5.5</version>
        <configuration>
            <argLine>-Xmx2g</argLine>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <attach>false</attach>
          <descriptors>
            <descriptor>src/main/assembly/bin.xml</descriptor>
            <descriptor>src/main/assembly/src.xml</descriptor>
          </descriptors>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>sign-artifacts</id>
      <activation>
        <property>
          <name>performRelease</name>
          <value>true</value>
        </property>
      </activation>
      <repositories>
        <repository>
          <id>central-portal-staging</id>
          <name>Central Portal Staging</name>
          <url>https://central.sonatype.com/api/v1/publisher/deployments/download/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>
        </repository>
      </repositories>
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-gpg-plugin</artifactId>
            <version>3.2.8</version>
            <executions>
              <execution>
                <id>sign-artifacts</id>
                <phase>verify</phase>
                <goals>
                  <goal>sign</goal>
                </goals>
              </execution>
            </executions>
            <configuration>
              <passphrase>${env.GPG_PASSPHRASE}</passphrase>
              <useAgent>false</useAgent>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>


================================================
FILE: platform/src/main/assembly/bin.xml
================================================
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
  <id>${project.version}-bin</id>
  <formats>
    <format>zip</format>
  </formats>
  <baseDirectory>${project.artifactId}-${project.version}-bin</baseDirectory>
  <fileSets>
    <fileSet>
      <directory>${project.basedir}/..</directory>
      <outputDirectory>/</outputDirectory>
      <includes>
        <include>samples/*</include>
        <include>CHANGELOG*</include>
        <include>README*</include>
        <include>LICENSE*</include>
        <include>NOTICE*</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}</directory>
      <outputDirectory>/</outputDirectory>
      <includes>
        <include>*.jar</include>
      </includes>
      <excludes>
        <exclude>android*.jar</exclude>
        <exclude>gluegen*.jar</exclude>
        <exclude>hamcrest*.jar</exclude>
        <exclude>junit*.jar</exclude>
        <exclude>jogl*.jar</exclude>
        <exclude>jocl*.jar</exclude>
        <exclude>*-javadoc.jar</exclude>
        <exclude>*-sources.jar</exclude>
      </excludes>
      <fileMode>0644</fileMode>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}/site</directory>
      <outputDirectory>docs</outputDirectory>
    </fileSet>
  </fileSets>
</assembly>


================================================
FILE: platform/src/main/assembly/src.xml
================================================
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
  <id>${project.version}-src</id>
  <formats>
    <format>zip</format>
  </formats>
  <baseDirectory>${project.artifactId}-${project.version}</baseDirectory>
  <fileSets>
    <fileSet>
      <directory>${project.basedir}/..</directory>
      <outputDirectory>/</outputDirectory>
      <useDefaultExcludes>true</useDefaultExcludes>
      <excludes>
        <!-- TODO: use expresssions instead: ${project.build.sourceDirectory}, etc -->
        <exclude>**/target/**</exclude>
        <exclude>**/cppbuild/**</exclude>
      </excludes>
    </fileSet>
  </fileSets>
</assembly>



================================================
FILE: platform/src/main/java9/module-info.java
================================================
module org.bytedeco.javacv.platform {
    requires transitive org.bytedeco.javacv;
    requires org.bytedeco.opencv.platform;
    requires org.bytedeco.ffmpeg.platform;
    requires org.bytedeco.flycapture.platform;
    requires org.bytedeco.libdc1394.platform;
    requires org.bytedeco.libfreenect.platform;
    requires org.bytedeco.libfreenect2.platform;
    requires org.bytedeco.librealsense.platform;
    requires org.bytedeco.librealsense2.platform;
    requires org.bytedeco.videoinput.platform;
    requires org.bytedeco.artoolkitplus.platform;
    requires org.bytedeco.flandmark.platform;
    requires org.bytedeco.leptonica.platform;
    requires org.bytedeco.tesseract.platform;
}


================================================
FILE: platform/src/test/java/org/bytedeco/javacv/FrameConverterTest.java
================================================
/*
 * Copyright (C) 2015-2016 Samuel Audet
 *
 * Licensed either under the Apache License, Version 2.0, or (at your option)
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation (subject to the "Classpath" exception),
 * either version 2, or any later version (collectively, 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
 *     http://www.gnu.org/licenses/
 *     http://www.gnu.org/software/classpath/license.html
 *
 * or as provided in the LICENSE.txt file that accompanied this code.
 * 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.
 */

package org.bytedeco.javacv;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.WritableRaster;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import org.bytedeco.javacpp.BytePointer;
import org.bytedeco.javacpp.Loader;
import org.bytedeco.javacpp.indexer.Indexer;
import org.bytedeco.javacpp.indexer.UByteIndexer;
import org.junit.Test;

import org.bytedeco.leptonica.PIX;
import org.bytedeco.opencv.opencv_core.*;
import org.bytedeco.opencv.opencv_imgproc.*;
import static org.bytedeco.opencv.global.opencv_core.*;
import static org.bytedeco.opencv.global.opencv_imgproc.*;
import static org.junit.Assert.*;

/**
 * Test cases for FrameConverter classes. Also uses other classes from JavaCV.
 *
 * @author Samuel Audet
 */
public class FrameConverterTest {

    @Test public void testAndroidFrameConverter() {
        System.out.println("AndroidFrameConverter");

        AndroidFrameConverter converter = new AndroidFrameConverter();

        int width = 512;
        int height = 1024;
        byte[] yuvData = new byte[3 * width * height / 2];
        for (int i = 0; i < yuvData.length; i++) {
            yuvData[i] = (byte)i;
        }
        Mat yuvImage = new Mat(3 * height / 2, width, CV_8UC1, new BytePointer(yuvData));
        Mat bgrImage = new Mat(height, width, CV_8UC3);
        cvtColor(yuvImage, bgrImage, CV_YUV2BGR_NV21);
        Frame bgrFrame = converter.convert(yuvData, width, height);

        UByteIndexer bgrImageIdx = bgrImage.createIndexer();
        UByteIndexer bgrFrameIdx = bgrFrame.createIndexer();
        assertEquals(bgrImageIdx.rows(), bgrFrameIdx.rows());
        assertEquals(bgrImageIdx.cols(), bgrFrameIdx.cols());
        assertEquals(bgrImageIdx.channels(), bgrFrameIdx.channels());
        for (int i = 0; i < bgrImageIdx.rows(); i++) {
            for (int j = 0; j < bgrImageIdx.cols(); j++) {
                for (int k = 0; k < bgrImageIdx.channels(); k++) {
                    assertEquals((float)bgrImageIdx.get(i, j, k), (float)bgrFrameIdx.get(i, j, k), 1.0f);
                }
            }
        }
        bgrImageIdx.release();
        bgrFrameIdx.release();

        Frame grayFrame = new Frame(1024 + 1, 768, Frame.DEPTH_UBYTE, 1);
        Frame colorFrame = new Frame(640 + 1, 480, Frame.DEPTH_UBYTE, 3);

        UByteIndexer grayFrameIdx = grayFrame.createIndexer();
        for (int i = 0; i < grayFrameIdx.rows(); i++) {
            for (int j = 0; j < grayFrameIdx.cols(); j++) {
                grayFrameIdx.put(i, j, i + j);
            }
        }

        UByteIndexer colorFrameIdx = colorFrame.createIndexer();
        for (int i = 0; i < colorFrameIdx.rows(); i++) {
            for (int j = 0; j < colorFrameIdx.cols(); j++) {
                for (int k = 0; k < colorFrameIdx.channels(); k++) {
                    colorFrameIdx.put(i, j, k, i + j + k);
                }
            }
        }

        width = grayFrame.imageWidth;
        height = grayFrame.imageHeight;
        int stride = grayFrame.imageStride;
        int rowBytes = width * 4;
        ByteBuffer in = (ByteBuffer)grayFrame.image[0];
        ByteBuffer buffer = converter.gray2rgba(in, width, height, stride, rowBytes);
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // GRAY -> RGBA
                byte B = in.get(y * stride + x);
                assertEquals(buffer.get(y * rowBytes + 4 * x    ), B);
                assertEquals(buffer.get(y * rowBytes + 4 * x + 1), B);
                assertEquals(buffer.get(y * rowBytes + 4 * x + 2), B);
                assertEquals(buffer.get(y * rowBytes + 4 * x + 3), (byte)0xFF);
            }
        }

        width = colorFrame.imageWidth;
        height = colorFrame.imageHeight;
        stride = colorFrame.imageStride;
        rowBytes = width * 4;
        in = (ByteBuffer)colorFrame.image[0];
        buffer = converter.bgr2rgba(in, width, height, stride, rowBytes);
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // BGR -> RGBA
                byte B = in.get(y * stride + 3 * x    );
                byte G = in.get(y * stride + 3 * x + 1);
                byte R = in.get(y * stride + 3 * x + 2);
                assertEquals(buffer.get(y * rowBytes + 4 * x    ), R);
                assertEquals(buffer.get(y * rowBytes + 4 * x + 1), G);
                assertEquals(buffer.get(y * rowBytes + 4 * x + 2), B);
                assertEquals(buffer.get(y * rowBytes + 4 * x + 3), (byte)0xFF);
            }
        }

        colorFrameIdx.release();
        grayFrameIdx.release();
        converter.close();
        colorFrame.close();
        grayFrame.close();
    }

    @Test public void testJava2DFrameConverter() {
        System.out.println("Java2DFrameConverter");

        int[] depths = {Frame.DEPTH_UBYTE, Frame.DEPTH_SHORT, Frame.DEPTH_FLOAT};
        int[] channels = {1, 3, 4};
        for (int i = 0; i < depths.length; i++) {
            for (int j = 0; j < channels.length; j++) {
                Frame frame = new Frame(640 + 1, 480, depths[i], channels[j]);
                Java2DFrameConverter converter = new Java2DFrameConverter();

                Indexer frameIdx = frame.createIndexer();
                for (int y = 0; y < frameIdx.rows(); y++) {
                    for (int x = 0; x < frameIdx.cols(); x++) {
                        for (int z = 0; z < frameIdx.channels(); z++) {
                            frameIdx.putDouble(new long[] {y, x, z}, y + x + z);
                        }
                    }
                }

                BufferedImage image = converter.convert(frame);
                converter.frame = null;
                Frame frame2 = converter.convert(image);

                Indexer frame2Idx = frame2.createIndexer();
                for (int y = 0; y < frameIdx.rows(); y++) {
                    for (int x = 0; x < frameIdx.cols(); x++) {
                        for (int z = 0; z < frameIdx.channels(); z++) {
                            double value = frameIdx.getDouble(y, x, z);
                            assertEquals(value, frame2Idx.getDouble(y, x, z), 0);
                        }
                    }
                }

                try {
                    frame2Idx.getDouble(frameIdx.rows() + 1, frameIdx.cols() + 1);
                    fail("IndexOutOfBoundsException should have been thrown.");
                } catch (IndexOutOfBoundsException e) { }

                frameIdx.release();
                frame2Idx.release();
                converter.close();
                frame.close();
            }
        }

        int[] types = {BufferedImage.TYPE_INT_RGB, BufferedImage.TYPE_INT_ARGB,
                       BufferedImage.TYPE_INT_ARGB_PRE, BufferedImage.TYPE_INT_BGR};
        for (int i = 0; i < types.length; i++) {
            BufferedImage image = new BufferedImage(640 + 1, 480, types[i]);
            Java2DFrameConverter converter = new Java2DFrameConverter();

            WritableRaster raster = image.getRaster();
            int[] array = ((DataBufferInt)raster.getDataBuffer()).getData();
            for (int j = 0; j < array.length; j++) {
                array[j] = j;
            }

            Frame frame = converter.convert(image);
            converter.bufferedImage = null;
            BufferedImage image2 = converter.convert(frame);

            WritableRaster raster2 = image2.getRaster();
            byte[] array2 = ((DataBufferByte)raster2.getDataBuffer()).getData();
            for (int j = 0; j < array.length; j++) {
                int n = ((array2[4 * j    ] & 0xFF) << 24) | ((array2[4 * j + 1] & 0xFF) << 16)
                      | ((array2[4 * j + 2] & 0xFF) << 8)  |  (array2[4 * j + 3] & 0xFF);
                assertEquals(array[j], n);
            }
            converter.close();
        }
    }

    @Test public void testOpenCVFrameConverter() {
        System.out.println("OpenCVFrameConverter");
        Loader.load(org.bytedeco.opencv.opencv_java.class);

        for (int depth = 8; depth <= 64; depth *= 2) {
            assertEquals(depth, OpenCVFrameConverter.getFrameDepth(OpenCVFrameConverter.getIplImageDepth(depth)));
            assertEquals(depth, OpenCVFrameConverter.getFrameDepth(OpenCVFrameConverter.getMatDepth(depth)));
            if (depth < 64) {
                assertEquals(-depth, OpenCVFrameConverter.getFrameDepth(OpenCVFrameConverter.getIplImageDepth(-depth)));
                assertEquals(-depth, OpenCVFrameConverter.getFrameDepth(OpenCVFrameConverter.getMatDepth(-depth)));
            }
        }

        Frame frame = new Frame(640 + 1, 480, Frame.DEPTH_UBYTE, 3);
        OpenCVFrameConverter.ToIplImage converter1 = new OpenCVFrameConverter.ToIplImage();
        OpenCVFrameConverter.ToMat converter2 = new OpenCVFrameConverter.ToMat();
        OpenCVFrameConverter.ToOrgOpenCvCoreMat converter3 = new OpenCVFrameConverter.ToOrgOpenCvCoreMat();

        UByteIndexer frameIdx = frame.createIndexer();
        for (int i = 0; i < frameIdx.rows(); i++) {
            for (int j = 0; j < frameIdx.cols(); j++) {
                for (int k = 0; k < frameIdx.channels(); k++) {
                    frameIdx.put(i, j, k, i + j + k);
                }
            }
        }

        IplImage image = converter1.convert(frame);
        Mat mat = converter2.convert(frame);
        final org.opencv.core.Mat cvmat = converter3.convert(frame);

        converter1.frame = null;
        converter2.frame = null;
        converter3.frame = null;
        Frame frame1 = converter1.convert(image);
        Frame frame2 = converter2.convert(mat);
        Frame frame3 = converter3.convert(cvmat);
        assertEquals(frame2.opaque, mat);
        assertEquals(frame3.opaque, cvmat);

        Mat mat2 = new Mat(mat.rows(), mat.cols(), mat.type(), mat.data(), mat.step());
        org.opencv.core.Mat cvmat2 = new org.opencv.core.Mat(cvmat.rows(), cvmat.cols(), cvmat.type(),
                new BytePointer() { { address = cvmat.dataAddr(); } }.capacity(cvmat.rows() * cvmat.cols() * cvmat.elemSize()).asByteBuffer(),
                cvmat.step1() * cvmat.elemSize1());
        assertNotEquals(mat, mat2);
        assertNotEquals(cvmat, cvmat2);

        frame2 = converter2.convert(mat2);
        frame3 = converter3.convert(cvmat2);
        assertEquals(frame2.opaque, mat2);
        assertEquals(frame3.opaque, cvmat2);
        assertEquals(frame3.imageStride, cvmat2.step1() * cvmat2.elemSize1());

        UByteIndexer frame1Idx = frame1.createIndexer();
        UByteIndexer frame2Idx = frame2.createIndexer();
        UByteIndexer frame3Idx = frame3.createIndexer();
        for (int i = 0; i < frameIdx.rows(); i++) {
            for (int j = 0; j < frameIdx.cols(); j++) {
                for (int k = 0; k < frameIdx.channels(); k++) {
                    int b = frameIdx.get(i, j, k);
                    assertEquals(b, frame1Idx.get(i, j, k));
                    assertEquals(b, frame2Idx.get(i, j, k));
                    assertEquals(b, frame3Idx.get(i, j, k));
                }
            }
        }

        try {
            frame1Idx.get(frameIdx.rows() + 1, frameIdx.cols() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        try {
            frame2Idx.get(frameIdx.rows() + 1, frameIdx.cols() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        try {
            frame3Idx.get(frameIdx.rows() + 1, frameIdx.cols() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        frameIdx.release();
        frame1Idx.release();
        frame2Idx.release();
        frame3Idx.release();
        converter1.close();
        converter2.close();
        converter3.close();
        frame.close();
    }

    @Test public void testLeptonicaFrameConverter() {
        System.out.println("LeptonicaFrameConverter");

        Frame frame = new Frame(640 + 1, 480, Frame.DEPTH_UBYTE, 3);
        LeptonicaFrameConverter converter = new LeptonicaFrameConverter();

        UByteIndexer frameIdx = frame.createIndexer();
        for (int i = 0; i < frameIdx.rows(); i++) {
            for (int j = 0; j < frameIdx.cols(); j++) {
                for (int k = 0; k < frameIdx.channels(); k++) {
                    frameIdx.put(i, j, k, i + j + k);
                }
            }
        }

        PIX pix = converter.convert(frame);

        converter.frame = null;
        Frame frame1 = converter.convert(pix);
//        assertEquals(frame1.opaque, pix);

        PIX pix2 = PIX.createHeader(pix.w(), pix.h(), pix.d()).data(pix.data()).wpl(pix.wpl());
        assertNotEquals(pix, pix2);

        Frame frame2 = converter.convert(pix2);
//        assertEquals(frame2.opaque, pix2);

        IntBuffer frameBuf = ((ByteBuffer)frame.image[0].position(0)).asIntBuffer();
        IntBuffer frame1Buf = ((ByteBuffer)frame1.image[0].position(0)).asIntBuffer();
        IntBuffer frame2Buf = ((ByteBuffer)frame2.image[0].position(0)).asIntBuffer();
        IntBuffer pixBuf = pix.createBuffer().order(ByteOrder.BIG_ENDIAN).asIntBuffer();
        IntBuffer pix2Buf = pix2.createBuffer().order(ByteOrder.BIG_ENDIAN).asIntBuffer();
        for (int i = 0; i < frameBuf.capacity(); i++) {
            int j = frameBuf.get(i);
            assertEquals(j, frame1Buf.get(i));
            assertEquals(j, frame2Buf.get(i));
            assertEquals(j, pixBuf.get(i));
            assertEquals(j, pix2Buf.get(i));
        }

        try {
            frame1Buf.get(frameBuf.capacity() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        try {
            frame2Buf.get(frameBuf.capacity() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        try {
            pixBuf.get(frameBuf.capacity() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        try {
            pix2Buf.get(frameBuf.capacity() + 1);
            fail("IndexOutOfBoundsException should have been thrown.");
        } catch (IndexOutOfBoundsException e) { }

        pix2.deallocate();
        pix.deallocate();
        converter.close();
        frame.close();
    }
}


================================================
FILE: platform/src/test/java/org/bytedeco/javacv/FrameFilterTest.java
================================================
/*
 * Copyright (C) 2018 Samuel Audet
 *
 * Licensed either under the Apache License, Version 2.0, or (at your option)
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation (subject to the "Classpath" exception),
 * either version 2, or any later version (collectively, 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
 *     http://www.gnu.org/licenses/
 *     http://www.gnu.org/software/classpath/license.html
 *
 * or as provided in the LICENSE.txt file that accompanied this code.
 * 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.
 */

package org.bytedeco.javacv;

import java.io.File;
import java.nio.ByteBuffer;
import java.nio.ShortBuffer;
import org.bytedeco.javacpp.Loader;
import org.junit.Test;

import static org.bytedeco.ffmpeg.global.avcodec.*;
import static org.bytedeco.ffmpeg.global.avutil.*;
import static org.junit.Assert.*;

/**
 * Test cases for FrameFilter classes. Also uses other classes from JavaCV.
 *
 * @author Samuel Audet
 */
public class FrameFilterTest {

    @Test
    public void testFFmpegFrameFilter() {
        System.out.println("FFmpegFrameFilter");

        File tempFile = new File(Loader.getTempDir(), "test.mov");
        try {
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(tempFile, 800, 600, 2);
            recorder.setFormat("mov");
            recorder.setPixelFormat(AV_PIX_FMT_YUV420P);
            recorder.setFrameRate(30);
            recorder.setVideoCodec(AV_CODEC_ID_H264);
            recorder.setVideoQuality(10);
            recorder.setSampleFormat(AV_SAMPLE_FMT_FLTP);
            recorder.setSampleRate(48000);
            recorder.setAudioCodec(AV_CODEC_ID_AAC);
            recorder.setAudioQuality(10);
            recorder.start();

            int n = 1000;
            Frame frame = new Frame(800, 600, Frame.DEPTH_UBYTE, 3);
            for (int i = 0; i < n; i++) {
                recorder.record(frame);
            }
            Frame audioFrame = new Frame();
            ShortBuffer audioBuffer = ShortBuffer.allocate(48000 * 2 * n / 30);
            audioFrame.sampleRate = 48000;
            audioFrame.audioChannels = 2;
            audioFrame.samples = new ShortBuffer[] {audioBuffer};
            recorder.record(audioFrame);
            recorder.stop();
            recorder.release();

            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(tempFile);
            grabber.setSampleMode(FrameGrabber.SampleMode.FLOAT);
            grabber.start();

            FFmpegFrameFilter filter = new FFmpegFrameFilter(
                    "scale=400x300,transpose=cclock_flip,format=gray",
                    "volume=0.5,aformat=sample_fmts=u8:channel_layouts=mono",
                    grabber.getImageWidth(), grabber.getImageHeight(), grabber.getAudioChannels());
            filter.setPixelFormat(grabber.getPixelFormat());
            filter.setSampleFormat(grabber.getSampleFormat());
            filter.setFrameRate(grabber.getFrameRate());
            filter.setSampleRate(grabber.getSampleRate());
            filter.start();

            FFmpegFrameFilter nullFilter = new FFmpegFrameFilter(null, null, 0, 0, 0);
            nullFilter.start();

            int a = 0, b = 0, c = 0, d = 0;
            Frame frame2;
            while ((frame2 = grabber.grab()) != null) {
                if (frame2.image != null) {
                    a++;
                }
                if (frame2.samples != null) {
                    b++;
                }
                filter.push(frame2);
                Frame frame3;
                while ((frame3 = filter.pull()) != null) {
                    if (frame3.image != null) {
                        c++;
                        assertEquals(300, frame3.imageWidth);
                        assertEquals(400, frame3.imageHeight);
                        assertEquals(1, frame3.imageChannels);
                    }
                    if (frame3.samples != null) {
                        d++;
                        assertEquals(1, frame3.audioChannels);
                        assertEquals(1, frame3.samples.length);
                        assertTrue(frame3.samples[0] instanceof ByteBuffer);
                        assertEquals(frame2.samples.length, frame3.samples.length);
                        assertEquals(frame2.samples[0].limit() / 2, frame3.samples[0].limit());
                    }
                    assertEquals(frame2.timestamp, frame3.timestamp);
                }
                nullFilter.push(frame2);
                assertEquals(frame2, nullFilter.pull());
            }
            filter.push(null);
            assertEquals(null, filter.pull());
            assertEquals(a, c);
            assertEquals(b, d);
            assertEquals(null, grabber.grab());
            filter.stop();
            filter.release();
            grabber.restart();
            grabber.stop();
            grabber.release();
            frame.close();
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception should not have been thrown: " + e);
        } finally {
            tempFile.delete();
        }
    }

    @Test
    public void testFFmpegFrameFilterMultipleInputs() {
        System.out.println("FFmpegFrameFilterMultipleInputs");

        File tempFile = new File(Loader.getTempDir(), "test.avi");
        try {
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(tempFile, 320, 200, 2);
            recorder.setVideoCodec(AV_CODEC_ID_VP8);
            recorder.setAudioCodec(AV_CODEC_ID_VORBIS);
            recorder.start();

            int n = 1000;
            Frame frame = new Frame(320, 200, Frame.DEPTH_UBYTE, 3);
            for (int i = 0; i < n; i++) {
                recorder.record(frame);
            }
            Frame audioFrame = new Frame();
            ShortBuffer audioBuffer = ShortBuffer.allocate(8000 * 2 * n / 30);
            audioFrame.sampleRate = 8000;
            audioFrame.audioChannels = 2;
            audioFrame.samples = new ShortBuffer[] {audioBuffer};
            recorder.record(audioFrame);
            recorder.stop();
            recorder.release();

            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(tempFile);
            grabber.start();

            FFmpegFrameFilter filter = new FFmpegFrameFilter(
                    "[0:v][1:v]hstack=inputs=2[v]",
                    "[0:a][1:a]amerge[a]",
                    grabber.getImageWidth(), grabber.getImageHeight(), grabber.getAudioChannels());
            filter.setPixelFormat(grabber.getPixelFormat());
            filter.setSampleFormat(grabber.getSampleFormat());
            filter.setVideoInputs(2);
            filter.setAudioInputs(2);
            filter.start();

            int a = 0, b = 0, c = 0, d = 0;
            Frame frame2;
            while ((frame2 = grabber.grab()) != null) {
                if (frame2.image != null) {
                    a++;
                }
                if (frame2.samples != null) {
                    b++;
                }
                filter.push(0, frame2);
                filter.push(1, frame2);
                Frame frame3;
                while ((frame3 = filter.pull()) != null) {
                    if (frame3.image != null) {
                        c++;
                        assertEquals(640, frame3.imageWidth);
                        assertEquals(200, frame3.imageHeight);
                        assertEquals(3, frame3.imageChannels);
                    }
                    if (frame3.samples != null) {
                        d++;
                        assertEquals(4, frame3.audioChannels);
                        assertEquals(1, frame3.samples.length);
                        assertTrue(frame3.samples[0] instanceof ShortBuffer);
                        assertEquals(frame2.samples.length, frame3.samples.length);
                        assertEquals(2 * frame2.samples[0].limit(), frame3.samples[0].limit());
                    }
                }
            }
            filter.push(0, null);
            filter.push(1, null);
            assertEquals(null, filter.pull());
            assertEquals(a, c);
            assertEquals(b, d);
            assertEquals(null, grabber.grab());
            filter.stop();
            filter.release();
            grabber.restart();
            grabber.stop();
            grabber.release();
            frame.close();
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception should not have been thrown: " + e);
        } finally {
            tempFile.delete();
        }
    }

}


================================================
FILE: platform/src/test/java/org/bytedeco/javacv/FrameGrabberChangingResolutionTest.java
================================================
/*
 * Copyright (C) 2016-2017 Samuel Audet
 *
 * Licensed either under the Apache License, Version 2.0, or (at your option)
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation (subject to the "Classpath" exception),
 * either version 2, or any later version (collectively, 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
 *     http://www.gnu.org/licenses/
 *     http://www.gnu.org/software/classpath/license.html
 *
 * or as provided in the LICENSE.txt file that accompanied this code.
 * 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.
 */

package org.bytedeco.javacv;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import org.bytedeco.javacpp.Loader;
import org.bytedeco.javacpp.indexer.UByteIndexer;
import org.junit.Test;

import static org.bytedeco.ffmpeg.global.avcodec.*;
import static org.bytedeco.ffmpeg.global.avutil.*;
import static org.junit.Assert.*;

/**
 * Complex Test case for FrameGrabber classes - change the resolution during runtime.
 * Also uses other classes from JavaCV.
 *
 * @author Samuel Audet, Michael Fritscher
 */
public class FrameGrabberChangingResolutionTest {
    private File tempFile = new File(Loader.getTempDir(), "test.mkv");
    private File tempTargetFile = new File(Loader.getTempDir(), "target.mkv");
    private boolean endRequested;

    private void makeTestfile() throws Exception {
        FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(new FileOutputStream(tempFile), 640, 480, 2);
        recorder.setFormat("matroska"); // mp4 doesn't support streaming
        recorder.setPixelFormat(AV_PIX_FMT_YUV420P);
        recorder.setVideoCodec(AV_CODEC_ID_H264);
        recorder.setVideoQuality(0); // lossless
        recorder.setFrameRate(30);
        recorder.startUnsafe();

        Frame[] frames = new Frame[60];
        for (int n = 0; n < frames.length; n++) {
            Frame frame = new Frame(640, 480, Frame.DEPTH_UBYTE, 3);
            UByteIndexer frameIdx = frame.createIndexer();
            for (int i = 0; i < frameIdx.rows(); i++) {
                for (int j = 0; j < frameIdx.cols(); j++) {
                    for (int k = 0; k < frameIdx.channels(); k++) {
                        frameIdx.put(i, j, k, n + i + j + k);
                    }
                }
            }
            recorder.record(frame);
            frames[n] = frame;
        }
        recorder.stop();
        recorder.release();
        for (int n = 0; n < frames.length; n++) {
            frames[n].close();
        }
    }

    final public void setupUDPSender(final int x, final int y, final int bandwidth, final int count) throws IOException {
        final FFmpegFrameGrabber fg = new FFmpegFrameGrabber(tempFile);
        fg.setFrameRate(30);

        final FFmpegFrameRecorder fr = new FFmpegFrameRecorder("udp://127.0.0.1:2345", 0);
        fr.setVideoCodecName("mpeg2video");
        fr.setFormat("mpegts");

        fr.setImageWidth(x);
        fr.setImageHeight(y);
        fr.setVideoBitrate(bandwidth);

        fr.setFrameRate(30);

        fg.startUnsafe();
        fr.startUnsafe();

        final boolean[] b = new boolean[1];
        Thread t = new Thread() {
            public void run() {
                try {
                    for (int i = 0; i < count; i++) {
                        /*- System.out.println("S: " + fg.getFrameNumber() + " " + fg.getTimestamp() + " "
                                + fg.getFrameRate() + " " + fg.getImageWidth() + "x" + fg.getImageHeight() + " "
                                + fg.getVideoCodec() + " " + fg.getVideoBitrate() + " " + i); */
                        Frame source = fg.grabFrame();
                        fr.record(source);
                    }
                    fg.close();
                    fr.close();
                    b[0] = true;
                } catch (Exception e) {
                    e.printStackTrace();
                    fail("Exception should not have been thrown: " + e);
                    try {
                        fg.close();
                        fr.close();
                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                    b[0] = true;
                }
            }
        };
        t.setName("Sender");
        t.start();

        while (!b[0]) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    final public void setupUDPReceiver() throws IOException {
        Thread t = new Thread() {

            public void run() {
                FFmpegFrameGrabber fg = new FFmpegFrameGrabber("udp://127.0.0.1:2345");
                fg.setFrameRate(30);

                FFmpegFrameRecorder fr = new FFmpegFrameRecorder(tempTargetFile, 0);
                fr.setVideoCodecName("mpeg2video");
                fr.setFormat("mpegts");

                fr.setImageWidth(640);
                fr.setImageHeight(480);
                fr.setVideoBitrate(8000000);

                fr.setFrameRate(30);

                try {
                    fg.startUnsafe();
                    fr.startUnsafe();
                } catch (Exception e) {
                    e.printStackTrace();
                }

                // Tests whether the width of the picture changes trough all
                // qualities and every step has a few pictures.
                try {
                    int n = 0;
                    int m = 0; // Pictures in this quality
                    int q = 0; // which quality state?
                    int[] qualities = { 160, 320, 640, 160, 320, 640, 320, 160 };
                    while (!endRequested) {
                        /*- System.out.println("R: " + fg.getFrameNumber() + " " + fg.getTimestamp() + " "
                                + fg.getFrameRate() + " " + fg.getImageWidth() + "x" + fg.getImageHeight() + " "
                                + fg.getVideoCodec() + " " + fg.getVideoBitrate()); */
                        Frame source = fg.grabFrame();
                        n++;
                        m++;
                        // System.out.println("WRITTEN: " + n + " " + m + " " +
                        // q + " " + source.imageWidth);
                        if (source.imageWidth != qualities[q]) {
                            q++;
                            assertEquals(source.imageWidth, qualities[q]);
                            assertTrue(m > 5);
                            assertTrue(m <= 60);
                            m = 0;
                        }
                        fr.record(source);
                    }
                    assertEquals(q, qualities.length - 1);
                    assertTrue(n > 300);
                    assertTrue(n <= 480);
                    fr.close();
                } catch (Exception e) {
                    e.printStackTrace();
                    fail("Exception should not have been thrown: " + e);
                    try {
                        fg.close();
                        fr.close();
                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                }
            }
        };
        t.setName("Receiver");
        t.start();
    }

    @Test
    public void testFFmpegFrameGrabber() {
        System.out.println("FFmpegFrameGrabber");

        try {
            makeTestfile();

            setupUDPReceiver();

            System.out.println("Changing to 160x120");
            setupUDPSender(160, 120, 50000, 60);

            System.out.println("Changing to 320x240");
            setupUDPSender(320, 240, 100000, 60);

            System.out.println("Changing to 640x480");
            setupUDPSender(640, 480, 200000, 60);

            System.out.println("Changing to 160x120");
            setupUDPSender(160, 120, 50000, 60);

            System.out.println("Changing to 320x240");
            setupUDPSender(320, 240, 100000, 60);

            System.out.println("Changing to 640x480");
            setupUDPSender(640, 480, 200000, 60);

            System.out.println("Changing to 320x240");
            setupUDPSender(320, 240, 100000, 60);

            System.out.println("Changing to 160x120");
            setupUDPSender(160, 120, 50000, 60);

            Thread.sleep(3000);
            endRequested = true;
        } catch (Exception e) {
            tempFile.delete();
            tempTargetFile.delete();
            e.printStackTrace();
            fail("Exception should not have been thrown: " + e);
        }

        try {
            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(new FileInputStream(tempTargetFile));
            grabber.setSampleMode(FrameGrabber.SampleMode.FLOAT);
            grabber.startUnsafe();

            int n = 0;
            Frame frame2;
            while ((frame2 = grabber.grab()) != null) {
                if (frame2.image != null) {
                    n++;
                    assertEquals(640, frame2.imageWidth);
                }
            }

            // It seems that ffmpeg lose some frames while switching (ideal
            // value would be 240)
            // System.out.println("END NUMBER: " + n);
            assertTrue(n > 300);
            assertTrue(n <= 480);
            assertEquals(null, grabber.grab());
            grabber.stop();
            grabber.release();
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception should not have been thrown: " + e);
        } finally {
            tempFile.delete();
            tempTargetFile.delete();
        }
    }
}


================================================
FILE: platform/src/test/java/org/bytedeco/javacv/FrameGrabberTest.java
================================================
/*
 * Copyright (C) 2016-2023 Samuel Audet
 *
 * Licensed either under the Apache License, Version 2.0, or (at your option)
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation (subject to the "Classpath" exception),
 * either version 2, or any later version (collectively, 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
 *     http://www.gnu.org/licenses/
 *     http://www.gnu.org/software/classpath/license.html
 *
 * or as provided in the LICENSE.txt file that accompanied this code.
 * 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.
 */

package org.bytedeco.javacv;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import java.util.Random;
import org.bytedeco.javacpp.Loader;
import org.bytedeco.javacpp.PointerScope;
import org.bytedeco.javacpp.indexer.UByteIndexer;
import org.junit.Test;

import static org.bytedeco.ffmpeg.global.avcodec.*;
import static org.bytedeco.ffmpeg.global.avutil.*;
import static org.junit.Assert.*;

/**
 * Test cases for FrameGrabber classes. Also uses other classes from JavaCV.
 *
 * @author Samuel Audet
 */
public class FrameGrabberTest {

    @Test
    public void testFFmpegFrameGrabber() {
        System.out.println("FFmpegFrameGrabber");

        File tempFile = new File(Loader.getTempDir(), "test.mkv");
        try {
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(new FileOutputStream(tempFile), 640, 480, 2);
            recorder.setFormat("matroska"); // mp4 doesn't support streaming
            recorder.setPixelFormat(AV_PIX_FMT_BGR24);
            recorder.setVideoCodecName("jpegls");
            recorder.setVideoQuality(0); // lossless
            recorder.setSampleFormat(AV_SAMPLE_FMT_S16);
            recorder.setSampleRate(44100);
            recorder.setAudioCodecName("pcm_s16le");
            recorder.start();

            Frame[] frames = new Frame[1000];
            for (int n = 0; n < frames.length; n++) {
                Frame frame = new Frame(640, 480, Frame.DEPTH_UBYTE, 3);
                UByteIndexer frameIdx = frame.createIndexer();
                for (int i = 0; i < frameIdx.rows(); i++) {
                    for (int j = 0; j < frameIdx.cols(); j++) {
                        for (int k = 0; k < frameIdx.channels(); k++) {
                            frameIdx.put(i, j, k, n + i + j + k);
                        }
                    }
                }
                recorder.record(frame);
                frames[n] = frame;
            }
            Frame audioFrame = new Frame();
            ShortBuffer audioBuffer = ShortBuffer.allocate(64 * 1024);
            audioFrame.sampleRate = 44100;
            audioFrame.audioChannels = 2;
            audioFrame.samples = new ShortBuffer[] {audioBuffer};
            for (int i = 0; i < audioBuffer.capacity(); i++) {
                audioBuffer.put(i, (short)i);
            }
            recorder.record(audioFrame);
            recorder.stop();
            recorder.release();

            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(new FileInputStream(tempFile));
            grabber.setSampleMode(FrameGrabber.SampleMode.FLOAT);
            grabber.start();

            int n = 0, m = 0;
            Frame frame2;
            long startTime = System.nanoTime();
            while ((frame2 = grabber.grabAtFrameRate()) != null) {
                long delay = frame2.timestamp * 1000 - (System.nanoTime() - startTime);
                if (delay < -1_000_000_000 / grabber.getFrameRate()) {
                    // skip to catch up with frame rate
                    if (frame2.image != null) {
                        n++;
                    } else {
                        m++;
                    }
                    continue;
                }
                Frame clone2 = frame2.clone();
                if (frame2.image != null) {
                    Frame frame = frames[n++];
                    assertEquals(frame.imageWidth, frame2.imageWidth);
                    assertEquals(frame.imageHeight, frame2.imageHeight);
                    assertEquals(frame.imageChannels, frame2.imageChannels);
                    assertEquals(frame.imageWidth, clone2.imageWidth);
                    assertEquals(frame.imageHeight, clone2.imageHeight);
                    assertEquals(frame.imageChannels, clone2.imageChannels);

                    UByteIndexer frameIdx = frame.createIndexer();
                    UByteIndexer frame2Idx = frame2.createIndexer();
                    UByteIndexer clone2Idx = clone2.createIndexer();
                    for (int i = 0; i < frameIdx.rows(); i++) {
                        for (int j = 0; j < frameIdx.cols(); j++) {
                            for (int k = 0; k < frameIdx.channels(); k++) {
                                int b = frameIdx.get(i, j, k);
                                assertEquals(b, frame2Idx.get(i, j, k));
                                assertEquals(b, clone2Idx.get(i, j, k));
                            }
                        }
                    }
                } else {
                    FloatBuffer audioBuffer2 = (FloatBuffer)frame2.samples[0];
                    FloatBuffer cloneBuffer2 = (FloatBuffer)clone2.samples[0];
                    while (audioBuffer2.hasRemaining()) {
                        assertEquals((float)audioBuffer.get(m) / (Short.MAX_VALUE + 1), audioBuffer2.get(), 0);
                        assertEquals((float)audioBuffer.get(m) / (Short.MAX_VALUE + 1), cloneBuffer2.get(), 0);
                        m++;
                    }
                }
                clone2.close();
            }
            long stopTime = System.nanoTime();
            assertEquals(n, (stopTime - startTime) * grabber.getFrameRate() / 1_000_000_000, 3.0);
            assertEquals(frames.length, n);
            assertEquals(null, grabber.grab());
            grabber.restart();
            grabber.stop();
            grabber.release();
            for (n = 0; n < frames.length; n++) {
                frames[n].close();
            }
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception should not have been thrown: " + e);
        } finally {
            tempFile.delete();
        }
    }

    @Test
    public void testFFmpegFrameGrabberLockingTest() {
        final boolean[] failed = {false};
        final int numberOfInstances = 20;
        System.out.println("FFmpegFrameGrabberLocking");

        Runnable[] runables = new Runnable[numberOfInstances];
        Thread[] threads = new Thread[numberOfInstances];
        final boolean[] finish = new boolean[numberOfInstances];
        for (int instance = 0; instance < numberOfInstances; instance++) {
            final int instance_final = instance;
            Runnable r = new Runnable() {
                public void run() {

                    File tempFile = new File(Loader.getTempDir(), "test" + instance_final + ".mkv");
                    try (PointerScope scope = new PointerScope()) {
                        FFmpegLogCallback.set();
                        FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(new FileOutputStream(tempFile), 640, 480, 2);
                        recorder.setFormat("matroska"); // mp4 doesn't support streaming
                        recorder.setPixelFormat(AV_PIX_FMT_BGR24);
                        recorder.setVideoCodecName("jpegls");
                        recorder.setVideoQuality(0); // lossless
                        recorder.setSampleFormat(AV_SAMPLE_FMT_S16);
                        recorder.setSampleRate(44100);
                        recorder.setAudioCodecName("pcm_s16le");
                        recorder.startUnsafe();

                        Frame[] frames = new Frame[10];
                        for (int n = 0; n < frames.length; n++) {
                            Frame frame = new Frame(640, 480, Frame.DEPTH_UBYTE, 3);
                            UByteIndexer frameIdx = frame.createIndexer();
                            for (int i = 0; i < frameIdx.rows(); i++) {
                                for (int j = 0; j < frameIdx.cols(); j++) {
                                    for (int k = 0; k < frameIdx.channels(); k++) {
                                        frameIdx.put(i, j, k, n + i + j + k);
                                    }
                                }
                            }
                            recorder.record(frame);
                            frames[n] = frame;
                        }
                        Frame audioFrame = new Frame();
                        ShortBuffer audioBuffer = ShortBuffer.allocate(64 * 1024);
                        audioFrame.sampleRate = 44100;
                        audioFrame.audioChannels = 2;
                        audioFrame.samples = new ShortBuffer[] { audioBuffer };
                        for (int i = 0; i < audioBuffer.capacity(); i++) {
                            audioBuffer.put(i, (short) i);
                        }
                        recorder.record(audioFrame);
                        recorder.stop();
                        recorder.release();

                        Thread.sleep(1000);

                        FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(new FileInputStream(tempFile));
                        grabber.setSampleMode(FrameGrabber.SampleMode.FLOAT);
                        grabber.startUnsafe();

                        int n = 0, m = 0;
                        Frame frame2;
                        while ((frame2 = grabber.grab()) != null) {
                            if (frame2.image != null) {
                                Frame frame = frames[n++];
                                assertEquals(frame.imageWidth, frame2.imageWidth);
                                assertEquals(frame.imageHeight, frame2.imageHeight);
                                assertEquals(frame.imageChannels, frame2.imageChannels);

                                UByteIndexer frameIdx = frame.createIndexer();
                                UByteIndexer frame2Idx = frame2.createIndexer();
                                for (int i = 0; i < frameIdx.rows(); i++) {
                                    for (int j = 0; j < frameIdx.cols(); j++) {
                                        for (int k = 0; k < frameIdx.channels(); k++) {
                                            int b = frameIdx.get(i, j, k);
                                            assertEquals(b, frame2Idx.get(i, j, k));
                                        }
                                    }
                                }
                            } else {
                                FloatBuffer audioBuffer2 = (FloatBuffer) frame2.samples[0];
                                while (audioBuffer2.hasRemaining()) {
                                    assertEquals((float) audioBuffer.get(m++) / (Short.MAX_VALUE + 1),
                                            audioBuffer2.get(), 0);
                                }
                            }
                        }
                        assertEquals(frames.length, n);
                        assertEquals(null, grabber.grab());
                        grabber.restart();
                        grabber.stop();
                        grabber.release();
                        for (n = 0; n < frames.length; n++) {
                            frames[n].close();
                        }
                    } catch (Error | Exception e) {
                        failed[0] = true;
                        e.printStackTrace();
                        fail("Exception should not have been thrown: " + e);
                    } finally {
                        tempFile.delete();
                        finish[instance_final] = true;
                    }
                }
            };

            runables[instance_final] = r;
        }

        for (int instance = 0; instance < numberOfInstances; instance++) {
            threads[instance] = new Thread(runables[instance]);
            threads[instance].setName("Testthread-" + instance);
        }

        for (int instance = 0; instance < numberOfInstances; instance++) {
            threads[instance].start();
        }

        while (true) {
            boolean finished = true;
            for (int instance = 0; instance < numberOfInstances; instance++) {
                if (!finish[instance]) {
                    finished = false;
                    break;
                }
            }

            if (!finished) {
                System.out.println("Still waiting...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } else {
                break;
            }
        }
        assertFalse(failed[0]);
    }

    @Test
    public void testFFmpegFrameGrabberSeeking() throws IOException {
        System.out.println("FFmpegFrameGrabberSeeking");

        for(int seektestnum = 0; seektestnum < 3; seektestnum++) try (PointerScope scope = new PointerScope()) {
            FFmpegLogCallback.set();
            String fileName = seektestnum==0?"testAV.mp4":seektestnum==1?"testV.mp4":"testA.mp4";
            File tempFile = new File(Loader.getTempDir(), fileName);
            tempFile.deleteOnExit();
            FFmpegFrameRecorder recorder = seektestnum == 0? new FFmpegFrameRecorder(tempFile, 640, 480, 2)
                                         : seektestnum == 1? new FFmpegFrameRecorder(tempFile, 640, 480, 0)
                                         : new FFmpegFrameRecorder(tempFile, 0, 0, 2);
            recorder.setFormat("mp4");
            recorder.setFrameRate(30);
            recorder.setPixelFormat(AV_PIX_FMT_YUV420P);
            recorder.setVideoCodec(AV_CODEC_ID_MPEG4);
            recorder.setVideoQuality(10);
            recorder.setSampleRate(48000);
            recorder.setSampleFormat(AV_SAMPLE_FMT_FLTP);
            recorder.setAudioCodec(AV_CODEC_ID_AAC);
            recorder.setAudioQuality(0);
            recorder.setDisplayRotation((seektestnum - 2) * 90.0);
            recorder.start();
            if (seektestnum!=2) {
                Frame frame = new Frame(640, 480, Frame.DEPTH_UBYTE, 3);
                UByteIndexer frameIdx = frame.createIndexer();
                for (int n = 0; n < 10000; n++) {
                    for (int i = 0; i < frameIdx.rows(); i++) {
                        for (int j = 0; j < frameIdx.cols(); j++) {
                            for (int k = 0; k < frameIdx.channels(); k++) {
                                frameIdx.put(i, j, k, n + i + j + k);
                            }
                        }
                    }
                    recorder.record(frame);
                    if (n == 5000 && seektestnum!=1){
                        Frame audioFrame = new Frame();
                        ShortBuffer audioBuffer = ShortBuffer.allocate(48000 * 2 * 10000 / 30);
                        audioFrame.sampleRate = 48000;
                        audioFrame.audioChannels = 2;
                        audioFrame.samples = new ShortBuffer[] {audioBuffer};
                        for (int i = 0; i < audioBuffer.capacity(); i++) {
                            audioBuffer.put(i, (short)i);
                        }
                        recorder.record(audioFrame);
                    }
                }
                frame.close();
            } else {
                Frame audioFrame = new Frame();
                ShortBuffer audioBuffer = ShortBuffer.allocate(48000 * 2 * 10000 / 30);
                audioFrame.sampleRate = 48000;
                audioFrame.audioChannels = 2;
                audioFrame.samples = new ShortBuffer[] {audioBuffer};
                for (int i = 0; i < audioBuffer.capacity(); i++) {
                    audioBuffer.put(i, (short)i);
                }
                recorder.record(audioFrame);
            }
            recorder.stop();
            recorder.release();

            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(tempFile);
            grabber.setVideoOption("threads", "1"); // more precise without threads
            grabber.start();
            assertEquals((seektestnum - 2) * 90.0, grabber.getDisplayRotation(), 0);
            int length = (int) ( grabber.getLengthInTime() - 1000000L);


            System.out.println();
            System.out.println("Seek in file containing "+(seektestnum==0?"video and audio":seektestnum==1?"video only":"audio only"));
            System.out.println("============================================");
            System.out.println("Testing file "+tempFile.getName());
            System.out.println("Length = "+grabber.getLengthInTime());
            System.out.println("Framerate = "+grabber.getFrameRate());
            System.out.println();
            System.out.println("has video stream = "+(grabber.hasVideo()?"YES":"NO")+", has audio stream = "+(grabber.hasAudio()?"YES":"NO"));
            long tolerance = 1000000L + (grabber.getFrameRate() > 0.0? (long) (5000000/grabber.getFrameRate()):500000L);
            Random random = new Random(29);

            for (int frametypenum = 0; frametypenum < 4; frametypenum++) {
                long mindelta = Long.MAX_VALUE;
                long maxdelta = Long.MIN_VALUE;
                System.out.println();
                System.out.println("Seek by " 
                                    + (frametypenum == 0 ? "any" : frametypenum == 1 ? "video" : frametypenum == 2  ? "audio" : "old method")
                                    + (frametypenum == 0 ? " frames" : ""));

                System.out.println("--------------------");
                for (int i = 0; i < 200; i++) {
                    long timestamp = random.nextInt(length);
                    switch (frametypenum) {
                        case 0:
                            grabber.setTimestamp(timestamp, true);
                            break;
                        case 1:
                            grabber.setVideoTimestamp(timestamp);
                            break;
                        case 2:
                            grabber.setAudioTimestamp(timestamp);
                            break;
                        case 3:
                            grabber.setTimestamp(timestamp);
                            break;
                    }

                    Frame frame = grabber.grab();
                    long timestamp2 = grabber.getTimestamp();
                    long delta = timestamp2 - timestamp;
                    if (delta > maxdelta) maxdelta = delta;
            
Download .txt
gitextract_7jum8khe/

├── .github/
│   ├── FUNDING.yml
│   └── workflows/
│       └── javacv.yml
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── LICENSE.txt
├── README.md
├── platform/
│   ├── pom.xml
│   └── src/
│       ├── main/
│       │   ├── assembly/
│       │   │   ├── bin.xml
│       │   │   └── src.xml
│       │   └── java9/
│       │       └── module-info.java
│       └── test/
│           └── java/
│               └── org/
│                   └── bytedeco/
│                       └── javacv/
│                           ├── FrameConverterTest.java
│                           ├── FrameFilterTest.java
│                           ├── FrameGrabberChangingResolutionTest.java
│                           ├── FrameGrabberTest.java
│                           └── SeekableByteArrayOutputStreamTest.java
├── pom.xml
├── samples/
│   ├── AudioSplitMergeHelper.java
│   ├── BioInspiredRetina.java
│   ├── BlobDemo.java
│   ├── CaffeGooglenet.java
│   ├── ColoredObjectTrack.java
│   ├── DeepLearningFaceDetection.java
│   ├── DeinterlacedVideoPlayer.java
│   ├── Demo.java
│   ├── FFmpegStreamingTimeout.java
│   ├── FaceApplet.html
│   ├── FaceApplet.java
│   ├── FaceApplet.jnlp
│   ├── FacePreview.java
│   ├── FaceRecognizerInVideo.java
│   ├── HoughLines.java
│   ├── ImageSegmentation.java
│   ├── JavaFxPlayVideoAndAudio.java
│   ├── KazemiFacemarkExample.java
│   ├── LBFFacemarkExampleWithVideo.java
│   ├── MotionDetector.java
│   ├── OpenCVFaceRecognizer.java
│   ├── OpenCVFeatures2dSerialization.java
│   ├── OpticalFlowDense.java
│   ├── OpticalFlowTracker.java
│   ├── PacketRecorderTest.java
│   ├── PerspectiveWarpDemo.java
│   ├── PrincipalComponentAnalysis.java
│   ├── RLSA.java
│   ├── RealSense2DepthMeasuring.java
│   ├── RecordActivity.java
│   ├── Similarity.java
│   ├── Smoother.java
│   ├── Square.java
│   ├── TemplateMatching.java
│   ├── WebcamAndMicrophoneCapture.java
│   ├── YOLONet.java
│   ├── haarcascade_frontalface_alt2.xml
│   └── pom.xml
└── src/
    └── main/
        ├── java/
        │   ├── cl/
        │   │   └── eye/
        │   │       └── CLCamera.java
        │   └── org/
        │       └── bytedeco/
        │           └── javacv/
        │               ├── AndroidFrameConverter.java
        │               ├── BaseChildSettings.java
        │               ├── BaseSettings.java
        │               ├── Blobs.java
        │               ├── BufferRing.java
        │               ├── CameraDevice.java
        │               ├── CameraSettings.java
        │               ├── CanvasFrame.java
        │               ├── ColorCalibrator.java
        │               ├── DC1394FrameGrabber.java
        │               ├── FFmpegFrameFilter.java
        │               ├── FFmpegFrameGrabber.java
        │               ├── FFmpegFrameRecorder.java
        │               ├── FFmpegLockCallback.java
        │               ├── FFmpegLogCallback.java
        │               ├── FlyCapture2FrameGrabber.java
        │               ├── FlyCaptureFrameGrabber.java
        │               ├── Frame.java
        │               ├── FrameConverter.java
        │               ├── FrameFilter.java
        │               ├── FrameGrabber.java
        │               ├── FrameRecorder.java
        │               ├── GLCanvasFrame.java
        │               ├── GNImageAligner.java
        │               ├── GNImageAlignerCL.java
        │               ├── GeometricCalibrator.java
        │               ├── HandMouse.java
        │               ├── IPCameraFrameGrabber.java
        │               ├── ImageAligner.java
        │               ├── ImageAlignerCL.java
        │               ├── ImageTransformer.java
        │               ├── ImageTransformerCL.java
        │               ├── Java2DFrameConverter.java
        │               ├── Java2DFrameUtils.java
        │               ├── JavaCV.java
        │               ├── JavaCVCL.java
        │               ├── JavaCvErrorCallback.java
        │               ├── JavaFXFrameConverter.java
        │               ├── LeptonicaFrameConverter.java
        │               ├── LibgdxFrameConverter.java
        │               ├── MarkedPlane.java
        │               ├── Marker.java
        │               ├── MarkerDetector.java
        │               ├── ObjectFinder.java
        │               ├── OpenCVFrameConverter.java
        │               ├── OpenCVFrameGrabber.java
        │               ├── OpenCVFrameRecorder.java
        │               ├── OpenKinect2FrameGrabber.java
        │               ├── OpenKinectFrameGrabber.java
        │               ├── PS3EyeFrameGrabber.java
        │               ├── Parallel.java
        │               ├── ProCamColorCalibrator.java
        │               ├── ProCamGeometricCalibrator.java
        │               ├── ProCamTransformer.java
        │               ├── ProCamTransformerCL.java
        │               ├── ProjectiveColorTransformer.java
        │               ├── ProjectiveColorTransformerCL.java
        │               ├── ProjectiveDevice.java
        │               ├── ProjectiveTransformer.java
        │               ├── ProjectiveTransformerCL.java
        │               ├── ProjectorDevice.java
        │               ├── ProjectorSettings.java
        │               ├── RealSense2FrameGrabber.java
        │               ├── RealSenseFrameGrabber.java
        │               ├── ReflectanceInitializer.java
        │               ├── Seekable.java
        │               ├── SeekableByteArrayOutputStream.java
        │               ├── VideoInputFrameGrabber.java
        │               └── cvkernels.java
        ├── java9/
        │   └── module-info.java
        └── resources/
            └── org/
                └── bytedeco/
                    └── javacv/
                        ├── ImageTransformer.cl
                        ├── JavaCV.cl
                        ├── ProCamTransformer.cl
                        ├── ProjectiveColorTransformer.cl
                        └── ProjectiveTransformer.cl
Download .txt
Showing preview only (207K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2320 symbols across 109 files)

FILE: platform/src/test/java/org/bytedeco/javacv/FrameConverterTest.java
  class FrameConverterTest (line 50) | public class FrameConverterTest {
    method testAndroidFrameConverter (line 52) | @Test public void testAndroidFrameConverter() {
    method testJava2DFrameConverter (line 145) | @Test public void testJava2DFrameConverter() {
    method testOpenCVFrameConverter (line 217) | @Test public void testOpenCVFrameConverter() {
    method testLeptonicaFrameConverter (line 309) | @Test public void testLeptonicaFrameConverter() {

FILE: platform/src/test/java/org/bytedeco/javacv/FrameFilterTest.java
  class FrameFilterTest (line 40) | public class FrameFilterTest {
    method testFFmpegFrameFilter (line 42) | @Test
    method testFFmpegFrameFilterMultipleInputs (line 141) | @Test

FILE: platform/src/test/java/org/bytedeco/javacv/FrameGrabberChangingResolutionTest.java
  class FrameGrabberChangingResolutionTest (line 45) | public class FrameGrabberChangingResolutionTest {
    method makeTestfile (line 50) | private void makeTestfile() throws Exception {
    method setupUDPSender (line 80) | final public void setupUDPSender(final int x, final int y, final int b...
    method setupUDPReceiver (line 136) | final public void setupUDPReceiver() throws IOException {
    method testFFmpegFrameGrabber (line 205) | @Test

FILE: platform/src/test/java/org/bytedeco/javacv/FrameGrabberTest.java
  class FrameGrabberTest (line 46) | public class FrameGrabberTest {
    method testFFmpegFrameGrabber (line 48) | @Test
    method testFFmpegFrameGrabberLockingTest (line 159) | @Test
    method testFFmpegFrameGrabberSeeking (line 300) | @Test

FILE: platform/src/test/java/org/bytedeco/javacv/SeekableByteArrayOutputStreamTest.java
  class SeekableByteArrayOutputStreamTest (line 41) | public class SeekableByteArrayOutputStreamTest {
    method writeByte (line 47) | private int writeByte(byte[] originalBytes, int offset, SeekableByteAr...
    method writePartialBytes (line 52) | private int writePartialBytes(byte[] originalBytes, int offset, Random...
    method writeBytes (line 59) | private int writeBytes(byte[] originalBytes, int offset, Random random,
    method createVideo (line 66) | private void createVideo(FFmpegFrameRecorder recorder) throws Exception {
    method serialWriteByteTest (line 88) | @Test
    method serialWriteBytesTest (line 106) | @Test
    method serialWritePartialBytesTest (line 124) | @Test
    method serialWriteTest (line 142) | @Test
    method seekWriteTest (line 170) | public void seekWriteTest() {
    method testVideoBytesEqual (line 228) | @Test

FILE: samples/AudioSplitMergeHelper.java
  class AudioSplitMergeHelper (line 32) | public class AudioSplitMergeHelper {
    method split (line 47) | public static void split(String input, String outputLeft, String outpu...
    method merge (line 105) | public static void merge(String inputLeft, String inputRight, String o...

FILE: samples/BioInspiredRetina.java
  class BioInspiredRetina (line 30) | public class BioInspiredRetina {
    method main (line 39) | public static void main(String[] args) {
    method execute (line 50) | private void execute(String[] args) throws Exception {
    method showImage (line 71) | private void showImage(Mat matrix) {

FILE: samples/BlobDemo.java
  class BlobDemo (line 19) | public class BlobDemo
    method main (line 21) | public static void main(String[] args)
    method demo (line 28) | public static void demo()
    method ShowImage (line 96) | public static void ShowImage(IplImage image, String caption)
    method ShowImage (line 107) | public static void ShowImage(IplImage image, String caption, int size)
    method ShowImage (line 119) | public static void ShowImage(IplImage image, String caption, int width...
    method Highlight (line 128) | public static void Highlight(IplImage image, int [] inVec)
    method Highlight (line 132) | public static void Highlight(IplImage image, int [] inVec, int Thick)
    method Highlight (line 136) | public static void Highlight(IplImage image, int xMin, int yMin, int x...
    method Highlight (line 140) | public static void Highlight(IplImage image, int xMin, int yMin, int x...
    method PrintGrayImage (line 148) | public static void PrintGrayImage(IplImage image, String caption)
    method PrintGrayImage (line 160) | public static void PrintGrayImage(IplImage image, String caption, int ...
    method PrintImageProperties (line 197) | public static void PrintImageProperties(IplImage image)
    method BinaryHistogram (line 206) | public static float BinaryHistogram(IplImage image)
    method SkewGrayImage (line 217) | public static IplImage SkewGrayImage(IplImage Src, double angle)    //...
    method TransposeImage (line 262) | public static IplImage TransposeImage(IplImage SrcImage)

FILE: samples/CaffeGooglenet.java
  class CaffeGooglenet (line 23) | public class CaffeGooglenet {
    method getMaxClass (line 26) | public static void getMaxClass(Mat probBlob, Point classId, double[] c...
    method readClassNames (line 31) | public static List<String> readClassNames() {
    method main (line 48) | public static void main(String[] args) throws Exception {

FILE: samples/ColoredObjectTrack.java
  class ColoredObjectTrack (line 23) | public class ColoredObjectTrack implements Runnable {
    method main (line 25) | public static void main(String[] args) {
    method ColoredObjectTrack (line 47) | public ColoredObjectTrack() {
    method run (line 53) | @Override
    method paint (line 88) | private void paint(IplImage img, int posX, int posY) {
    method getThresholdImage (line 99) | private IplImage getThresholdImage(IplImage orgImg) {
    method Equalize (line 110) | public IplImage Equalize(BufferedImage bufferedimg) {

FILE: samples/DeepLearningFaceDetection.java
  class DeepLearningFaceDetection (line 34) | public class DeepLearningFaceDetection {
    method detectAndDraw (line 45) | private static void detectAndDraw(Mat image) {//detect faces and draw ...
    method main (line 76) | public static void main(String[] args) {

FILE: samples/DeinterlacedVideoPlayer.java
  class DeinterlacedVideoPlayer (line 11) | public class DeinterlacedVideoPlayer {
    method DeinterlacedVideoPlayer (line 22) | public DeinterlacedVideoPlayer() {}
    method start (line 24) | public void start() {
    method startFrameGrabber (line 50) | private void startFrameGrabber() throws Exception {
    method releaseGrabberAndFilter (line 59) | private void releaseGrabberAndFilter(FrameGrabber grabber, FrameFilter...
    method releaseFilter (line 71) | private void releaseFilter(FrameFilter filter) {

FILE: samples/Demo.java
  class Demo (line 37) | public class Demo {
    method main (line 38) | public static void main(String[] args) throws Exception {

FILE: samples/FFmpegStreamingTimeout.java
  class FFmpegStreamingTimeout (line 15) | public class FFmpegStreamingTimeout {
    type TimeoutOption (line 21) | private static enum TimeoutOption {
      method getKey (line 41) | public String getKey() {
    method main (line 50) | public static void main(String[] args) {
    method rtspStreamingTest (line 55) | private static void rtspStreamingTest() {
    method testWithCallback (line 90) | private static void testWithCallback() {

FILE: samples/FaceApplet.java
  class FaceApplet (line 27) | public class FaceApplet extends Applet implements Runnable {
    method init (line 39) | @Override public void init() {
    method start (line 65) | @Override public void start() {
    method run (line 76) | public void run() {
    method update (line 117) | @Override public void update(Graphics g) {
    method paint (line 121) | @Override public void paint(Graphics g) {
    method stop (line 147) | @Override public void stop() {
    method destroy (line 151) | @Override public void destroy() { }

FILE: samples/FacePreview.java
  class FacePreview (line 81) | public class FacePreview extends Activity {
    method onCreate (line 86) | @Override
  class FaceView (line 112) | class FaceView extends View implements Camera.PreviewCallback {
    method FaceView (line 119) | public FaceView(FacePreview context) throws IOException {
    method onPreviewFrame (line 137) | public void onPreviewFrame(final byte[] data, final Camera camera) {
    method processImage (line 147) | protected void processImage(byte[] data, int width, int height) {
    method onDraw (line 171) | @Override
  class Preview (line 198) | class Preview extends SurfaceView implements SurfaceHolder.Callback {
    method Preview (line 203) | Preview(Context context, Camera.PreviewCallback previewCallback) {
    method surfaceCreated (line 214) | public void surfaceCreated(SurfaceHolder holder) {
    method surfaceDestroyed (line 227) | public void surfaceDestroyed(SurfaceHolder holder) {
    method getOptimalPreviewSize (line 237) | private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
    method surfaceChanged (line 270) | public void surfaceChanged(SurfaceHolder holder, int format, int w, in...

FILE: samples/FaceRecognizerInVideo.java
  class FaceRecognizerInVideo (line 27) | public class FaceRecognizerInVideo {
    method main (line 29) | public static void main(String[] args) throws Exception {

FILE: samples/HoughLines.java
  class HoughLines (line 18) | public class HoughLines {
    method main (line 23) | public static void main(String[] args) {

FILE: samples/ImageSegmentation.java
  class ImageSegmentation (line 27) | public class ImageSegmentation {
    method main (line 31) | public static void main(String[] args) {
    method imshow (line 150) | private static void imshow(String txt, Mat img) {

FILE: samples/JavaFxPlayVideoAndAudio.java
  class JavaFxPlayVideoAndAudio (line 27) | public class JavaFxPlayVideoAndAudio extends Application {
    class PlaybackTimer (line 29) | private static class PlaybackTimer {
      method PlaybackTimer (line 33) | public PlaybackTimer(DataLine soundLine) {
      method PlaybackTimer (line 37) | public PlaybackTimer() {
      method start (line 41) | public void start() {
      method elapsedMicros (line 47) | public long elapsedMicros() {
    method main (line 63) | public static void main(String[] args) {
    method start (line 67) | @Override
    method stop (line 195) | @Override

FILE: samples/KazemiFacemarkExample.java
  class KazemiFacemarkExample (line 26) | public class KazemiFacemarkExample {
    method main (line 27) | public static void main(String[] args) throws IOException, URISyntaxEx...

FILE: samples/LBFFacemarkExampleWithVideo.java
  class LBFFacemarkExampleWithVideo (line 26) | public class LBFFacemarkExampleWithVideo {
    method main (line 34) | public static void main(String[] args) throws IOException, URISyntaxEx...

FILE: samples/MotionDetector.java
  class MotionDetector (line 21) | public class MotionDetector {
    method main (line 22) | public static void main(String[] args) throws Exception {

FILE: samples/OpenCVFaceRecognizer.java
  class OpenCVFaceRecognizer (line 40) | public class OpenCVFaceRecognizer {
    method main (line 41) | public static void main(String[] args) {

FILE: samples/OpenCVFeatures2dSerialization.java
  class OpenCVFeatures2dSerialization (line 24) | public class OpenCVFeatures2dSerialization {
    method main (line 26) | public static void main(String[] args) throws IOException {
    method serializeFile (line 41) | private static void serializeFile(Mat matrix, String fileName) throws ...
    method deserializeFile (line 54) | private static void deserializeFile(String file) {
    method serializeMemory (line 67) | private static String serializeMemory(Mat matrix) throws UnsupportedEn...
    method deserializeMemory (line 81) | private static void deserializeMemory(String serialized) {

FILE: samples/OpticalFlowDense.java
  class OpticalFlowDense (line 17) | public class OpticalFlowDense {
    method main (line 19) | public static void main(final String[] args) {

FILE: samples/OpticalFlowTracker.java
  class OpticalFlowTracker (line 22) | public class OpticalFlowTracker {
    method main (line 26) | public static void main(String[] args) {

FILE: samples/PacketRecorderTest.java
  class PacketRecorderTest (line 8) | public class PacketRecorderTest {
    method main (line 16) | public static void main(String[] args) throws FrameRecorder.Exception,...
    method frameRecord (line 30) | public static void frameRecord(String inputFile, String outputFile) th...
    method packetRecord (line 52) | public static void packetRecord(String inputFile, String outputFile) t...

FILE: samples/PerspectiveWarpDemo.java
  class PerspectiveWarpDemo (line 17) | public class PerspectiveWarpDemo extends Thread {
    method main (line 22) | public static void main(String[] args) {
    method performPerspectiveWarp (line 49) | private static Mat performPerspectiveWarp(Mat imageMat, int x1, int y1...

FILE: samples/PrincipalComponentAnalysis.java
  class PrincipalComponentAnalysis (line 27) | public class PrincipalComponentAnalysis {
    method main (line 36) | public static void main(String[] args) {
    method execute (line 47) | private void execute(String[] args) throws Exception {
    method principalComponentAnalysis (line 91) | private void principalComponentAnalysis(Mat contour, int entry, Mat ma...
    method drawAxis (line 163) | private void drawAxis(Mat matrix, double radian, Point cntr, double x,...
    method printMat (line 174) | public static void printMat(Mat mat) {

FILE: samples/RLSA.java
  class RLSA (line 19) | public class RLSA {
    method main (line 21) | public static void main(String[] args) {
    method runLengthSmoothingAlgorithm (line 43) | public static IplImage runLengthSmoothingAlgorithm(IplImage image) {

FILE: samples/RealSense2DepthMeasuring.java
  class RealSense2DepthMeasuring (line 31) | public class RealSense2DepthMeasuring {
    method main (line 32) | public static void main(String[] args) throws FrameGrabber.Exception {

FILE: samples/RecordActivity.java
  class RecordActivity (line 99) | public class RecordActivity extends Activity implements OnClickListener {
    method onCreate (line 154) | @Override
    method onDestroy (line 164) | @Override
    method initLayout (line 182) | private void initLayout() {
    method initRecorder (line 227) | private void initRecorder() {
    method startRecording (line 266) | public void startRecording() {
    method stopRecording (line 285) | public void stopRecording() {
    method onKeyDown (line 357) | @Override
    class AudioRecordRunnable (line 377) | class AudioRecordRunnable implements Runnable {
      method run (line 379) | @Override
    class CameraView (line 445) | class CameraView extends SurfaceView implements SurfaceHolder.Callback...
      method CameraView (line 450) | public CameraView(Context context, Camera camera) {
      method surfaceCreated (line 460) | @Override
      method surfaceChanged (line 471) | public void surfaceChanged(SurfaceHolder holder, int format, int wid...
      method surfaceDestroyed (line 513) | @Override
      method startPreview (line 523) | public void startPreview() {
      method stopPreview (line 530) | public void stopPreview() {
      method onPreviewFrame (line 537) | @Override
    method onClick (line 578) | @Override

FILE: samples/Similarity.java
  class Similarity (line 30) | public class Similarity {
    method getPSNR (line 31) | private static double getPSNR(Mat I1, Mat I2) {
    method getMSSIM (line 50) | private static Scalar getMSSIM(Mat i1, Mat i2) {
    method main (line 92) | public static void main(String[] args) {

FILE: samples/Smoother.java
  class Smoother (line 29) | public class Smoother {
    method smooth (line 30) | public static void smooth(String filename) {

FILE: samples/Square.java
  class Square (line 28) | public class Square {
    method angle (line 43) | double angle(CvPoint pt1, CvPoint pt2, CvPoint pt0) {
    method findSquares4 (line 54) | CvSeq findSquares4(IplImage img, CvMemStorage storage) {
    method drawSquares (line 177) | void drawSquares(IplImage img, CvSeq squares) {
    method main (line 251) | public static void main(String args[]) throws Exception {
    method main (line 255) | public void main() throws InterruptedException {

FILE: samples/TemplateMatching.java
  class TemplateMatching (line 29) | public class TemplateMatching {
    method main (line 31) | public static void main(String[] args) throws Exception {
    method newStyle (line 40) | public static void newStyle(String[] args){
    method randColor (line 68) | public static Scalar randColor(){
    method getPointsFromMatAboveThreshold (line 76) | public static List<Point> getPointsFromMatAboveThreshold(Mat m, float t){
    method oldStyle (line 90) | public static void oldStyle(String[] args){

FILE: samples/WebcamAndMicrophoneCapture.java
  class WebcamAndMicrophoneCapture (line 33) | public class WebcamAndMicrophoneCapture
    method main (line 44) | public static void main(String[] args) throws Exception, org.bytedeco....

FILE: samples/YOLONet.java
  class YOLONet (line 69) | public class YOLONet {
    method main (line 71) | public static void main(String[] args) {
    method YOLONet (line 120) | public YOLONet(String configPath, String weightsPath, String namesPath...
    method setup (line 133) | public boolean setup() {
    method predict (line 164) | public List<ObjectDetectionResult> predict(Mat frame) {
    method postprocess (line 194) | private List<ObjectDetectionResult> postprocess(Mat frame, MatVector o...
    class ObjectDetectionResult (line 277) | public static class ObjectDetectionResult {

FILE: src/main/java/cl/eye/CLCamera.java
  class CLCamera (line 17) | public class CLCamera
    method CLEyeGetCameraCount (line 54) | native static int CLEyeGetCameraCount();
    method CLEyeGetCameraUUID (line 55) | native static String CLEyeGetCameraUUID(int index);
    method CLEyeCreateCamera (line 56) | native static int CLEyeCreateCamera(int cameraIndex, int mode, int res...
    method CLEyeDestroyCamera (line 57) | native static boolean CLEyeDestroyCamera(int cameraIndex);
    method CLEyeCameraStart (line 58) | native static boolean CLEyeCameraStart(int cameraInstance);
    method CLEyeCameraStop (line 59) | native static boolean CLEyeCameraStop(int cameraInstance);
    method CLEyeSetCameraParameter (line 60) | native static boolean CLEyeSetCameraParameter(int cameraInstance, int ...
    method CLEyeGetCameraParameter (line 61) | native static int CLEyeGetCameraParameter(int cameraInstance, int param);
    method CLEyeCameraGetFrame (line 62) | native static boolean CLEyeCameraGetFrame(int cameraInstance, int[] im...
    method IsLibraryLoaded (line 94) | public static boolean IsLibraryLoaded()
    method loadLibrary (line 98) | public static void loadLibrary(String libraryPath)
    method cameraCount (line 111) | public static int cameraCount()
    method cameraUUID (line 115) | public static String cameraUUID(int index)
    method dispose (line 125) | public void dispose()
    method createCamera (line 130) | public boolean createCamera(int cameraIndex, int mode, int resolution,...
    method destroyCamera (line 135) | public boolean destroyCamera()
    method startCamera (line 139) | public boolean startCamera()
    method stopCamera (line 143) | public boolean stopCamera()
    method getCameraFrame (line 147) | public boolean getCameraFrame(int[] imgData, int waitTimeout)
    method setCameraParam (line 151) | public boolean setCameraParam(int param, int val)
    method getCameraParam (line 155) | public int getCameraParam(int param)

FILE: src/main/java/org/bytedeco/javacv/AndroidFrameConverter.java
  class AndroidFrameConverter (line 42) | public class AndroidFrameConverter extends FrameConverter<Bitmap> {
    method convert (line 51) | public Frame convert(byte[] data, int width, int height) {
    method convert (line 102) | @Override public Frame convert(Bitmap bitmap) {
    method gray2rgba (line 129) | ByteBuffer gray2rgba(ByteBuffer in, int width, int height, int stride,...
    method bgr2rgba (line 150) | ByteBuffer bgr2rgba(ByteBuffer in, int width, int height, int stride, ...
    method convert (line 175) | @Override public Bitmap convert(Frame frame) {

FILE: src/main/java/org/bytedeco/javacv/BaseChildSettings.java
  class BaseChildSettings (line 38) | public class BaseChildSettings extends BeanContextChildSupport implement...
    method addPropertyChangeListener (line 40) | public void addPropertyChangeListener(PropertyChangeListener listener) {
    method removePropertyChangeListener (line 43) | public void removePropertyChangeListener(PropertyChangeListener listen...
    method compareTo (line 47) | public int compareTo(BaseChildSettings o) {
    method getName (line 51) | protected String getName() {
    class PropertyVetoExceptionThatNetBeansLikes (line 55) | public static class PropertyVetoExceptionThatNetBeansLikes extends Pro...
      method PropertyVetoExceptionThatNetBeansLikes (line 56) | public PropertyVetoExceptionThatNetBeansLikes(String mess, PropertyC...
      method call (line 59) | public Object call() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/BaseSettings.java
  class BaseSettings (line 33) | public class BaseSettings extends BeanContextSupport implements Comparab...
    method addPropertyChangeListener (line 35) | public void addPropertyChangeListener(PropertyChangeListener listener) {
    method removePropertyChangeListener (line 45) | public void removePropertyChangeListener(PropertyChangeListener listen...
    method compareTo (line 56) | public int compareTo(BaseSettings o) {
    method getName (line 60) | protected String getName() {
    method toArray (line 64) | @Override public Object[] toArray() {
    method toArray (line 69) | @Override public Object[] toArray(Object[] a) {

FILE: src/main/java/org/bytedeco/javacv/Blobs.java
  class Blobs (line 62) | public class Blobs
    method PrintRegionData (line 103) | public void PrintRegionData() { PrintRegionData(0, MaxLabel); }
    method PrintRegionData (line 104) | public void PrintRegionData(int Label0, int Label1)
    method NextRegion (line 140) | public static int NextRegion(int Parent, int Color, double MinArea, do...
    method PriorRegion (line 161) | public static int PriorRegion(int Parent, int Color, double MinArea, d...
    method ResetRegion (line 181) | public void ResetRegion(int Label)
    method OldRegion (line 201) | public void OldRegion(
    method NewRegion (line 243) | public void NewRegion(int ParentLabel)
    method Subsume (line 275) | public void Subsume(int GoodLabel, int BadLabel, int PSign) // Combine...
    method SubsumptionChain (line 299) | public static int SubsumptionChain(int x) { return SubsumptionChain(x,...
    method SubsumptionChain (line 300) | public static int SubsumptionChain(int x, int Print)
    method BlobAnalysis (line 321) | public int BlobAnalysis(IplImage Src,           // input image
    method SortRegions (line 632) | public static void SortRegions(int Col)

FILE: src/main/java/org/bytedeco/javacv/BufferRing.java
  class BufferRing (line 29) | public class BufferRing<B extends BufferRing.ReleasableBuffer> {
    method BufferRing (line 30) | public BufferRing(BufferFactory<B> factory, int size) {
    type BufferFactory (line 38) | public interface BufferFactory<B extends ReleasableBuffer> {
      method create (line 39) | B create();
    type ReleasableBuffer (line 42) | public interface ReleasableBuffer {
      method release (line 43) | void release();
    method capacity (line 49) | public int capacity() {
    method position (line 53) | public int position() {
    method position (line 56) | public BufferRing position(int position) {
    method get (line 61) | @SuppressWarnings("unchecked")
    method get (line 66) | @SuppressWarnings("unchecked")
    method release (line 71) | @SuppressWarnings("unchecked")

FILE: src/main/java/org/bytedeco/javacv/CameraDevice.java
  class CameraDevice (line 40) | public class CameraDevice extends ProjectiveDevice {
    method CameraDevice (line 41) | public CameraDevice(String name) {
    method CameraDevice (line 44) | public CameraDevice(String name, String filename) throws Exception {
    method CameraDevice (line 49) | public CameraDevice(String name, FileStorage fs) throws Exception {
    method CameraDevice (line 54) | public CameraDevice(Settings settings) throws Exception {
    type Settings (line 58) | public interface Settings {
      method getName (line 59) | String getName();
      method setName (line 60) | void setName(String name);
      method getResponseGamma (line 61) | double getResponseGamma();
      method setResponseGamma (line 62) | void setResponseGamma(double gamma);
      method getDeviceNumber (line 64) | Integer getDeviceNumber();
      method setDeviceNumber (line 65) | void setDeviceNumber(Integer deviceNumber) throws PropertyVetoExcept...
      method getDeviceFile (line 66) | File getDeviceFile();
      method setDeviceFile (line 67) | void setDeviceFile(File deviceFile) throws PropertyVetoException;
      method getDeviceFilename (line 68) | String getDeviceFilename();
      method setDeviceFilename (line 69) | void setDeviceFilename(String deviceFilename) throws PropertyVetoExc...
      method getDevicePath (line 70) | String getDevicePath();
      method setDevicePath (line 71) | void setDevicePath(String devicePath) throws PropertyVetoException;
      method getFrameGrabber (line 72) | Class<? extends FrameGrabber> getFrameGrabber();
      method setFrameGrabber (line 73) | void setFrameGrabber(Class<? extends FrameGrabber> frameGrabber);
      method getDescription (line 74) | String getDescription();
      method getFormat (line 76) | String getFormat();
      method setFormat (line 77) | void setFormat(String format);
      method getImageWidth (line 78) | int getImageWidth();
      method setImageWidth (line 79) | void setImageWidth(int imageWidth);
      method getImageHeight (line 80) | int getImageHeight();
      method setImageHeight (line 81) | void setImageHeight(int imageHeight);
      method getFrameRate (line 82) | double getFrameRate();
      method setFrameRate (line 83) | void setFrameRate(double frameRate);
      method isTriggerMode (line 84) | boolean isTriggerMode();
      method setTriggerMode (line 85) | void setTriggerMode(boolean triggerMode);
      method getBitsPerPixel (line 86) | int getBitsPerPixel();
      method setBitsPerPixel (line 87) | void setBitsPerPixel(int bitsPerPixel);
      method getImageMode (line 88) | FrameGrabber.ImageMode getImageMode();
      method setImageMode (line 89) | void setImageMode(FrameGrabber.ImageMode imageMode);
      method getTimeout (line 90) | int getTimeout();
      method setTimeout (line 91) | void setTimeout(int timeout);
      method getNumBuffers (line 92) | int getNumBuffers();
      method setNumBuffers (line 93) | void setNumBuffers(int numBuffers);
      method isDeinterlace (line 94) | boolean isDeinterlace();
      method setDeinterlace (line 95) | void setDeinterlace(boolean deinterlace);
      method addPropertyChangeListener (line 97) | void addPropertyChangeListener(PropertyChangeListener listener);
      method removePropertyChangeListener (line 98) | void removePropertyChangeListener(PropertyChangeListener listener);
    class SettingsImplementation (line 101) | public static class SettingsImplementation extends ProjectiveDevice.Se...
      method SettingsImplementation (line 102) | public SettingsImplementation() { name = "Camera  0"; }
      method SettingsImplementation (line 103) | public SettingsImplementation(ProjectiveDevice.Settings settings) {
      method getDeviceNumber (line 129) | public Integer getDeviceNumber() {
      method setDeviceNumber (line 132) | public void setDeviceNumber(Integer deviceNumber) throws PropertyVet...
      method getDeviceFile (line 154) | public File getDeviceFile() {
      method setDeviceFile (line 157) | public void setDeviceFile(File deviceFile) throws PropertyVetoExcept...
      method getDeviceFilename (line 175) | public String getDeviceFilename() {
      method setDeviceFilename (line 178) | public void setDeviceFilename(String deviceFilename) throws Property...
      method getDevicePath (line 183) | public String getDevicePath() {
      method setDevicePath (line 186) | public void setDevicePath(String devicePath) throws PropertyVetoExce...
      method getFrameGrabber (line 205) | public Class<? extends FrameGrabber> getFrameGrabber() {
      method setFrameGrabber (line 208) | public void setFrameGrabber(Class<? extends FrameGrabber> frameGrabb...
      method getDescription (line 250) | public String getDescription() {
      method getFormat (line 274) | public String getFormat() {
      method setFormat (line 277) | public void setFormat(String format) {
      method getImageWidth (line 281) | public int getImageWidth() {
      method setImageWidth (line 284) | public void setImageWidth(int imageWidth) {
      method getImageHeight (line 288) | public int getImageHeight() {
      method setImageHeight (line 291) | public void setImageHeight(int imageHeight) {
      method getFrameRate (line 295) | public double getFrameRate() {
      method setFrameRate (line 298) | public void setFrameRate(double frameRate) {
      method isTriggerMode (line 302) | public boolean isTriggerMode() {
      method setTriggerMode (line 305) | public void setTriggerMode(boolean triggerMode) {
      method getBitsPerPixel (line 309) | public int getBitsPerPixel() {
      method setBitsPerPixel (line 312) | public void setBitsPerPixel(int bitsPerPixel) {
      method getImageMode (line 316) | public FrameGrabber.ImageMode getImageMode() {
      method setImageMode (line 319) | public void setImageMode(FrameGrabber.ImageMode imageMode) {
      method getTimeout (line 323) | public int getTimeout() {
      method setTimeout (line 326) | public void setTimeout(int timeout) {
      method getNumBuffers (line 330) | public int getNumBuffers() {
      method setNumBuffers (line 333) | public void setNumBuffers(int numBuffers) {
      method isDeinterlace (line 337) | public boolean isDeinterlace() {
      method setDeinterlace (line 340) | public void setDeinterlace(boolean deinterlace) {
    class CalibrationSettings (line 346) | public static class CalibrationSettings extends ProjectiveDevice.Calib...
      method CalibrationSettings (line 347) | public CalibrationSettings() { }
      method CalibrationSettings (line 348) | public CalibrationSettings(ProjectiveDevice.CalibrationSettings sett...
      method firePropertyChange (line 355) | @Override public void firePropertyChange(String propertyName, Object...
      method getName (line 360) | @Override public String getName() { return si.getName(); }
      method setName (line 361) | @Override public void setName(String name) { si.setName(name); }
      method getResponseGamma (line 362) | @Override public double getResponseGamma() { return si.getResponseGa...
      method setResponseGamma (line 363) | @Override public void setResponseGamma(double responseGamma) { si.se...
      method getDeviceNumber (line 367) | public Integer getDeviceNumber() { return si.getDeviceNumber(); }
      method setDeviceNumber (line 368) | public void setDeviceNumber(Integer deviceNumber) throws PropertyVet...
      method getDeviceFile (line 369) | public File getDeviceFile() { return si.getDeviceFile(); }
      method setDeviceFile (line 370) | public void setDeviceFile(File deviceFile) throws PropertyVetoExcept...
      method getDeviceFilename (line 371) | public String getDeviceFilename() { return si.getDeviceFilename(); }
      method setDeviceFilename (line 372) | public void setDeviceFilename(String deviceFilename) throws Property...
      method getDevicePath (line 373) | public String getDevicePath() { return si.getDevicePath(); }
      method setDevicePath (line 374) | public void setDevicePath(String devicePath) throws PropertyVetoExce...
      method getFrameGrabber (line 375) | public Class<? extends FrameGrabber> getFrameGrabber() { return si.g...
      method setFrameGrabber (line 376) | public void setFrameGrabber(Class<? extends FrameGrabber> frameGrabb...
      method getDescription (line 377) | public String getDescription() { return si.getDescription(); }
      method getFormat (line 379) | public String getFormat() { return si.getFormat(); }
      method setFormat (line 380) | public void setFormat(String format) { si.setFormat(format); }
      method getImageWidth (line 381) | public int getImageWidth() { return si.getImageWidth(); }
      method setImageWidth (line 382) | public void setImageWidth(int imageWidth) { si.setImageWidth(imageWi...
      method getImageHeight (line 383) | public int getImageHeight() { return si.getImageHeight(); }
      method setImageHeight (line 384) | public void setImageHeight(int imageHeight) { si.setImageHeight(imag...
      method getFrameRate (line 385) | public double getFrameRate() { return si.getFrameRate(); }
      method setFrameRate (line 386) | public void setFrameRate(double frameRate) { si.setFrameRate(frameRa...
      method isTriggerMode (line 387) | public boolean isTriggerMode() { return si.isTriggerMode(); }
      method setTriggerMode (line 388) | public void setTriggerMode(boolean triggerMode) { si.setTriggerMode(...
      method getBitsPerPixel (line 389) | public int getBitsPerPixel() { return si.getBitsPerPixel(); }
      method setBitsPerPixel (line 390) | public void setBitsPerPixel(int bitsPerPixel) { si.setBitsPerPixel(b...
      method getImageMode (line 391) | public FrameGrabber.ImageMode getImageMode() { return si.getImageMod...
      method setImageMode (line 392) | public void setImageMode(FrameGrabber.ImageMode imageMode) { si.setI...
      method getTimeout (line 393) | public int getTimeout() { return si.getTimeout(); }
      method setTimeout (line 394) | public void setTimeout(int timeout) { si.setTimeout(timeout); }
      method getNumBuffers (line 395) | public int getNumBuffers() { return si.getNumBuffers(); }
      method setNumBuffers (line 396) | public void setNumBuffers(int numBuffers) { si.setNumBuffers(numBuff...
      method isDeinterlace (line 397) | public boolean isDeinterlace() { return si.isDeinterlace(); }
      method setDeinterlace (line 398) | public void setDeinterlace(boolean deinterlace) { si.setDeinterlace(...
    class CalibratedSettings (line 401) | public static class CalibratedSettings extends ProjectiveDevice.Calibr...
      method CalibratedSettings (line 402) | public CalibratedSettings() { }
      method CalibratedSettings (line 403) | public CalibratedSettings(ProjectiveDevice.CalibratedSettings settin...
      method firePropertyChange (line 410) | @Override public void firePropertyChange(String propertyName, Object...
      method getName (line 415) | @Override public String getName() { return si.getName(); }
      method setName (line 416) | @Override public void setName(String name) { si.setName(name); }
      method getResponseGamma (line 417) | @Override public double getResponseGamma() { return si.getResponseGa...
      method setResponseGamma (line 418) | @Override public void setResponseGamma(double responseGamma) { si.se...
      method getDeviceNumber (line 422) | public Integer getDeviceNumber() { return si.getDeviceNumber(); }
      method setDeviceNumber (line 423) | public void setDeviceNumber(Integer deviceNumber) throws PropertyVet...
      method getDeviceFile (line 424) | public File getDeviceFile() { return si.getDeviceFile(); }
      method setDeviceFile (line 425) | public void setDeviceFile(File deviceFile) throws PropertyVetoExcept...
      method getDeviceFilename (line 426) | public String getDeviceFilename() { return si.getDeviceFilename(); }
      method setDeviceFilename (line 427) | public void setDeviceFilename(String deviceFilename) throws Property...
      method getDevicePath (line 428) | public String getDevicePath() { return si.getDevicePath(); }
      method setDevicePath (line 429) | public void setDevicePath(String devicePath) throws PropertyVetoExce...
      method getFrameGrabber (line 430) | public Class<? extends FrameGrabber> getFrameGrabber() { return si.g...
      method setFrameGrabber (line 431) | public void setFrameGrabber(Class<? extends FrameGrabber> frameGrabb...
      method getDescription (line 432) | public String getDescription() { return si.getDescription(); }
      method getFormat (line 434) | public String getFormat() { return si.getFormat(); }
      method setFormat (line 435) | public void setFormat(String format) { si.setFormat(format); }
      method getImageWidth (line 436) | public int getImageWidth() { return si.getImageWidth(); }
      method setImageWidth (line 437) | public void setImageWidth(int imageWidth) { si.setImageWidth(imageWi...
      method getImageHeight (line 438) | public int getImageHeight() { return si.getImageHeight(); }
      method setImageHeight (line 439) | public void setImageHeight(int imageHeight) { si.setImageHeight(imag...
      method getFrameRate (line 440) | public double getFrameRate() { return si.getFrameRate(); }
      method setFrameRate (line 441) | public void setFrameRate(double frameRate) { si.setFrameRate(frameRa...
      method isTriggerMode (line 442) | public boolean isTriggerMode() { return si.isTriggerMode(); }
      method setTriggerMode (line 443) | public void setTriggerMode(boolean triggerMode) { si.setTriggerMode(...
      method getBitsPerPixel (line 444) | public int getBitsPerPixel() { return si.getBitsPerPixel(); }
      method setBitsPerPixel (line 445) | public void setBitsPerPixel(int bitsPerPixel) { si.setBitsPerPixel(b...
      method getImageMode (line 446) | public FrameGrabber.ImageMode getImageMode() { return si.getImageMod...
      method setImageMode (line 447) | public void setImageMode(FrameGrabber.ImageMode imageMode) { si.setI...
      method getTimeout (line 448) | public int getTimeout() { return si.getTimeout(); }
      method setTimeout (line 449) | public void setTimeout(int timeout) { si.setTimeout(timeout); }
      method getNumBuffers (line 450) | public int getNumBuffers() { return si.getNumBuffers(); }
      method setNumBuffers (line 451) | public void setNumBuffers(int numBuffers) { si.setNumBuffers(numBuff...
      method isDeinterlace (line 452) | public boolean isDeinterlace() { return si.isDeinterlace(); }
      method setDeinterlace (line 453) | public void setDeinterlace(boolean deinterlace) { si.setDeinterlace(...
    method getSettings (line 457) | @Override public ProjectiveDevice.Settings getSettings() {
    method setSettings (line 460) | public void setSettings(Settings settings) {
    method setSettings (line 463) | @Override public void setSettings(ProjectiveDevice.Settings settings) {
    method createFrameGrabber (line 477) | public FrameGrabber createFrameGrabber() throws FrameGrabber.Exception {
    method read (line 517) | public static CameraDevice[] read(String filename) throws Exception {
    method read (line 523) | public static CameraDevice[] read(FileStorage fs) throws Exception {

FILE: src/main/java/org/bytedeco/javacv/CameraSettings.java
  class CameraSettings (line 31) | public class CameraSettings extends BaseSettings {
    method CameraSettings (line 33) | public CameraSettings() {
    method CameraSettings (line 36) | public CameraSettings(boolean calibrated) {
    method getQuantity (line 44) | public int getQuantity() {
    method setQuantity (line 47) | public void setQuantity(int quantity) throws PropertyVetoException {
    method getMonitorWindowsScale (line 67) | public double getMonitorWindowsScale() {
    method setMonitorWindowsScale (line 70) | public void setMonitorWindowsScale(double monitorWindowsScale) {
    method getFrameGrabber (line 74) | public Class<? extends FrameGrabber> getFrameGrabber() {
    method setFrameGrabber (line 77) | public void setFrameGrabber(Class<? extends FrameGrabber> frameGrabber) {
    method toArray (line 81) | @Override public CameraDevice.Settings[] toArray() {

FILE: src/main/java/org/bytedeco/javacv/CanvasFrame.java
  class CanvasFrame (line 59) | public class CanvasFrame extends JFrame {
    class Exception (line 61) | public static class Exception extends java.lang.Exception {
      method Exception (line 62) | public Exception(String message) { super(message); }
      method Exception (line 63) | public Exception(String message, Throwable cause) { super(message, c...
    method getScreenDescriptions (line 66) | public static String[] getScreenDescriptions() {
    method getDisplayMode (line 74) | public static DisplayMode getDisplayMode(int screenNumber) {
    method getGamma (line 82) | public static double getGamma(int screenNumber) {
    method getDefaultGamma (line 90) | public static double getDefaultGamma() {
    method getGamma (line 94) | public static double getGamma(GraphicsDevice screen) {
    method getScreenDevice (line 105) | public static GraphicsDevice getScreenDevice(int screenNumber) throws ...
    method getScreenDevices (line 113) | public static GraphicsDevice[] getScreenDevices() {
    method getDefaultScreenDevice (line 116) | public static GraphicsDevice getDefaultScreenDevice() {
    method CanvasFrame (line 120) | public CanvasFrame(String title) {
    method CanvasFrame (line 123) | public CanvasFrame(String title, double gamma) {
    method CanvasFrame (line 128) | public CanvasFrame(String title, GraphicsConfiguration gc) {
    method CanvasFrame (line 131) | public CanvasFrame(String title, GraphicsConfiguration gc, double gamm...
    method CanvasFrame (line 136) | public CanvasFrame(String title, int screenNumber, DisplayMode display...
    method CanvasFrame (line 139) | public CanvasFrame(String title, int screenNumber, DisplayMode display...
    method init (line 144) | private void init(final boolean fullScreen, final DisplayMode displayM...
    method initCanvas (line 189) | protected void initCanvas(boolean fullScreen, DisplayMode displayMode,...
    method dispatchKeyEvent (line 248) | public boolean dispatchKeyEvent(KeyEvent e) {
    method getLatency (line 268) | public long getLatency() {
    method setLatency (line 273) | public void setLatency(long latency) {
    method waitLatency (line 276) | public void waitLatency() throws InterruptedException {
    method waitKey (line 280) | public KeyEvent waitKey() throws InterruptedException {
    method waitKey (line 283) | public synchronized KeyEvent waitKey(int delay) throws InterruptedExce...
    method getCanvas (line 293) | public Canvas getCanvas() {
    method getCanvasSize (line 297) | public Dimension getCanvasSize() {
    method setCanvasSize (line 300) | public void setCanvasSize(final int width, final int height) {
    method getCanvasScale (line 330) | public double getCanvasScale() {
    method setCanvasScale (line 333) | public void setCanvasScale(double initialScale) {
    method createGraphics (line 338) | public Graphics2D createGraphics() {
    method releaseGraphics (line 351) | public void releaseGraphics(Graphics2D g) {
    method showColor (line 356) | public void showColor(Color color) {
    method showImage (line 364) | public void showImage(Frame image) {
    method showImage (line 367) | public void showImage(Frame image, boolean flipChannels) {
    method showImage (line 371) | public void showImage(Image image) {
    method tile (line 387) | public static void tile(final CanvasFrame[] frames) {

FILE: src/main/java/org/bytedeco/javacv/ColorCalibrator.java
  class ColorCalibrator (line 34) | public class ColorCalibrator {
    method ColorCalibrator (line 35) | public ColorCalibrator(ProjectiveDevice device) {
    method calibrate (line 41) | public double calibrate(Color[] referenceColors, Color[] deviceColors) {

FILE: src/main/java/org/bytedeco/javacv/DC1394FrameGrabber.java
  class DC1394FrameGrabber (line 43) | public class DC1394FrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 44) | public static String[] getDeviceDescriptions() throws Exception {
    method createDefault (line 79) | public static DC1394FrameGrabber createDefault(File deviceFile)   thro...
    method createDefault (line 80) | public static DC1394FrameGrabber createDefault(String devicePath) thro...
    method createDefault (line 81) | public static DC1394FrameGrabber createDefault(int deviceNumber)  thro...
    method tryLoad (line 84) | public static void tryLoad() throws Exception {
    method DC1394FrameGrabber (line 96) | public DC1394FrameGrabber(int deviceNumber) throws Exception {
    method release (line 117) | public void release() throws Exception {
    method finalize (line 128) | @Override protected void finalize() throws Throwable {
    method getGamma (line 150) | @Override public double getGamma() {
    method getImageWidth (line 154) | @Override public int getImageWidth() {
    method getImageHeight (line 158) | @Override public int getImageHeight() {
    method getFrameRate (line 162) | @Override public double getFrameRate() {
    method setImageMode (line 175) | @Override public void setImageMode(ImageMode imageMode) {
    method start (line 183) | public void start() throws Exception {
    method start (line 186) | public void start(boolean tryReset, boolean try1394b) throws Exception {
    method stop (line 371) | public void stop() throws Exception {
    method enqueue (line 395) | private void enqueue() throws Exception {
    method enqueue (line 399) | private void enqueue(dc1394video_frame_t image) throws Exception {
    method trigger (line 408) | public void trigger() throws Exception {
    method grab (line 431) | public Frame grab() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/FFmpegFrameFilter.java
  class FFmpegFrameFilter (line 86) | public class FFmpegFrameFilter extends FrameFilter {
    class Exception (line 88) | public static class Exception extends FrameFilter.Exception {
      method Exception (line 89) | public Exception(String message) { super(message + " (For more detai...
      method Exception (line 90) | public Exception(String message, Throwable cause) { super(message, c...
    method tryLoad (line 94) | public static void tryLoad() throws Exception {
    method FFmpegFrameFilter (line 125) | public FFmpegFrameFilter(String videoFilters, String audioFilters, int...
    method FFmpegFrameFilter (line 141) | public FFmpegFrameFilter(String filters, int imageWidth, int imageHeig...
    method FFmpegFrameFilter (line 145) | public FFmpegFrameFilter(String afilters, int audioChannels) {
    method release (line 149) | @Override public void release() throws Exception {
    method releaseUnsafe (line 154) | public synchronized void releaseUnsafe() throws Exception {
    method finalize (line 211) | @Override protected void finalize() throws Throwable {
    method getImageWidth (line 241) | @Override public int getImageWidth() {
    method getImageHeight (line 245) | @Override public int getImageHeight() {
    method getPixelFormat (line 249) | @Override public int getPixelFormat() {
    method getFrameRate (line 253) | @Override public double getFrameRate() {
    method getAspectRatio (line 266) | @Override public double getAspectRatio() {
    method getAudioChannels (line 276) | @Override public int getAudioChannels() {
    method getSampleFormat (line 280) | @Override public int getSampleFormat() {
    method getSampleRate (line 284) | @Override public int getSampleRate() {
    method start (line 288) | @Override public void start() throws Exception {
    method startUnsafe (line 293) | public synchronized void startUnsafe() throws Exception {
    method startVideoUnsafe (line 333) | private void startVideoUnsafe() throws Exception {
    method startAudioUnsafe (line 435) | private void startAudioUnsafe() throws Exception {
    method stop (line 535) | @Override public void stop() throws Exception {
    method push (line 539) | @Override public void push(Frame frame) throws Exception {
    method push (line 542) | public void push(Frame frame, int pixelFormat) throws Exception {
    method push (line 545) | public void push(int n, Frame frame) throws Exception {
    method push (line 548) | public synchronized void push(int n, Frame frame, int pixelFormat) thr...
    method pushImage (line 574) | public synchronized void pushImage(int n, int width, int height, int d...
    method pushSamples (line 622) | public synchronized void pushSamples(int n, int audioChannels, int sam...
    method pull (line 681) | @Override public synchronized Frame pull() throws Exception {
    method pullImage (line 714) | public synchronized Frame pullImage() throws Exception {
    method pullSamples (line 771) | public synchronized Frame pullSamples() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/FFmpegFrameGrabber.java
  class FFmpegFrameGrabber (line 89) | public class FFmpegFrameGrabber extends FrameGrabber {
    class Exception (line 91) | public static class Exception extends FrameGrabber.Exception {
      method Exception (line 92) | public Exception(String message) { super(message + " (For more detai...
      method Exception (line 93) | public Exception(String message, Throwable cause) { super(message, c...
    method getDeviceDescriptions (line 96) | public static String[] getDeviceDescriptions() throws Exception {
    method createDefault (line 101) | public static FFmpegFrameGrabber createDefault(File deviceFile)   thro...
    method createDefault (line 102) | public static FFmpegFrameGrabber createDefault(String devicePath) thro...
    method createDefault (line 103) | public static FFmpegFrameGrabber createDefault(int deviceNumber)  thro...
    method tryLoad (line 106) | public static void tryLoad() throws Exception {
    method FFmpegFrameGrabber (line 142) | public FFmpegFrameGrabber(URL url) {
    method FFmpegFrameGrabber (line 145) | public FFmpegFrameGrabber(File file) {
    method FFmpegFrameGrabber (line 148) | public FFmpegFrameGrabber(String filename) {
    method FFmpegFrameGrabber (line 155) | public FFmpegFrameGrabber(InputStream inputStream) {
    method FFmpegFrameGrabber (line 159) | public FFmpegFrameGrabber(InputStream inputStream, int maximumSize) {
    method release (line 166) | public void release() throws Exception {
    method releaseUnsafe (line 171) | public synchronized void releaseUnsafe() throws Exception {
    method finalize (line 296) | @Override protected void finalize() throws Throwable {
    class ReadCallback (line 303) | static class ReadCallback extends Read_packet_Pointer_BytePointer_int {
      method call (line 304) | @Override public int call(Pointer opaque, BytePointer buf, int buf_s...
    class SeekCallback (line 323) | static class SeekCallback extends Seek_Pointer_long_int {
      method call (line 324) | @Override public long call(Pointer opaque, long offset, int whence) {
    method isCloseInputStream (line 404) | public boolean isCloseInputStream() {
    method setCloseInputStream (line 407) | public void setCloseInputStream(boolean closeInputStream) {
    method hasVideo (line 415) | public boolean hasVideo() {
    method hasAudio (line 423) | public boolean hasAudio() {
    method getGamma (line 427) | @Override public double getGamma() {
    method getFormat (line 436) | @Override public String getFormat() {
    method getImageWidth (line 444) | @Override public int getImageWidth() {
    method getImageHeight (line 448) | @Override public int getImageHeight() {
    method getAudioChannels (line 452) | @Override public int getAudioChannels() {
    method getPixelFormat (line 456) | @Override public int getPixelFormat() {
    method getVideoCodec (line 470) | @Override public int getVideoCodec() {
    method getVideoCodecName (line 474) | @Override
    method getVideoBitrate (line 479) | @Override public int getVideoBitrate() {
    method getAspectRatio (line 483) | @Override public double getAspectRatio() {
    method getFrameRate (line 494) | @Override public double getFrameRate() {
    method getAudioFrameRate (line 506) | public double getAudioFrameRate() {
    method getVideoFrameRate (line 525) | public double getVideoFrameRate() {
    method getAudioCodec (line 537) | @Override public int getAudioCodec() {
    method getAudioCodecName (line 541) | @Override public String getAudioCodecName() {
    method getAudioBitrate (line 545) | @Override public int getAudioBitrate() {
    method getSampleFormat (line 549) | @Override public int getSampleFormat() {
    method getSampleRate (line 563) | @Override public int getSampleRate() {
    method getMetadata (line 567) | @Override public Map<String, String> getMetadata() {
    method getVideoMetadata (line 579) | @Override public Map<String, String> getVideoMetadata() {
    method getAudioMetadata (line 591) | @Override public Map<String, String> getAudioMetadata() {
    method getMetadata (line 603) | @Override public String getMetadata(String key) {
    method getVideoMetadata (line 611) | @Override public String getVideoMetadata(String key) {
    method getAudioMetadata (line 619) | @Override public String getAudioMetadata(String key) {
    method getVideoSideData (line 627) | @Override public Map<String, Buffer> getVideoSideData() {
    method getVideoSideData (line 641) | @Override public Buffer getVideoSideData(String key) {
    method getDisplayRotation (line 646) | public double getDisplayRotation() {
    method getAudioSideData (line 651) | @Override public Map<String, Buffer> getAudioSideData() {
    method getAudioSideData (line 665) | @Override public Buffer getAudioSideData(String key) {
    method setFrameNumber (line 671) | @Override public void setFrameNumber(int frameNumber) throws Exception {
    method setVideoFrameNumber (line 678) | public void setVideoFrameNumber(int frameNumber) throws Exception {
    method setAudioFrameNumber (line 686) | public void setAudioFrameNumber(int frameNumber) throws Exception {
    method setTimestamp (line 692) | @Override public void setTimestamp(long timestamp) throws Exception {
    method setTimestamp (line 699) | public void setTimestamp(long timestamp, boolean checkFrame) throws Ex...
    method setVideoTimestamp (line 707) | public void setVideoTimestamp(long timestamp) throws Exception {
    method setAudioTimestamp (line 715) | public void setAudioTimestamp(long timestamp) throws Exception {
    method setTimestamp (line 724) | private synchronized void setTimestamp(long timestamp, EnumSet<Frame.T...
    method getLengthInFrames (line 884) | @Override public int getLengthInFrames() {
    method getLengthInTime (line 889) | @Override public long getLengthInTime() {
    method getLengthInVideoFrames (line 894) | public int getLengthInVideoFrames() {
    method getLengthInAudioFrames (line 899) | public int getLengthInAudioFrames() {
    method getFormatContext (line 906) | public AVFormatContext getFormatContext() {
    method start (line 911) | @Override public void start() throws Exception {
    method start (line 915) | public void start(boolean findStreamInfo) throws Exception {
    method startUnsafe (line 920) | public void startUnsafe() throws Exception {
    method startUnsafe (line 923) | public synchronized void startUnsafe(boolean findStreamInfo) throws Ex...
    method initPictureRGB (line 1147) | private void initPictureRGB() {
    method stop (line 1198) | @Override public void stop() throws Exception {
    method trigger (line 1202) | @Override public synchronized void trigger() throws Exception {
    method processImage (line 1218) | private void processImage() throws Exception {
    method processSamples (line 1274) | private void processSamples() throws Exception {
    method grab (line 1373) | public Frame grab() throws Exception {
    method grabImage (line 1376) | public Frame grabImage() throws Exception {
    method grabSamples (line 1379) | public Frame grabSamples() throws Exception {
    method grabKeyFrame (line 1382) | public Frame grabKeyFrame() throws Exception {
    method grabFrame (line 1385) | public Frame grabFrame(boolean doAudio, boolean doVideo, boolean doPro...
    method grabFrame (line 1388) | public synchronized Frame grabFrame(boolean doAudio, boolean doVideo, ...
    method grabPacket (line 1595) | public synchronized AVPacket grabPacket() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/FFmpegFrameRecorder.java
  class FFmpegFrameRecorder (line 95) | public class FFmpegFrameRecorder extends FrameRecorder {
    class Exception (line 97) | public static class Exception extends FrameRecorder.Exception {
      method Exception (line 98) | public Exception(String message) { super(message + " (For more detai...
      method Exception (line 99) | public Exception(String message, Throwable cause) { super(message, c...
    method createDefault (line 102) | public static FFmpegFrameRecorder createDefault(File f, int w, int h) ...
    method createDefault (line 103) | public static FFmpegFrameRecorder createDefault(String f, int w, int h...
    method tryLoad (line 106) | public static void tryLoad() throws Exception {
    method FFmpegFrameRecorder (line 142) | public FFmpegFrameRecorder(URL url, int audioChannels) {
    method FFmpegFrameRecorder (line 145) | public FFmpegFrameRecorder(File file, int audioChannels) {
    method FFmpegFrameRecorder (line 148) | public FFmpegFrameRecorder(String filename, int audioChannels) {
    method FFmpegFrameRecorder (line 151) | public FFmpegFrameRecorder(URL url, int imageWidth, int imageHeight) {
    method FFmpegFrameRecorder (line 154) | public FFmpegFrameRecorder(File file, int imageWidth, int imageHeight) {
    method FFmpegFrameRecorder (line 157) | public FFmpegFrameRecorder(String filename, int imageWidth, int imageH...
    method FFmpegFrameRecorder (line 160) | public FFmpegFrameRecorder(URL url, int imageWidth, int imageHeight, i...
    method FFmpegFrameRecorder (line 163) | public FFmpegFrameRecorder(File file, int imageWidth, int imageHeight,...
    method FFmpegFrameRecorder (line 166) | public FFmpegFrameRecorder(String filename, int imageWidth, int imageH...
    method FFmpegFrameRecorder (line 185) | public FFmpegFrameRecorder(OutputStream outputStream, int audioChannel...
    method FFmpegFrameRecorder (line 190) | public FFmpegFrameRecorder(OutputStream outputStream, int imageWidth, ...
    method FFmpegFrameRecorder (line 195) | public FFmpegFrameRecorder(OutputStream outputStream, int imageWidth, ...
    method release (line 200) | public void release() throws Exception {
    method releaseUnsafe (line 205) | public synchronized void releaseUnsafe() throws Exception {
    method finalize (line 333) | @Override protected void finalize() throws Throwable {
    class WriteCallback (line 340) | static class WriteCallback extends Write_packet_Pointer_BytePointer_int {
      method call (line 341) | @Override public int call(Pointer opaque, BytePointer buf, int buf_s...
    class SeekCallback (line 358) | static class SeekCallback extends Seek_Pointer_long_int {
      method call (line 360) | @Override public long call(Pointer opaque, long offset, int whence) {
    method isCloseOutputStream (line 407) | public boolean isCloseOutputStream() {
    method setCloseOutputStream (line 410) | public void setCloseOutputStream(boolean closeOutputStream) {
    method setDisplayRotation (line 415) | public void setDisplayRotation(double angle) {
    method getFrameNumber (line 423) | @Override public int getFrameNumber() {
    method setFrameNumber (line 426) | @Override public void setFrameNumber(int frameNumber) {
    method getTimestamp (line 431) | @Override public long getTimestamp() {
    method setTimestamp (line 434) | @Override public void setTimestamp(long timestamp)  {
    method start (line 438) | public void start(AVFormatContext inputFormatContext) throws Exception {
    method start (line 443) | @Override public void start() throws Exception {
    method startUnsafe (line 449) | public synchronized void startUnsafe() throws Exception {
    method flush (line 1009) | public synchronized void flush() throws Exception {
    method stop (line 1023) | public void stop() throws Exception {
    method record (line 1036) | @Override public void record(Frame frame) throws Exception {
    method record (line 1039) | public synchronized void record(Frame frame, int pixelFormat) throws E...
    method recordImage (line 1053) | public synchronized boolean recordImage(int width, int height, int dep...
    method recordSamples (line 1174) | public boolean recordSamples(Buffer ... samples) throws Exception {
    method recordSamples (line 1177) | public synchronized boolean recordSamples(int sampleRate, int audioCha...
    method writeSamples (line 1345) | private void writeSamples(int nb_samples) throws Exception {
    method writeFrame (line 1371) | private boolean writeFrame(AVFrame frame) throws Exception {
    method writePacket (line 1415) | private void writePacket(int mediaType, AVPacket avPacket) throws Exce...
    method recordPacket (line 1436) | public synchronized boolean recordPacket(AVPacket pkt) throws Exception {

FILE: src/main/java/org/bytedeco/javacv/FFmpegLockCallback.java
  class FFmpegLockCallback (line 15) | public class FFmpegLockCallback {
    method call (line 21) | @Override
    method init (line 65) | public static synchronized void init() {

FILE: src/main/java/org/bytedeco/javacv/FFmpegLogCallback.java
  class FFmpegLogCallback (line 38) | public class FFmpegLogCallback extends LogCallback {
    method getInstance (line 45) | public static FFmpegLogCallback getInstance() {
    method set (line 50) | public static void set() {
    method getLevel (line 55) | public static int getLevel() {
    method setLevel (line 60) | public static void setLevel(int level) {
    method logRejectedOptions (line 65) | public static void logRejectedOptions(final AVDictionary options, fina...
    method call (line 76) | @Override public void call(int level, BytePointer msg) {

FILE: src/main/java/org/bytedeco/javacv/FlyCapture2FrameGrabber.java
  class FlyCapture2FrameGrabber (line 47) | public class FlyCapture2FrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 49) | public static String[] getDeviceDescriptions() throws FrameGrabber.Exc...
    method PrintError (line 86) | static void PrintError(Error error) {
    method CameraInfo (line 90) | static String CameraInfo(CameraInfo pCamInfo) {
    method createDefault (line 101) | public static FlyCapture2FrameGrabber createDefault(File deviceFile) t...
    method createDefault (line 105) | public static FlyCapture2FrameGrabber createDefault(String devicePath)...
    method createDefault (line 109) | public static FlyCapture2FrameGrabber createDefault(int deviceNumber) ...
    method tryLoad (line 115) | public static void tryLoad() throws FrameGrabber.Exception {
    method FlyCapture2FrameGrabber (line 128) | public FlyCapture2FrameGrabber(int deviceNumber) throws FrameGrabber.E...
    method release (line 157) | public void release() throws FrameGrabber.Exception {
    method finalize (line 165) | @Override
    method getGamma (line 190) | @Override
    method getImageWidth (line 195) | @Override
    method getImageHeight (line 200) | @Override
    method getFrameRate (line 205) | @Override
    method setImageMode (line 217) | @Override
    method start (line 227) | public void start() throws FrameGrabber.Exception {
    method waitForTriggerReady (line 378) | private void waitForTriggerReady() throws Exception {
    method stop (line 394) | public void stop() throws FrameGrabber.Exception {
    method trigger (line 409) | public void trigger() throws FrameGrabber.Exception {
    method getNumChannels (line 418) | private int getNumChannels(int pixelFormat) {
    method getDepth (line 444) | private int getDepth(int pixelFormat) {
    method setPixelFormat (line 470) | private void setPixelFormat(Image image, int pixelFormat) {
    method setStride (line 478) | private void setStride(Image image, int stride) {
    method grab (line 486) | public Frame grab() throws FrameGrabber.Exception {

FILE: src/main/java/org/bytedeco/javacv/FlyCaptureFrameGrabber.java
  class FlyCaptureFrameGrabber (line 43) | public class FlyCaptureFrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 44) | public static String[] getDeviceDescriptions() throws Exception {
    method createDefault (line 72) | public static FlyCaptureFrameGrabber createDefault(File deviceFile)   ...
    method createDefault (line 73) | public static FlyCaptureFrameGrabber createDefault(String devicePath) ...
    method createDefault (line 74) | public static FlyCaptureFrameGrabber createDefault(int deviceNumber)  ...
    method tryLoad (line 77) | public static void tryLoad() throws Exception {
    method FlyCaptureFrameGrabber (line 89) | public FlyCaptureFrameGrabber(int deviceNumber) throws Exception {
    method release (line 99) | public void release() throws Exception {
    method finalize (line 109) | @Override protected void finalize() throws Throwable {
    method getGamma (line 132) | @Override public double getGamma() {
    method getImageWidth (line 136) | @Override public int getImageWidth() {
    method getImageHeight (line 140) | @Override public int getImageHeight() {
    method getFrameRate (line 144) | @Override public double getFrameRate() {
    method setImageMode (line 153) | @Override public void setImageMode(ImageMode imageMode) {
    method start (line 161) | public void start() throws Exception {
    method waitForTriggerReady (line 281) | private void waitForTriggerReady() throws Exception {
    method stop (line 296) | public void stop() throws Exception {
    method trigger (line 307) | public void trigger() throws Exception {
    method getNumChannels (line 315) | private int getNumChannels(int pixelFormat) {
    method getDepth (line 340) | private int getDepth(int pixelFormat) {
    method grab (line 366) | public Frame grab() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/Frame.java
  class Frame (line 60) | public class Frame implements AutoCloseable, Indexable {
    type Type (line 79) | public static enum Type {
    method pixelSize (line 119) | public static int pixelSize(int depth) {
    method Frame (line 124) | public Frame() { }
    method Frame (line 127) | public Frame(int width, int height, int depth, int channels) {
    method Frame (line 130) | public Frame(int width, int height, int depth, int channels, int image...
    method createIndexer (line 159) | public <I extends Indexer> I createIndexer() {
    method createIndexer (line 162) | @Override public <I extends Indexer> I createIndexer(boolean direct) {
    method createIndexer (line 166) | public <I extends Indexer> I createIndexer(boolean direct, int i) {
    method clone (line 218) | @Override
    method cloneBufferArray (line 269) | private static Pointer cloneBufferArray(Buffer[] srcBuffers, Buffer[] ...
    method getTypes (line 361) | public EnumSet<Type> getTypes() {
    method close (line 369) | @Override public void close() {

FILE: src/main/java/org/bytedeco/javacv/FrameConverter.java
  class FrameConverter (line 37) | public abstract class FrameConverter<F> implements AutoCloseable {
    method convert (line 40) | public abstract Frame convert(F f);
    method convert (line 41) | public abstract F convert(Frame frame);
    method close (line 43) | @Override public void close() {

FILE: src/main/java/org/bytedeco/javacv/FrameFilter.java
  class FrameFilter (line 34) | public abstract class FrameFilter implements Closeable {
    method createDefault (line 35) | public static FrameFilter createDefault(String filtersDescr, int image...
    method getFilters (line 55) | public String getFilters() {
    method setFilters (line 58) | public void setFilters(String filters) {
    method getImageWidth (line 62) | public int getImageWidth() {
    method setImageWidth (line 65) | public void setImageWidth(int imageWidth) {
    method getImageHeight (line 69) | public int getImageHeight() {
    method setImageHeight (line 72) | public void setImageHeight(int imageHeight) {
    method getPixelFormat (line 76) | public int getPixelFormat() {
    method setPixelFormat (line 79) | public void setPixelFormat(int pixelFormat) {
    method getFrameRate (line 83) | public double getFrameRate() {
    method setFrameRate (line 86) | public void setFrameRate(double frameRate) {
    method getAspectRatio (line 90) | public double getAspectRatio() {
    method setAspectRatio (line 93) | public void setAspectRatio(double aspectRatio) {
    method getVideoInputs (line 97) | public int getVideoInputs() {
    method setVideoInputs (line 100) | public void setVideoInputs(int videoInputs) {
    method getVideoFilterArgs (line 104) | public String[] getVideoFilterArgs() {
    method setVideoFilterArgs (line 108) | public void setVideoFilterArgs(String[] videoFilterArgs) {
    method getAudioChannels (line 112) | public int getAudioChannels() {
    method setAudioChannels (line 115) | public void setAudioChannels(int audioChannels) {
    method getSampleFormat (line 119) | public int getSampleFormat() {
    method setSampleFormat (line 122) | public void setSampleFormat(int sampleFormat) {
    method getSampleRate (line 126) | public int getSampleRate() {
    method setSampleRate (line 129) | public void setSampleRate(int sampleRate) {
    method getAudioInputs (line 133) | public int getAudioInputs() {
    method setAudioInputs (line 136) | public void setAudioInputs(int audioInputs) {
    method getAudioFilterArgs (line 140) | public String[] getAudioFilterArgs() {
    method setAudioFilterArgs (line 144) | public void setAudioFilterArgs(String[] audioFilterArgs) {
    class Exception (line 148) | public static class Exception extends IOException {
      method Exception (line 149) | public Exception(String message) { super(message); }
      method Exception (line 150) | public Exception(String message, Throwable cause) { super(message, c...
    method start (line 153) | public abstract void start() throws Exception;
    method stop (line 154) | public abstract void stop() throws Exception;
    method push (line 155) | public abstract void push(Frame frame) throws Exception;
    method pull (line 156) | public abstract Frame pull() throws Exception;
    method release (line 157) | public abstract void release() throws Exception;
    method close (line 159) | @Override public void close() throws Exception {
    method restart (line 164) | public void restart() throws Exception {
    method flush (line 168) | public void flush() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/FrameGrabber.java
  class FrameGrabber (line 47) | public abstract class FrameGrabber implements Closeable {
    method init (line 51) | public static void init() {
    method getDefault (line 61) | public static Class<? extends FrameGrabber> getDefault() {
    method get (line 87) | public static Class<? extends FrameGrabber> get(String className) thro...
    method create (line 101) | public static FrameGrabber create(Class<? extends FrameGrabber> c, Cla...
    method createDefault (line 119) | public static FrameGrabber createDefault(File deviceFile) throws Excep...
    method createDefault (line 122) | public static FrameGrabber createDefault(String devicePath) throws Exc...
    method createDefault (line 125) | public static FrameGrabber createDefault(int deviceNumber) throws Exce...
    method create (line 133) | public static FrameGrabber create(String className, File deviceFile) t...
    method create (line 136) | public static FrameGrabber create(String className, String devicePath)...
    method create (line 139) | public static FrameGrabber create(String className, int deviceNumber) ...
    class PropertyEditor (line 147) | public static class PropertyEditor extends PropertyEditorSupport {
      method getAsText (line 148) | @Override public String getAsText() {
      method setAsText (line 152) | @Override public void setAsText(String s) {
      method getTags (line 162) | @Override public String[] getTags() {
    type ImageMode (line 168) | public static enum ImageMode {
    type SampleMode (line 172) | public static enum SampleMode {
    method getVideoStream (line 212) | public int getVideoStream() {
    method setVideoStream (line 215) | public void setVideoStream(int videoStream) {
    method getAudioStream (line 219) | public int getAudioStream() {
    method setAudioStream (line 222) | public void setAudioStream(int audioStream) {
    method setVideoDisposition (line 226) | public void setVideoDisposition(int videoDisposition) {
    method getVideoDisposition (line 229) | public int getVideoDisposition() {
    method setAudioDisposition (line 233) | public void setAudioDisposition(int audioDisposition) {
    method getAudioDisposition (line 236) | public int getAudioDisposition() {
    method getFormat (line 240) | public String getFormat() {
    method setFormat (line 243) | public void setFormat(String format) {
    method getVideoCodecName (line 247) | public String getVideoCodecName() {
    method setVideoCodecName (line 250) | public void setVideoCodecName(String videoCodecName) {
    method getAudioCodecName (line 254) | public String getAudioCodecName() {
    method setAudioCodecName (line 257) | public void setAudioCodecName(String audioCodecName) {
    method getImageWidth (line 261) | public int getImageWidth() {
    method setImageWidth (line 264) | public void setImageWidth(int imageWidth) {
    method getImageHeight (line 268) | public int getImageHeight() {
    method setImageHeight (line 271) | public void setImageHeight(int imageHeight) {
    method getAudioChannels (line 275) | public int getAudioChannels() {
    method setAudioChannels (line 278) | public void setAudioChannels(int audioChannels) {
    method getImageMode (line 282) | public ImageMode getImageMode() {
    method setImageMode (line 285) | public void setImageMode(ImageMode imageMode) {
    method getSensorPattern (line 289) | public long getSensorPattern() {
    method setSensorPattern (line 292) | public void setSensorPattern(long sensorPattern) {
    method getPixelFormat (line 296) | public int getPixelFormat() {
    method setPixelFormat (line 299) | public void setPixelFormat(int pixelFormat) {
    method getVideoCodec (line 303) | public int getVideoCodec() {
    method setVideoCodec (line 306) | public void setVideoCodec(int videoCodec) {
    method getVideoBitrate (line 310) | public int getVideoBitrate() {
    method setVideoBitrate (line 313) | public void setVideoBitrate(int videoBitrate) {
    method getImageScalingFlags (line 317) | public int getImageScalingFlags() {
    method setImageScalingFlags (line 320) | public void setImageScalingFlags(int imageScalingFlags) {
    method getAspectRatio (line 324) | public double getAspectRatio() {
    method setAspectRatio (line 327) | public void setAspectRatio(double aspectRatio) {
    method getFrameRate (line 331) | public double getFrameRate() {
    method setFrameRate (line 334) | public void setFrameRate(double frameRate) {
    method getAudioCodec (line 338) | public int getAudioCodec() {
    method setAudioCodec (line 341) | public void setAudioCodec(int audioCodec) {
    method getAudioBitrate (line 345) | public int getAudioBitrate() {
    method setAudioBitrate (line 348) | public void setAudioBitrate(int audioBitrate) {
    method getSampleMode (line 352) | public SampleMode getSampleMode() {
    method setSampleMode (line 355) | public void setSampleMode(SampleMode samplesMode) {
    method getSampleFormat (line 359) | public int getSampleFormat() {
    method setSampleFormat (line 362) | public void setSampleFormat(int sampleFormat) {
    method getSampleRate (line 366) | public int getSampleRate() {
    method setSampleRate (line 369) | public void setSampleRate(int sampleRate) {
    method isTriggerMode (line 373) | public boolean isTriggerMode() {
    method setTriggerMode (line 376) | public void setTriggerMode(boolean triggerMode) {
    method getBitsPerPixel (line 380) | public int getBitsPerPixel() {
    method setBitsPerPixel (line 383) | public void setBitsPerPixel(int bitsPerPixel) {
    method getTimeout (line 387) | public int getTimeout() {
    method setTimeout (line 390) | public void setTimeout(int timeout) {
    method getNumBuffers (line 394) | public int getNumBuffers() {
    method setNumBuffers (line 397) | public void setNumBuffers(int numBuffers) {
    method getGamma (line 401) | public double getGamma() {
    method setGamma (line 404) | public void setGamma(double gamma) {
    method isDeinterlace (line 408) | public boolean isDeinterlace() {
    method setDeinterlace (line 411) | public void setDeinterlace(boolean deinterlace) {
    method getCharset (line 415) | public Charset getCharset() {
    method setCharset (line 418) | public void setCharset(Charset charset) {
    method getOptions (line 422) | public Map<String, String> getOptions() {
    method setOptions (line 425) | public void setOptions(Map<String, String> options) {
    method getVideoOptions (line 429) | public Map<String, String> getVideoOptions() {
    method setVideoOptions (line 432) | public void setVideoOptions(Map<String, String> options) {
    method getAudioOptions (line 436) | public Map<String, String> getAudioOptions() {
    method setAudioOptions (line 439) | public void setAudioOptions(Map<String, String> options) {
    method getMetadata (line 443) | public Map<String, String> getMetadata() {
    method setMetadata (line 446) | public void setMetadata(Map<String, String> metadata) {
    method getVideoMetadata (line 450) | public Map<String, String> getVideoMetadata() {
    method setVideoMetadata (line 453) | public void setVideoMetadata(Map<String, String> metadata) {
    method getAudioMetadata (line 457) | public Map<String, String> getAudioMetadata() {
    method setAudioMetadata (line 460) | public void setAudioMetadata(Map<String, String> metadata) {
    method getOption (line 464) | public String getOption(String key) {
    method setOption (line 467) | public void setOption(String key, String value) {
    method getVideoOption (line 471) | public String getVideoOption(String key) {
    method setVideoOption (line 474) | public void setVideoOption(String key, String value) {
    method getAudioOption (line 478) | public String getAudioOption(String key) {
    method setAudioOption (line 481) | public void setAudioOption(String key, String value) {
    method getMetadata (line 485) | public String getMetadata(String key) {
    method setMetadata (line 488) | public void setMetadata(String key, String value) {
    method getVideoMetadata (line 492) | public String getVideoMetadata(String key) {
    method setVideoMetadata (line 495) | public void setVideoMetadata(String key, String value) {
    method getAudioMetadata (line 499) | public String getAudioMetadata(String key) {
    method setAudioMetadata (line 502) | public void setAudioMetadata(String key, String value) {
    method getVideoSideData (line 506) | public Map<String, Buffer> getVideoSideData() {
    method setVideoSideData (line 509) | public void setVideoSideData(Map<String, Buffer> videoSideData) {
    method getVideoSideData (line 513) | public Buffer getVideoSideData(String key) {
    method setVideoSideData (line 516) | public void setVideoSideData(String key, Buffer value) {
    method getAudioSideData (line 520) | public Map<String, Buffer> getAudioSideData() {
    method setAudioSideData (line 523) | public void setAudioSideData(Map<String, Buffer> audioSideData) {
    method getAudioSideData (line 527) | public Buffer getAudioSideData(String key) {
    method setAudioSideData (line 530) | public void setAudioSideData(String key, Buffer value) {
    method getFrameNumber (line 534) | public int getFrameNumber() {
    method setFrameNumber (line 537) | public void setFrameNumber(int frameNumber) throws Exception {
    method getTimestamp (line 541) | public long getTimestamp() {
    method setTimestamp (line 544) | public void setTimestamp(long timestamp) throws Exception {
    method getMaxDelay (line 548) | public int getMaxDelay() {
    method setMaxDelay (line 551) | public void setMaxDelay(int maxDelay) {
    method getLengthInFrames (line 555) | public int getLengthInFrames() {
    method getLengthInTime (line 558) | public long getLengthInTime() {
    class Exception (line 562) | public static class Exception extends IOException {
      method Exception (line 563) | public Exception(String message) { super(message); }
      method Exception (line 564) | public Exception(String message, Throwable cause) { super(message, c...
    method start (line 567) | public abstract void start() throws Exception;
    method stop (line 568) | public abstract void stop() throws Exception;
    method trigger (line 569) | public abstract void trigger() throws Exception;
    method close (line 571) | @Override public void close() throws Exception {
    method grab (line 594) | public abstract Frame grab() throws Exception;
    method grabFrame (line 595) | public Frame grabFrame() throws Exception { return grab(); }
    method release (line 596) | public abstract void release() throws Exception;
    method restart (line 598) | public void restart() throws Exception {
    method flush (line 602) | public void flush() throws Exception {
    method delayedGrab (line 612) | public void delayedGrab(final long delayTime) {
    method getDelayedTime (line 627) | public long getDelayedTime() throws InterruptedException, ExecutionExc...
    method getDelayedFrame (line 634) | public Frame getDelayedFrame() throws InterruptedException, ExecutionE...
    class Array (line 642) | public static class Array {
      method Array (line 645) | protected Array(FrameGrabber[] frameGrabbers) {
      method getFrameGrabbers (line 656) | public FrameGrabber[] getFrameGrabbers() {
      method setFrameGrabbers (line 659) | public void setFrameGrabbers(FrameGrabber[] frameGrabbers) {
      method size (line 666) | public int size() {
      method start (line 670) | public void start() throws Exception {
      method stop (line 675) | public void stop() throws Exception {
      method trigger (line 681) | public void trigger() throws Exception {
      method grab (line 689) | public Frame[] grab() throws Exception {
      method release (line 773) | public void release() throws Exception {
    method createArray (line 780) | public Array createArray(FrameGrabber[] frameGrabbers) {
    method grabAtFrameRate (line 785) | public Frame grabAtFrameRate() throws Exception, InterruptedException {
    method waitForTimestamp (line 794) | public boolean waitForTimestamp(Frame frame) throws InterruptedExcepti...
    method resetStartTime (line 807) | public void resetStartTime() {

FILE: src/main/java/org/bytedeco/javacv/FrameRecorder.java
  class FrameRecorder (line 41) | public abstract class FrameRecorder implements Closeable {
    method init (line 44) | public static void init() {
    method getDefault (line 52) | public static Class<? extends FrameRecorder> getDefault() {
    method get (line 63) | public static Class<? extends FrameRecorder> get(String className) thr...
    method create (line 77) | public static FrameRecorder create(Class<? extends FrameRecorder> c, C...
    method createDefault (line 95) | public static FrameRecorder createDefault(File file, int width, int he...
    method createDefault (line 98) | public static FrameRecorder createDefault(String filename, int width, ...
    method create (line 102) | public static FrameRecorder create(String className, File file, int wi...
    method create (line 105) | public static FrameRecorder create(String className, String filename, ...
    method getFormat (line 131) | public String getFormat() {
    method setFormat (line 134) | public void setFormat(String format) {
    method getVideoCodecName (line 138) | public String getVideoCodecName() {
    method setVideoCodecName (line 141) | public void setVideoCodecName(String videoCodecName) {
    method getAudioCodecName (line 145) | public String getAudioCodecName() {
    method setAudioCodecName (line 148) | public void setAudioCodecName(String audioCodecName) {
    method getImageWidth (line 152) | public int getImageWidth() {
    method setImageWidth (line 155) | public void setImageWidth(int imageWidth) {
    method getImageHeight (line 159) | public int getImageHeight() {
    method setImageHeight (line 162) | public void setImageHeight(int imageHeight) {
    method getAudioChannels (line 166) | public int getAudioChannels() {
    method setAudioChannels (line 169) | public void setAudioChannels(int audioChannels) {
    method getPixelFormat (line 173) | public int getPixelFormat() {
    method setPixelFormat (line 176) | public void setPixelFormat(int pixelFormat) {
    method getVideoCodec (line 180) | public int getVideoCodec() {
    method setVideoCodec (line 183) | public void setVideoCodec(int videoCodec) {
    method getVideoBitrate (line 187) | public int getVideoBitrate() {
    method setVideoBitrate (line 190) | public void setVideoBitrate(int videoBitrate) {
    method getImageScalingFlags (line 194) | public int getImageScalingFlags() {
    method setImageScalingFlags (line 197) | public void setImageScalingFlags(int imageScalingFlags) {
    method getGopSize (line 201) | public int getGopSize() {
    method setGopSize (line 204) | public void setGopSize(int gopSize) {
    method getVideoProfile (line 208) | public int getVideoProfile() {
    method setVideoProfile (line 211) | public void setVideoProfile(int videoProfile) {
    method getAspectRatio (line 215) | public double getAspectRatio() {
    method setAspectRatio (line 218) | public void setAspectRatio(double aspectRatio) {
    method getFrameRate (line 222) | public double getFrameRate() {
    method setFrameRate (line 225) | public void setFrameRate(double frameRate) {
    method getVideoQuality (line 229) | public double getVideoQuality() {
    method setVideoQuality (line 232) | public void setVideoQuality(double videoQuality) {
    method getSampleFormat (line 236) | public int getSampleFormat() {
    method setSampleFormat (line 239) | public void setSampleFormat(int sampleFormat) {
    method getAudioCodec (line 243) | public int getAudioCodec() {
    method setAudioCodec (line 246) | public void setAudioCodec(int audioCodec) {
    method getAudioBitrate (line 250) | public int getAudioBitrate() {
    method setAudioBitrate (line 253) | public void setAudioBitrate(int audioBitrate) {
    method getSampleRate (line 257) | public int getSampleRate() {
    method setSampleRate (line 260) | public void setSampleRate(int sampleRate) {
    method getAudioQuality (line 264) | public double getAudioQuality() {
    method setAudioQuality (line 267) | public void setAudioQuality(double audioQuality) {
    method isInterleaved (line 271) | public boolean isInterleaved() {
    method setInterleaved (line 274) | public void setInterleaved(boolean interleaved) {
    method getCharset (line 278) | public Charset getCharset() {
    method setCharset (line 281) | public void setCharset(Charset charset) {
    method getOptions (line 285) | public Map<String, String> getOptions() {
    method setOptions (line 288) | public void setOptions(Map<String, String> options) {
    method getVideoOptions (line 292) | public Map<String, String> getVideoOptions() {
    method setVideoOptions (line 295) | public void setVideoOptions(Map<String, String> options) {
    method getAudioOptions (line 299) | public Map<String, String> getAudioOptions() {
    method setAudioOptions (line 302) | public void setAudioOptions(Map<String, String> options) {
    method getMetadata (line 306) | public Map<String, String> getMetadata() {
    method setMetadata (line 309) | public void setMetadata(Map<String, String> metadata) {
    method getVideoMetadata (line 313) | public Map<String, String> getVideoMetadata() {
    method setVideoMetadata (line 316) | public void setVideoMetadata(Map<String, String> metadata) {
    method getAudioMetadata (line 320) | public Map<String, String> getAudioMetadata() {
    method setAudioMetadata (line 323) | public void setAudioMetadata(Map<String, String> metadata) {
    method getOption (line 327) | public String getOption(String key) {
    method setOption (line 330) | public void setOption(String key, String value) {
    method getVideoOption (line 334) | public String getVideoOption(String key) {
    method setVideoOption (line 337) | public void setVideoOption(String key, String value) {
    method getAudioOption (line 341) | public String getAudioOption(String key) {
    method setAudioOption (line 344) | public void setAudioOption(String key, String value) {
    method getMetadata (line 348) | public String getMetadata(String key) {
    method setMetadata (line 351) | public void setMetadata(String key, String value) {
    method getVideoMetadata (line 355) | public String getVideoMetadata(String key) {
    method setVideoMetadata (line 358) | public void setVideoMetadata(String key, String value) {
    method getAudioMetadata (line 362) | public String getAudioMetadata(String key) {
    method setAudioMetadata (line 365) | public void setAudioMetadata(String key, String value) {
    method getVideoSideData (line 369) | public Map<String, Buffer> getVideoSideData() {
    method setVideoSideData (line 372) | public void setVideoSideData(Map<String, Buffer> videoSideData) {
    method getVideoSideData (line 376) | public Buffer getVideoSideData(String key) {
    method setVideoSideData (line 379) | public void setVideoSideData(String key, Buffer value) {
    method getAudioSideData (line 383) | public Map<String, Buffer> getAudioSideData() {
    method setAudioSideData (line 386) | public void setAudioSideData(Map<String, Buffer> audioSideData) {
    method getAudioSideData (line 390) | public Buffer getAudioSideData(String key) {
    method setAudioSideData (line 393) | public void setAudioSideData(String key, Buffer value) {
    method getFrameNumber (line 397) | public int getFrameNumber() {
    method setFrameNumber (line 400) | public void setFrameNumber(int frameNumber) {
    method getTimestamp (line 404) | public long getTimestamp() {
    method setTimestamp (line 407) | public void setTimestamp(long timestamp) {
    method getMaxBFrames (line 411) | public int getMaxBFrames() {
    method setMaxBFrames (line 414) | public void setMaxBFrames(int maxBFrames) {
    method getTrellis (line 418) | public int getTrellis() {
    method setTrellis (line 422) | public void setTrellis(int trellis) {
    method getMaxDelay (line 426) | public int getMaxDelay() {
    method setMaxDelay (line 430) | public void setMaxDelay(int maxDelay) {
    class Exception (line 434) | public static class Exception extends IOException {
      method Exception (line 435) | public Exception(String message) { super(message); }
      method Exception (line 436) | public Exception(String message, Throwable cause) { super(message, c...
    method start (line 439) | public abstract void start() throws Exception;
    method flush (line 440) | public abstract void flush() throws Exception;
    method stop (line 441) | public abstract void stop() throws Exception;
    method record (line 442) | public abstract void record(Frame frame) throws Exception;
    method release (line 443) | public abstract void release() throws Exception;
    method close (line 445) | @Override public void close() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/GLCanvasFrame.java
  class GLCanvasFrame (line 63) | public class GLCanvasFrame extends CanvasFrame {
    method GLCanvasFrame (line 64) | public GLCanvasFrame(String title) {
    method GLCanvasFrame (line 67) | public GLCanvasFrame(String title, double gamma) {
    method GLCanvasFrame (line 72) | public GLCanvasFrame(String title, GraphicsConfiguration gc,
    method GLCanvasFrame (line 76) | public GLCanvasFrame(String title, GraphicsConfiguration gc,
    method GLCanvasFrame (line 82) | public GLCanvasFrame(String title, int screenNumber, DisplayMode displ...
    method GLCanvasFrame (line 85) | public GLCanvasFrame(String title, int screenNumber, DisplayMode displ...
    method GLCanvasFrame (line 90) | public GLCanvasFrame(String title, int screenNumber, DisplayMode displ...
    method GLCanvasFrame (line 94) | public GLCanvasFrame(String title, int screenNumber, DisplayMode displ...
    method init (line 100) | private void init(final boolean fullScreen,
    method initCanvas (line 136) | @Override protected void initCanvas(boolean fullScreen, DisplayMode di...
    method init (line 145) | public void init(GLAutoDrawable drawable) {
    method dispose (line 157) | public void dispose(GLAutoDrawable drawable) {
    method display (line 166) | public void display(GLAutoDrawable drawable) {
    method reshape (line 209) | public void reshape(GLAutoDrawable drawable, int x, int y, int width, ...
    method getGLCanvas (line 212) | public GLCanvas getGLCanvas() {
    method showColor (line 216) | @Override public void showColor(Color color) {
    method showImage (line 222) | @Override public void showImage(Frame frame) {
    method showImage (line 225) | @Override public void showImage(Frame frame, boolean flipChannels) {
    method showImage (line 255) | @Override public void showImage(Image image) {
    method showImage (line 261) | public void showImage(BufferedImage image) {
    method showImage (line 300) | public void showImage(int renderBuffer) {
    method main (line 311) | public static void main(String[] args) throws java.lang.Exception {

FILE: src/main/java/org/bytedeco/javacv/GNImageAligner.java
  class GNImageAligner (line 38) | public class GNImageAligner implements ImageAligner {
    method GNImageAligner (line 39) | public GNImageAligner(ImageTransformer transformer, Parameters initial...
    method GNImageAligner (line 43) | public GNImageAligner(ImageTransformer transformer, Parameters initial...
    method GNImageAligner (line 92) | protected GNImageAligner(ImageTransformer transformer, Parameters init...
    class Settings (line 122) | public static class Settings extends ImageAligner.Settings implements ...
      method Settings (line 123) | public Settings() { }
      method Settings (line 124) | public Settings(Settings s) {
      method getStepSize (line 147) | public double getStepSize() {
      method setStepSize (line 150) | public void setStepSize(double stepSize) {
      method getLineSearch (line 154) | public double[] getLineSearch() {
      method setLineSearch (line 157) | public void setLineSearch(double[] lineSearch) {
      method getDeltaMin (line 161) | public double getDeltaMin() {
      method setDeltaMin (line 164) | public void setDeltaMin(double deltaMin) {
      method getDeltaMax (line 168) | public double getDeltaMax() {
      method setDeltaMax (line 171) | public void setDeltaMax(double deltaMax) {
      method getDisplacementMax (line 175) | public double getDisplacementMax() {
      method setDisplacementMax (line 178) | public void setDisplacementMax(double displacementMax) {
      method getAlphaSubspace (line 182) | public double getAlphaSubspace() {
      method setAlphaSubspace (line 185) | public void setAlphaSubspace(double alphaSubspace) {
      method getAlphaTikhonov (line 189) | public double getAlphaTikhonov() {
      method setAlphaTikhonov (line 192) | public void setAlphaTikhonov(double alphaTikhonov) {
      method getGammaTgamma (line 196) | public CvMat getGammaTgamma() {
      method setGammaTgamma (line 199) | public void setGammaTgamma(CvMat gammaTgamma) {
      method clone (line 210) | @Override public Settings clone() {
    method getSettings (line 216) | public Settings getSettings() {
    method setSettings (line 219) | public void setSettings(ImageAligner.Settings settings) {
    method getTemplateImage (line 244) | public IplImage getTemplateImage() {
    method setTemplateImage (line 247) | public void setTemplateImage(IplImage template0, double[] roiPts) {
    method getTargetImage (line 275) | public IplImage getTargetImage() {
    method setTargetImage (line 278) | public void setTargetImage(IplImage target0) {
    method getPyramidLevel (line 336) | public int getPyramidLevel() {
    method setPyramidLevel (line 339) | public void setPyramidLevel(int pyramidLevel) {
    method isConstrained (line 345) | public boolean isConstrained()  {
    method setConstrained (line 348) | public void setConstrained(boolean constrained) {
    method getParameters (line 370) | public Parameters getParameters() {
    method setParameters (line 373) | public void setParameters(Parameters parameters) {
    method getPriorParameters (line 384) | public Parameters getPriorParameters() {
    method setPriorParameters (line 387) | public void setPriorParameters(Parameters priorParameters) {
    method getTransformedRoiPts (line 391) | public double[] getTransformedRoiPts() {
    method getTransformedImage (line 399) | public IplImage getTransformedImage() {
    method getResidualImage (line 406) | public IplImage getResidualImage() {
    method getMaskImage (line 413) | public IplImage getMaskImage() {
    method getRMSE (line 417) | public double getRMSE() {
    method getPixelCount (line 425) | public int getPixelCount() {
    method getOutlierCount (line 433) | public int getOutlierCount() {
    method getRoi (line 437) | public CvRect getRoi() {
    method getLastLinePosition (line 443) | public int getLastLinePosition() {
    method getImages (line 447) | public IplImage[] getImages() {
    method iterate (line 456) | public boolean iterate(double[] delta) {
    method doHessianGradient (line 532) | protected void doHessianGradient(final double[] scale) {
    method doRegularization (line 584) | protected void doRegularization(final double[] scale) {
    method doRoi (line 717) | protected void doRoi() {
    method doResidual (line 735) | protected void doResidual() {

FILE: src/main/java/org/bytedeco/javacv/GNImageAlignerCL.java
  class GNImageAlignerCL (line 42) | public class GNImageAlignerCL extends GNImageAligner implements ImageAli...
    method GNImageAlignerCL (line 43) | public GNImageAlignerCL(ImageTransformerCL transformer, Parameters ini...
    method GNImageAlignerCL (line 47) | public GNImageAlignerCL(ImageTransformerCL transformer, Parameters ini...
    method release (line 104) | public void release() {
    method finalize (line 132) | @Override protected void finalize() throws Throwable {
    method getTemplateImage (line 146) | @Override public IplImage getTemplateImage() {
    method getTemplateImage (line 149) | public IplImage getTemplateImage(boolean blocking) {
    method setTemplateImage (line 157) | @Override public void setTemplateImage(IplImage template0, double[] ro...
    method getTargetImage (line 162) | @Override public IplImage getTargetImage() {
    method getTargetImage (line 165) | public IplImage getTargetImage(boolean blocking) {
    method setTargetImage (line 168) | @Override public void setTargetImage(IplImage target0) {
    method getTransformedImage (line 173) | @Override public IplImage getTransformedImage() {
    method getTransformedImage (line 176) | public IplImage getTransformedImage(boolean blocking) {
    method getResidualImage (line 180) | @Override public IplImage getResidualImage() {
    method getResidualImage (line 183) | public IplImage getResidualImage(boolean blocking) {
    method getMaskImage (line 187) | @Override public IplImage getMaskImage() {
    method getMaskImage (line 190) | public IplImage getMaskImage(boolean blocking) {
    method getRMSE (line 197) | @Override public double getRMSE() {
    method getPixelCount (line 205) | @Override public int getPixelCount() {
    method getOutlierCount (line 213) | @Override public int getOutlierCount() {
    method getRoi (line 217) | @Override public CvRect getRoi() {
    method getImages (line 225) | @Override public IplImage[] getImages() {
    method getImages (line 228) | public IplImage[] getImages(boolean blocking) {
    method getTemplateImageCL (line 237) | public CLImage2d getTemplateImageCL() {
    method setTemplateImageCL (line 240) | public void setTemplateImageCL(CLImage2d template0, double[] roiPts) {
    method getTargetImageCL (line 273) | public CLImage2d getTargetImageCL() {
    method setTargetImageCL (line 276) | public void setTargetImageCL(CLImage2d target0) {
    method getTransformedImageCL (line 296) | public CLImage2d getTransformedImageCL() {
    method getResidualImageCL (line 303) | public CLImage2d getResidualImageCL() {
    method getMaskImageCL (line 310) | public CLImage2d getMaskImageCL() {
    method getImagesCL (line 314) | public CLImage2d[] getImagesCL() {
    method doHessianGradient (line 323) | @Override protected void doHessianGradient(final double[] scale) {
    method doRoi (line 364) | @Override protected void doRoi() {
    method doResidual (line 408) | @Override protected void doResidual() {

FILE: src/main/java/org/bytedeco/javacv/GeometricCalibrator.java
  class GeometricCalibrator (line 43) | public class GeometricCalibrator {
    method GeometricCalibrator (line 44) | public GeometricCalibrator(Settings settings, MarkerDetector.Settings ...
    class Settings (line 61) | public static class Settings extends BaseChildSettings {
      method getDetectedBoardMin (line 66) | public double getDetectedBoardMin() {
      method setDetectedBoardMin (line 69) | public void setDetectedBoardMin(double detectedBoardMin) {
      method getPatternSteadySize (line 73) | public double getPatternSteadySize() {
      method setPatternSteadySize (line 76) | public void setPatternSteadySize(double patternSteadySize) {
      method getPatternMovedSize (line 80) | public double getPatternMovedSize() {
      method setPatternMovedSize (line 83) | public void setPatternMovedSize(double patternMovedSize) {
    method getMarkerDetector (line 104) | public MarkerDetector getMarkerDetector() {
    method getMarkedPlane (line 107) | public MarkedPlane getMarkedPlane() {
    method getProjectiveDevice (line 110) | public ProjectiveDevice getProjectiveDevice() {
    method getAllObjectMarkers (line 114) | public LinkedList<Marker[]> getAllObjectMarkers() {
    method setAllObjectMarkers (line 117) | public void setAllObjectMarkers(LinkedList<Marker[]> allObjectMarkers) {
    method getAllImageMarkers (line 121) | public LinkedList<Marker[]> getAllImageMarkers() {
    method setAllImageMarkers (line 124) | public void setAllImageMarkers(LinkedList<Marker[]> allImageMarkers) {
    method processImage (line 128) | public Marker[] processImage(IplImage image) {
    method drawMarkers (line 173) | public void drawMarkers(IplImage image) {
    method addMarkers (line 177) | public void addMarkers() {
    method addMarkers (line 180) | public void addMarkers(Marker[] imageMarkers) {
    method addMarkers (line 183) | public void addMarkers(Marker[] objectMarkers, Marker[] imageMarkers) {
    method getImageCount (line 210) | public int getImageCount() {
    method getObjectPoints (line 215) | private Point3fVectorVector getObjectPoints(CvMat points, CvMat counts) {
    method getImagePoints (line 231) | private Point2fVectorVector getImagePoints(CvMat points, CvMat counts) {
    method getPoints (line 247) | private CvMat[] getPoints(boolean useCenters) {
    method computeReprojectionError (line 299) | public static double[] computeReprojectionError(CvMat object_points,
    method calibrate (line 357) | public double[] calibrate(boolean useCenters) {
    method computeStereoError (line 420) | public static double[] computeStereoError(CvMat imagePoints1, CvMat im...
    method calibrateStereo (line 455) | public double[] calibrateStereo(boolean useCenters, GeometricCalibrato...

FILE: src/main/java/org/bytedeco/javacv/HandMouse.java
  class HandMouse (line 40) | public class HandMouse {
    method HandMouse (line 41) | public HandMouse() {
    method HandMouse (line 44) | public HandMouse(Settings settings) {
    class Settings (line 48) | public static class Settings extends BaseChildSettings {
      method Settings (line 49) | public Settings() { }
      method Settings (line 50) | public Settings(Settings s) {
      method getMopIterations (line 72) | public int getMopIterations() {
      method setMopIterations (line 75) | public void setMopIterations(int mopIterations) {
      method getClickSteadySize (line 79) | public double getClickSteadySize() {
      method setClickSteadySize (line 82) | public void setClickSteadySize(double clickSteadySize) {
      method getClickSteadyTime (line 86) | public long getClickSteadyTime() {
      method setClickSteadyTime (line 89) | public void setClickSteadyTime(long clickSteadyTime) {
      method getEdgeAreaMin (line 93) | public double getEdgeAreaMin() {
      method setEdgeAreaMin (line 96) | public void setEdgeAreaMin(double edgeAreaMin) {
      method getEdgeAreaMax (line 100) | public double getEdgeAreaMax() {
      method setEdgeAreaMax (line 103) | public void setEdgeAreaMax(double edgeAreaMax) {
      method getThresholdHigh (line 107) | public double getThresholdHigh() {
      method setThresholdHigh (line 110) | public void setThresholdHigh(double thresholdHigh) {
      method getThresholdLow (line 114) | public double getThresholdLow() {
      method setThresholdLow (line 117) | public void setThresholdLow(double thresholdLow) {
      method getBrightnessMin (line 121) | public double getBrightnessMin() {
      method setBrightnessMin (line 124) | public void setBrightnessMin(double brightnessMin) {
      method getUpdateAlpha (line 128) | public double getUpdateAlpha() {
      method setUpdateAlpha (line 131) | public void setUpdateAlpha(double updateAlpha) {
    method getSettings (line 137) | public Settings getSettings() {
    method setSettings (line 140) | public void setSettings(Settings settings) {
    method reset (line 159) | public void reset() {
    method update (line 163) | public void update(IplImage[] images, int pyramidLevel, CvRect roi, do...
    method getRelativeResidual (line 347) | public IplImage getRelativeResidual() {
    method getResultImage (line 350) | public IplImage getResultImage() {
    method getX (line 372) | public double getX() {
    method getY (line 375) | public double getY() {
    method isSteady (line 379) | public boolean isSteady() {
    method isClick (line 389) | public boolean isClick() {

FILE: src/main/java/org/bytedeco/javacv/IPCameraFrameGrabber.java
  class IPCameraFrameGrabber (line 43) | public class IPCameraFrameGrabber extends FrameGrabber {
    method tryLoad (line 54) | public static void tryLoad() throws Exception {
    method IPCameraFrameGrabber (line 86) | public IPCameraFrameGrabber(URL url, int startTimeout, int grabTimeout...
    method IPCameraFrameGrabber (line 101) | public IPCameraFrameGrabber(String urlstr, int connectionTimeout, int ...
    method IPCameraFrameGrabber (line 113) | @Deprecated
    method start (line 118) | @Override
    method stop (line 140) | @Override
    method trigger (line 156) | @Override
    method grab (line 160) | @Override
    method grabBufferedImage (line 172) | public BufferedImage grabBufferedImage() throws IOException {
    method releaseDecoded (line 182) | private void releaseDecoded() {
    method readImage (line 189) | private byte[] readImage() throws IOException {
    method release (line 241) | @Override
    method ensureBufferCapacity (line 252) | private void ensureBufferCapacity(int desiredCapacity) {
    method toIntExact (line 273) | private static int toIntExact(long value) {

FILE: src/main/java/org/bytedeco/javacv/ImageAligner.java
  type ImageAligner (line 34) | public interface ImageAligner {
    class Settings (line 36) | public class Settings extends BaseChildSettings implements Cloneable {
      method Settings (line 37) | public Settings() { }
      method Settings (line 38) | public Settings(Settings s) {
      method getPyramidLevelMin (line 52) | public int getPyramidLevelMin() {
      method setPyramidLevelMin (line 55) | public void setPyramidLevelMin(int pyramidLevelMin) {
      method getPyramidLevelMax (line 59) | public int getPyramidLevelMax() {
      method setPyramidLevelMax (line 62) | public void setPyramidLevelMax(int pyramidLevelMax) {
      method getThresholdsZero (line 66) | public double[] getThresholdsZero() {
      method setThresholdsZero (line 69) | public void setThresholdsZero(double[] thresholdsZero) {
      method getThresholdsOutlier (line 73) | public double[] getThresholdsOutlier() {
      method setThresholdsOutlier (line 76) | public void setThresholdsOutlier(double[] thresholdsOutlier) {
      method isThresholdsMulRMSE (line 80) | public boolean isThresholdsMulRMSE() {
      method setThresholdsMulRMSE (line 83) | public void setThresholdsMulRMSE(boolean thresholdsMulRMSE) {
      method clone (line 87) | @Override public Settings clone() {
    method getSettings (line 91) | Settings getSettings();
    method setSettings (line 92) | void setSettings(Settings settings);
    method getTemplateImage (line 94) | IplImage getTemplateImage();
    method setTemplateImage (line 95) | void setTemplateImage(IplImage template0, double[] roiPts);
    method getTargetImage (line 97) | IplImage getTargetImage();
    method setTargetImage (line 98) | void setTargetImage(IplImage target0);
    method getPyramidLevel (line 100) | int getPyramidLevel();
    method setPyramidLevel (line 101) | void setPyramidLevel(int pyramidLevel);
    method getParameters (line 103) | Parameters getParameters();
    method setParameters (line 104) | void setParameters(Parameters parameters);
    method getTransformedRoiPts (line 106) | double[] getTransformedRoiPts();
    method getTransformedImage (line 107) | IplImage getTransformedImage();
    method getResidualImage (line 108) | IplImage getResidualImage();
    method getMaskImage (line 109) | IplImage getMaskImage();
    method getRMSE (line 110) | double getRMSE();
    method getRoi (line 111) | CvRect getRoi();
    method getImages (line 113) | IplImage[] getImages();
    method iterate (line 115) | boolean iterate(double[] delta);

FILE: src/main/java/org/bytedeco/javacv/ImageAlignerCL.java
  type ImageAlignerCL (line 31) | public interface ImageAlignerCL extends ImageAligner {
    method getTemplateImageCL (line 33) | CLImage2d getTemplateImageCL();
    method setTemplateImageCL (line 34) | void setTemplateImageCL(CLImage2d template0, double[] roiPts);
    method getTargetImageCL (line 36) | CLImage2d getTargetImageCL();
    method setTargetImageCL (line 37) | void setTargetImageCL(CLImage2d target0);
    method getTransformedImageCL (line 39) | CLImage2d getTransformedImageCL();
    method getResidualImageCL (line 40) | CLImage2d getResidualImageCL();
    method getMaskImageCL (line 41) | CLImage2d getMaskImageCL();
    method getImagesCL (line 43) | CLImage2d[] getImagesCL();

FILE: src/main/java/org/bytedeco/javacv/ImageTransformer.java
  type ImageTransformer (line 36) | public interface ImageTransformer {
    class Data (line 38) | public class Data {
      method Data (line 39) | public Data() { this(null, null, null, null, 0, 0, 0, null, null, 0); }
      method Data (line 40) | public Data(IplImage srcImg, IplImage subImg, IplImage srcDotImg, Ip...
    type Parameters (line 69) | public interface Parameters extends Cloneable {
      method size (line 70) | int size();
      method get (line 71) | double[] get();
      method get (line 72) | double   get(int i);
      method set (line 73) | void set(double ... p);
      method set (line 74) | void set(int i, double p);
      method set (line 75) | void set(Parameters p);
      method reset (line 76) | void reset(boolean asIdentity);
      method getConstraintError (line 77) | double getConstraintError();
      method compose (line 78) | void compose(Parameters p1, boolean inverse1, Parameters p2, boolean...
      method preoptimize (line 79) | boolean preoptimize();
      method getSubspace (line 80) | double[] getSubspace();
      method setSubspace (line 81) | void setSubspace(double ... p);
      method clone (line 82) | Parameters clone();
    method createParameters (line 85) | Parameters createParameters();
    method transform (line 86) | void transform(Data[] data, CvRect roi, Parameters[] parameters, boole...
    method transform (line 87) | void transform(CvMat srcPts, CvMat dstPts, Parameters parameters, bool...

FILE: src/main/java/org/bytedeco/javacv/ImageTransformerCL.java
  type ImageTransformerCL (line 34) | public interface ImageTransformerCL extends ImageTransformer {
    class InputData (line 36) | public class InputData {
      method InputData (line 37) | public InputData() { this(true); }
      method InputData (line 38) | public InputData(boolean autoWrite) { this.autoWrite = autoWrite; }
      method getBuffer (line 47) | CLBuffer<ByteBuffer> getBuffer(JavaCVCL context) {
      method writeBuffer (line 56) | public CLBuffer<ByteBuffer> writeBuffer(JavaCVCL context) {
    class OutputData (line 66) | public class OutputData {
      method OutputData (line 67) | public OutputData() { this(true); }
      method OutputData (line 68) | public OutputData(boolean autoRead) { this.autoRead = autoRead; }
      method getBuffer (line 76) | CLBuffer<ByteBuffer> getBuffer(JavaCVCL context, int dotSize, int re...
      method readBuffer (line 89) | public CLBuffer<ByteBuffer> readBuffer(JavaCVCL context) {
    method getContext (line 100) | JavaCVCL getContext();
    method transform (line 102) | void transform(CLImage2d srcImg, CLImage2d subImg, CLImage2d srcDotImg...

FILE: src/main/java/org/bytedeco/javacv/Java2DFrameConverter.java
  class Java2DFrameConverter (line 60) | public class Java2DFrameConverter extends FrameConverter<BufferedImage> {
    method convert (line 62) | @Override public Frame convert(BufferedImage img) {
    method convert (line 66) | @Override public BufferedImage convert(Frame frame) {
    method cloneBufferedImage (line 74) | public static BufferedImage cloneBufferedImage(BufferedImage source) {
    method decodeGamma22 (line 104) | public static int decodeGamma22(int value) {
    method encodeGamma22 (line 107) | public static int encodeGamma22(int value) {
    method flipCopyWithGamma (line 110) | public static void flipCopyWithGamma(ByteBuffer srcBuf, int srcBufferI...
    method flipCopyWithGamma (line 196) | public static void flipCopyWithGamma(ShortBuffer srcBuf, int srcBuffer...
    method flipCopyWithGamma (line 274) | public static void flipCopyWithGamma(IntBuffer srcBuf, int srcBufferIn...
    method flipCopyWithGamma (line 321) | public static void flipCopyWithGamma(FloatBuffer srcBuf, int srcBuffer...
    method flipCopyWithGamma (line 368) | public static void flipCopyWithGamma(DoubleBuffer srcBuf, int srcBuffe...
    method applyGamma (line 416) | public static void applyGamma(Frame frame, double gamma) {
    method applyGamma (line 419) | public static void applyGamma(Buffer buffer, int depth, int stride, do...
    method copy (line 450) | public static void copy(Frame frame, BufferedImage bufferedImage) {
    method copy (line 453) | public static void copy(Frame frame, BufferedImage bufferedImage, doub...
    method copy (line 456) | public static void copy(Frame frame, BufferedImage bufferedImage, doub...
    method copy (line 506) | public static void copy(BufferedImage image, Frame frame) {
    method copy (line 509) | public static void copy(BufferedImage image, Frame frame, double gamma) {
    method copy (line 512) | public static void copy(BufferedImage image, Frame frame, double gamma...
    method getBufferedImageType (line 563) | public static int getBufferedImageType(Frame frame) {
    method getBufferedImage (line 591) | public BufferedImage getBufferedImage(Frame frame) {
    method getBufferedImage (line 594) | public BufferedImage getBufferedImage(Frame frame, double gamma) {
    method getBufferedImage (line 597) | public BufferedImage getBufferedImage(Frame frame, double gamma, boole...
    method getFrame (line 691) | public Frame getFrame(BufferedImage image) {
    method getFrame (line 697) | public Frame getFrame(BufferedImage image, double gamma) {
    method getFrame (line 703) | public Frame getFrame(BufferedImage image, double gamma, boolean flipC...

FILE: src/main/java/org/bytedeco/javacv/Java2DFrameUtils.java
  class Java2DFrameUtils (line 33) | public class Java2DFrameUtils {
    method deepCopy (line 47) | public static BufferedImage deepCopy(BufferedImage source) {
    method toBufferedImage (line 51) | public synchronized static BufferedImage toBufferedImage(IplImage src) {
    method toBufferedImage (line 57) | public synchronized static BufferedImage toBufferedImage(Mat src) {
    method toBufferedImage (line 63) | public synchronized static BufferedImage toBufferedImage(Frame src) {
    method toIplImage (line 69) | public synchronized static IplImage toIplImage(Mat src){
    method toIplImage (line 73) | public synchronized static IplImage toIplImage(Frame src){
    method toIplImage (line 77) | public synchronized static IplImage toIplImage(BufferedImage src){
    method toMat (line 81) | public synchronized static Mat toMat(IplImage src){
    method toMat (line 85) | public synchronized static Mat toMat(Frame src){
    method toMat (line 89) | public synchronized static Mat toMat(BufferedImage src){
    method toFrame (line 93) | public synchronized static Frame toFrame(IplImage src){
    method toFrame (line 97) | public synchronized static Frame toFrame(Mat src){
    method toFrame (line 101) | public synchronized static Frame toFrame(BufferedImage src){

FILE: src/main/java/org/bytedeco/javacv/JavaCV.java
  class JavaCV (line 43) | public class JavaCV {
    method distanceToLine (line 51) | public static double distanceToLine(double x1, double y1, double x2, d...
    method boundedRect (line 70) | public static CvBox2D boundedRect(CvMat contour, CvBox2D box) {
    method boundingRect (line 110) | public static CvRect boundingRect(double[] contour, CvRect rect,
    method getPerspectiveTransform (line 141) | public static CvMat getPerspectiveTransform(double[] src, double[] dst...
    method perspectiveTransform (line 171) | public static void perspectiveTransform(double[] src, double[] dst, Cv...
    method getPlaneParameters (line 189) | public static CvMat getPlaneParameters(double[] src, double[] dst,
    method getPerspectiveTransform (line 213) | public static CvMat getPerspectiveTransform(double[] src, double[] dst,
    method perspectiveTransform (line 229) | public static void perspectiveTransform(double[] src, double[] dst,
    method HtoRt (line 252) | public static void HtoRt(CvMat H, CvMat R, CvMat t) {
    method HnToRt (line 274) | public static double HnToRt(CvMat H, CvMat n, CvMat R, CvMat t) {
    method homogToRt (line 347) | public static double homogToRt(CvMat H,
    method homogToRt (line 355) | public static double homogToRt(CvMat S, CvMat U, CvMat V,
    method unitize (line 400) | public static double[] unitize(double a, double b) {
    method adaptiveThreshold (line 410) | public static void adaptiveThreshold(IplImage srcImage, final IplImage...
    method hysteresisThreshold (line 523) | public static void hysteresisThreshold(IplImage srcImage, IplImage dst...
    method clamp (line 733) | public static void clamp(IplImage src, IplImage dst, double min, doubl...
    method norm (line 796) | public static double norm(double[] v) {
    method norm (line 800) | public static double norm(double[] v, double p) {
    method norm (line 836) | public static double norm(CvMat A) {
    method norm (line 840) | public static double norm(CvMat A, double p) {
    method norm (line 844) | public static double norm(CvMat A, double p, CvMat W) {
    method cond (line 878) | public static double cond(CvMat A) {
    method cond (line 881) | public static double cond(CvMat A, double p) {
    method cond (line 884) | public static double cond(CvMat A, double p, CvMat W) {
    method median (line 908) | public static double median(double[] doubles) {
    method median (line 917) | public static <T extends Object> T median(T[] objects) {
    method fractalTriangleWave (line 923) | public static void fractalTriangleWave(double[] line, int i, int j, do...
    method fractalTriangleWave (line 926) | public static void fractalTriangleWave(double[] line, int i, int j, do...
    method fractalTriangleWave (line 941) | public static void fractalTriangleWave(IplImage image, CvMat H) {
    method fractalTriangleWave (line 944) | public static void fractalTriangleWave(IplImage image, CvMat H, int ro...
    method main (line 990) | public static void main(String[] args) {

FILE: src/main/java/org/bytedeco/javacv/JavaCVCL.java
  class JavaCVCL (line 76) | public class JavaCVCL {
    method JavaCVCL (line 77) | public JavaCVCL(CLContext context) {
    method JavaCVCL (line 80) | public JavaCVCL(CLContext context, CLDevice device) {
    method getDefaultGLCapabilities (line 91) | public static GLCapabilities getDefaultGLCapabilities(GLProfile profil...
    method JavaCVCL (line 98) | public JavaCVCL() {
    method JavaCVCL (line 101) | public JavaCVCL(boolean createPbuffer) {
    method JavaCVCL (line 104) | public JavaCVCL(GLContext shareWith) {
    method JavaCVCL (line 108) | public JavaCVCL(GLCapabilitiesImmutable caps, GLContext shareWith, CLD...
    method release (line 168) | public void release() {
    method finalize (line 179) | @Override protected void finalize() throws Throwable {
    method getCLContext (line 195) | public CLContext getCLContext() {
    method getCLCommandQueue (line 199) | public CLCommandQueue getCLCommandQueue() {
    method getCLGLContext (line 203) | public CLGLContext getCLGLContext() {
    method getGLContext (line 207) | public GLContext getGLContext() {
    method getGL (line 211) | public GL getGL() {
    method getGL2 (line 216) | public GL2 getGL2() {
    method getGLU (line 221) | public GLU getGLU() {
    method buildKernel (line 225) | public CLKernel buildKernel(String resourceNames, String kernelName) {
    method buildKernel (line 228) | public CLKernel buildKernel(String compilerOptions, String resourceNam...
    method buildKernels (line 232) | public CLKernel[] buildKernels(String compilerOptions, String resource...
    method buildKernels (line 235) | public CLKernel[] buildKernels(String compilerOptions, Class resourceC...
    method createCLImageFrom (line 266) | public CLImage2d createCLImageFrom(IplImage image, CLImage2d.Mem ... f...
    method createCLGLImageFrom (line 298) | public CLGLImage2d createCLGLImageFrom(IplImage image, CLImage2d.Mem ....
    method releaseCLGLImage (line 368) | public void releaseCLGLImage(CLGLImage2d image) {
    method createPinnedBuffer (line 373) | @SuppressWarnings("unchecked")
    class PinnedIplImage (line 382) | class PinnedIplImage extends IplImage {
      method PinnedIplImage (line 383) | PinnedIplImage(int width, int height, int depth, int channels) {
      method getCLBuffer (line 391) | public CLBuffer getCLBuffer() {
      method getByteBuffer (line 395) | @Override public ByteBuffer getByteBuffer() {
      method release (line 399) | @Override public void release() {
    method createPinnedIplImage (line 406) | public IplImage createPinnedIplImage(int width, int height, int depth,...
    method createIplImageFrom (line 410) | public IplImage createIplImageFrom(CLImage2d image) {
    method readImage (line 463) | @SuppressWarnings("unchecked")
    method writeImage (line 487) | @SuppressWarnings("unchecked")
    method acquireGLObject (line 511) | public void acquireGLObject(CLObject object) {
    method releaseGLObject (line 516) | public void releaseGLObject(CLObject object) {
    method readBuffer (line 522) | public void readBuffer(CLBuffer<?> buffer, boolean blocking) {
    method writeBuffer (line 525) | public void writeBuffer(CLBuffer<?> buffer, boolean blocking) {
    method executeKernel (line 529) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 534) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 539) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 546) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 555) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 564) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 575) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 584) | public void executeKernel(CLKernel kernel,
    method executeKernel (line 593) | public void executeKernel(CLKernel kernel,
    method finish (line 604) | public void finish() {
    method flush (line 607) | public void flush() {
    method alignCeil (line 611) | public static int alignCeil(int x, int n) {
    method alignFloor (line 614) | public static int alignFloor(int x, int n) {
    method pyrDown (line 618) | public void pyrDown(CLImage2d srcImg, CLImage2d dstImg) {
    method remap (line 630) | public void remap(CLImage2d srcImg, CLImage2d dstImg, CLImage2d mapxIm...
    method remap (line 633) | public void remap(CLImage2d srcImg, CLImage2d dstImg, CLImage2d mapxIm...
    method main (line 650) | public static void main(String[] args) {

FILE: src/main/java/org/bytedeco/javacv/JavaCvErrorCallback.java
  class JavaCvErrorCallback (line 40) | public class JavaCvErrorCallback extends CvErrorCallback {
    method JavaCvErrorCallback (line 44) | public JavaCvErrorCallback() {
    method JavaCvErrorCallback (line 47) | public JavaCvErrorCallback(boolean showDialog) {
    method JavaCvErrorCallback (line 50) | public JavaCvErrorCallback(boolean showDialog, Component parent) {
    method JavaCvErrorCallback (line 53) | public JavaCvErrorCallback(boolean showDialog, Component parent, int r...
    method call (line 65) | @Override public int call(int status, BytePointer func_name, BytePoint...

FILE: src/main/java/org/bytedeco/javacv/JavaFXFrameConverter.java
  class JavaFXFrameConverter (line 39) | public class JavaFXFrameConverter extends FrameConverter<Image> {
    method convert (line 41) | @Override
    method convert (line 46) | @Override
    class FramePixelReader (line 55) | class FramePixelReader implements PixelReader {
      method FramePixelReader (line 59) | FramePixelReader(Frame f) {
      method getPixelFormat (line 63) | @Override
      method getArgb (line 68) | @Override
      method getColor (line 73) | @Override
      method getPixels (line 78) | @Override
      method getPixels (line 100) | @Override
      method getPixels (line 105) | @Override

FILE: src/main/java/org/bytedeco/javacv/LeptonicaFrameConverter.java
  class LeptonicaFrameConverter (line 42) | public class LeptonicaFrameConverter extends FrameConverter<PIX> {
    method isEqual (line 49) | static boolean isEqual(Frame frame, PIX pix) {
    method convert (line 58) | public PIX convert(Frame frame) {
    method convert (line 91) | public Frame convert(PIX pix) {
    method close (line 155) | @Override public void close() {

FILE: src/main/java/org/bytedeco/javacv/LibgdxFrameConverter.java
  class LibgdxFrameConverter (line 35) | public class LibgdxFrameConverter extends FrameConverter<Pixmap> {
    method convert (line 42) | @Override
    method convert (line 73) | @Override
    method fastConvert (line 107) | public Pixmap fastConvert(Frame frame) {

FILE: src/main/java/org/bytedeco/javacv/MarkedPlane.java
  class MarkedPlane (line 36) | public class MarkedPlane {
    method MarkedPlane (line 38) | public MarkedPlane(int width, int height, Marker[] planeMarkers, doubl...
    method MarkedPlane (line 41) | public MarkedPlane(int width, int height, Marker[] markers,
    method getForegroundColor (line 112) | public CvScalar getForegroundColor() {
    method setForegroundColor (line 115) | public void setForegroundColor(CvScalar foregroundColor) {
    method getBackgroundColor (line 120) | public CvScalar getBackgroundColor() {
    method setBackgroundColor (line 123) | public void setBackgroundColor(CvScalar backgroundColor) {
    method getMarkers (line 128) | public Marker[] getMarkers() {
    method setColors (line 131) | public void setColors(CvScalar foregroundColor, CvScalar backgroundCol...
    method getPrewarp (line 137) | public CvMat getPrewarp() {
    method setPrewarp (line 140) | public void setPrewarp(CvMat prewarp) {
    method getImage (line 161) | public IplImage getImage() {
    method getWidth (line 164) | public int getWidth() {
    method getHeight (line 167) | public int getHeight() {
    method getTotalWarp (line 171) | public double getTotalWarp(Marker[] imagedMarkers, CvMat totalWarp) {
    method getTotalWarp (line 176) | public double getTotalWarp(Marker[] imagedMarkers, CvMat totalWarp, bo...

FILE: src/main/java/org/bytedeco/javacv/Marker.java
  class Marker (line 39) | public class Marker implements Cloneable {
    method Marker (line 40) | public Marker(int id, double[] corners, double confidence) {
    method Marker (line 45) | public Marker(int id, double ... corners) {
    method clone (line 48) | @Override public Marker clone() {
    method hashCode (line 55) | @Override public int hashCode() {
    method equals (line 61) | @Override public boolean equals(Object o) {
    method getCenter (line 69) | public double[] getCenter() {
    method getImage (line 96) | public IplImage getImage() {
    method getImage (line 101) | public static IplImage getImage(int id) {
    method draw (line 110) | public void draw(IplImage image) {
    method draw (line 113) | public void draw(IplImage image, CvScalar color, double scale, CvMat p...
    method draw (line 120) | public void draw(IplImage image, CvScalar color, double scaleX, double...
    class ArraySettings (line 165) | public static class ArraySettings extends BaseChildSettings {
      method getRows (line 170) | public int getRows() {
      method setRows (line 173) | public void setRows(int rows) {
      method getColumns (line 177) | public int getColumns() {
      method setColumns (line 180) | public void setColumns(int columns) {
      method getSizeX (line 184) | public double getSizeX() {
      method setSizeX (line 187) | public void setSizeX(double sizeX) {
      method getSizeY (line 190) | public double getSizeY() {
      method setSizeY (line 193) | public void setSizeY(double sizeY) {
      method getSpacingX (line 197) | public double getSpacingX() {
      method setSpacingX (line 200) | public void setSpacingX(double spacingX) {
      method getSpacingY (line 203) | public double getSpacingY() {
      method setSpacingY (line 206) | public void setSpacingY(double spacingY) {
      method isCheckered (line 210) | public boolean isCheckered() {
      method setCheckered (line 213) | public void setCheckered(boolean checkered) {
    method createArray (line 217) | public static Marker[][] createArray(ArraySettings settings) {
    method createArray (line 220) | public static Marker[][] createArray(ArraySettings settings, double ma...
    method createArray (line 251) | public static Marker[][] createArray(int rows, int columns, double siz...
    method applyWarp (line 261) | public static void applyWarp(Marker[] markers, CvMat warp) {
    method toString (line 270) | @Override public String toString() {

FILE: src/main/java/org/bytedeco/javacv/MarkerDetector.java
  class MarkerDetector (line 39) | public class MarkerDetector {
    method MarkerDetector (line 40) | public MarkerDetector(Settings settings) {
    method MarkerDetector (line 43) | public MarkerDetector() {
    class Settings (line 51) | public static class Settings extends BaseChildSettings {
      method getThresholdWindowMin (line 59) | public int getThresholdWindowMin() {
      method setThresholdWindowMin (line 62) | public void setThresholdWindowMin(int thresholdWindowMin) {
      method getThresholdWindowMax (line 66) | public int getThresholdWindowMax() {
      method setThresholdWindowMax (line 69) | public void setThresholdWindowMax(int thresholdWindowMax) {
      method getThresholdVarMultiplier (line 73) | public double getThresholdVarMultiplier() {
      method setThresholdVarMultiplier (line 76) | public void setThresholdVarMultiplier(double thresholdVarMultiplier) {
      method getThresholdKBlackMarkers (line 80) | public double getThresholdKBlackMarkers() {
      method setThresholdKBlackMarkers (line 83) | public void setThresholdKBlackMarkers(double thresholdKBlackMarkers) {
      method getThresholdKWhiteMarkers (line 87) | public double getThresholdKWhiteMarkers() {
      method setThresholdKWhiteMarkers (line 90) | public void setThresholdKWhiteMarkers(double thresholdKWhiteMarkers) {
      method getSubPixelWindow (line 94) | public int getSubPixelWindow() {
      method setSubPixelWindow (line 97) | public void setSubPixelWindow(int subPixelWindow) {
    method getSettings (line 103) | public Settings getSettings() {
    method setSettings (line 106) | public void setSettings(Settings settings) {
    method getThresholdedImage (line 126) | public IplImage getThresholdedImage() {
    method init (line 130) | private void init(IplImage image) {
    method detect (line 179) | public Marker[] detect(IplImage image, boolean whiteMarkers) {
    method draw (line 279) | public void draw(IplImage image, Marker[] markers) {

FILE: src/main/java/org/bytedeco/javacv/ObjectFinder.java
  class ObjectFinder (line 63) | public class ObjectFinder {
    method ObjectFinder (line 64) | public ObjectFinder(IplImage objectImage) {
    method ObjectFinder (line 69) | public ObjectFinder(Settings settings) {
    class Settings (line 73) | public static class Settings extends BaseChildSettings {
      method getObjectImage (line 81) | public IplImage getObjectImage() {
      method setObjectImage (line 84) | public void setObjectImage(IplImage objectImage) {
      method getDescriptorType (line 88) | public int getDescriptorType() {
      method setDescriptorType (line 91) | public void setDescriptorType(int dtype) {
      method getDescriptorSize (line 95) | public int getDescriptorSize() {
      method setDescriptorSize (line 98) | public void setDescriptorSize(int dsize) {
      method getDescriptorChannels (line 102) | public int getDescriptorChannels() {
      method setDescriptorChannels (line 105) | public void setDescriptorChannels(int dch) {
      method getThreshold (line 109) | public double getThreshold() {
      method setThreshold (line 112) | public void setThreshold(double threshold) {
      method getNOctaves (line 116) | public int getNOctaves() {
      method setNOctaves (line 119) | public void setNOctaves(int nOctaves) {
      method getNOctaveLayers (line 123) | public int getNOctaveLayers() {
      method setNOctaveLayers (line 126) | public void setNOctaveLayers(int nOctaveLayers) {
      method getDistanceThreshold (line 130) | public double getDistanceThreshold() {
      method setDistanceThreshold (line 133) | public void setDistanceThreshold(double distanceThreshold) {
      method getMatchesMin (line 137) | public int getMatchesMin() {
      method setMatchesMin (line 140) | public void setMatchesMin(int matchesMin) {
      method getRansacReprojThreshold (line 144) | public double getRansacReprojThreshold() {
      method setRansacReprojThreshold (line 147) | public void setRansacReprojThreshold(double ransacReprojThreshold) {
      method isUseFLANN (line 151) | public boolean isUseFLANN() {
      method setUseFLANN (line 154) | public void setUseFLANN(boolean useFLANN) {
    method getSettings (line 160) | public Settings getSettings() {
    method setSettings (line 163) | public void setSettings(Settings settings) {
    method find (line 199) | public double[] find(IplImage image) {
    method compareDescriptors (line 231) | int compareDescriptors(ByteBuffer d1, ByteBuffer d2, int best) {
    method naiveNearestNeighbor (line 242) | int naiveNearestNeighbor(ByteBuffer vec, ByteBuffer modelDescriptors) {
    method findPairs (line 263) | void findPairs(Mat objectDescriptors, Mat imageDescriptors) {
    method flannFindPairs (line 278) | void flannFindPairs(Mat objectDescriptors, Mat imageDescriptors) {
    method locatePlanarObject (line 296) | double[] locatePlanarObject(KeyPointVector objectKeypoints, Mat object...
    method main (line 340) | public static void main(String[] args) throws Exception {

FILE: src/main/java/org/bytedeco/javacv/OpenCVFrameConverter.java
  class OpenCVFrameConverter (line 42) | public abstract class OpenCVFrameConverter<F> extends FrameConverter<F> {
    class ToIplImage (line 49) | public static class ToIplImage extends OpenCVFrameConverter<IplImage> {
      method convert (line 50) | @Override public Frame convert(IplImage img) { return super.convert(...
      method convert (line 51) | @Override public IplImage convert(Frame frame) { return convertToIpl...
    class ToMat (line 54) | public static class ToMat extends OpenCVFrameConverter<Mat> {
      method convert (line 55) | @Override public Frame convert(Mat mat) { return super.convert(mat); }
      method convert (line 56) | @Override public Mat convert(Frame frame) { return convertToMat(fram...
    class ToOrgOpenCvCoreMat (line 59) | public static class ToOrgOpenCvCoreMat extends OpenCVFrameConverter<or...
      method convert (line 60) | @Override public Frame convert(org.opencv.core.Mat mat) { return sup...
      method convert (line 61) | @Override public org.opencv.core.Mat convert(Frame frame) { return c...
    method getFrameDepth (line 64) | public static int getFrameDepth(int depth) {
    method getIplImageDepth (line 77) | public static int getIplImageDepth(int depth) {
    method isEqual (line 89) | static boolean isEqual(Frame frame, IplImage img) {
    method convertToIplImage (line 96) | public IplImage convertToIplImage(Frame frame) {
    method convert (line 112) | public Frame convert(IplImage img) {
    method getMatDepth (line 128) | public static int getMatDepth(int depth) {
    method isEqual (line 140) | static boolean isEqual(Frame frame, Mat mat) {
    method convertToMat (line 147) | public Mat convertToMat(Frame frame) {
    method convert (line 162) | public Frame convert(Mat mat) {
    method isEqual (line 178) | static boolean isEqual(Frame frame, org.opencv.core.Mat mat) {
    method convertToOrgOpenCvCoreMat (line 184) | public org.opencv.core.Mat convertToOrgOpenCvCoreMat(Frame frame) {
    method convert (line 198) | public Frame convert(final org.opencv.core.Mat mat) {
    method close (line 236) | @Override public void close() {

FILE: src/main/java/org/bytedeco/javacv/OpenCVFrameGrabber.java
  class OpenCVFrameGrabber (line 42) | public class OpenCVFrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 43) | public static String[] getDeviceDescriptions() throws Exception {
    method createDefault (line 48) | public static OpenCVFrameGrabber createDefault(File deviceFile)   thro...
    method createDefault (line 49) | public static OpenCVFrameGrabber createDefault(String devicePath) thro...
    method createDefault (line 50) | public static OpenCVFrameGrabber createDefault(int deviceNumber)  thro...
    method tryLoad (line 53) | public static void tryLoad() throws Exception {
    method OpenCVFrameGrabber (line 65) | public OpenCVFrameGrabber(int deviceNumber) {
    method OpenCVFrameGrabber (line 68) | public OpenCVFrameGrabber(File file) {
    method OpenCVFrameGrabber (line 71) | public OpenCVFrameGrabber(File file, int apiPreference) {
    method OpenCVFrameGrabber (line 74) | public OpenCVFrameGrabber(String filename) {
    method OpenCVFrameGrabber (line 77) | public OpenCVFrameGrabber(String filename, int apiPreference) {
    method release (line 82) | public void release() throws Exception {
    method finalize (line 85) | @Override protected void finalize() throws Throwable {
    method getGamma (line 98) | @Override public double getGamma() {
    method getFormat (line 107) | @Override public String getFormat() {
    method getImageWidth (line 119) | @Override public int getImageWidth() {
    method getImageHeight (line 127) | @Override public int getImageHeight() {
    method getPixelFormat (line 135) | @Override public int getPixelFormat() {
    method getFrameRate (line 139) | @Override public double getFrameRate() {
    method setImageMode (line 143) | @Override public void setImageMode(ImageMode imageMode) {
    method getFrameNumber (line 150) | @Override public int getFrameNumber() {
    method setFrameNumber (line 154) | @Override public void setFrameNumber(int frameNumber) throws Exception {
    method getTimestamp (line 164) | @Override public long getTimestamp() {
    method setTimestamp (line 168) | @Override public void setTimestamp(long timestamp) throws Exception {
    method getLengthInFrames (line 178) | @Override public int getLengthInFrames() {
    method getLengthInTime (line 182) | @Override public long getLengthInTime() {
    method getOption (line 186) | public double getOption(int propId) {
    method setOption (line 198) | public void setOption(int propId, double value) {
    method start (line 205) | public void start() throws Exception {
    method stop (line 275) | public void stop() throws Exception {
    method trigger (line 282) | public void trigger() throws Exception {
    method grab (line 292) | public Frame grab() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/OpenCVFrameRecorder.java
  class OpenCVFrameRecorder (line 39) | public class OpenCVFrameRecorder extends FrameRecorder {
    method createDefault (line 40) | public static OpenCVFrameRecorder createDefault(File f, int w, int h) ...
    method createDefault (line 41) | public static OpenCVFrameRecorder createDefault(String f, int w, int h...
    method tryLoad (line 44) | public static void tryLoad() throws Exception {
    method OpenCVFrameRecorder (line 56) | public OpenCVFrameRecorder(File file, int imageWidth, int imageHeight) {
    method OpenCVFrameRecorder (line 59) | public OpenCVFrameRecorder(String filename, int imageWidth, int imageH...
    method release (line 69) | public void release() throws Exception {
    method finalize (line 75) | @Override protected void finalize() throws Throwable {
    method getOption (line 85) | public double getOption(int propId) {
    method setOption (line 97) | public void setOption(int propId, double value) {
    method start (line 104) | public void start() throws Exception {
    method isColour (line 115) | private boolean isColour() {
    method fourCCCodec (line 122) | private int fourCCCodec() {
    method flush (line 126) | public void flush() throws Exception {
    method stop (line 129) | public void stop() throws Exception {
    method record (line 133) | public void record(Frame frame) throws Exception {

FILE: src/main/java/org/bytedeco/javacv/OpenKinect2FrameGrabber.java
  class OpenKinect2FrameGrabber (line 41) | public class OpenKinect2FrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 43) | public static String[] getDeviceDescriptions() throws FrameGrabber.Exc...
    method getByteOrder (line 68) | public ByteOrder getByteOrder() {
    method setByteOrder (line 72) | public void setByteOrder(ByteOrder byteOrder) {
    method createDefault (line 76) | public static OpenKinect2FrameGrabber createDefault(int deviceNumber) ...
    method createDefault (line 80) | public static OpenKinect2FrameGrabber createDefault(File deviceFile) t...
    method createDefault (line 84) | public static OpenKinect2FrameGrabber createDefault(String devicePath)...
    method tryLoad (line 91) | public static void tryLoad() throws FrameGrabber.Exception {
    method OpenKinect2FrameGrabber (line 120) | public OpenKinect2FrameGrabber(int deviceNumber) {
    method enableColorStream (line 124) | public void enableColorStream() {
    method enableDepthStream (line 131) | public void enableDepthStream() {
    method enableIRStream (line 138) | public void enableIRStream() {
    method release (line 145) | public void release() throws FrameGrabber.Exception {
    method finalize (line 148) | @Override
    method start (line 154) | @Override
    method startDevice (line 159) | public void startDevice(PacketPipeline pipeline) throws FrameGrabber.E...
    method stop (line 203) | @Override
    method grabVideo (line 216) | protected void grabVideo() {
    method grabIR (line 238) | protected void grabIR() {
    method grabDepth (line 262) | protected void grabDepth() {
    method grab (line 289) | public Frame grab() throws Exception {
    method getVideoImage (line 311) | public IplImage getVideoImage() {
    method getIRImage (line 316) | public IplImage getIRImage() {
    method getDepthImage (line 320) | public IplImage getDepthImage() {
    method trigger (line 324) | @Override
    method getDepthImageWidth (line 329) | public int getDepthImageWidth() {
    method setDepthImageWidth (line 333) | public void setDepthImageWidth(int depthImageWidth) {
    method getDepthImageHeight (line 337) | public int getDepthImageHeight() {
    method setDepthImageHeight (line 341) | public void setDepthImageHeight(int depthImageHeight) {
    method getIRImageWidth (line 345) | public int getIRImageWidth() {
    method setIRImageWidth (line 349) | public void setIRImageWidth(int IRImageWidth) {
    method getIRImageHeight (line 353) | public int getIRImageHeight() {
    method setIRImageHeight (line 357) | public void setIRImageHeight(int IRImageHeight) {
    method getDepthFrameRate (line 361) | public int getDepthFrameRate() {
    method setDepthFrameRate (line 365) | public void setDepthFrameRate(int frameRate) {

FILE: src/main/java/org/bytedeco/javacv/OpenKinectFrameGrabber.java
  class OpenKinectFrameGrabber (line 44) | public class OpenKinectFrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 45) | public static String[] getDeviceDescriptions() throws Exception {
    method createDefault (line 71) | public static OpenKinectFrameGrabber createDefault(File deviceFile)   ...
    method createDefault (line 72) | public static OpenKinectFrameGrabber createDefault(String devicePath) ...
    method createDefault (line 73) | public static OpenKinectFrameGrabber createDefault(int deviceNumber)  ...
    method tryLoad (line 76) | public static void tryLoad() throws Exception {
    method OpenKinectFrameGrabber (line 88) | public OpenKinectFrameGrabber(int deviceNumber) {
    method release (line 91) | public void release() throws Exception {
    method finalize (line 94) | @Override protected void finalize() throws Throwable {
    method getByteOrder (line 111) | public ByteOrder getByteOrder() {
    method setByteOrder (line 114) | public void setByteOrder(ByteOrder byteOrder) {
    method getDepthFormat (line 118) | public int getDepthFormat() {
    method setDepthFormat (line 121) | public void setDepthFormat(int depthFormat) {
    method getVideoFormat (line 125) | public int getVideoFormat() {
    method setVideoFormat (line 128) | public void setVideoFormat(int videoFormat) {
    method getGamma (line 132) | @Override public double getGamma() {
    method setImageMode (line 141) | @Override public void setImageMode(ImageMode imageMode) {
    method start (line 148) | public void start() throws Exception {
    method stop (line 152) | public void stop() throws Exception {
    method trigger (line 156) | public void trigger() throws Exception {
    method grabDepth (line 174) | public IplImage grabDepth() throws Exception {
    method grabVideo (line 211) | public IplImage grabVideo() throws Exception {
    method grabIR (line 252) | public IplImage grabIR() throws Exception {
    method grab (line 270) | public Frame grab() throws Exception {

FILE: src/main/java/org/bytedeco/javacv/PS3EyeFrameGrabber.java
  class PS3EyeFrameGrabber (line 68) | public class PS3EyeFrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 69) | public static String[] getDeviceDescriptions() throws Exception {
    method createDefault (line 78) | public static PS3EyeFrameGrabber createDefault(File deviceFile)   thro...
    method createDefault (line 79) | public static PS3EyeFrameGrabber createDefault(String devicePath) thro...
    method createDefault (line 80) | public static PS3EyeFrameGrabber createDefault(int deviceNumber)  thro...
    method tryLoad (line 83) | public static void tryLoad() throws Exception {
    type Triggered (line 109) | protected enum Triggered {NO_TRIGGER, HAS_FRAME, NO_FRAME}
    method PS3EyeFrameGrabber (line 116) | public PS3EyeFrameGrabber() throws Exception {
    method PS3EyeFrameGrabber (line 123) | public PS3EyeFrameGrabber(int cameraIndex) throws Exception {
    method PS3EyeFrameGrabber (line 127) | public PS3EyeFrameGrabber(int cameraIndex, int imageWidth, int imageHe...
    method PS3EyeFrameGrabber (line 140) | public PS3EyeFrameGrabber(int cameraIndex, int imageWidth, int imageHe...
    method getCameraCount (line 171) | public static int getCameraCount() {
    method listPS3Cameras (line 180) | public static String[] listPS3Cameras() {
    method makeImage (line 198) | public IplImage makeImage(int[] frame) {
    method grab_raw (line 208) | public int[] grab_raw() {
    method trigger (line 215) | public void trigger() throws Exception {
    method grab_RGB4 (line 236) | public IplImage grab_RGB4() {
    method grab (line 252) | @Override
    method start (line 280) | public void start() throws Exception {
    method stop (line 306) | public void stop() throws Exception {
    method release (line 318) | public void release() {
    method dispose (line 342) | public void dispose() {
    method finalize (line 346) | @Override protected void finalize() throws Throwable {
    method getCamera (line 358) | public CLCamera getCamera() { return camera; }
    method getUUID (line 360) | public String getUUID() { return uuid; }
    method toString (line 365) | @Override public String toString() {
    method main (line 378) | public static void main(String[] argv) {

FILE: src/main/java/org/bytedeco/javacv/Parallel.java
  class Parallel (line 33) | public class Parallel {
    method getNumThreads (line 37) | public static int getNumThreads() {
    method setNumThreads (line 48) | public static void setNumThreads(int numThreads) {
    method getNumCores (line 52) | public static int getNumCores() {
    method run (line 56) | public static void run(Runnable ... runnables) {
    type Looper (line 86) | public interface Looper {
      method loop (line 87) | void loop(int from, int to, int looperID);
    method loop (line 90) | public static void loop(int from, int to, final Looper looper) {
    method loop (line 93) | public static void loop(int from, int to, int numThreads, final Looper...

FILE: src/main/java/org/bytedeco/javacv/ProCamColorCalibrator.java
  class ProCamColorCalibrator (line 36) | public class ProCamColorCalibrator {
    method ProCamColorCalibrator (line 38) | public ProCamColorCalibrator(Settings settings, MarkerDetector.Setting...
    class Settings (line 68) | public static class Settings extends BaseChildSettings {
      method getSamplesPerChannel (line 73) | public int getSamplesPerChannel() {
      method setSamplesPerChannel (line 76) | public void setSamplesPerChannel(int samplesPerChannel) {
      method getDetectedBoardMin (line 87) | public double getDetectedBoardMin() {
      method setDetectedBoardMin (line 90) | public void setDetectedBoardMin(double detectedBoardMin) {
    method getColorCount (line 109) | public int getColorCount() {
    method getProjectorColors (line 113) | public Color[] getProjectorColors() {
    method getProjectorColor (line 130) | public Color getProjectorColor() {
    method getCameraColors (line 134) | public Color[] getCameraColors() {
    method getCameraColor (line 137) | public Color getCameraColor() {
    method addCameraColor (line 141) | public void addCameraColor() {
    method addCameraColor (line 144) | public void addCameraColor(Color color) {
    method getMaskImage (line 148) | public IplImage getMaskImage() {
    method getUndistortedCameraImage (line 151) | public IplImage getUndistortedCameraImage() {
    method processCameraImage (line 199) | public boolean processCameraImage(IplImage cameraImage) {
    method calibrate (line 321) | public double calibrate() {

FILE: src/main/java/org/bytedeco/javacv/ProCamGeometricCalibrator.java
  class ProCamGeometricCalibrator (line 38) | public class ProCamGeometricCalibrator {
    method ProCamGeometricCalibrator (line 39) | public ProCamGeometricCalibrator(Settings settings, MarkerDetector.Set...
    method ProCamGeometricCalibrator (line 47) | @SuppressWarnings("unchecked")
    class Settings (line 113) | public static class Settings extends GeometricCalibrator.Settings {
      method getDetectedProjectorMin (line 118) | public double getDetectedProjectorMin() {
      method setDetectedProjectorMin (line 121) | public void setDetectedProjectorMin(double detectedProjectorMin) {
      method isUseOnlyIntersection (line 125) | public boolean isUseOnlyIntersection() {
      method setUseOnlyIntersection (line 128) | public void setUseOnlyIntersection(boolean useOnlyIntersection) {
      method getPrewarpUpdateErrorMax (line 132) | public double getPrewarpUpdateErrorMax() {
      method setPrewarpUpdateErrorMax (line 135) | public void setPrewarpUpdateErrorMax(double prewarpUpdateErrorMax) {
    method getBoardPlane (line 162) | public MarkedPlane getBoardPlane() {
    method getProjectorPlane (line 165) | public MarkedPlane getProjectorPlane() {
    method getCameraCalibrators (line 168) | public GeometricCalibrator[] getCameraCalibrators() {
    method getProjectorCalibrator (line 171) | public GeometricCalibrator getProjectorCalibrator() {
    method getImageCount (line 174) | public int getImageCount() {
    method processCameraImage (line 182) | public Marker[][] processCameraImage(IplImage cameraImage) {
    method processCameraImage (line 185) | public Marker[][] processCameraImage(IplImage cameraImage, final int c...
    method drawMarkers (line 243) | public void drawMarkers(IplImage image) {
    method drawMarkers (line 246) | public void drawMarkers(IplImage image, int cameraNumber) {
    method processMarkers (line 253) | public boolean processMarkers() {
    method processMarkers (line 256) | public boolean processMarkers(int cameraNumber) {
    method processMarkers (line 260) | public boolean processMarkers(Marker[] imagedBoardMarkers, Marker[] im...
    method processMarkers (line 263) | public boolean processMarkers(Marker[] imagedBoardMarkers,
    method addMarkers (line 304) | public void addMarkers() throws InterruptedException {
    method addMarkers (line 307) | public void addMarkers(int cameraNumber) throws InterruptedException {
    method addMarkers (line 310) | public void addMarkers(Marker[] imagedBoardMarkers, Marker[] imagedPro...
    method addMarkers (line 315) | public void addMarkers(Marker[] imagedBoardMarkers,
    method getProjectorImage (line 377) | public IplImage getProjectorImage() {
    method calibrate (line 400) | public double[] calibrate(boolean useCenters, boolean calibrateCameras) {
    method calibrate (line 403) | @SuppressWarnings("unchecked")

FILE: src/main/java/org/bytedeco/javacv/ProCamTransformer.java
  class ProCamTransformer (line 37) | public class ProCamTransformer implements ImageTransformer {
    method ProCamTransformer (line 38) | public ProCamTransformer(double[] referencePoints,
    method ProCamTransformer (line 42) | public ProCamTransformer(double[] referencePoints,
    method getNumGains (line 88) | public int getNumGains() {
    method getNumBiases (line 91) | public int getNumBiases() {
    method getFillColor (line 95) | public CvScalar getFillColor() {
    method setFillColor (line 98) | public void setFillColor(CvScalar fillColor) {
    method getSurfaceTransformer (line 102) | public ProjectiveColorTransformer getSurfaceTransformer() {
    method getProjectorTransformer (line 105) | public ProjectiveColorTransformer getProjectorTransformer() {
    method getProjectorImage (line 109) | public IplImage getProjectorImage(int pyramidLevel) {
    method setProjectorImage (line 112) | public void setProjectorImage(IplImage projectorImage0, int minLevel, ...
    method setProjectorImage (line 115) | public void setProjectorImage(IplImage projectorImage0, int minLevel, ...
    method getSurfaceImage (line 168) | public IplImage getSurfaceImage(int pyramidLevel) {
    method setSurfaceImage (line 171) | public void setSurfaceImage(IplImage surfaceImage0, int pyramidLevels) {
    method prepareTransforms (line 192) | protected void prepareTransforms(CvMat H1, CvMat H2, CvMat X, int pyra...
    method transform (line 226) | public void transform(final IplImage srcImage, final IplImage dstImage...
    method transform (line 263) | public void transform(CvMat srcPts, CvMat dstPts, ImageTransformer.Par...
    method transform (line 271) | public void transform(Data[] data, CvRect roi, ImageTransformer.Parame...
    method createParameters (line 340) | public Parameters createParameters() {
    class Parameters (line 344) | public class Parameters implements ImageTransformer.Parameters {
      method Parameters (line 345) | protected Parameters() {
      method Parameters (line 348) | protected Parameters(ProjectiveColorTransformer.Parameters surfacePa...
      method getSurfaceParameters (line 359) | public ProjectiveColorTransformer.Parameters getSurfaceParameters() {
      method getProjectorParameters (line 362) | public ProjectiveColorTransformer.Parameters getProjectorParameters() {
      method getSizeForSurface (line 366) | private int getSizeForSurface() {
      method getSizeForProjector (line 370) | private int getSizeForProjector() {
      method size (line 373) | public int size() {
      method get (line 376) | public double[] get() {
      method get (line 383) | public double get(int i) {
      method set (line 390) | public void set(double ... p) {
      method set (line 395) | public void set(int i, double p) {
      method set (line 402) | public void set(ImageTransformer.Parameters p) {
      method reset (line 410) | public void reset(boolean asIdentity) {
      method reset (line 413) | public void reset(ProjectiveColorTransformer.Parameters surfaceParam...
      method getConstraintError (line 443) | public double getConstraintError() {
      method compose (line 448) | public void compose(ImageTransformer.Parameters p1, boolean inverse1,
      method preoptimize (line 453) | public boolean preoptimize() {
      method setSubspace (line 463) | public void setSubspace(double ... p) {
      method getSubspace (line 469) | public double[] getSubspace() {
      method setSubspaceInternal (line 473) | private double[] setSubspaceInternal(double ... p) {
      method getSubspaceInternal (line 511) | private double[] getSubspaceInternal() {
      method getN (line 526) | public CvMat getN() {
      method getN0 (line 546) | public CvMat getN0() {
      method clone (line 571) | @Override public Parameters clone() {
      method toString (line 578) | @Override public String toString() {

FILE: src/main/java/org/bytedeco/javacv/ProCamTransformerCL.java
  class ProCamTransformerCL (line 41) | public class ProCamTransformerCL extends ProCamTransformer implements Im...
    method ProCamTransformerCL (line 42) | public ProCamTransformerCL(JavaCVCL context, double[] referencePoints,
    method ProCamTransformerCL (line 46) | public ProCamTransformerCL(JavaCVCL context, double[] referencePoints,
    method getContext (line 80) | public JavaCVCL getContext() {
    method getSurfaceTransformerCL (line 84) | public ProjectiveColorTransformerCL getSurfaceTransformerCL() {
    method getProjectorTransformerCL (line 87) | public ProjectiveColorTransformerCL getProjectorTransformerCL() {
    method getProjectorImageCL (line 91) | public CLImage2d getProjectorImageCL(int pyramidLevel) {
    method setProjectorImageCL (line 94) | public void setProjectorImageCL(CLImage2d projectorImage0, int minPyra...
    method getSurfaceImageCL (line 109) | public CLImage2d getSurfaceImageCL(int pyramidLevel) {
    method setSurfaceImageCL (line 112) | public void setSurfaceImageCL(CLImage2d surfaceImage0, int pyramidLeve...
    method prepareTransforms (line 128) | protected void prepareTransforms(CLBuffer H1Buffer, CLBuffer H2Buffer,...
    method transform (line 156) | @Override public void transform(CLImage2d srcImg, CLImage2d subImg, CL...

FILE: src/main/java/org/bytedeco/javacv/ProjectiveColorTransformer.java
  class ProjectiveColorTransformer (line 35) | public class ProjectiveColorTransformer extends ProjectiveTransformer {
    method ProjectiveColorTransformer (line 36) | public ProjectiveColorTransformer(CvMat K1, CvMat K2, CvMat R, CvMat t,
    method getX (line 56) | public CvMat getX() {
    method getNumGains (line 59) | public int getNumGains() {
    method getNumBiases (line 62) | public int getNumBiases() {
    method transformColor (line 66) | public void transformColor(IplImage srcImage, IplImage dstImage, CvRec...
    method prepareColorTransform (line 94) | protected void prepareColorTransform(CvMat X2, int pyramidLevel, Param...
    method transform (line 123) | @Override public void transform(Data[] data, CvRect roi, ImageTransfor...
    method createParameters (line 179) | @Override public Parameters createParameters() {
    class Parameters (line 183) | public class Parameters extends ProjectiveTransformer.Parameters {
      method Parameters (line 184) | protected Parameters() {
      method getColorParameters (line 219) | public double[] getColorParameters() {
      method getIdentityColorParameters (line 222) | public double[] getIdentityColorParameters() {
      method size (line 226) | @Override public int size() {
      method get (line 229) | @Override public double get(int i) {
      method set (line 237) | @Override public void set(int i, double p) {
      method reset (line 248) | @Override public void reset(boolean asIdentity) {
      method resetColor (line 252) | public void resetColor(boolean asIdentity) {
      method compose (line 277) | @Override public void compose(ImageTransformer.Parameters p1, boolea...
      method composeColor (line 282) | public void composeColor(ImageTransformer.Parameters p1, boolean inv...
      method getA (line 337) | public CvMat getA() {
      method getB (line 341) | public CvMat getB() {
      method update (line 346) | @Override protected void update() {
      method clone (line 375) | @Override public Parameters clone() {

FILE: src/main/java/org/bytedeco/javacv/ProjectiveColorTransformerCL.java
  class ProjectiveColorTransformerCL (line 38) | public class ProjectiveColorTransformerCL extends ProjectiveColorTransfo...
    method ProjectiveColorTransformerCL (line 39) | public ProjectiveColorTransformerCL(JavaCVCL context, CvMat K1, CvMat ...
    method getContext (line 63) | public JavaCVCL getContext() {
    method prepareHomographies (line 67) | protected void prepareHomographies(CLBuffer HBuffer, int pyramidLevel,
    method prepareColorTransforms (line 81) | protected void prepareColorTransforms(CLBuffer XBuffer, int pyramidLevel,
    method transform (line 95) | @Override public void transform(CLImage2d srcImg, CLImage2d subImg, CL...

FILE: src/main/java/org/bytedeco/javacv/ProjectiveDevice.java
  class ProjectiveDevice (line 41) | public class ProjectiveDevice {
    method ProjectiveDevice (line 42) | public ProjectiveDevice(String name) {
    method ProjectiveDevice (line 47) | public ProjectiveDevice(String name, File file) throws Exception {
    method ProjectiveDevice (line 51) | public ProjectiveDevice(String name, String filename) throws Exception {
    method ProjectiveDevice (line 55) | public ProjectiveDevice(String name, FileStorage fs) throws Exception {
    method ProjectiveDevice (line 59) | public ProjectiveDevice(Settings settings) throws Exception {
    class Settings (line 66) | public static class Settings extends BaseChildSettings {
      method Settings (line 67) | public Settings() { }
      method Settings (line 68) | public Settings(ProjectiveDevice.Settings settings) {
      method getName (line 77) | @Override public String getName() {
      method setName (line 80) | public void setName(String name) {
      method getResponseGamma (line 84) | public double getResponseGamma() {
      method setResponseGamma (line 87) | public void setResponseGamma(double responseGamma) {
    class CalibrationSettings (line 99) | public static class CalibrationSettings extends Settings {
      method CalibrationSettings (line 100) | public CalibrationSettings() { }
      method CalibrationSettings (line 101) | public CalibrationSettings(ProjectiveDevice.CalibrationSettings sett...
      method getInitAspectRatio (line 111) | public double getInitAspectRatio() {
      method setInitAspectRatio (line 114) | public void setInitAspectRatio(double initAspectRatio) {
      method isUseIntrinsicGuess (line 118) | public boolean isUseIntrinsicGuess() {
      method setUseIntrinsicGuess (line 121) | public void setUseIntrinsicGuess(boolean useIntrinsicGuess) {
      method isFixAspectRatio (line 129) | public boolean isFixAspectRatio() {
      method setFixAspectRatio (line 132) | public void setFixAspectRatio(boolean fixAspectRatio) {
      method isFixPrincipalPoint (line 140) | public boolean isFixPrincipalPoint() {
      method setFixPrincipalPoint (line 143) | public void setFixPrincipalPoint(boolean fixPrincipalPoint) {
      method isZeroTangentDist (line 151) | public boolean isZeroTangentDist() {
      method setZeroTangentDist (line 154) | public void setZeroTangentDist(boolean zeroTangentDist) {
      method isFixFocalLength (line 162) | public boolean isFixFocalLength() {
      method setFixFocalLength (line 165) | public void setFixFocalLength(boolean fixFocalLength) {
      method isFixK1 (line 173) | public boolean isFixK1() {
      method setFixK1 (line 176) | public void setFixK1(boolean fixK1) {
      method isFixK2 (line 184) | public boolean isFixK2() {
      method setFixK2 (line 187) | public void setFixK2(boolean fixK2) {
      method isFixK3 (line 195) | public boolean isFixK3() {
      method setFixK3 (line 198) | public void setFixK3(boolean fixK3) {
      method isFixK4 (line 206) | public boolean isFixK4() {
      method setFixK4 (line 209) | public void setFixK4(boolean fixK4) {
      method isFixK5 (line 217) | public boolean isFixK5() {
      method setFixK5 (line 220) | public void setFixK5(boolean fixK5) {
      method isFixK6 (line 228) | public boolean isFixK6() {
      method setFixK6 (line 231) | public void setFixK6(boolean fixK6) {
      method isRationalModel (line 239) | public boolean isRationalModel() {
      method setRationalModel (line 242) | public void setRationalModel(boolean rationalModel) {
      method isStereoFixIntrinsic (line 250) | public boolean isStereoFixIntrinsic() {
      method setStereoFixIntrinsic (line 253) | public void setStereoFixIntrinsic(boolean stereoFixIntrinsic) {
      method isStereoSameFocalLength (line 261) | public boolean isStereoSameFocalLength() {
      method setStereoSameFocalLength (line 264) | public void setStereoSameFocalLength(boolean stereoSameFocalLength) {
    class CalibratedSettings (line 273) | public static class CalibratedSettings extends Settings {
      method CalibratedSettings (line 274) | public CalibratedSettings() { }
      method CalibratedSettings (line 275) | public CalibratedSettings(ProjectiveDevice.CalibratedSettings settin...
      method getParametersFile (line 281) | public File getParametersFile() {
      method setParametersFile (line 284) | public void setParametersFile(File parametersFile) {
      method getParametersFilename (line 287) | public String getParametersFilename() {
      method setParametersFilename (line 290) | public void setParametersFilename(String parametersFilename) {
    method getSettings (line 297) | public Settings getSettings() {
    method setSettings (line 300) | public void setSettings(Settings settings) {
    method rescale (line 318) | public void rescale(int imageWidth, int imageHeight) {
    method getRGBColorOrder (line 336) | public int[] getRGBColorOrder() {
    method undistort (line 375) | public static double[] undistort(double[] xd, double[] k) {
    method undistort (line 403) | public double[] undistort(double ... x) {
    method distort (line 409) | public static double[] distort(double[] xu, double[] k) {
    method distort (line 434) | public double[] distort(double ... x) {
    method normalize (line 440) | public static double[] normalize(double[] xu, CvMat K) {
    method unnormalize (line 454) | public static double[] unnormalize(double[] xn, CvMat K) {
    method isFixedPointMaps (line 476) | public boolean isFixedPointMaps() {
    method setFixedPointMaps (line 479) | public void setFixedPointMaps(boolean fixedPointMaps) {
    method getMapsPyramidLevel (line 487) | public int getMapsPyramidLevel() {
    method setMapsPyramidLevel (line 490) | public void setMapsPyramidLevel(int mapsPyramidLevel) {
    method initUndistortMaps (line 504) | private void initUndistortMaps() {
    method getUndistortMap1 (line 561) | public IplImage getUndistortMap1() {
    method getUndistortMap2 (line 565) | public IplImage getUndistortMap2() {
    method undistort (line 569) | public void undistort(IplImage src, IplImage dst) {
    method undistort (line 576) | public IplImage undistort(IplImage image) {
    method initDistortMaps (line 588) | private void initDistortMaps() {
    method getDistortMap1 (line 626) | public IplImage getDistortMap1() {
    method getDistortMap2 (line 630) | public IplImage getDistortMap2() {
    method distort (line 634) | public void distort(IplImage src, IplImage dst) {
    method distort (line 641) | public IplImage distort(IplImage image) {
    method getBackProjectionMatrix (line 658) | public CvMat getBackProjectionMatrix(CvMat n, double d, CvMat B) {
    method getFrontoParallelH (line 687) | public CvMat getFrontoParallelH(double[] roipts, CvMat n, CvMat H) {
    method getRectifyingHomography (line 731) | public CvMat getRectifyingHomography(ProjectiveDevice peer, CvMat H) {
    class Exception (line 752) | public static class Exception extends java.lang.Exception {
      method Exception (line 753) | public Exception(String message) { super(message); }
      method Exception (line 754) | public Exception(String message, Throwable cause) { super(message, c...
    method read (line 757) | public static ProjectiveDevice[] read(String filename) throws Exception {
    method write (line 773) | public static void write(String filename, ProjectiveDevice[] ... devic...
    method write (line 787) | public static void write(String filename, ProjectiveDevice ... devices) {
    method writeParameters (line 812) | public void writeParameters(File file) {
    method writeParameters (line 815) | public void writeParameters(String filename) {
    method writeParameters (line 820) | public void writeParameters(FileStorage fs) {
    method readParameters (line 861) | public void readParameters(File file) throws Exception {
    method readParameters (line 864) | public void readParameters(String filename) throws Exception {
    method readParameters (line 869) | public void readParameters(FileStorage fs) throws Exception {
    method toString (line 918) | @Override public String toString() {

FILE: src/main/java/org/bytedeco/javacv/ProjectiveTransformer.java
  class ProjectiveTransformer (line 37) | public class ProjectiveTransformer implements ImageTransformer {
    method ProjectiveTransformer (line 38) | public ProjectiveTransformer() {
    method ProjectiveTransformer (line 41) | public ProjectiveTransformer(double[] referencePoints) {
    method ProjectiveTransformer (line 44) | public ProjectiveTransformer(ProjectiveDevice d1, ProjectiveDevice d2,...
    method ProjectiveTransformer (line 49) | public ProjectiveTransformer(CvMat K1, CvMat K2, CvMat R, CvMat t, CvM...
    method getFillColor (line 80) | public CvScalar getFillColor() {
    method setFillColor (line 83) | public void setFillColor(CvScalar fillColor) {
    method getReferencePoints1 (line 87) | public double[] getReferencePoints1() {
    method getReferencePoints2 (line 90) | public double[] getReferencePoints2() {
    method getK1 (line 93) | public CvMat getK1() {
    method getK2 (line 96) | public CvMat getK2() {
    method getInvK1 (line 99) | public CvMat getInvK1() {
    method getInvK2 (line 102) | public CvMat getInvK2() {
    method getR (line 105) | public CvMat getR() {
    method getT (line 108) | public CvMat getT() {
    method getN (line 111) | public CvMat getN() {
    method prepareHomography (line 115) | protected void prepareHomography(CvMat H, int pyramidLevel, Parameters...
    method transform (line 139) | public void transform(IplImage srcImage, IplImage dstImage, CvRect roi...
    method transform (line 185) | public void transform(CvMat srcPts, CvMat dstPts, ImageTransformer.Par...
    method transform (line 197) | public void transform(Data[] data, CvRect roi, ImageTransformer.Parame...
    method createParameters (line 246) | public Parameters createParameters() {
    class Parameters (line 250) | public class Parameters implements ImageTransformer.Parameters {
      method Parameters (line 251) | protected Parameters() {
      method isUpdateNeeded (line 261) | public boolean isUpdateNeeded() {
      method setUpdateNeeded (line 264) | public void setUpdateNeeded(boolean updateNeeded) {
      method size (line 268) | public int size() {
      method get (line 271) | public double[] get() {
      method get (line 278) | public double get(int i) {
      method set (line 281) | public void set(double ... p) {
      method set (line 286) | public void set(int i, double p) {
      method set (line 292) | public void set(ImageTransformer.Parameters p) {
      method reset (line 296) | public void reset(boolean asIdentity) {
      method getConstraintError (line 348) | public double getConstraintError() {
      method set (line 352) | public void set(CvMat setH, boolean inverse) {
      method compose (line 375) | public void compose(ImageTransformer.Parameters p1, boolean inverse1,
      method compose (line 386) | public void compose(CvMat H1, boolean inverse1, CvMat H2, boolean in...
      method getH (line 402) | public CvMat getH() {
      method getN (line 406) | public CvMat getN() {
      method getR (line 410) | public CvMat getR() {
      method getT (line 414) | public CvMat getT() {
      method update (line 419) | protected void update() {
      method preoptimize (line 524) | public boolean preoptimize() {
      method getSubspace (line 527) | public double[] getSubspace() {
      method setSubspace (line 530) | public void setSubspace(double ... p) {
      method clone (line 533) | @Override public Parameters clone() {
      method toString (line 539) | @Override public String toString() {

FILE: src/main/java/org/bytedeco/javacv/ProjectiveTransformerCL.java
  class ProjectiveTransformerCL (line 38) | public class ProjectiveTransformerCL extends ProjectiveTransformer imple...
    method ProjectiveTransformerCL (line 39) | public ProjectiveTransformerCL(JavaCVCL context) {
    method ProjectiveTransformerCL (line 42) | public ProjectiveTransformerCL(JavaCVCL context, double[] referencePoi...
    method ProjectiveTransformerCL (line 45) | public ProjectiveTransformerCL(JavaCVCL context, ProjectiveDevice d1, ...
    method ProjectiveTransformerCL (line 50) | public ProjectiveTransformerCL(JavaCVCL context, CvMat K1, CvMat K2, C...
    method getContext (line 72) | public JavaCVCL getContext() {
    method prepareHomographies (line 76) | protected void prepareHomographies(CLBuffer HBuffer, int pyramidLevel,
    method transform (line 90) | public void transform(CLImage2d srcImg, CLImage2d subImg, CLImage2d sr...

FILE: src/main/java/org/bytedeco/javacv/ProjectorDevice.java
  class ProjectorDevice (line 38) | public class ProjectorDevice extends ProjectiveDevice {
    method ProjectorDevice (line 39) | public ProjectorDevice(String name) {
    method ProjectorDevice (line 42) | public ProjectorDevice(String name, String filename) throws Exception {
    method ProjectorDevice (line 47) | public ProjectorDevice(String name, FileStorage fs) throws Exception {
    method ProjectorDevice (line 52) | public ProjectorDevice(Settings settings) throws Exception {
    type Settings (line 56) | public interface Settings {
      method getName (line 57) | String getName();
      method setName (line 58) | void setName(String name);
      method getResponseGamma (line 59) | double getResponseGamma();
      method setResponseGamma (line 60) | void setResponseGamma(double gamma);
      method getScreenNumber (line 62) | int getScreenNumber();
      method setScreenNumber (line 63) | void setScreenNumber(int screenNumber);
      method getLatency (line 64) | long getLatency();
      method setLatency (line 65) | void setLatency(long latency);
      method getDescription (line 66) | String getDescription();
      method getImageWidth (line 68) | int getImageWidth();
      method setImageWidth (line 69) | void setImageWidth(int imageWidth);
      method getImageHeight (line 70) | int getImageHeight();
      method setImageHeight (line 71) | void setImageHeight(int imageHeight);
      method getBitDepth (line 72) | int getBitDepth();
      method setBitDepth (line 73) | void setBitDepth(int bitDepth);
      method getRefreshRate (line 74) | int getRefreshRate();
      method setRefreshRate (line 75) | void setRefreshRate(int refreshRate);
      method isUseOpenGL (line 77) | boolean isUseOpenGL();
      method setUseOpenGL (line 78) | void setUseOpenGL(boolean useOpenGL);
      method addPropertyChangeListener (line 80) | void addPropertyChangeListener(PropertyChangeListener listener);
      method removePropertyChangeListener (line 81) | void removePropertyChangeListener(PropertyChangeListener listener);
    class SettingsImplementation (line 84) | public static class SettingsImplementation extends ProjectiveDevice.Se...
      method SettingsImplementation (line 85) | public SettingsImplementation() { name = "Projector  0"; setScreenNu...
      method SettingsImplementation (line 86) | public SettingsImplementation(ProjectiveDevice.Settings settings) {
      method getScreenNumber (line 103) | public int getScreenNumber() {
      method setScreenNumber (line 106) | public void setScreenNumber(int screenNumber) {
      method getLatency (line 118) | public long getLatency() {
      method setLatency (line 121) | public void setLatency(long latency) {
      method getDescription (line 125) | public String getDescription() {
      method getImageWidth (line 138) | public int getImageWidth() {
      method setImageWidth (line 141) | public void setImageWidth(int imageWidth) {
      method getImageHeight (line 145) | public int getImageHeight() {
      method setImageHeight (line 148) | public void setImageHeight(int imageHeight) {
      method getBitDepth (line 152) | public int getBitDepth() {
      method setBitDepth (line 155) | public void setBitDepth(int bitDepth) {
      method getRefreshRate (line 159) | public int getRefreshRate() {
      method setRefreshRate (line 162) | public void setRefreshRate(int refreshRate) {
      method isUseOpenGL (line 168) | public boolean isUseOpenGL() {
      method setUseOpenGL (line 171) | public void setUseOpenGL(boolean useOpenGL) {
    class CalibrationSettings (line 177) | public static class CalibrationSettings extends ProjectiveDevice.Calib...
      method CalibrationSettings (line 178) | public CalibrationSettings() { }
      method CalibrationSettings (line 179) | public CalibrationSettings(ProjectiveDevice.CalibrationSettings sett...
      method firePropertyChange (line 189) | @Override public void firePropertyChange(String propertyName, Object...
      method getName (line 194) | @Override public String getName() { return si.getName(); }
      method setName (line 195) | @Override public void setName(String name) { si.setName(name); }
      method getResponseGamma (line 196) | @Override public double getResponseGamma() { return si.getResponseGa...
      method setResponseGamma (line 197) | @Override public void setResponseGamma(double responseGamma) { si.se...
      method getScreenNumber (line 201) | public int getScreenNumber() { return si.getScreenNumber(); }
      method setScreenNumber (line 202) | public void setScreenNumber(int screenNumber) { si.setScreenNumber(s...
      method getLatency (line 203) | public long getLatency() { return si.getLatency(); }
      method setLatency (line 204) | public void setLatency(long latency) { si.setLatency(latency); }
      method getDescription (line 205) | public String getDescription() { return si.getDescription(); }
      method getImageWidth (line 207) | public int getImageWidth() { return si.getImageWidth(); }
      method setImageWidth (line 208) | public void setImageWidth(int imageWidth) { si.setImageWidth(imageWi...
      method getImageHeight (line 209) | public int getImageHeight() { return si.getImageHeight(); }
      method setImageHeight (line 210) | public void setImageHeight(int imageHeight) { si.setImageHeight(imag...
      method getBitDepth (line 211) | public int getBitDepth() { return si.getBitDepth(); }
      method setBitDepth (line 212) | public void setBitDepth(int bitDepth) { si.setBitDepth(bitDepth); }
      method getRefreshRate (line 213) | public int getRefreshRate() { return si.getRefreshRate(); }
      method setRefreshRate (line 214) | public void setRefreshRate(int refreshRate) { si.setRefreshRate(refr...
      method isUseOpenGL (line 216) | public boolean isUseOpenGL() { return si.isUseOpenGL(); }
      method setUseOpenGL (line 217) | public void setUseOpenGL(boolean useOpenGL) { si.setUseOpenGL(useOpe...
      method getBrightnessBackground (line 221) | public double getBrightnessBackground() {
      method setBrightnessBackground (line 224) | public void setBrightnessBackground(double brightnessBackground) {
      method getBrightnessForeground (line 229) | public double getBrightnessForeground() {
      method setBrightnessForeground (line 232) | public void setBrightnessForeground(double brightnessForeground) {
    class CalibratedSettings (line 238) | public static class CalibratedSettings extends ProjectiveDevice.Calibr...
      method CalibratedSettings (line 239) | public CalibratedSettings() { }
      method CalibratedSettings (line 240) | public CalibratedSettings(ProjectiveDevice.CalibratedSettings settin...
      method firePropertyChange (line 247) | @Override public void firePropertyChange(String propertyName, Object...
      method getName (line 252) | @Override public String getName() { return si.getName(); }
      method setName (line 253) | @Override public void setName(String name) { si.setName(name); }
      method getResponseGamma (line 254) | @Override public double getResponseGamma() { return si.getResponseGa...
      method setResponseGamma (line 255) | @Override public void setResponseGamma(double responseGamma) { si.se...
      method getScreenNumber (line 259) | public int getScreenNumber() { return si.getScreenNumber(); }
      method setScreenNumber (line 260) | public void setScreenNumber(int screenNumber) { si.setScreenNumber(s...
      method getLatency (line 261) | public long getLatency() { return si.getLatency(); }
      method setLatency (line 262) | public void setLatency(long latency) { si.setLatency(latency); }
      method getDescription (line 263) | public String getDescription() { return si.getDescription(); }
      method getImageWidth (line 265) | public int getImageWidth() { return si.getImageWidth(); }
      method setImageWidth (line 266) | public void setImageWidth(int imageWidth) { si.setImageWidth(imageWi...
      method getImageHeight (line 267) | public int getImageHeight() { return si.getImageHeight(); }
      method setImageHeight (line 268) | public void setImageHeight(int imageHeight) { si.setImageHeight(imag...
      method getBitDepth (line 269) | public int getBitDepth() { return si.getBitDepth(); }
      method setBitDepth (line 270) | public void setBitDepth(int bitDepth) { si.setBitDepth(bitDepth); }
      method getRefreshRate (line 271) | public int getRefreshRate() { return si.getRefreshRate(); }
      method setRefreshRate (line 272) | public void setRefreshRate(int refreshRate) { si.setRefreshRate(refr...
      method isUseOpenGL (line 274) | public boolean isUseOpenGL() { return si.isUseOpenGL(); }
      method setUseOpenGL (line 275) | public void setUseOpenGL(boolean useOpenGL) { si.setUseOpenGL(useOpe...
    method getSettings (line 279) | @Override public ProjectiveDevice.Settings getSettings() {
    method setSettings (line 282) | public void setSettings(Settings settings) {
    method setSettings (line 285) | @Override public void setSettings(ProjectiveDevice.Settings settings) {
    method createCanvasFrame (line 299) | public CanvasFrame createCanvasFrame() throws CanvasFrame.Exception {
    method getAttenuation (line 345) | public double getAttenuation(double x, double y, CvMat n, double d) {
    method read (line 373) | public static ProjectorDevice[] read(String filename) throws Exception {
    method read (line 379) | public static ProjectorDevice[] read(FileStorage fs) throws Exception {

FILE: src/main/java/org/bytedeco/javacv/ProjectorSettings.java
  class ProjectorSettings (line 31) | public class ProjectorSettings extends BaseSettings {
    method ProjectorSettings (line 33) | public ProjectorSettings() {
    method ProjectorSettings (line 36) | public ProjectorSettings(boolean calibrated) {
    method getQuantity (line 42) | public int getQuantity() {
    method setQuantity (line 45) | public void setQuantity(int quantity) {
    method toArray (line 66) | @Override public ProjectorDevice.Settings[] toArray() {

FILE: src/main/java/org/bytedeco/javacv/RealSense2FrameGrabber.java
  class RealSense2FrameGrabber (line 38) | public class RealSense2FrameGrabber extends FrameGrabber {
    method tryLoad (line 46) | public static void tryLoad() throws FrameGrabber.Exception {
    method RealSense2FrameGrabber (line 74) | public RealSense2FrameGrabber() throws Exception {
    method RealSense2FrameGrabber (line 78) | public RealSense2FrameGrabber(int deviceNumber) throws Exception {
    method getDeviceInfos (line 85) | public List<RealSense2DeviceInfo> getDeviceInfos() throws Exception {
    method getDeviceDescriptions (line 108) | public static String[] getDeviceDescriptions() throws Exception {
    method disableAllStreams (line 122) | public void disableAllStreams() {
    method getEnabledStreams (line 126) | public List<RealSenseStream> getEnabledStreams() {
    method enableStream (line 130) | public void enableStream(RealSenseStream stream) {
    method enableColorStream (line 134) | public void enableColorStream(int width, int height, int frameRate) {
    method enableDepthStream (line 144) | public void enableDepthStream(int width, int height, int frameRate) {
    method enableIRStream (line 154) | public void enableIRStream(int width, int height, int frameRate, int i...
    method enableIRStream (line 164) | public void enableIRStream(int width, int height, int frameRate) {
    method open (line 168) | public void open() throws Exception {
    method start (line 180) | @Override
    method stop (line 219) | @Override
    method readNextFrameSet (line 232) | private void readNextFrameSet() throws Exception {
    method trigger (line 241) | @Override
    method grab (line 251) | @Override
    method grab (line 268) | public Frame grab(int streamType, int streamIndex, int iplDepth, int c...
    method getDistance (line 275) | public float getDistance(int x, int y) throws Exception {
    method grabColor (line 286) | public Frame grabColor() throws Exception {
    method grabDepth (line 293) | public Frame grabDepth() throws Exception {
    method grabIR (line 300) | public Frame grabIR() throws Exception {
    method grabIR (line 304) | public Frame grabIR(int streamIndex) throws Exception {
    method getLargestStreamByArea (line 311) | private RealSenseStream getLargestStreamByArea() {
    method grabCVFrame (line 321) | private Frame grabCVFrame(int streamType, int streamIndex, int iplDept...
    method findFrameByStreamType (line 348) | private rs2_frame findFrameByStreamType(rs2_frame frameset, int stream...
    method release (line 381) | @Override
    method setSensorOption (line 387) | public void setSensorOption(Rs2SensorType sensorType, int optionIndex,...
    method setSensorOption (line 391) | public void setSensorOption(Rs2SensorType sensorType, int optionIndex,...
    method createContext (line 409) | private rs2_context createContext() throws Exception {
    method createDeviceList (line 415) | private rs2_device_list createDeviceList() throws Exception {
    method createDevice (line 421) | private rs2_device createDevice(rs2_device_list deviceList, int index)...
    method createPipeline (line 427) | private rs2_pipeline createPipeline() throws Exception {
    method createConfig (line 433) | private rs2_config createConfig() throws Exception {
    method getFrameTimeStamp (line 439) | private double getFrameTimeStamp(rs2_frame frame) throws Exception {
    method getDeviceCount (line 445) | private int getDeviceCount() throws Exception {
    method getDeviceInfo (line 454) | private String getDeviceInfo(rs2_device device, int info) throws Excep...
    method getSensorInfo (line 470) | private String getSensorInfo(rs2_sensor sensor, int info) throws Excep...
    method getFrameData (line 486) | private Pointer getFrameData(rs2_frame frame) throws Exception {
    method getFrameSize (line 492) | private Size getFrameSize(rs2_frame frame) throws Exception {
    method getStreamProfile (line 500) | private rs2_stream_profile getStreamProfile(rs2_frame frame) throws Ex...
    method getStreamProfileData (line 506) | private StreamProfileData getStreamProfileData(rs2_stream_profile stre...
    method isSensorExtendableTo (line 533) | private boolean isSensorExtendableTo(rs2_sensor sensor, int extension)...
    method isStreamProfile (line 539) | private boolean isStreamProfile(rs2_stream_profile profile, int type) ...
    method matchesVideoStreamProfile (line 545) | private boolean matchesVideoStreamProfile(rs2_stream_profile profile,
    method setRs2Option (line 560) | private void setRs2Option(rs2_options options, int optionIndex, float ...
    method getSensors (line 572) | private rs2_sensor[] getSensors(rs2_device device) throws Exception {
    method getStreamProfiles (line 593) | private rs2_stream_profile[] getStreamProfiles(rs2_sensor sensor) thro...
    method enableAllVideoStreams (line 613) | private void enableAllVideoStreams() throws Exception {
    method checkError (line 638) | private static void checkError(rs2_error e) throws Exception {
    method toBoolean (line 647) | private static boolean toBoolean(int value) {
    method toBoolean (line 651) | private static boolean toBoolean(String value) {
    class StreamProfileData (line 658) | static class StreamProfileData {
    class VideoStreamProfileData (line 666) | static class VideoStreamProfileData extends StreamProfileData {
    class RealSenseStream (line 671) | public static class RealSenseStream implements Comparable<RealSenseStr...
      method RealSenseStream (line 678) | public RealSenseStream(int type, int index, Size size, int frameRate...
      method getType (line 686) | public int getType() {
      method getIndex (line 690) | public int getIndex() {
      method getSize (line 694) | public Size getSize() {
      method getFrameRate (line 698) | public int getFrameRate() {
      method getFormat (line 702) | public int getFormat() {
      method compareTo (line 706) | @Override
    class RealSense2DeviceInfo (line 712) | public static class RealSense2DeviceInfo {
      method RealSense2DeviceInfo (line 719) | RealSense2DeviceInfo(String name, String serialNumber, String firmwa...
      method getName (line 727) | public String getName() {
      method getSerialNumber (line 731) | public String getSerialNumber() {
      method getFirmware (line 735) | public String getFirmware() {
      method isInAdvancedMode (line 739) | public boolean isInAdvancedMode() {
      method isLocked (line 743) | public boolean isLocked() {
      method toString (line 747) | @Override
    type Rs2SensorType (line 753) | public enum Rs2SensorType {
      method Rs2SensorType (line 759) | Rs2SensorType(String name) {
      method getName (line 763) | public String getName() {

FILE: src/main/java/org/bytedeco/javacv/RealSenseFrameGrabber.java
  class RealSenseFrameGrabber (line 43) | public class RealSenseFrameGrabber extends FrameGrabber {
    method getDeviceDescriptions (line 45) | public static String[] getDeviceDescriptions() throws FrameGrabber.Exc...
    method getByteOrder (line 69) | public ByteOrder getByteOrder() {
    method setByteOrder (line 73) | public void setByteOrder(ByteOrder byteOrder) {
    method createDefault (line 77) | public static RealSenseFrameGrabber createDefault(int deviceNumber) th...
    method createDefault (line 81) | public static RealSenseFrameGrabber createDefault(File deviceFile) thr...
    method createDefault (line 85) | public static RealSenseFrameGrabber createDefault(String devicePath) t...
    method tryLoad (line 91) | public static void tryLoad() throws FrameGrabber.Exception {
    method RealSenseFrameGrabber (line 121) | public RealSenseFrameGrabber(int deviceNumber) {
    method main (line 125) | public static void main(String[] args) {
    method enableColorStream (line 133) | public void enableColorStream() {
    method disableColorStream (line 148) | public void disableColorStream() {
    method enableDepthStream (line 155) | public void enableDepthStream() {
    method disableDepthStream (line 162) | public void disableDepthStream() {
    method enableIRStream (line 169) | public void enableIRStream() {
    method disableIRStream (line 176) | public void disableIRStream() {
    method release (line 183) | public void release() throws FrameGrabber.Exception {
    method finalize (line 186) | @Override
    method getRealSenseDevice (line 197) | public device getRealSenseDevice() {
    method getDepthScale (line 201) | public float getDepthScale() {
    method getFrameRate (line 205) | @Override
    method loadDevice (line 213) | public device loadDevice() throws FrameGrabber.Exception {
    method start (line 224) | @Override
    method stop (line 284) | @Override
    method grabDepth (line 297) | public IplImage grabDepth() {
    method grabVideo (line 330) | public IplImage grabVideo() {
    method grabIR (line 363) | public IplImage grabIR() {
    method grab (line 399) | public Frame grab() throws Exception {
    method trigger (line 437) | @Override
    method getDepthImageWidth (line 442) | public int getDepthImageWidth() {
    method setDepthImageWidth (line 446) | public void setDepthImageWidth(int depthImageWidth) {
    method getDepthImageHeight (line 450) | public int getDepthImageHeight() {
    method setDepthImageHeight (line 454) | public void setDepthImageHeight(int depthImageHeight) {
    method getIRImageWidth (line 458) | public int getIRImageWidth() {
    method setIRImageWidth (line 462) | public void setIRImageWidth(int IRImageWidth) {
    method getIRImageHeight (line 466) | public int getIRImageHeight() {
    method setIRImageHeight (line 470) | public void setIRImageHeight(int IRImageHeight) {
    method getDepthFrameRate (line 474) | public int getDepthFrameRate() {
    method setDepthFrameRate (line 478) | public void setDepthFrameRate(int frameRate) {
    method getIRFrameRate (line 482) | public int getIRFrameRate() {
    method setIRFrameRate (line 486) | public void setIRFrameRate(int IRFrameRate) {
    method getGamma (line 490) | @Override
    method setPreset (line 508) | public void setPreset(int preset) {
    method setShortRange (line 513) | public void setShortRange() {
    method setLongRange (line 517) | public void setLongRange() {
    method setMidRange (line 521) | public void setMidRange() {
    method setDefaultPreset (line 525) | public void setDefaultPreset() {
    method setObjectScanningPreset (line 529) | public void setObjectScanningPreset() {
    method setCursorPreset (line 533) | public void setCursorPreset() {
    method setGestureRecognitionPreset (line 537) | public void setGestureRecognitionPreset() {
    method setBackgroundSegmentationPreset (line 541) | public void setBackgroundSegmentationPreset() {
    method setIROnlyPreset (line 545) | public void setIROnlyPreset() {
    method setOption (line 550) | public void setOption(int option, int value) {
    method set (line 557) | public void set(int value) {
    method setColorBrightness (line 564) | public void setColorBrightness(int value) {
    method setColorContrast (line 571) | public void setColorContrast(int value) {
    method setColorExposure (line 579) | public void setColorExposure(int value) {
    method setColorGain (line 586) | public void setColorGain(int value) {
    method setColorGamma (line 593) | public void setColorGamma(int value) {
    method setColorHue (line 600) | public void setColorHue(int value) {
    method setColorSaturation (line 607) | public void setColorSaturation(int value) {
    method setColorSharpness (line 614) | public void setColorSharpness(int value) {
    method setColorWhiteBalance (line 622) | public void setColorWhiteBalance(int value) {
    method setColorEnableAutoExposure (line 629) | public void setColorEnableAutoExposure(int value) {
    method setColorEnableAutoWhiteBalance (line 636) | public void setColorEnableAutoWhiteBalance(int value) {
    method setLaserPower (line 643) | public void setLaserPower(int value) {
    method setAccuracy (line 653) | public void setAccuracy(int value) {
    method setMotionRange (line 661) | public void setMotionRange(int value) {
    method setFilterOption (line 669) | public void setFilterOption(int value) {
    method setConfidenceThreshold (line 678) | public void setConfidenceThreshold(int value) {
    method setDynamicFPS (line 686) | public void setDynamicFPS(int value) {
    method setLR_AutoExposureEnabled (line 694) | public void setLR_AutoExposureEnabled(int value) {
    method setLR_Gain (line 701) | public void setLR_Gain(int value) {
    method setLR_Exposure (line 709) | public void setLR_Exposure(int value) {
    method setEmitterEnabled (line 716) | public void setEmitterEnabled(int value) {
    method setDepthUnits (line 724) | public void setDepthUnits(int value) {
    method setDepthClampMin (line 733) | public void setDepthClampMin(int value) {
    method setDepthClampMax (line 742) | public void setDepthClampMax(int value) {
    method setDisparityMultiplier (line 750) | public void setDisparityMultiplier(int value) {
    method setDisparityShift (li
Condensed preview — 131 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,117K chars).
[
  {
    "path": ".github/FUNDING.yml",
    "chars": 17,
    "preview": "github: bytedeco\n"
  },
  {
    "path": ".github/workflows/javacv.yml",
    "chars": 1701,
    "preview": "name: javacv\non: [push, pull_request, workflow_dispatch]\nenv:\n  CI_DEPLOY_MODULE: .\n  CI_DEPLOY_PLATFORM: ${{ github.job"
  },
  {
    "path": ".gitignore",
    "chars": 95,
    "preview": "**/target/**\n\n# Mac\n.DS_Store\n\n# Eclipse\n.classpath\n.project\n.settings\n\n# IntelliJ\n*.iml\n.idea\n"
  },
  {
    "path": ".travis.yml",
    "chars": 3188,
    "preview": "dist: xenial\ncache:\n  directories:\n    - $HOME/.m2/repository\n\nbefore_install:\n  - \"echo '<settings><localRepository>${e"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 75129,
    "preview": "\r\n * Compile classes with `parameters` bumping minimum requirements to Java SE 8 and Android 7.0 ([issue bytedeco/javacp"
  },
  {
    "path": "LICENSE.txt",
    "chars": 31556,
    "preview": "You may use this work under the terms of either the Apache License,\r\nVersion 2.0, or the GNU General Public License (GPL"
  },
  {
    "path": "README.md",
    "chars": 19439,
    "preview": "JavaCV\r\n======\r\n\r\n[![Gitter](https://badges.gitter.im/bytedeco/javacv.svg)](https://gitter.im/bytedeco/javacv) [![Maven "
  },
  {
    "path": "platform/pom.xml",
    "chars": 9458,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2"
  },
  {
    "path": "platform/src/main/assembly/bin.xml",
    "chars": 1537,
    "preview": "<assembly xmlns=\"http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0\" xmlns:xsi=\"http://www.w3.org/2001"
  },
  {
    "path": "platform/src/main/assembly/src.xml",
    "chars": 860,
    "preview": "<assembly xmlns=\"http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0\" xmlns:xsi=\"http://www.w3.org/2001"
  },
  {
    "path": "platform/src/main/java9/module-info.java",
    "chars": 695,
    "preview": "module org.bytedeco.javacv.platform {\n    requires transitive org.bytedeco.javacv;\n    requires org.bytedeco.opencv.plat"
  },
  {
    "path": "platform/src/test/java/org/bytedeco/javacv/FrameConverterTest.java",
    "chars": 15641,
    "preview": "/*\n * Copyright (C) 2015-2016 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "platform/src/test/java/org/bytedeco/javacv/FrameFilterTest.java",
    "chars": 9050,
    "preview": "/*\n * Copyright (C) 2018 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n "
  },
  {
    "path": "platform/src/test/java/org/bytedeco/javacv/FrameGrabberChangingResolutionTest.java",
    "chars": 10212,
    "preview": "/*\n * Copyright (C) 2016-2017 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "platform/src/test/java/org/bytedeco/javacv/FrameGrabberTest.java",
    "chars": 23306,
    "preview": "/*\n * Copyright (C) 2016-2023 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "platform/src/test/java/org/bytedeco/javacv/SeekableByteArrayOutputStreamTest.java",
    "chars": 10411,
    "preview": "/*\n * Copyright (C) 2019 Sven Vorlauf\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n "
  },
  {
    "path": "pom.xml",
    "chars": 15557,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2"
  },
  {
    "path": "samples/AudioSplitMergeHelper.java",
    "chars": 6608,
    "preview": "import org.bytedeco.javacv.*;\n\nimport java.nio.Buffer;\nimport java.nio.ShortBuffer;\n\n/**\n * This code is a sample which "
  },
  {
    "path": "samples/BioInspiredRetina.java",
    "chars": 3383,
    "preview": "import java.awt.*;\nimport java.awt.image.BufferedImage;\nimport java.io.File;\nimport javax.imageio.ImageIO;\n\nimport org.b"
  },
  {
    "path": "samples/BlobDemo.java",
    "chars": 11543,
    "preview": "import org.bytedeco.javacv.Blobs;\nimport org.bytedeco.javacv.CanvasFrame;\nimport org.bytedeco.javacv.OpenCVFrameConverte"
  },
  {
    "path": "samples/CaffeGooglenet.java",
    "chars": 4051,
    "preview": "/*\n * JavaCV version of OpenCV caffe_googlenet.cpp\n * https://github.com/ludv1x/opencv_contrib/blob/master/modules/dnn/s"
  },
  {
    "path": "samples/ColoredObjectTrack.java",
    "chars": 4532,
    "preview": "/*\n * Just an example using the opencv to make a colored object tracking,\n * i adpted this code to bytedeco/javacv, i th"
  },
  {
    "path": "samples/DeepLearningFaceDetection.java",
    "chars": 4618,
    "preview": "import org.bytedeco.javacpp.indexer.FloatIndexer;\nimport org.bytedeco.javacv.CanvasFrame;\nimport org.bytedeco.javacv.Ope"
  },
  {
    "path": "samples/DeinterlacedVideoPlayer.java",
    "chars": 2209,
    "preview": "import org.bytedeco.javacpp.Loader;\nimport org.bytedeco.javacv.FFmpegFrameFilter;\nimport org.bytedeco.javacv.Frame;\nimpo"
  },
  {
    "path": "samples/Demo.java",
    "chars": 8153,
    "preview": "/*\n * Copyright (C) 2009-2018 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "samples/FFmpegStreamingTimeout.java",
    "chars": 5523,
    "preview": "import java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicBoolean;\nimport org.bytedeco.javacpp.Poin"
  },
  {
    "path": "samples/FaceApplet.html",
    "chars": 677,
    "preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html lang=\"en-US\">\n  <head>\n    <title>FaceApplet</titl"
  },
  {
    "path": "samples/FaceApplet.java",
    "chars": 5756,
    "preview": "import java.applet.Applet;\nimport java.awt.BasicStroke;\nimport java.awt.Color;\nimport java.awt.Graphics;\nimport java.awt"
  },
  {
    "path": "samples/FaceApplet.jnlp",
    "chars": 538,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<jnlp spec=\"1.0+\" href=\"FaceApplet.jnlp\">\n    <information>\n        <title>FaceAp"
  },
  {
    "path": "samples/FacePreview.java",
    "chars": 10704,
    "preview": "/*\n * Copyright (C) 2010-2019 Samuel Audet\n *\n * FacePreview - A fusion of OpenCV's facedetect and Android's CameraPrevi"
  },
  {
    "path": "samples/FaceRecognizerInVideo.java",
    "chars": 4556,
    "preview": "import java.io.File;\n\nimport org.bytedeco.javacpp.IntPointer;\nimport org.bytedeco.javacpp.DoublePointer;\n\nimport org.byt"
  },
  {
    "path": "samples/HoughLines.java",
    "chars": 5614,
    "preview": "import javax.swing.JFrame;\nimport org.bytedeco.javacpp.*;\nimport org.bytedeco.javacv.*;\n\nimport org.bytedeco.opencv.open"
  },
  {
    "path": "samples/ImageSegmentation.java",
    "chars": 6834,
    "preview": "/*\n * JavaCV version of OpenCV imageSegmentation.cpp\n * https://github.com/opencv/opencv/blob/master/samples/cpp/tutoria"
  },
  {
    "path": "samples/JavaFxPlayVideoAndAudio.java",
    "chars": 8123,
    "preview": "import java.nio.ByteBuffer;\nimport java.nio.ShortBuffer;\nimport java.util.concurrent.ExecutorService;\nimport java.util.c"
  },
  {
    "path": "samples/KazemiFacemarkExample.java",
    "chars": 2577,
    "preview": "/**\n * Kazemi Facemark example for JavaCV\n * \n * @author Théophile Gonos\n *\n * Link to Kazemi model : \n * https://raw.gi"
  },
  {
    "path": "samples/LBFFacemarkExampleWithVideo.java",
    "chars": 3406,
    "preview": "/**\n * LBF Facemark example for JavaCV with Video camera and Transparent API\n * \n * @author Théophile Gonos\n *\n * you ca"
  },
  {
    "path": "samples/MotionDetector.java",
    "chars": 4472,
    "preview": "/* \n * I developed some code for recognize motion detections with JavaCV.\n * Actually, it works with an array of Rect, p"
  },
  {
    "path": "samples/OpenCVFaceRecognizer.java",
    "chars": 3146,
    "preview": "import java.io.File;\nimport java.io.FilenameFilter;\nimport java.nio.IntBuffer;\n\nimport org.bytedeco.javacpp.BytePointer;"
  },
  {
    "path": "samples/OpenCVFeatures2dSerialization.java",
    "chars": 4832,
    "preview": "import java.awt.image.BufferedImage;\nimport java.io.File;\nimport java.io.IOException;\nimport java.io.UnsupportedEncoding"
  },
  {
    "path": "samples/OpticalFlowDense.java",
    "chars": 1820,
    "preview": "import java.nio.FloatBuffer;\n\nimport org.bytedeco.opencv.opencv_core.*;\nimport org.bytedeco.opencv.opencv_optflow.*;\nimp"
  },
  {
    "path": "samples/OpticalFlowTracker.java",
    "chars": 3246,
    "preview": "/*\n * Because I believe that examples are the easiest way how to use JavaCV, I am \n * sending a sample based on http://d"
  },
  {
    "path": "samples/PacketRecorderTest.java",
    "chars": 2509,
    "preview": "import java.text.DateFormat;\nimport java.text.SimpleDateFormat;\nimport java.util.Date;\nimport org.bytedeco.javacv.*;\n\nim"
  },
  {
    "path": "samples/PerspectiveWarpDemo.java",
    "chars": 3230,
    "preview": "import org.bytedeco.javacpp.FloatPointer;\nimport org.bytedeco.javacv.CanvasFrame;\nimport org.bytedeco.javacv.OpenCVFrame"
  },
  {
    "path": "samples/PrincipalComponentAnalysis.java",
    "chars": 8490,
    "preview": "import java.awt.image.BufferedImage;\nimport java.io.File;\nimport java.util.ArrayList;\nimport javax.imageio.ImageIO;\n\nimp"
  },
  {
    "path": "samples/RLSA.java",
    "chars": 3975,
    "preview": "import java.awt.image.BufferedImage;\nimport java.io.File;\nimport java.nio.ByteBuffer;\nimport javax.imageio.ImageIO;\nimpo"
  },
  {
    "path": "samples/RealSense2DepthMeasuring.java",
    "chars": 3730,
    "preview": "/*\n * Copyright (C) 2019 Florian Bruggisser\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opt"
  },
  {
    "path": "samples/RecordActivity.java",
    "chars": 21784,
    "preview": "/*\n * Copyright (C) 2012,2013 Qianliang Zhang, Shawn Van Every, Samuel Audet\n *\n * IMPORTANT - Make sure the AndroidMani"
  },
  {
    "path": "samples/Similarity.java",
    "chars": 4574,
    "preview": "/**\n * Copyright 2021 JavaCV\n * \n *  Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use "
  },
  {
    "path": "samples/Smoother.java",
    "chars": 1514,
    "preview": "/*\n * Copyright (C) 2009-2018 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "samples/Square.java",
    "chars": 13442,
    "preview": "import java.awt.event.KeyEvent;\n\nimport org.bytedeco.javacpp.*;\nimport org.bytedeco.javacv.*;\n\nimport org.bytedeco.openc"
  },
  {
    "path": "samples/TemplateMatching.java",
    "chars": 5342,
    "preview": "import java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.ThreadLocalRandom;\n\nimport org.bytedeco.j"
  },
  {
    "path": "samples/WebcamAndMicrophoneCapture.java",
    "chars": 10618,
    "preview": "/**\n * @author Ben Davenport\n * \n * This class is a simple example for broadcasting a video capture device (ie, webcam) "
  },
  {
    "path": "samples/YOLONet.java",
    "chars": 10138,
    "preview": "/*\nMIT License\n\nCopyright (c) 2021 Florian Bruggisser\n\nPermission is hereby granted, free of charge, to any person obtai"
  },
  {
    "path": "samples/haarcascade_frontalface_alt2.xml",
    "chars": 540616,
    "preview": "<?xml version=\"1.0\"?>\n<!--\n    Tree-based 20x20 gentle adaboost frontal face detector.\n    Created by Rainer Lienhart.\n\n"
  },
  {
    "path": "samples/pom.xml",
    "chars": 1529,
    "preview": "<project>\n    <modelVersion>4.0.0</modelVersion>\n    <groupId>org.bytedeco.javacv</groupId>\n    <artifactId>demo</artifa"
  },
  {
    "path": "src/main/java/cl/eye/CLCamera.java",
    "chars": 6066,
    "preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/AndroidFrameConverter.java",
    "chars": 8034,
    "preview": "/*\n * Copyright (C) 2015-2016 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/BaseChildSettings.java",
    "chars": 2583,
    "preview": "/*\n * Copyright (C) 2009-2011 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/BaseSettings.java",
    "chars": 2594,
    "preview": "/*\n * Copyright (C) 2009-2011 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Blobs.java",
    "chars": 28920,
    "preview": "package org.bytedeco.javacv;\n\nimport org.bytedeco.opencv.opencv_core.*;\nimport static org.bytedeco.opencv.global.opencv_"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/BufferRing.java",
    "chars": 2317,
    "preview": "/*\n * Copyright (C) 2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n "
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/CameraDevice.java",
    "chars": 25159,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/CameraSettings.java",
    "chars": 2881,
    "preview": "/*\n * Copyright (C) 2009-2011 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/CanvasFrame.java",
    "chars": 17243,
    "preview": "/*\n * Copyright (C) 2009-2015 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ColorCalibrator.java",
    "chars": 4146,
    "preview": "/*\n * Copyright (C) 2009-2011 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/DC1394FrameGrabber.java",
    "chars": 28294,
    "preview": "/*\n * Copyright (C) 2009-2016 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FFmpegFrameFilter.java",
    "chars": 36874,
    "preview": "/*\n * Copyright (C) 2015-2024 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FFmpegFrameGrabber.java",
    "chars": 69963,
    "preview": "/*\n * Copyright (C) 2009-2025 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FFmpegFrameRecorder.java",
    "chars": 67297,
    "preview": "/*\n * Copyright (C) 2009-2025 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FFmpegLockCallback.java",
    "chars": 2648,
    "preview": "package org.bytedeco.javacv;\n\nimport java.util.HashMap;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport java.ut"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FFmpegLogCallback.java",
    "chars": 3458,
    "preview": "/*\n * Copyright (C) 2015-2021 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FlyCapture2FrameGrabber.java",
    "chars": 23738,
    "preview": "/*\n * Copyright (C) 2014,2017 Jeremy Laviole, Samuel Audet, Jarek Sacha\n *\n * Licensed either under the Apache License, "
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FlyCaptureFrameGrabber.java",
    "chars": 20473,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Frame.java",
    "chars": 17075,
    "preview": "/*\n * Copyright (C) 2015-2021 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FrameConverter.java",
    "chars": 1979,
    "preview": "/*\n * Copyright (C) 2015-2021 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FrameFilter.java",
    "chars": 4984,
    "preview": "/*\n * Copyright (C) 2015-2018 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FrameGrabber.java",
    "chars": 26821,
    "preview": "/*\n * Copyright (C) 2009-2022 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/FrameRecorder.java",
    "chars": 13812,
    "preview": "/*\n * Copyright (C) 2009-2023 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/GLCanvasFrame.java",
    "chars": 14564,
    "preview": "/*\n * Copyright (C) 2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n "
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/GNImageAligner.java",
    "chars": 29602,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/GNImageAlignerCL.java",
    "chars": 17936,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/GeometricCalibrator.java",
    "chars": 23392,
    "preview": "/*\n * Copyright (C) 2009-2011 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/HandMouse.java",
    "chars": 15064,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/IPCameraFrameGrabber.java",
    "chars": 10644,
    "preview": "/*\n * Copyright (C) 2013 Greg Perry\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n * "
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ImageAligner.java",
    "chars": 3751,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ImageAlignerCL.java",
    "chars": 1479,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ImageTransformer.java",
    "chars": 3343,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ImageTransformerCL.java",
    "chars": 4276,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Java2DFrameConverter.java",
    "chars": 34878,
    "preview": "/*\n * Copyright (C) 2015-2019 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Java2DFrameUtils.java",
    "chars": 3670,
    "preview": "package org.bytedeco.javacv;\n\nimport java.awt.image.BufferedImage;\nimport java.awt.image.ColorModel;\nimport java.awt.ima"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/JavaCV.java",
    "chars": 38352,
    "preview": "/*\n * Copyright (C) 2009-2016 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/JavaCVCL.java",
    "chars": 29617,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/JavaCvErrorCallback.java",
    "chars": 3377,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/JavaFXFrameConverter.java",
    "chars": 4165,
    "preview": "/*\n * Copyright (C) 2018 Samuel Audet, Johan Vos\n *\n * Licensed either under the Apache License, Version 2.0, or (at you"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/LeptonicaFrameConverter.java",
    "chars": 6616,
    "preview": "/*\n * Copyright (C) 2018-2021 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/LibgdxFrameConverter.java",
    "chars": 4191,
    "preview": "/*\n * Copyright (C) 2025 shan-luan\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n * u"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/MarkedPlane.java",
    "chars": 9627,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Marker.java",
    "chars": 10320,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/MarkerDetector.java",
    "chars": 13526,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ObjectFinder.java",
    "chars": 15957,
    "preview": "/*\n * Copyright (C) 2009-2015 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/OpenCVFrameConverter.java",
    "chars": 11229,
    "preview": "/*\n * Copyright (C) 2015-2021 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/OpenCVFrameGrabber.java",
    "chars": 11232,
    "preview": "/*\n * Copyright (C) 2009-2019 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/OpenCVFrameRecorder.java",
    "chars": 4902,
    "preview": "/*\n * Copyright (C) 2009-2019 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/OpenKinect2FrameGrabber.java",
    "chars": 11665,
    "preview": "/*\n * Copyright (C) 2014 Jeremy Laviole, Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (a"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/OpenKinectFrameGrabber.java",
    "chars": 11781,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/PS3EyeFrameGrabber.java",
    "chars": 13961,
    "preview": "/*\n * Copyright (C) 2011-2012 Jiri Masa, Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (a"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Parallel.java",
    "chars": 3563,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProCamColorCalibrator.java",
    "chars": 13263,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProCamGeometricCalibrator.java",
    "chars": 24469,
    "preview": "/*\n * Copyright (C) 2009-2011 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProCamTransformer.java",
    "chars": 24326,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProCamTransformerCL.java",
    "chars": 10311,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectiveColorTransformer.java",
    "chars": 13715,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectiveColorTransformerCL.java",
    "chars": 6940,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectiveDevice.java",
    "chars": 37747,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectiveTransformer.java",
    "chars": 20538,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectiveTransformerCL.java",
    "chars": 6588,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectorDevice.java",
    "chars": 17262,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ProjectorSettings.java",
    "chars": 2388,
    "preview": "/*\n * Copyright (C) 2009-2010 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/RealSense2FrameGrabber.java",
    "chars": 24905,
    "preview": "/*\n * Copyright (C) 2019-2022 Florian Bruggisser, Samuel Audet\n *\n * Licensed either under the Apache License, Version 2"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/RealSenseFrameGrabber.java",
    "chars": 31651,
    "preview": "/*\n * Copyright (C) 2014 Jeremy Laviole, Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (a"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/ReflectanceInitializer.java",
    "chars": 8863,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/Seekable.java",
    "chars": 1098,
    "preview": "/*\n * Copyright (C) 2019 Sven Vorlauf\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n "
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/SeekableByteArrayOutputStream.java",
    "chars": 1974,
    "preview": "/*\n * Copyright (C) 2019 Sven Vorlauf\n *\n * Licensed either under the Apache License, Version 2.0, or (at your option)\n "
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/VideoInputFrameGrabber.java",
    "chars": 7812,
    "preview": "/*\n * Copyright (C) 2011-2013 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java/org/bytedeco/javacv/cvkernels.java",
    "chars": 5182,
    "preview": "/*\n * Copyright (C) 2009-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/java9/module-info.java",
    "chars": 662,
    "preview": "module org.bytedeco.javacv {\n    exports org.bytedeco.javacv;\n    requires java.desktop;\n    requires javafx.graphics;\n "
  },
  {
    "path": "src/main/resources/org/bytedeco/javacv/ImageTransformer.cl",
    "chars": 10968,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/resources/org/bytedeco/javacv/JavaCV.cl",
    "chars": 5442,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/resources/org/bytedeco/javacv/ProCamTransformer.cl",
    "chars": 2889,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/resources/org/bytedeco/javacv/ProjectiveColorTransformer.cl",
    "chars": 2707,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  },
  {
    "path": "src/main/resources/org/bytedeco/javacv/ProjectiveTransformer.cl",
    "chars": 2639,
    "preview": "/*\n * Copyright (C) 2011-2012 Samuel Audet\n *\n * Licensed either under the Apache License, Version 2.0, or (at your opti"
  }
]

About this extraction

This page contains the full source code of the bytedeco/javacv GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 131 files (1.9 MB), approximately 575.6k tokens, and a symbol index with 2320 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!