javacv
vaCV 1.5.11
Accompagnement commercial :
JavaCV utilise des wrappers des préréglages JavaCPP de bibliothèques couramment utilisées par les chercheurs dans le domaine de la vision par ordinateur (OpenCV, FFmpeg, libdc1394, FlyCapture, Spinnaker, OpenKinect, librealsense, CL PS3 Eye Driver, videoInput, ARToolKitPlus, flandmark, Leptonica et Tesseract). et fournit des classes utilitaires pour rendre leurs fonctionnalités plus faciles à utiliser sur la plate-forme Java, y compris Android.
JavaCV est également livré avec un affichage d'image plein écran accéléré par le matériel ( CanvasFrame et GLCanvasFrame ), des méthodes faciles à utiliser pour exécuter du code en parallèle sur plusieurs cœurs ( Parallel ), un étalonnage géométrique et des couleurs convivial des caméras et des projecteurs ( GeometricCalibrator , ProCamGeometricCalibrator , ProCamColorCalibrator ), détection et mise en correspondance de points caractéristiques ( ObjectFinder ), un ensemble de classes qui implémentent l'alignement direct de l'image des systèmes projecteur-caméra (principalement GNImageAligner , ProjectiveTransformer , ProjectiveColorTransformer , ProCamTransformer et ReflectanceInitializer ), un package d'analyse de blob ( Blobs ), ainsi que diverses fonctionnalités de la classe JavaCV . Certaines de ces classes ont également un homologue OpenCL et OpenGL, dont les noms se terminent par CL ou commencent par GL , c'est à dire : JavaCVCL , GLCanvasFrame , etc.
Pour apprendre à utiliser l'API, la documentation faisant actuellement défaut, veuillez vous référer à la section Exemples d'utilisation ci-dessous ainsi qu'aux exemples de programmes, dont deux pour Android ( FacePreview.java et RecordActivity.java ), également présents dans le répertoire samples . Vous trouverez peut-être également utile de vous référer au code source de ProCamCalib et ProCamTracker ainsi qu'aux exemples portés depuis OpenCV2 Cookbook et les pages wiki associées.
Merci de me tenir informé de toute mise à jour ou correctif que vous apportez au code afin que je puisse les intégrer dans la prochaine version. Merci! Et n'hésitez pas à poser des questions sur la liste de diffusion ou sur le forum de discussion si vous rencontrez des problèmes avec le logiciel ! Je suis sûr que c'est loin d'être parfait...
Les archives contenant des fichiers JAR sont disponibles sous forme de versions. L'archive binaire contient des versions pour Android, iOS, Linux, Mac OS X et Windows. Les fichiers JAR pour des modules ou plates-formes enfants spécifiques peuvent également être obtenus individuellement à partir du référentiel central Maven.
Pour installer manuellement les fichiers JAR, suivez les instructions de la section Installation manuelle ci-dessous.
Nous pouvons également tout télécharger et installer automatiquement avec :
pom.xml ) < dependency >
< groupId >org.bytedeco</ groupId >
< artifactId >javacv-platform</ artifactId >
< version >1.5.11</ version >
</ dependency >build.gradle.kts ou build.gradle ) dependencies {
implementation( " org.bytedeco:javacv-platform:1.5.11 " )
}project.clj ) :dependencies [
[org.bytedeco/javacv-platform " 1.5.11 " ]
]build.sbt ) libraryDependencies += " org.bytedeco " % " javacv-platform " % " 1.5.11 " Cela télécharge les binaires pour toutes les plates-formes, mais pour obtenir les binaires pour une seule plate-forme, nous pouvons définir la propriété système javacpp.platform (via l'option de ligne de commande -D ) sur quelque chose comme android-arm , linux-x86_64 , macosx-x86_64 , windows-x86_64 , etc. Veuillez vous référer au fichier README.md des préréglages JavaCPP pour plus de détails. Une autre option disponible pour les utilisateurs de Gradle est Gradle JavaCPP, et de même pour les utilisateurs de Scala, il existe SBT-JavaCV.
Pour utiliser JavaCV, vous devrez d'abord télécharger et installer le logiciel suivant :
De plus, bien que cela ne soit pas toujours nécessaire, certaines fonctionnalités de JavaCV reposent également sur :
Enfin, assurez-vous que tout a le même nombre de bits : les modules 32 bits et 64 bits ne se mélangent en aucun cas .
Placez simplement tous les fichiers JAR souhaités ( opencv*.jar , ffmpeg*.jar , etc.), en plus de javacpp.jar et javacv.jar , quelque part dans votre chemin de classe. Voici quelques instructions plus spécifiques pour les cas courants :
NetBeans (Java SE 7 ou version ultérieure) :
Eclipse (Java SE 7 ou version ultérieure) :
Visual Studio Code (Java SE 7 ou version ultérieure) :
+ .IntelliJ IDEA (Android 7.0 ou version ultérieure) :
app/libs .+ et sélectionnez « 2 Dépendance de fichier ».libs .android:extractNativeLibs="true"Après cela, les classes wrapper pour OpenCV et FFmpeg, par exemple, peuvent accéder automatiquement à toutes leurs API C/C++ :
Les définitions de classe sont essentiellement des ports vers Java des fichiers d'en-tête d'origine en C/C++, et j'ai délibérément décidé de conserver autant que possible la syntaxe d'origine. Par exemple, voici une méthode qui tente de charger un fichier image, de le lisser et de le réenregistrer sur le disque :
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 est également livré avec des classes et des méthodes d'assistance en plus d'OpenCV et FFmpeg pour faciliter leur intégration à la plate-forme Java. Voici un petit programme de démonstration démontrant les parties les plus fréquemment utiles :
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 ();
}
} De plus, après avoir créé un fichier pom.xml avec le contenu suivant :
< project >
< modelVersion >4.0.0</ modelVersion >
< groupId >org.bytedeco.javacv</ groupId >
< artifactId >demo</ artifactId >
< version >1.5.11</ version >
< properties >
< maven .compiler.source>1.7</ maven .compiler.source>
< maven .compiler.target>1.7</ maven .compiler.target>
</ properties >
< dependencies >
< dependency >
< groupId >org.bytedeco</ groupId >
< artifactId >javacv-platform</ artifactId >
< version >1.5.11</ version >
</ dependency >
<!-- Additional dependencies required to use CUDA and cuDNN -->
< dependency >
< groupId >org.bytedeco</ groupId >
< artifactId >opencv-platform-gpu</ artifactId >
< version >4.10.0-1.5.11</ version >
</ dependency >
<!-- Optional GPL builds with (almost) everything enabled -->
< dependency >
< groupId >org.bytedeco</ groupId >
< artifactId >ffmpeg-platform-gpl</ artifactId >
< version >7.1-1.5.11</ version >
</ dependency >
</ dependencies >
< build >
< sourceDirectory >.</ sourceDirectory >
</ build >
</ project > Et en plaçant le code source ci-dessus dans Demo.java , ou de la même manière pour d'autres classes trouvées dans les samples , nous pouvons utiliser la commande suivante pour que tout soit d'abord installé automatiquement puis exécuté par Maven :
$ mvn compile exec:java -Dexec.mainClass=Demo Remarque : En cas d'erreurs, assurez-vous que l' artifactId dans le fichier pom.xml lit javacv-platform , pas uniquement javacv , par exemple. L'artefact javacv-platform ajoute toutes les dépendances binaires nécessaires.
Si les fichiers binaires disponibles ci-dessus ne suffisent pas à vos besoins, vous devrez peut-être les reconstruire à partir du code source. A cet effet, les dossiers projets ont été créés pour :
Une fois installé, appelez simplement la commande mvn install habituelle pour JavaCPP, ses préréglages et JavaCV. Par défaut, aucune autre dépendance qu'un compilateur C++ pour JavaCPP n'est requise. Veuillez vous référer aux commentaires à l'intérieur des fichiers pom.xml pour plus de détails.
Au lieu de créer manuellement les bibliothèques natives, nous pouvons exécuter mvn install pour JavaCV uniquement et nous appuyer sur les artefacts d'instantané des versions CI :
Responsable du projet : Samuel Audet samuel.audet at gmail.com
Site développeur : https://github.com/bytedeco/javacv
Groupe de discussion : http://groups.google.com/group/javacv
