Fond
Il y a environ six mois, j’ai décidé de commencer à décorer ma nouvelle maison. Avant de me lancer, j’ai fait de nombreuses recherches sur une variété de sujets liés à la décoration intérieure, comme comment choisir une palette de couleurs cohérente, quelles mesures prendre et comment les faire, et comment choisir le bon mobilier. Cependant, mes préparatifs m’ont fait réaliser que peu importe à quel point vous êtes bien préparé, vous allez toujours rencontrer de nombreux défis inattendus.
Avant de me précipiter au magasin de meubles, j’ai répertorié tous les différents meubles que je voulais placer dans mon salon, y compris un canapé, une table à thé, des plantes en pot, une table à manger et un tapis, et j’ai déterminé les dimensions, couleurs et styles de ces différents meubles.
Cependant, lorsque je suis finalement arrivé au magasin de meubles, la variété vertigineuse de choix m’a troublé et j’ai trouvé très difficile d’imaginer à quoi ressembleraient les différents choix de meubles dans un salon réel. À ce moment-là, une pensée m’est venue à l’esprit : ne serait-il pas formidable qu’il y ait une application qui permette aux utilisateurs de télécharger des images de leur maison, puis de sélectionner librement différents produits d’ameublement pour voir à quoi ils ressembleront dans leur maison ? Une telle application permettrait sûrement aux utilisateurs souhaitant décorer leur maison d’économiser beaucoup de temps et de problèmes inutiles et réduirait les risques d’insatisfaction des utilisateurs avec le résultat final de la décoration.
C’est alors que l’idée de développer une application par moi-même m’est venue à l’esprit. Mon idée initiale était de concevoir une application que les gens pourraient utiliser pour les aider à satisfaire rapidement leurs besoins de décoration intérieure en leur permettant de voir à quoi ressembleraient les meubles dans leur maison. Le fonctionnement de base de l’application est que les utilisateurs téléchargent d’abord une ou plusieurs images d’une pièce qu’ils souhaitent décorer, puis définissent un paramètre de référence, tel que la distance entre le sol et le plafond. Armée de ces informations, l’application calculerait alors automatiquement les paramètres des autres zones de la pièce. Ensuite, les utilisateurs peuvent télécharger des images de meubles qu’ils aiment dans un panier virtuel. Lors du téléchargement de telles images, les utilisateurs doivent spécifier les dimensions du meuble. Depuis l’écran d’édition, les utilisateurs peuvent faire glisser et déposer des meubles du panier sur l’image de la pièce pour prévisualiser l’effet. Mais alors un problème se pose : les images de meubles traînés et déposés dans la pièce semblent collées et ne se fondent pas naturellement avec leur environnement.
Par un coup de chance, j’ai découvert HMS Core AR Engine en cherchant une solution au problème susmentionné. Ce kit de développement offre la possibilité d’intégrer des objets virtuels de manière réaliste dans le monde réel, ce qui est exactement ce dont mon application a besoin. Grâce à sa capacité de détection d’avions, mon application pourra détecter les vrais avions dans une maison et permettre aux utilisateurs de placer des meubles virtuels basés sur ces avions ; et grâce à sa capacité de test de réussite, les utilisateurs peuvent interagir avec des meubles virtuels pour changer leur position et leur orientation de manière naturelle.
AR Engine suit l’éclairage, les plans, les images, les objets, les surfaces et d’autres informations environnementales pour permettre aux applications d’intégrer des objets virtuels dans le monde physique et d’avoir l’apparence et le comportement qu’ils auraient s’ils étaient réels. Sa capacité de détection de plan identifie les points caractéristiques en groupes sur des plans horizontaux et verticaux, ainsi que les limites des plans, garantissant que votre application peut y placer des objets virtuels.
De plus, le kit suit en permanence l’emplacement et l’orientation des appareils par rapport à leur environnement et établit un espace géométrique unifié entre le monde virtuel et le monde physique. Le kit utilise sa capacité de test de frappe pour cartographier un point d’intérêt que les utilisateurs appuient sur l’écran à un point d’intérêt dans l’environnement réel, d’où un rayon sera émis pointant vers l’emplacement de la caméra de l’appareil, et renverra le point d’intersection entre le rayon et le plan. De cette façon, les utilisateurs peuvent interagir avec n’importe quel objet virtuel sur l’écran de leur appareil.
Fonctions et caractéristiques
- Détection de plan : les plans horizontaux et verticaux sont pris en charge.
- Précision : La marge d’erreur est d’environ 2,5 cm lorsque le plan cible est à 1 m de la caméra.
- Délai de reconnaissance de texture : < 1s
- Prend en charge l’ajustement de polygones et la fusion de plans.
Développement de la détection de plan
1. Créez un WorldActivity chose. Cet exemple montre comment utiliser le scénario AR mondial d’AR Engine.
Public class WorldActivity extends BaseActivity{
Protected void onCreate (Bundle saveInstanceState) {
Initialize DisplayRotationManager.
mDisplayRotationManager = new DisplayRotationManager(this);
Initialize WorldRenderManager.
mWorldRenderManager = new WorldRenderManager(this,this);
}
// Create a gesture processor.
Private void initGestureDetector(){
mGestureDetector = new GestureDetector(this,new GestureDetector.SimpleOnGestureListener()){
}
}
mSurfaceView.setOnTouchListener(new View.OnTouchListener()){
public Boolean onTouch(View v,MotionEvent event){
return mGestureDetector.onTouchEvent(event);
}
}
// Create ARWorldTrackingConfig in the onResume lifecycle.
protected void onResume(){
mArSession = new ARSession(this.getApplicationContext());
mConfig = new ARWorldTrackingConfig(mArSession);
…
}
// Initialize a refresh configuration class.
private void refreshConfig(int lightingMode){
// Set the focus.
mConfig.setFocusMode(ARConfigBase.FocusMode.AUTO_FOCUS);
mArSession.configure(mConfig);
}
}2. Initialisez le WorldRenderManager classe, qui gère le rendu lié aux scénarios du monde, y compris le rendu des étiquettes et le rendu des objets virtuels.
public class WorldRenderManager implements GLSurfaceView.Renderr{
// Initialize a class for frame drawing.
Public void onDrawFrame(GL10 unused){
// Set the openGL textureId for storing the camera preview stream data.
mSession.setCameraTextureName(mTextureDisplay.getExternalTextureId());
// Update the calculation result of AR Engine. You are advised to call this API when your app needs to obtain the latest data.
ARFrame arFrame = mSession.update();
// Obtains the camera specifications of the current frame.
ARCamera arCamera = arFrame.getCamera();
// Returns a projection matrix used for coordinate calculation, which can be used for the transformation from the camera coordinate system to the clip coordinate system.
arCamera.getProjectionMatrix(projectionMatrix, PROJ_MATRIX_OFFSET, PROJ_MATRIX_NEAR, PROJ_MATRIX_FAR);
Session.getAllTrackables(ARPlane.class)
...
}
}3. Initialisez le VirtualObject classe, qui fournit les propriétés de l’objet virtuel et les méthodes nécessaires pour rendre l’objet virtuel.
Public class VirtualObject{
}4. Initialisez le ObjectDisplay classe pour dessiner des objets virtuels en fonction de paramètres spécifiés.
Public class ObjectDisplay{
}Développer des tests de réussite
1. Initialisez le WorldRenderManager classe, qui gère le rendu lié aux scénarios du monde, y compris le rendu des étiquettes et le rendu des objets virtuels.
public class WorldRenderManager implementsGLSurfaceView.Renderer{
// Pass the context.
public WorldRenderManager(Activity activity, Context context) {
mActivity = activity;
mContext = context;
…
}
// Set ARSession, which updates and obtains the latest data in OnDrawFrame.
public void setArSession(ARSession arSession) {
if (arSession == null) {
LogUtil.error(TAG, "setSession error, arSession is null!");
return;
}
mSession = arSession;
}
// Set ARWorldTrackingConfig to obtain the configuration mode.
public void setArWorldTrackingConfig(ARWorldTrackingConfig arConfig) {
if (arConfig == null) {
LogUtil.error(TAG, "setArWorldTrackingConfig error, arConfig is null!");
return;
}
mArWorldTrackingConfig = arConfig;
}
// Implement the onDrawFrame() method.
@Override
public void onDrawFrame(GL10 unused) {
mSession.setCameraTextureName(mTextureDisplay.getExternalTextureId());
ARFrame arFrame = mSession.update();
ARCamera arCamera = arFrame.getCamera();
...
}
// Output the hit result.
private ARHitResult hitTest4Result(ARFrame frame, ARCamera camera, MotionEvent event) {
ARHitResult hitResult = null;
List<ARHitResult> hitTestResults = frame.hitTest(event);
// Determine whether the hit point is within the plane polygon.
ARHitResult hitResultTemp = hitTestResults.get(i);
if (hitResultTemp == null) {
continue;
}
ARTrackable trackable = hitResultTemp.getTrackable();
// Determine whether the point cloud is tapped and whether the point faces the camera.
boolean isPointHitJudge = trackable instanceof ARPoint
&& ((ARPoint) trackable).getOrientationMode() == ARPoint.OrientationMode.ESTIMATED_SURFACE_NORMAL;
// Select points on the plane preferentially.
if (isPlanHitJudge || isPointHitJudge) {
hitResult = hitResultTemp;
if (trackable instanceof ARPlane) {
break;
}
}
return hitResult;
}
}2. Créez un WorldActivity chose. Cet exemple montre comment utiliser le scénario AR mondial d’AR Engine.
public class WorldActivity extends BaseActivity {
private ARSession mArSession;
private GLSurfaceView mSurfaceView;
private ARWorldTrackingConfig mConfig;
@Override
protected void onCreate(Bundle savedInstanceState) {
LogUtil.info(TAG, "onCreate");
super.onCreate(savedInstanceState);
setContentView(R.layout.world_java_activity_main);
mWorldRenderManager = new WorldRenderManager(this, this);
mWorldRenderManager.setDisplayRotationManage(mDisplayRotationManager);
mWorldRenderManager.setQueuedSingleTaps(mQueuedSingleTaps)
}
@Override
protected void onResume() {
if (!PermissionManager.hasPermission(this)) {
this.finish();
}
errorMessage = null;
if (mArSession == null) {
try {
if (!arEngineAbilityCheck()) {
finish();
...