La réalité augmentée (AR) offre des interactions immersives en mélangeant les mondes réel et virtuel, rendant les interactions homme-machine plus intéressantes et pratiques que jamais. Une application courante de la RA consiste à placer un objet virtuel dans un environnement réel, où l’utilisateur est libre de contrôler ou d’interagir avec l’objet virtuel. Cependant, il y a tellement plus que AR peut faire au-delà de cela.
Pour rendre les interactions plus faciles et plus immersives, de nombreux développeurs d’applications mobiles permettent désormais aux utilisateurs de contrôler leurs appareils sans avoir à toucher l’écran en identifiant les mouvements du corps, les gestes de la main et les expressions faciales des utilisateurs en temps réel et en utilisant les informations identifiées pour déclencher différents événements dans l’application. Par exemple, dans un jeu somatosensoriel AR, les joueurs peuvent déclencher une action en prenant une pose, ce qui leur évite d’appuyer fréquemment sur les touches de la console de contrôle. De même, lors de la prise d’une image ou d’une courte vidéo, l’utilisateur peut appliquer des effets spéciaux à l’image ou à la vidéo en prenant des poses spécifiques sans même avoir à toucher l’écran. Dans une application de santé et de remise en forme guidée par un entraîneur, le système alimenté par AR peut identifier les postures en temps réel de l’utilisateur pour déterminer s’il fait l’exercice correctement et le guider pour qu’il s’entraîne correctement. Tout cela serait impossible sans AR.
Comment, alors, une application peut-elle identifier avec précision les postures des utilisateurs pour alimenter ces interactions en temps réel ?
Si vous envisagez également de développer une application AR qui doit identifier les mouvements de l’utilisateur en temps réel pour déclencher un événement spécifique, comme pour contrôler l’interface d’interaction sur un appareil ou pour reconnaître et contrôler les opérations de jeu, l’intégration d’un SDK qui fournit la reconnaissance de la posture la capacité est une évidence. L’intégration de ce SDK rationalisera considérablement le processus de développement et vous permettra de vous concentrer sur l’amélioration de la conception de l’application et de créer la meilleure expérience utilisateur possible.
HMS Core AR Engine fait une grande partie du gros du travail pour vous. Sa capacité de reconnaissance de la posture identifie avec précision les différentes postures corporelles des utilisateurs en temps réel. Après avoir intégré ce SDK, votre application pourra utiliser les caméras avant et arrière de l’appareil pour reconnaître six postures différentes d’une seule personne en temps réel et afficher et afficher les résultats de la reconnaissance dans l’application.
Le SDK fournit des fonctionnalités de base dont les applications de détection de mouvement auront besoin et enrichit vos applications AR avec des fonctionnalités de contrôle à distance et de collaboration.
Ici, je vais vous montrer comment intégrer AR Engine pour implémenter ces fonctionnalités étonnantes.
Comment développer
Exigences sur l’environnement de développement :
- JDK : 1.8.211 ou version ultérieure
- Android Studio : 3.0 ou version ultérieure
- minSdkVersion : 26 ou version ultérieure
- targetSdkVersion : 29 (recommandé)
- compileSdkVersion : 29 (recommandé)
- Version Gradle : 6.1.1 ou ultérieure (recommandé)
Assurez-vous d’avoir téléchargé l’APK AR Engine depuis AppGallery et de l’avoir installé sur l’appareil.
Si vous devez utiliser plusieurs kits HMS Core, utilisez les dernières versions requises pour ces kits.
Les préparatifs
1. Avant de commencer le développement, intégrez le SDK AR Engine via le référentiel Maven dans votre environnement de développement.
2. La procédure de configuration de l’adresse du référentiel Maven dans Android Studio varie pour le plug-in Gradle antérieur à 7.0, le plug-in Gradle 7.0 et le plug-in Gradle 7.1 ou version ultérieure. Vous devez le configurer en fonction de la version spécifique du plugin Gradle.
3. Prenez le plugin Gradle 7.0 comme exemple :
Ouvrir le niveau projet build.gradle fichier dans votre projet Android Studio et configurez l’adresse du référentiel Maven.
Aller à script de construction > référentiels et configurez l’adresse du référentiel Maven pour le SDK.
buildscript {
repositories {
google()
jcenter()
maven {url "https://developer.huawei.com/repo/" }
}
}4. Ouvrez le niveau du projet paramètres.gradle fichier et configurez l’adresse du référentiel Maven pour le SDK HMS Core.
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
repositories {
google()
jcenter()
maven {url "https://developer.huawei.com/repo/" }
}
}
}5. Ajoutez la dépendance de construction suivante dans le dépendances bloquer.
dependencies {
implementation 'com.huawei.hms:arenginesdk:{version}
}Développement d’applications
1. Vérifiez si AR Engine a été installé sur l’appareil actuel. Si tel est le cas, votre application pourra fonctionner correctement. Si ce n’est pas le cas, vous devez inviter l’utilisateur à installer AR Engine, par exemple en le redirigeant vers AppGallery. L’exemple de code est le suivant :
boolean isInstallArEngineApk =AREnginesApk.isAREngineApkReady(this);
if (!isInstallArEngineApk) {
// ConnectAppMarketActivity.class is the activity for redirecting users to AppGallery.
startActivity(new Intent(this, com.huawei.arengine.demos.common.ConnectAppMarketActivity.class));
isRemindInstall = true;
}2. Initialisez une scène AR. AR Engine prend en charge jusqu’à cinq scènes, y compris le suivi de mouvement (ARWorldTrackingConfig), suivi du visage (ARFaceTrackingConfig), reconnaissance de la main (ARHandTrackingConfig), suivi du corps humain (ARBodyTrackingConfig), et la reconnaissance d’image(ARImageTrackingConfig).
3. Appelez le ARBodyTrackingConfig API pour initialiser la scène de suivi du corps humain.
mArSession = new ARSession(context)
ARBodyTrackingConfig config = new ARHandTrackingConfig(mArSession);
Config.setEnableItem(ARConfigBase.ENABLE_DEPTH | ARConfigBase.ENABLE.MASK);
Configure the session information.
mArSession.configure(config);4. Initialisez le Affichage lié au corps API pour restituer les données liées au type AR principal.
Public interface BodyRelatedDisplay{
Void init();
Void onDrawFrame (Collection<ARBody> bodies,float[] projectionMatrix) ;
}5. Initialisez le BodyRenderManager classe, qui est utilisée pour rendre les données personnelles obtenues par AREngine.
Public class BodyRenderManager implements GLSurfaceView.Renderer{
// Implement the onDrawFrame() method.
Public void onDrawFrame(){
ARFrame frame = mSession.update();
ARCamera camera = Frame.getCramera();
// Obtain the projection matrix of the AR camera.
Camera.getProjectionMatrix();
// Obtain the set of all traceable objects of the specified type and pass ARBody.class to return the human body tracking result.
Collection<ARBody> bodies = mSession.getAllTrackbles(ARBody.class);
}
}6. Initialiser CorpsSqueletteAffichage pour obtenir des données squelettes et transmettre les données à OpenGL ES, qui restituera les données et les affichera sur l’écran de l’appareil.
Public class BodySkeletonDisplay implements BodyRelatedDisplay{
// Methods used in this class are as follows:
// Initialization method.
public void init(){
}
// Use OpenGL to update and draw the node data.
Public void onDrawFrame(Collection<ARBody> bodies,float[] projectionMatrix){
for (ARBody body : bodies) {
if (body.getTrackingState() == ARTrackable.TrackingState.TRACKING) {
float coordinate = 1.0f;
if (body.getCoordinateSystemType() == ARCoordinateSystemType.COORDINATE_SYSTEM_TYPE_3D_CAMERA) {
coordinate = DRAW_COORDINATE;
}
findValidSkeletonPoints(body);
updateBodySkeleton();
drawBodySkeleton(coordinate, projectionMatrix);
}
}
}
// Search for valid skeleton points.
private void findValidSkeletonPoints(ARBody arBody) {
int index = 0;
int[] isExists;
int validPointNum = 0;
float[] points;
float[] skeletonPoints;
if (arBody.getCoordinateSystemType() == ARCoordinateSystemType.COORDINATE_SYSTEM_TYPE_3D_CAMERA) {
isExists = arBody.getSkeletonPointIsExist3D();
points = new float[isExists.length * 3];
skeletonPoints = arBody.getSkeletonPoint3D();
} else {
isExists = arBody.getSkeletonPointIsExist2D();
points = new float[isExists.length * 3];
skeletonPoints = arBody.getSkeletonPoint2D();
}
for (int i = 0; i < isExists.length; i++) {
if (isExists[i] != 0) {
points[index++] = skeletonPoints[3 * i];
points[index++] = skeletonPoints[3 * i + 1];
points[index++] = skeletonPoints[3 * i + 2];
validPointNum++;
}
}
mSkeletonPoints = FloatBuffer.wrap(points);
mPointsNum = validPointNum;
}
}7. Obtenez les données de connexion du point squelette et transmettez-les à OpenGL ES, qui restituera ensuite les données et les affichera sur l’écran de l’appareil.
public class BodySkeletonLineDisplay implements BodyRelatedDisplay {
// Render the lines between body bones.
public void onDrawFrame(Collection<ARBody> bodies, float[] projectionMatrix) {
for (ARBody body : bodies) {
if (body.getTrackingState() == ARTrackable.TrackingState.TRACKING) {
float coordinate = 1.0f;
if (body.getCoordinateSystemType() == ARCoordinateSystemType.COORDINATE_SYSTEM_TYPE_3D_CAMERA) {
coordinate = COORDINATE_SYSTEM_TYPE_3D_FLAG;
}
updateBodySkeletonLineData(body);
drawSkeletonLine(coordinate, projectionMatrix);
}
}
}
}
Conclusion
En mélangeant les mondes réel et virtuel, la réalité augmentée donne aux utilisateurs les outils dont ils ont besoin pour superposer des effets créatifs dans des environnements réels et interagir avec ces éléments virtuels imaginaires. La réalité augmentée facilite la création d’interactions fantaisistes et immersives qui améliorent l’expérience utilisateur. De l’essayage virtuel, du gameplay, de la prise de vue photo et vidéo au lancement de produit, en passant par la formation et l’apprentissage, et la décoration de la maison, tout est rendu plus facile et plus intéressant…