Upload 37 files

experiments/image2image/image2image.py

@@ -0,0 +1,110 @@
+import torch
+import numpy as np
+import cv2
+from PIL import Image
+from diffusers import (
+    StableDiffusionControlNetPipeline, 
+    ControlNetModel, 
+    UniPCMultistepScheduler, 
+    AutoencoderKL,
+    StableDiffusionControlNetImg2ImgPipeline
+)
+
+# 1. Load both ControlNet models
+controlnets = [
+    ControlNetModel.from_pretrained("lllyasviel/control_v11f1p_sd15_depth", torch_dtype=torch.float16),
+    ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_canny", torch_dtype=torch.float16)
+]
+
+# 2. Load the base pipeline with the high-quality VAE
+vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", torch_dtype=torch.float16)
+# pipe = StableDiffusionControlNetPipeline.from_pretrained(
+#     "runwayml/stable-diffusion-v1-5", 
+#     controlnet=controlnets, 
+#     vae=vae,
+#     torch_dtype=torch.float16
+# )
+# pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+
+pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", 
+    controlnet=controlnets, 
+    vae=vae,
+    torch_dtype=torch.float16
+)
+pipe.enable_model_cpu_offload()
+
+# 3. Prepare Control Images
+init_image = Image.open("input/isaacsim.jpg").convert("RGB")
+# A. Depth Map Processing (Invert + CLAHE)
+depth_map_np = np.load("input/depth.npy")
+depth_map_np = np.clip(depth_map_np, 0, 20)
+depth_map_normalized = (depth_map_np - np.min(depth_map_np)) / (np.max(depth_map_np) - np.min(depth_map_np))
+depth_map_inverted = ( (1.0 - depth_map_normalized) * 255 ).astype(np.uint8)
+clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8,8))
+depth_final = Image.fromarray(clahe.apply(depth_map_inverted)).convert("RGB")
+
+# B. Canny Edge Processing (From your Isaac Sim RGB image)
+isaac_rgb = cv2.imread("input/isaacsim.jpg")
+# Detect edges (Thresholds 100, 200 are usually good for clean synthetic renders)
+canny_edges = cv2.Canny(isaac_rgb, 100, 200)
+canny_final = Image.fromarray(canny_edges).convert("RGB")
+
+# 4. Prompt based on Rosario/Real images
+prompt = ( 
+        "A photorealistic high-angle shot of a soybean field in Brazil." 
+        "real image, agriculture scene, natural lighting, high detail, 4k resolution," 
+        "field image," 
+        "Vibrant green leaves with detailed veins," 
+        "haze scattering effect" 
+        "leaves with natural aspects," 
+        "dark brown cloddy soil with organic dirt textures and pebbles,"
+        )
+negative_prompt = "cartoon, 3d render, plastic, smooth floor, blurry, low quality"
+
+# 5. Run Inference
+# We pass a list of images to match our list of ControlNets
+# conditioning_scale [0.8, 0.4] tells the AI: "Prioritize Depth structure, but use Canny for the sharp lines"
+generator = torch.Generator(device="cuda").manual_seed(42)
+
+# output_image = pipe(
+#     prompt=prompt,
+#     negative_prompt=negative_prompt,
+#     image=[depth_final, canny_final],
+#     num_inference_steps=10,
+#     guidance_scale=4.2,
+#     strength=0.27,
+#     controlnet_conditioning_scale=[0.8, 0.4], 
+#     generator=generator
+# ).images[0]
+
+output_image = pipe(
+    prompt=prompt,
+    negative_prompt=negative_prompt,
+    image=init_image,           # The "Starting" image for light/color
+    control_image=[depth_final, canny_final], # The "Guides" for geometry
+    num_inference_steps=50,     # Higher steps = better texture
+    strength=0.42,               # 0.7 allows significant texture replacement
+    guidance_scale=7.7,         # Higher guidance forces it to follow the prompt
+    controlnet_conditioning_scale=[0.9, 0.9],  # Both ControlNets are important for structure and details
+    generator=generator
+).images[0]
+
+output_image.save("soybean_translated.png")
+
+# Visualize the results, input, depth, canny, and output
+import matplotlib.pyplot as plt
+fig, axs = plt.subplots(2, 2, figsize=(20, 5))
+axs[0,0].imshow(cv2.cvtColor(isaac_rgb, cv2.COLOR_BGR2RGB))
+axs[0,0].set_title("Isaac Sim RGB")
+axs[0,0].axis("off")
+axs[1,0].imshow(depth_final)
+axs[1,0].set_title("Depth Map (Inverted + CLAHE)")
+axs[1,0].axis("off")
+axs[1,1].imshow(canny_final)
+axs[1,1].set_title("Canny Edges")
+axs[1,1].axis("off")
+axs[0,1].imshow(output_image)
+axs[0,1].set_title("Generated Image")
+axs[0,1].axis("off")
+plt.show()

experiments/image2image/image_similarity.py

@@ -0,0 +1,605 @@
+import torch
+import torch.nn.functional as F
+from torchvision import models, transforms
+from PIL import Image
+import numpy as np
+import os
+from pathlib import Path
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy.spatial.distance import sqeuclidean
+from scipy import linalg
+
+class ImageSimilarityFinder:
+    def __init__(self, model_name='resnet50', device=None):
+        """
+        Initialize the image similarity finder with a vision encoder model.
+        
+        Args:
+            model_name: Name of the pretrained model ('resnet50', 'vit_b_32', etc.)
+            device: torch device (cuda or cpu)
+        """
+        self.device = device if device else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {self.device}")
+        
+        # Load pretrained model
+        if model_name == 'resnet50':
+            self.model = models.resnet50(pretrained=True)
+            # Remove the final classification layer to get embeddings
+            self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+        elif model_name == 'efficientnet':
+            self.model = models.efficientnet_b0(pretrained=True)
+            self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+        else:
+            raise ValueError(f"Model {model_name} not supported")
+        
+        self.model = self.model.to(self.device)
+        self.model.eval()
+        
+        # Image preprocessing
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+    
+    def get_image_embedding(self, image_path):
+        """Extract embedding from an image."""
+        image = Image.open(image_path).convert('RGB')
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            embedding = self.model(image_tensor)
+        
+        # Flatten the embedding
+        embedding = embedding.view(embedding.size(0), -1)
+        return embedding
+    
+    def compute_similarity(self, embedding1, embedding2, metric='cosine'):
+        """
+        Compute similarity between two embeddings.
+        
+        Args:
+            embedding1, embedding2: Image embeddings
+            metric: 'cosine' or 'euclidean'
+        
+        Returns:
+            Similarity score (0-1 for cosine)
+        """
+        if metric == 'cosine':
+            similarity = F.cosine_similarity(embedding1, embedding2, dim=1)
+        elif metric == 'euclidean':
+            distance = torch.norm(embedding1 - embedding2, dim=1)
+            similarity = 1 / (1 + distance)  # Convert distance to similarity
+        else:
+            raise ValueError(f"Metric {metric} not supported")
+        
+        return similarity.item()
+    
+    def find_similar_images(self, folder_path, metric='cosine', target_image_file=None):
+        """
+        Find similarities between images in a folder.
+        
+        If target_image_file is specified, computes similarity of all other images to that one.
+        Otherwise, computes an all-vs-all similarity matrix.
+        
+        Args:
+            folder_path: Path to folder containing images
+            metric: 'cosine' or 'euclidean'
+            target_image_file: Filename of the image to compare against others.
+        
+        Returns:
+            If target_image_file is given: (other_image_files, similarity_scores_1d)
+            If target_image_file is None: (all_image_files, similarity_matrix_2d)
+        """
+        # Get all image files
+        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif'}
+        image_files = [
+            f for f in os.listdir(folder_path)
+            if os.path.splitext(f)[1].lower() in image_extensions
+        ]
+        
+        if not image_files:
+            print("No images found in the folder!")
+            return None
+        
+        print(f"Found {len(image_files)} images: {image_files}")
+        
+        # Get embeddings for all images
+        embeddings = {}
+        print("\nExtracting embeddings...")
+        for img_file in image_files:
+            img_path = os.path.join(folder_path, img_file)
+            embedding = self.get_image_embedding(img_path)
+            embeddings[img_file] = embedding
+            print(f"  ✓ {img_file}")
+
+        if target_image_file:
+            if target_image_file not in embeddings:
+                print(f"Error: Target image '{target_image_file}' not found in folder.")
+                return None
+            
+            print(f"\nComputing similarity of '{target_image_file}' against other images...")
+            target_embedding = embeddings[target_image_file]
+            
+            other_files = [f for f in image_files if f != target_image_file]
+            scores = []
+            
+            for other_file in other_files:
+                score = self.compute_similarity(target_embedding, embeddings[other_file], metric=metric)
+                scores.append(score)
+            
+            return other_files, np.array(scores)
+        
+        else:
+            # Compute similarity matrix
+            n_images = len(image_files)
+            similarity_matrix = np.zeros((n_images, n_images))
+            
+            print("\nComputing similarities...")
+            for i, img1 in enumerate(image_files):
+                for j, img2 in enumerate(image_files):
+                    similarity = self.compute_similarity(
+                        embeddings[img1],
+                        embeddings[img2],
+                        metric=metric
+                    )
+                    similarity_matrix[i, j] = similarity
+            
+            return image_files, similarity_matrix
+    
+    def plot_similarity_matrix(self, image_files, similarity_matrix, save_path=None, folder_path=None, target_image_file=None):
+        """Visualize the similarity matrix as a heatmap, or as a bar chart if a target image is provided."""
+        
+        if target_image_file and folder_path and similarity_matrix.ndim == 1:
+            # One-vs-all bar chart
+            from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+            plt.figure(figsize=(15, 9))
+            ax = plt.gca()
+
+            # Sort for better visualization
+            sorted_indices = np.argsort(similarity_matrix)[::-1]
+            sorted_files = [image_files[i] for i in sorted_indices]
+            sorted_scores = similarity_matrix[sorted_indices]
+
+            ax.bar(range(len(sorted_files)), sorted_scores, color='lightblue')
+
+            ax.set_xticks(range(len(sorted_files)))
+            ax.set_xticklabels([])  # Hide text labels, we will use images
+
+            for i, filename in enumerate(sorted_files):
+                try:
+                    img_path = os.path.join(folder_path, filename)
+                    img = Image.open(img_path).convert("RGB")
+                    img.thumbnail((120, 120))  # Resize for label
+
+                    oi = OffsetImage(img, zoom=0.7)
+                    box = AnnotationBbox(oi, (i, 0), frameon=False, xybox=(0, -50), boxcoords="data", pad=0, xycoords="data", box_alignment=(0.5, 1.0))
+                    ax.add_artist(box)
+                    
+                    # Add score text above bar
+                    ax.text(i, sorted_scores[i] + 0.01, f'{sorted_scores[i]:.3f}', ha='center', va='bottom', fontsize=9)
+
+                except FileNotFoundError:
+                    print(f"Warning: could not find image {filename} to create label.")
+                    ax.text(i, -0.1, filename, rotation=90, ha='center', va='top')
+
+            ax.set_ylim(0, 1.1)
+            ax.set_xlim(-0.7, len(image_files) - 0.3)
+            ax.set_ylabel('Cosine Similarity (higher = more similar)')
+            ax.set_title(f'Similarity of other images compared to "{target_image_file}"')
+            plt.tight_layout(rect=[0, 0.1, 1, 0.95]) # Adjust layout to make space for images
+
+        else:
+            # Original heatmap for matrix
+            plt.figure(figsize=(10, 8))
+            sns.heatmap(
+                similarity_matrix,
+                xticklabels=image_files,
+                yticklabels=image_files,
+                annot=True,
+                fmt='.3f',
+                cmap='coolwarm',
+                vmin=0,
+                vmax=1
+            )
+            plt.title('Image Similarity Matrix (Cosine Similarity)')
+            plt.tight_layout()
+
+        if save_path:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            plt.savefig(save_path, dpi=150, bbox_inches='tight')
+            print(f"\nPlot saved to {save_path}")
+        
+        plt.show()
+    
+    def print_similarity_results(self, image_files, similarity_matrix, target_image_file=None):
+        """Print similarity results in a readable format."""
+        print("\n" + "="*80)
+        print("IMAGE SIMILARITY RESULTS")
+        print("="*80 + "\n")
+
+        if target_image_file and similarity_matrix.ndim == 1:
+            print(f"Similarities compared to '{target_image_file}':\n")
+            
+            # Sort for printing
+            sorted_pairs = sorted(zip(similarity_matrix, image_files), reverse=True)
+
+            for similarity, img_file in sorted_pairs:
+                bar_length = int(similarity * 40)
+                bar = '█' * bar_length + '░' * (40 - bar_length)
+                print(f"{img_file}")
+                print(f"  [{bar}] {similarity:.4f}")
+        else:
+            for i in range(len(image_files)):
+                for j in range(i + 1, len(image_files)):
+                    img1 = image_files[i]
+                    img2 = image_files[j]
+                    similarity = similarity_matrix[i, j]
+                    
+                    # Create a visual representation
+                    bar_length = int(similarity * 40)
+                    bar = '█' * bar_length + '░' * (40 - bar_length)
+                    
+                    print(f"{img1} <-> {img2}")
+                    print(f"  [{bar}] {similarity:.4f}")
+
+
+class FIDSimilarityFinder:
+    """Compute Fréchet Inception Distance (FID) between images."""
+    
+    def __init__(self, device=None):
+        """
+        Initialize FID calculator using InceptionV3 model.
+        
+        Args:
+            device: torch device (cuda or cpu)
+        """
+        self.device = device if device else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {self.device}")
+        
+        # Load InceptionV3 model (pretrained on ImageNet)
+        inception = models.inception_v3(pretrained=True)
+        inception.eval()
+        
+        # Create a wrapper to extract features before the final layer
+        class InceptionFeatureExtractor(torch.nn.Module):
+            def __init__(self, inception_model):
+                super().__init__()
+                self.inception = inception_model
+                # Remove the final fc layer
+                self.inception.fc = torch.nn.Identity()
+            
+            def forward(self, x):
+                # Pass through all layers except fc
+                x = self.inception.Conv2d_1a_3x3(x)
+                x = self.inception.Conv2d_2a_3x3(x)
+                x = self.inception.Conv2d_2b_3x3(x)
+                x = self.inception.maxpool1(x)
+                x = self.inception.Conv2d_3b_1x1(x)
+                x = self.inception.Conv2d_4a_3x3(x)
+                x = self.inception.maxpool2(x)
+                x = self.inception.Mixed_5b(x)
+                x = self.inception.Mixed_5c(x)
+                x = self.inception.Mixed_5d(x)
+                x = self.inception.Mixed_6a(x)
+                x = self.inception.Mixed_6b(x)
+                x = self.inception.Mixed_6c(x)
+                x = self.inception.Mixed_6d(x)
+                x = self.inception.Mixed_6e(x)
+                x = self.inception.Mixed_7a(x)
+                x = self.inception.Mixed_7b(x)
+                x = self.inception.Mixed_7c(x)
+                x = self.inception.avgpool(x)
+                x = torch.flatten(x, 1)
+                return x
+        
+        self.model = InceptionFeatureExtractor(inception)
+        self.model = self.model.to(self.device)
+        self.model.eval()
+        
+        # Image preprocessing for InceptionV3
+        self.transform = transforms.Compose([
+            transforms.Resize((299, 299)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+    
+    def get_inception_features(self, image_path):
+        """Extract InceptionV3 features from an image."""
+        image = Image.open(image_path).convert('RGB')
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            # Pass through the model up to the average pool
+            features = self.model(image_tensor)
+            # Flatten to 1D vector for each image
+            features = features.view(features.size(0), -1)
+        
+        return features.cpu().numpy()
+    
+    def calculate_frechet_distance(self, mu1, sigma1, mu2, sigma2, eps=1e-6):
+        """Calculate Fréchet distance between two Gaussians."""
+        mu1 = np.atleast_1d(mu1)
+        mu2 = np.atleast_1d(mu2)
+        sigma1 = np.atleast_2d(sigma1)
+        sigma2 = np.atleast_2d(sigma2)
+        
+        assert mu1.shape == mu2.shape, "Statistics must have matching dimensions"
+        assert sigma1.shape == sigma2.shape, "Statistics must have matching dimensions"
+        
+        # Compute difference
+        diff = mu1 - mu2
+        
+        # Compute matrix square root
+        covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
+        
+        # Handle complex results
+        if np.iscomplexobj(covmean):
+            covmean = covmean.real
+        
+        # Calculate FID
+        tr_covmean = np.trace(covmean)
+        fid = diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean
+        
+        return np.sqrt(np.maximum(fid, 0.0))
+    
+    def compute_fid_matrix(self, folder_path, target_image_file=None):
+        """
+        Compute FID between all pairs of images in a folder, or against a single target image.
+        Lower FID indicates higher similarity.
+        
+        Args:
+            folder_path: Path to folder containing images
+            target_image_file: If specified, compute FID of other images against this one.
+        
+        Returns:
+            image_files, fid_scores (1D or 2D array)
+        """
+        # Get all image files
+        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif'}
+        image_files = sorted([
+            f for f in os.listdir(folder_path)
+            if os.path.splitext(f)[1].lower() in image_extensions
+        ])
+        
+        if not image_files:
+            print("No images found in the folder!")
+            return None
+        
+        print(f"Found {len(image_files)} images: {image_files}")
+        
+        # Extract features for all images
+        all_features = {}
+        print("\nExtracting InceptionV3 features...")
+        for img_file in image_files:
+            img_path = os.path.join(folder_path, img_file)
+            features = self.get_inception_features(img_path)
+            all_features[img_file] = features
+            print(f"  ✓ {img_file}")
+
+        if target_image_file:
+            if target_image_file not in all_features:
+                print(f"Error: Target image '{target_image_file}' not found.")
+                return None
+                
+            print(f"\nComputing FID of '{target_image_file}' against other images...")
+            target_mu = all_features[target_image_file].flatten()
+
+            other_files = [f for f in image_files if f != target_image_file]
+            fid_scores = []
+            
+            for other_file in other_files:
+                other_mu = all_features[other_file].flatten()
+                fid = np.linalg.norm(other_mu - target_mu)
+                fid_scores.append(fid)
+            
+            return other_files, np.array(fid_scores)
+
+        else:
+            # Compute FID matrix
+            n_images = len(image_files)
+            fid_matrix = np.zeros((n_images, n_images))
+            
+            print("\nComputing FID-based distances...")
+            
+            for i in range(n_images):
+                for j in range(i, n_images):
+                    if i == j:
+                        fid_matrix[i, j] = 0.0
+                    else:
+                        mu1 = all_features[image_files[i]].flatten()
+                        mu2 = all_features[image_files[j]].flatten()
+                        
+                        # Compute Euclidean distance as FID approximation
+                        fid = np.linalg.norm(mu1 - mu2)
+                        fid_matrix[i, j] = fid
+                        fid_matrix[j, i] = fid
+            
+            return image_files, fid_matrix
+    
+    def plot_fid_matrix(self, image_files, fid_matrix, save_path=None, folder_path=None, target_image_file=None):
+        """Visualize the FID matrix as a heatmap, or as a bar chart if a target image is provided."""
+        if target_image_file and folder_path and fid_matrix.ndim == 1:
+            # One-vs-all bar chart for FID
+            from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+            plt.figure(figsize=(15, 9))
+            ax = plt.gca()
+
+            # Sort by distance (ascending)
+            sorted_indices = np.argsort(fid_matrix)
+            sorted_files = [image_files[i] for i in sorted_indices]
+            sorted_scores = fid_matrix[sorted_indices]
+
+            ax.bar(range(len(sorted_files)), sorted_scores, color='lightgreen')
+
+            ax.set_xticks(range(len(sorted_files)))
+            ax.set_xticklabels([])
+
+            for i, filename in enumerate(sorted_files):
+                try:
+                    img_path = os.path.join(folder_path, filename)
+                    img = Image.open(img_path).convert("RGB")
+                    img.thumbnail((120, 120))
+
+                    oi = OffsetImage(img, zoom=0.7)
+                    box = AnnotationBbox(oi, (i, 0), frameon=False, xybox=(0, -50), boxcoords="data", pad=0, xycoords="data", box_alignment=(0.5, 1.0))
+                    ax.add_artist(box)
+                    
+                    ax.text(i, sorted_scores[i], f'{sorted_scores[i]:.2f}', ha='center', va='bottom', fontsize=9, bbox=dict(facecolor='white', alpha=0.5, pad=1))
+                except FileNotFoundError:
+                    print(f"Warning: could not find image {filename} to create label.")
+                    ax.text(i, -0.1, filename, rotation=90, ha='center', va='top')
+            
+            if len(sorted_scores) > 0:
+                ax.set_ylim(0, max(sorted_scores) * 1.15)
+            ax.set_xlim(-0.7, len(image_files) - 0.3)
+            ax.set_ylabel('FID Distance (lower = more similar)')
+            ax.set_title(f'FID Distance of other images from "{target_image_file}"')
+            plt.tight_layout(rect=[0, 0.1, 1, 0.95])
+
+        else:
+            # Original heatmap
+            plt.figure(figsize=(10, 8))
+            sns.heatmap(
+                fid_matrix,
+                xticklabels=image_files,
+                yticklabels=image_files,
+                annot=True,
+                fmt='.2f',
+                cmap='RdYlGn_r',  # Reversed: red = high distance (different), green = low distance (similar)
+                cbar_kws={'label': 'FID Distance (lower = more similar)'}
+            )
+            plt.title('Fréchet Inception Distance (FID) Matrix')
+            plt.tight_layout()
+        
+        if save_path:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            plt.savefig(save_path, dpi=150, bbox_inches='tight')
+            print(f"\nHeatmap saved to {save_path}")
+        
+        plt.show()
+    
+    def print_fid_results(self, image_files, fid_matrix, target_image_file=None):
+        """Print FID results in a readable format."""
+        print("\n" + "="*80)
+        print("FRÉCHET INCEPTION DISTANCE (FID) RESULTS")
+        print("="*80)
+        print("\nNote: Lower FID = more similar images\n")
+
+        if target_image_file and fid_matrix.ndim == 1:
+            print(f"FID distances from '{target_image_file}':\n")
+            
+            # Sort for printing
+            sorted_pairs = sorted(zip(fid_matrix, image_files))
+            
+            if not sorted_pairs: return
+
+            max_fid = sorted_pairs[-1][0] if sorted_pairs else 1
+
+            for fid, img_file in sorted_pairs:
+                # Inverted bar: shorter is better
+                bar_length = int((1 - fid / max_fid) * 40) if max_fid > 0 else 0
+                bar = '█' * bar_length + '░' * (40 - bar_length)
+                print(f"{img_file}")
+                print(f"  [{bar}] FID: {fid:.4f}")
+
+        else:
+            # Create sorted list of pairwise distances
+            distances = []
+            for i in range(len(image_files)):
+                for j in range(i + 1, len(image_files)):
+                    distances.append((
+                        image_files[i],
+                        image_files[j],
+                        fid_matrix[i, j]
+                    ))
+            
+            # Sort by FID distance
+            distances.sort(key=lambda x: x[2])
+            
+            if not distances: return
+
+            print("Pairwise FID Distances (sorted by similarity):")
+            max_fid = max(d[2] for d in distances) if distances else 1
+            for img1, img2, fid in distances:
+                # Create a visual representation (inverted: shorter bar = more similar)
+                bar_length = int((1 - fid / max_fid) * 40) if max_fid > 0 else 0
+                bar = '█' * bar_length + '░' * (40 - bar_length)
+                
+                print(f"{img1} <-> {img2}")
+                print(f"  [{bar}] FID: {fid:.4f}")
+
+
+def main():
+    # Set folder path and target image
+    folder_path = "./input"
+    target_image_file = "rosario.jpg"  # The image to compare against others
+    
+    # Check if target file exists
+    if not os.path.exists(os.path.join(folder_path, target_image_file)):
+        print(f"Error: Target image '{target_image_file}' not found in '{folder_path}'")
+        # List other available images
+        try:
+            image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif'}
+            avail_images = [f for f in os.listdir(folder_path) if os.path.splitext(f)[1].lower() in image_extensions]
+            if avail_images:
+                print("Available images:", avail_images)
+        except FileNotFoundError:
+            print(f"Error: Folder '{folder_path}' not found.")
+        return
+
+    print("\n" + "="*80)
+    print("IMAGE SIMILARITY ANALYSIS")
+    print(f"Target Image: {target_image_file}")
+    print("="*80)
+
+    # Always perform both analyses for the target image
+    
+    # Method 1: ResNet50 + Cosine Similarity
+    print("\n" + "="*80)
+    print("METHOD 1: ResNet50 + Cosine Similarity")
+    print("="*80)
+    similarity_finder = ImageSimilarityFinder(model_name='resnet50')
+    
+    results = similarity_finder.find_similar_images(
+        folder_path,
+        metric='cosine',
+        target_image_file=target_image_file
+    )
+    
+    if results:
+        image_files, similarity_scores = results
+        similarity_finder.print_similarity_results(image_files, similarity_scores, target_image_file=target_image_file)
+        output_path = os.path.join(folder_path,'output', f'similarity_to_{Path(target_image_file).stem}_resnet50.png')
+        similarity_finder.plot_similarity_matrix(image_files, similarity_scores, output_path, folder_path=folder_path, target_image_file=target_image_file)
+
+    # Method 2: InceptionV3 + FID
+    print("\n" + "="*80)
+    print("METHOD 2: InceptionV3 + Fréchet Inception Distance (FID)")
+    print("="*80)
+    fid_finder = FIDSimilarityFinder()
+    
+    results = fid_finder.compute_fid_matrix(folder_path, target_image_file=target_image_file)
+    
+    if results:
+        image_files, fid_scores = results
+        fid_finder.print_fid_results(image_files, fid_scores, target_image_file=target_image_file)
+        output_path = os.path.join(folder_path,'output', f'similarity_to_{Path(target_image_file).stem}_fid.png')
+        fid_finder.plot_fid_matrix(image_files, fid_scores, output_path, folder_path=folder_path, target_image_file=target_image_file)
+
+    print("\n" + "="*80)
+    print("✓ Analysis complete!")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()

experiments/image2image/image_similarity_all.py

@@ -0,0 +1,546 @@
+import torch
+import torch.nn.functional as F
+from torchvision import models, transforms
+from PIL import Image
+import numpy as np
+import os
+from pathlib import Path
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy.spatial.distance import sqeuclidean
+from scipy import linalg
+from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+
+
+class ImageSimilarityFinder:
+    def __init__(self, model_name='resnet50', device=None):
+        """
+        Initialize the image similarity finder with a vision encoder model.
+        
+        Args:
+            model_name: Name of the pretrained model ('resnet50', 'vit_b_32', etc.)
+            device: torch device (cuda or cpu)
+        """
+        self.device = device if device else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {self.device}")
+        
+        # Load pretrained model
+        if model_name == 'resnet50':
+            self.model = models.resnet50(pretrained=True)
+            # Remove the final classification layer to get embeddings
+            self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+        elif model_name == 'efficientnet':
+            self.model = models.efficientnet_b0(pretrained=True)
+            self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+        else:
+            raise ValueError(f"Model {model_name} not supported")
+        
+        self.model = self.model.to(self.device)
+        self.model.eval()
+        
+        # Image preprocessing
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+    
+    def get_image_embedding(self, image_path):
+        """Extract embedding from an image."""
+        image = Image.open(image_path).convert('RGB')
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            embedding = self.model(image_tensor)
+        
+        # Flatten the embedding
+        embedding = embedding.view(embedding.size(0), -1)
+        return embedding
+    
+    def compute_similarity(self, embedding1, embedding2, metric='cosine'):
+        """
+        Compute similarity between two embeddings.
+        
+        Args:
+            embedding1, embedding2: Image embeddings
+            metric: 'cosine' or 'euclidean'
+        
+        Returns:
+            Similarity score (0-1 for cosine)
+        """
+        if metric == 'cosine':
+            similarity = F.cosine_similarity(embedding1, embedding2, dim=1)
+        elif metric == 'euclidean':
+            distance = torch.norm(embedding1 - embedding2, dim=1)
+            similarity = 1 / (1 + distance)  # Convert distance to similarity
+        else:
+            raise ValueError(f"Metric {metric} not supported")
+        
+        return similarity.item()
+    
+    def find_similar_images(self, folder_path, metric='cosine'):
+        """
+        Find similarities between all images in a folder.
+        
+        Args:
+            folder_path: Path to folder containing images
+            metric: 'cosine' or 'euclidean'
+        
+        Returns:
+            Dictionary with image names and their similarity matrix
+        """
+        # Get all image files
+        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif'}
+        image_files = [
+            f for f in os.listdir(folder_path)
+            if os.path.splitext(f)[1].lower() in image_extensions
+        ]
+        
+        if not image_files:
+            print("No images found in the folder!")
+            return None
+        
+        print(f"Found {len(image_files)} images: {image_files}")
+        
+        # Get embeddings for all images
+        embeddings = {}
+        print("\nExtracting embeddings...")
+        for img_file in image_files:
+            img_path = os.path.join(folder_path, img_file)
+            embedding = self.get_image_embedding(img_path)
+            embeddings[img_file] = embedding
+            print(f"  ✓ {img_file}")
+        
+        # Compute similarity matrix
+        n_images = len(image_files)
+        similarity_matrix = np.zeros((n_images, n_images))
+        
+        print("\nComputing similarities...")
+        for i, img1 in enumerate(image_files):
+            for j, img2 in enumerate(image_files):
+                similarity = self.compute_similarity(
+                    embeddings[img1],
+                    embeddings[img2],
+                    metric=metric
+                )
+                similarity_matrix[i, j] = similarity
+        
+        return image_files, similarity_matrix
+    
+    # def plot_similarity_matrix(self, image_files, similarity_matrix, save_path=None):
+    #     """Visualize the similarity matrix as a heatmap."""
+    #     plt.figure(figsize=(10, 8))
+    #     sns.heatmap(
+    #         similarity_matrix,
+    #         xticklabels=image_files,
+    #         yticklabels=image_files,
+    #         annot=True,
+    #         fmt='.3f',
+    #         cmap='coolwarm',
+    #         vmin=0,
+    #         vmax=1
+    #     )
+    #     plt.title('Image Similarity Matrix (Cosine Similarity)')
+    #     plt.tight_layout()
+        
+    #     if save_path:
+    #         # Create directory if it doesn't exist
+    #         os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    #         plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    #         print(f"\nHeatmap saved to {save_path}")
+        
+    #     plt.show()
+
+
+    def plot_similarity_matrix(self, image_files, similarity_matrix, folder_path, save_path=None):
+        """Visualize the similarity matrix as a heatmap with images on the axes."""
+        fig, ax = plt.subplots(figsize=(12, 10))
+        
+        # Create the heatmap
+        sns.heatmap(
+            similarity_matrix,
+            annot=True,
+            fmt='.3f',
+            cmap='coolwarm',
+            vmin=0,
+            vmax=1,
+            ax=ax,
+            cbar_kws={'pad': 0.1} # Make room for images
+        )
+
+        def add_image_anchors(axis_type, tick_positions, labels):
+            for i, (pos, img_name) in enumerate(zip(tick_positions, labels)):
+                # Load and thumbnail the image
+                img_path = os.path.join('input', img_name)
+                img = Image.open(img_path).convert('RGB')
+                img.thumbnail((200, 200)) # Resize for the axis
+                
+                imagebox = OffsetImage(img, zoom=0.5) # Adjust zoom based on your DPI
+                
+                if axis_type == 'x':
+                    # Position image below the X-axis
+                    ab = AnnotationBbox(imagebox, (pos, 0),
+                                        xybox=(0, -65), # Distance from axis
+                                        xycoords=('data', 'axes fraction'),
+                                        boxcoords="offset points", 
+                                        frameon=False)
+                else:
+                    # Position image to the left of the Y-axis
+                    ab = AnnotationBbox(imagebox, (0, pos),
+                                        xybox=(-65, 0),
+                                        xycoords=('axes fraction', 'data'),
+                                        boxcoords="offset points", 
+                                        frameon=False)
+                ax.add_artist(ab)
+
+        # Get tick positions (Seaborn centers them at 0.5, 1.5, etc.)
+        tick_positions = np.arange(len(image_files)) + 0.5
+        
+        # Add images to both axes
+        add_image_anchors('x', tick_positions, image_files)
+        add_image_anchors('y', tick_positions, image_files)
+
+        # Remove text labels to avoid clutter
+        ax.set_xticklabels([])
+        ax.set_yticklabels([])
+        
+        plt.title('Visual Image Similarity Matrix', pad=20)
+        plt.tight_layout()
+        
+        if save_path:
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            plt.savefig(save_path, dpi=150, bbox_inches='tight')
+            print(f"\nHeatmap with images saved to {save_path}")
+        
+        plt.show()
+    
+    def print_similarity_results(self, image_files, similarity_matrix):
+        """Print similarity results in a readable format."""
+        print("\n" + "="*80)
+        print("IMAGE SIMILARITY RESULTS")
+        print("="*80 + "\n")
+        
+        for i in range(len(image_files)):
+            for j in range(i + 1, len(image_files)):
+                img1 = image_files[i]
+                img2 = image_files[j]
+                similarity = similarity_matrix[i, j]
+                
+                # Create a visual representation
+                bar_length = int(similarity * 40)
+                bar = '█' * bar_length + '░' * (40 - bar_length)
+                
+                print(f"{img1} <-> {img2}")
+                print(f"  [{bar}] {similarity:.4f}")
+
+
+class FIDSimilarityFinder:
+    """Compute Fréchet Inception Distance (FID) between images."""
+    
+    def __init__(self, device=None):
+        """
+        Initialize FID calculator using InceptionV3 model.
+        
+        Args:
+            device: torch device (cuda or cpu)
+        """
+        self.device = device if device else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {self.device}")
+        
+        # Load InceptionV3 model (pretrained on ImageNet)
+        inception = models.inception_v3(pretrained=True)
+        inception.eval()
+        
+        # Create a wrapper to extract features before the final layer
+        class InceptionFeatureExtractor(torch.nn.Module):
+            def __init__(self, inception_model):
+                super().__init__()
+                self.inception = inception_model
+                # Remove the final fc layer
+                self.inception.fc = torch.nn.Identity()
+            
+            def forward(self, x):
+                # Pass through all layers except fc
+                x = self.inception.Conv2d_1a_3x3(x)
+                x = self.inception.Conv2d_2a_3x3(x)
+                x = self.inception.Conv2d_2b_3x3(x)
+                x = self.inception.maxpool1(x)
+                x = self.inception.Conv2d_3b_1x1(x)
+                x = self.inception.Conv2d_4a_3x3(x)
+                x = self.inception.maxpool2(x)
+                x = self.inception.Mixed_5b(x)
+                x = self.inception.Mixed_5c(x)
+                x = self.inception.Mixed_5d(x)
+                x = self.inception.Mixed_6a(x)
+                x = self.inception.Mixed_6b(x)
+                x = self.inception.Mixed_6c(x)
+                x = self.inception.Mixed_6d(x)
+                x = self.inception.Mixed_6e(x)
+                x = self.inception.Mixed_7a(x)
+                x = self.inception.Mixed_7b(x)
+                x = self.inception.Mixed_7c(x)
+                x = self.inception.avgpool(x)
+                x = torch.flatten(x, 1)
+                return x
+        
+        self.model = InceptionFeatureExtractor(inception)
+        self.model = self.model.to(self.device)
+        self.model.eval()
+        
+        # Image preprocessing for InceptionV3
+        self.transform = transforms.Compose([
+            transforms.Resize((299, 299)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+    
+    def get_inception_features(self, image_path):
+        """Extract InceptionV3 features from an image."""
+        image = Image.open(image_path).convert('RGB')
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            # Pass through the model up to the average pool
+            features = self.model(image_tensor)
+            # Flatten to 1D vector for each image
+            features = features.view(features.size(0), -1)
+        
+        return features.cpu().numpy()
+    
+    def calculate_frechet_distance(self, mu1, sigma1, mu2, sigma2, eps=1e-6):
+        """Calculate Fréchet distance between two Gaussians."""
+        mu1 = np.atleast_1d(mu1)
+        mu2 = np.atleast_1d(mu2)
+        sigma1 = np.atleast_2d(sigma1)
+        sigma2 = np.atleast_2d(sigma2)
+        
+        assert mu1.shape == mu2.shape, "Statistics must have matching dimensions"
+        assert sigma1.shape == sigma2.shape, "Statistics must have matching dimensions"
+        
+        # Compute difference
+        diff = mu1 - mu2
+        
+        # Compute matrix square root
+        covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
+        
+        # Handle complex results
+        if np.iscomplexobj(covmean):
+            covmean = covmean.real
+        
+        # Calculate FID
+        tr_covmean = np.trace(covmean)
+        fid = diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean
+        
+        return np.sqrt(np.maximum(fid, 0.0))
+    
+    def compute_fid_matrix(self, folder_path):
+        """
+        Compute FID between all pairs of images in a folder.
+        Lower FID indicates higher similarity.
+        
+        Args:
+            folder_path: Path to folder containing images
+        
+        Returns:
+            image_files, fid_matrix
+        """
+        # Get all image files
+        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif'}
+        image_files = sorted([
+            f for f in os.listdir(folder_path)
+            if os.path.splitext(f)[1].lower() in image_extensions
+        ])
+        
+        if not image_files:
+            print("No images found in the folder!")
+            return None
+        
+        print(f"Found {len(image_files)} images: {image_files}")
+        
+        # Extract features for all images
+        all_features = {}
+        print("\nExtracting InceptionV3 features...")
+        for img_file in image_files:
+            img_path = os.path.join(folder_path, img_file)
+            features = self.get_inception_features(img_path)
+            all_features[img_file] = features
+            print(f"  ✓ {img_file}")
+        
+        # Compute FID matrix
+        n_images = len(image_files)
+        fid_matrix = np.zeros((n_images, n_images))
+        
+        print("\nComputing FID-based distances...")
+        
+        # For single images, we compute a simplified FID using the feature vectors themselves
+        # Stack all features for covariance computation
+        all_stacked = np.vstack([all_features[f] for f in image_files])
+        
+        for i in range(n_images):
+            for j in range(n_images):
+                if i == j:
+                    fid_matrix[i, j] = 0.0
+                else:
+                    # Get individual feature vectors
+                    mu1 = all_features[image_files[i]].flatten()
+                    mu2 = all_features[image_files[j]].flatten()
+                    
+                    # Use a simplified FID: just compute the Wasserstein distance between features
+                    # with a small regularization for covariance
+                    diff = mu1 - mu2
+                    
+                    # Compute Euclidean distance as FID approximation
+                    fid = np.linalg.norm(diff)
+                    fid_matrix[i, j] = fid
+        
+        return image_files, fid_matrix
+    
+    def plot_fid_matrix(self, image_files, fid_matrix, save_path=None):
+        """Visualize the FID matrix as a heatmap."""
+        fig, ax = plt.subplots(figsize=(12, 10))
+        sns.heatmap(
+            fid_matrix,
+            annot=True,
+            fmt='.2f',
+            ax=ax,
+            cmap='RdYlGn_r',  # Reversed: red = high distance (different), green = low distance (similar)
+            cbar_kws={'label': 'FID Distance (lower = more similar)'}
+        )
+
+        def add_image_anchors(axis_type, tick_positions, labels):
+            for i, (pos, img_name) in enumerate(zip(tick_positions, labels)):
+                # Load and thumbnail the image
+                img_path = os.path.join('input', img_name)
+                img = Image.open(img_path).convert('RGB')
+                img.thumbnail((200, 200)) # Resize for the axis
+                
+                imagebox = OffsetImage(img, zoom=0.5) # Adjust zoom based on your DPI
+                
+                if axis_type == 'x':
+                    # Position image below the X-axis
+                    ab = AnnotationBbox(imagebox, (pos, 0),
+                                        xybox=(0, -65), # Distance from axis
+                                        xycoords=('data', 'axes fraction'),
+                                        boxcoords="offset points", 
+                                        frameon=False)
+                else:
+                    # Position image to the left of the Y-axis
+                    ab = AnnotationBbox(imagebox, (0, pos),
+                                        xybox=(-65, 0),
+                                        xycoords=('axes fraction', 'data'),
+                                        boxcoords="offset points", 
+                                        frameon=False)
+                ax.add_artist(ab)
+
+        # Get tick positions (Seaborn centers them at 0.5, 1.5, etc.)
+        tick_positions = np.arange(len(image_files)) + 0.5
+        # Add images to both axes
+        add_image_anchors('x', tick_positions, image_files)
+        add_image_anchors('y', tick_positions, image_files)
+        # Remove text labels to avoid clutter
+        ax.set_xticklabels([])
+        ax.set_yticklabels([])
+
+        
+        plt.title('Fréchet Inception Distance (FID) Matrix')
+        plt.tight_layout()
+        
+        if save_path:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            plt.savefig(save_path, dpi=150, bbox_inches='tight')
+            print(f"\nHeatmap saved to {save_path}")
+        
+        plt.show()
+    
+    def print_fid_results(self, image_files, fid_matrix):
+        """Print FID results in a readable format."""
+        print("\n" + "="*80)
+        print("FRÉCHET INCEPTION DISTANCE (FID) RESULTS")
+        print("="*80)
+        print("\nNote: Lower FID = more similar images\n")
+        
+        # Create sorted list of pairwise distances
+        distances = []
+        for i in range(len(image_files)):
+            for j in range(i + 1, len(image_files)):
+                distances.append((
+                    image_files[i],
+                    image_files[j],
+                    fid_matrix[i, j]
+                ))
+        
+        # Sort by FID distance
+        distances.sort(key=lambda x: x[2])
+        
+        print("Pairwise FID Distances (sorted by similarity):")
+        for img1, img2, fid in distances:
+            # Create a visual representation (inverted: shorter bar = more similar)
+            max_fid = max(d[2] for d in distances)
+            bar_length = int((1 - fid / max_fid) * 40)
+            bar = '█' * bar_length + '░' * (40 - bar_length)
+            
+            print(f"{img1} <-> {img2}")
+            print(f"  [{bar}] FID: {fid:.4f}")
+
+
+def main():
+    # Set folder path
+    folder_path = "./input"
+    
+    print("\n" + "="*80)
+    print("IMAGE SIMILARITY ANALYSIS")
+    print("="*80)
+    print("\nChoose analysis method:")
+    print("1. ResNet50 + Cosine Similarity (faster, lightweight)")
+    print("2. InceptionV3 + Fréchet Inception Distance / FID (more robust)")
+    print("3. Both analyses")
+    
+    choice = input("\nEnter your choice (1-3): ").strip()
+    
+    # Method 1: ResNet50 + Cosine Similarity
+    if choice in ['1', '3']:
+        print("\n" + "="*80)
+        print("METHOD 1: ResNet50 + Cosine Similarity")
+        print("="*80)
+        similarity_finder = ImageSimilarityFinder(model_name='resnet50')
+        
+        results = similarity_finder.find_similar_images(
+            folder_path,
+            metric='cosine'
+        )
+        
+        if results:
+            image_files, similarity_matrix = results
+            similarity_finder.print_similarity_results(image_files, similarity_matrix)
+            output_path = os.path.join(folder_path,'output', 'similarity_heatmap_resnet50.png')
+            similarity_finder.plot_similarity_matrix(image_files, similarity_matrix, output_path)
+    
+    # Method 2: InceptionV3 + FID
+    if choice in ['2', '3']:
+        print("\n" + "="*80)
+        print("METHOD 2: InceptionV3 + Fréchet Inception Distance (FID)")
+        print("="*80)
+        fid_finder = FIDSimilarityFinder()
+        
+        results = fid_finder.compute_fid_matrix(folder_path)
+        
+        if results:
+            image_files, fid_matrix = results
+            fid_finder.print_fid_results(image_files, fid_matrix)
+            output_path = os.path.join('./output', 'similarity_heatmap_fid.png')
+            fid_finder.plot_fid_matrix(image_files, fid_matrix, output_path)
+    
+    print("\n" + "="*80)
+    print("✓ Analysis complete!")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()

experiments/image2image/input/depth.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4a853e7c39c0d6e498dda1f604cc073cdce83cc0c33f07d1fab17113e1bfb1d
+size 1228928

experiments/rtabmap/behavior_trees/navigate_through_poses_w_replanning_and_recovery.xml

@@ -0,0 +1,38 @@
+
+<!--
+  This Behavior Tree replans the global path periodically at 1 Hz through an array of poses continuously
+   and it also has recovery actions specific to planning / control as well as general system issues.
+-->
+<root main_tree_to_execute="MainTree">
+  <BehaviorTree ID="MainTree">
+    <RecoveryNode number_of_retries="6" name="NavigateRecovery">
+      <PipelineSequence name="NavigateWithReplanning">
+        <RateController hz="5.0">
+          <RecoveryNode number_of_retries="1" name="ComputePathThroughPoses">
+            <ReactiveSequence>
+              <RemovePassedGoals input_goals="{goals}" output_goals="{goals}" radius="0.7"/>
+              <ComputePathThroughPoses goals="{goals}" path="{path}" planner_id="GridBased"/>
+            </ReactiveSequence>
+            <ClearEntireCostmap name="ClearGlobalCostmap-Context" service_name="global_costmap/clear_entirely_global_costmap"/>
+          </RecoveryNode>
+        </RateController>
+        <RecoveryNode number_of_retries="1" name="FollowPath">
+          <FollowPath path="{path}" controller_id="FollowPath"/>
+          <ClearEntireCostmap name="ClearLocalCostmap-Context" service_name="local_costmap/clear_entirely_local_costmap"/>
+        </RecoveryNode>
+      </PipelineSequence>
+      <ReactiveFallback name="RecoveryFallback">
+        <GoalUpdated/>
+        <RoundRobin name="RecoveryActions">
+          <Sequence name="ClearingActions">
+            <ClearEntireCostmap name="ClearLocalCostmap-Subtree" service_name="local_costmap/clear_entirely_local_costmap"/>
+            <ClearEntireCostmap name="ClearGlobalCostmap-Subtree" service_name="global_costmap/clear_entirely_global_costmap"/>
+          </Sequence>
+          <Spin spin_dist="1.57"/>
+          <Wait wait_duration="5"/>
+          <BackUp backup_dist="0.30" backup_speed="0.05"/>
+        </RoundRobin>
+      </ReactiveFallback>
+    </RecoveryNode>
+  </BehaviorTree>
+</root>

experiments/rtabmap/behavior_trees/navigate_to_pose_w_replanning_and_recovery.xml

@@ -0,0 +1,36 @@
+
+<!--
+  This Behavior Tree replans the global path periodically at 1 Hz and it also has
+  recovery actions specific to planning / control as well as general system issues.
+  This will be continuous if a kinematically valid planner is selected.
+-->
+<root main_tree_to_execute="MainTree">
+  <BehaviorTree ID="MainTree">
+    <RecoveryNode number_of_retries="6" name="NavigateRecovery">
+      <PipelineSequence name="NavigateWithReplanning">
+        <RateController hz="5.0">
+          <RecoveryNode number_of_retries="1" name="ComputePathToPose">
+            <ComputePathToPose goal="{goal}" path="{path}" planner_id="GridBased"/>
+            <ClearEntireCostmap name="ClearGlobalCostmap-Context" service_name="global_costmap/clear_entirely_global_costmap"/>
+          </RecoveryNode>
+        </RateController>
+        <RecoveryNode number_of_retries="1" name="FollowPath">
+          <FollowPath path="{path}" controller_id="FollowPath"/>
+          <ClearEntireCostmap name="ClearLocalCostmap-Context" service_name="local_costmap/clear_entirely_local_costmap"/>
+        </RecoveryNode>
+      </PipelineSequence>
+      <ReactiveFallback name="RecoveryFallback">
+        <GoalUpdated/>
+        <RoundRobin name="RecoveryActions">
+          <Sequence name="ClearingActions">
+            <ClearEntireCostmap name="ClearLocalCostmap-Subtree" service_name="local_costmap/clear_entirely_local_costmap"/>
+            <ClearEntireCostmap name="ClearGlobalCostmap-Subtree" service_name="global_costmap/clear_entirely_global_costmap"/>
+          </Sequence>
+          <Spin spin_dist="1.57"/>
+          <Wait wait_duration="5"/>
+          <BackUp backup_dist="0.30" backup_speed="0.05"/>
+        </RoundRobin>
+      </ReactiveFallback>
+    </RecoveryNode>
+  </BehaviorTree>
+</root>

experiments/rtabmap/nav2.launch.py

@@ -0,0 +1,52 @@
+import os
+
+from launch_ros.actions import Node
+from ament_index_python.packages import get_package_share_directory
+from launch import LaunchDescription
+from launch.actions import IncludeLaunchDescription
+from launch.launch_description_sources import PythonLaunchDescriptionSource
+from launch.actions import DeclareLaunchArgument
+from launch.substitutions import LaunchConfiguration
+
+def generate_launch_description():
+    # Package Paths
+    nav2_bringup_dir = get_package_share_directory('nav2_bringup')
+
+    # Launch Arguments
+    use_sim_time = LaunchConfiguration('use_sim_time', default='true')
+    params_file = LaunchConfiguration('params_file', default=os.path.join(
+        NAME_OF_YOUR_PKG, 'params', 'nav2_params.yaml'))
+
+    return LaunchDescription([
+        DeclareLaunchArgument(
+            'use_sim_time',
+            default_value='true',
+            description='Use simulation clock if true'),
+
+        DeclareLaunchArgument(
+            'params_file',
+            default_value=params_file,
+            description='Full path to param file to load'),
+        
+
+        IncludeLaunchDescription(
+            PythonLaunchDescriptionSource(
+                os.path.join(nav2_bringup_dir, 'launch', 'navigation_launch.py')
+            ),
+            launch_arguments={
+                'use_sim_time': use_sim_time,
+                'params_file': params_file,
+                'autostart': 'false'
+            }.items(),
+        ),
+
+        Node(
+            package='NAME_OF_YOUR_PKG',
+            executable='follow_route',
+            name='follow_route',
+            parameters=[{
+                'use_sim_time': True
+            }],
+            output='screen'
+        ),
+    ])

experiments/rtabmap/params/nav2_params.yaml

@@ -0,0 +1,468 @@
+# GPS WPF CHANGES:
+# - amcl params where removed. They are not needed because global localization is provided
+#   by an ekf node on robot_localization fusing gps data with local odometry sources
+# - static layer is removed from both costmaps, in this tutorial we assume there is no map
+#   of the environment
+# - global costmap is set to be rolling to allow the robot to traverse big environment by
+#   following successive relatively close waypoints that fit in a smaller rolling costmap
+
+bt_navigator:
+  ros__parameters:
+    use_sim_time: True
+    global_frame: map
+    robot_base_frame: base_link
+    odom_topic: /odom
+    bt_loop_duration: 10
+    default_server_timeout: 20
+    wait_for_service_timeout: 1000
+    navigators: ["navigate_to_pose", "navigate_through_poses"]
+    navigate_to_pose:
+      plugin: "nav2_bt_navigator::NavigateToPoseNavigator"
+    navigate_through_poses:
+      plugin: "nav2_bt_navigator::NavigateThroughPosesNavigator"
+    # 'default_nav_through_poses_bt_xml' and 'default_nav_to_pose_bt_xml' are use defaults:
+    # nav2_bt_navigator/navigate_to_pose_w_replanning_and_recovery.xml
+    # nav2_bt_navigator/navigate_through_poses_w_replanning_and_recovery.xml
+    # They can be set here or via a RewrittenYaml remap from a parent launch file to Nav2.
+    default_nav_to_pose_bt_xml:  $(find-pkg-share NAME_OF_YOUR_PKG)/behavior_trees/navigate_to_pose_w_replanning_and_recovery.xml
+    default_nav_through_poses_bt_xml: $(find-pkg-share NAME_OF_YOUR_PKG)/behavior_trees/navigate_through_poses_w_replanning_and_recovery.xml
+
+    # plugin_lib_names is used to add custom BT plugins to the executor (vector of strings).
+    # Built-in plugins are added automatically
+    # plugin_lib_names: []
+
+    error_code_name_prefixes:
+      - compute_path
+      - follow_path
+
+controller_server:
+  ros__parameters:
+    use_sim_time: True
+    controller_frequency: 30.0
+    min_x_velocity_threshold: 0.001
+    min_y_velocity_threshold: 0.5
+    min_theta_velocity_threshold: 0.001
+    failure_tolerance: 30.0
+    progress_checker_plugins: ["progress_checker"]
+    goal_checker_plugins: ["general_goal_checker"] # "precise_goal_checker"
+    controller_plugins: ["FollowPath"]
+
+    # Progress checker parameters
+    progress_checker:
+      plugin: "nav2_controller::SimpleProgressChecker"
+      required_movement_radius: 0.5
+      movement_time_allowance: 10.0
+    # Goal checker parameters
+    #precise_goal_checker:
+    #  plugin: "nav2_controller::SimpleGoalChecker"
+    #  xy_goal_tolerance: 0.25
+    #  yaw_goal_tolerance: 0.25
+    #  stateful: True
+    general_goal_checker:
+      stateful: True
+      plugin: "nav2_controller::SimpleGoalChecker"
+      xy_goal_tolerance: 0.25
+      yaw_goal_tolerance: 0.25
+    # DWB parameters
+    FollowPath:
+      FollowPath:
+      plugin: "nav2_mppi_controller::MPPIController"
+      time_steps: 42
+      model_dt: 0.05
+      batch_size: 2000
+      vx_std: 0.2
+      vy_std: 0.2
+      wz_std: 0.4
+      vx_max: 1.2
+      vx_min: -0.35
+      vy_max: 0.5
+      wz_max: 3.5
+      iteration_count: 1
+      prune_distance: 3.0
+      transform_tolerance: 0.2
+      temperature: 0.3
+      gamma: 0.01
+      motion_model: "DiffDrive"
+      visualize: false
+      regenerate_noises: false
+      TrajectoryVisualizer:
+        trajectory_step: 5
+        time_step: 3
+      AckermannConstraints:
+        min_turning_r: 0.2
+      critics:
+        [
+          "ConstraintCritic",
+          "CostCritic",
+          "GoalCritic",
+          "GoalAngleCritic",
+          "PathAlignCritic",
+          "PathFollowCritic",
+          "PathAngleCritic",
+          "PreferForwardCritic",
+        ]
+      ConstraintCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 4.0
+      GoalCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 5.0
+        threshold_to_consider: 1.4
+      GoalAngleCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 2.0
+        threshold_to_consider: 0.5
+      PreferForwardCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 5.0
+        threshold_to_consider: 0.5
+      CostCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 3.81
+        near_collision_cost: 253
+        critical_cost: 300.0
+        consider_footprint: false
+        collision_cost: 1000000.0
+        near_goal_distance: 1.0
+        trajectory_point_step: 2
+      PathAlignCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 15.0
+        max_path_occupancy_ratio: 0.05
+        trajectory_point_step: 4
+        threshold_to_consider: 0.25
+        offset_from_furthest: 2
+        use_path_orientations: false
+      PathFollowCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 5.0
+        offset_from_furthest: 5
+        threshold_to_consider: 1.4
+      PathAngleCritic:
+        enabled: true
+        cost_power: 1
+        cost_weight: 7.0
+        offset_from_furthest: 4
+        threshold_to_consider: 0.25
+        max_angle_to_furthest: 1.0
+        mode: 0
+      # TwirlingCritic:
+      #   enabled: true
+      #   twirling_cost_power: 1
+      #   twirling_cost_weight: 10.0
+
+# GPS WPF CHANGE: Remove static layer
+local_costmap:
+  local_costmap:
+    ros__parameters:
+      use_sim_time: True
+      update_frequency: 5.0
+      publish_frequency: 5.0
+      global_frame: map
+      robot_base_frame: base_link
+      rolling_window: true
+      width: 10
+      height: 10
+      resolution: 0.1
+      robot_radius: 0.22
+      plugins: ["voxel_layer", "inflation_layer"]
+      inflation_layer:
+        plugin: "nav2_costmap_2d::InflationLayer"
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.55
+      voxel_layer:
+        plugin: "nav2_costmap_2d::VoxelLayer"
+        enabled: false
+        publish_voxel_map: True
+        origin_z: 0.0
+        z_resolution: 0.05
+        z_voxels: 16
+        max_obstacle_height: 2.0
+        mark_threshold: 0
+        observation_sources: pointcloud
+        pointcloud:
+          topic: /cloud_map
+          max_obstacle_height: 2.0
+          min_obstacle_height: 0.0
+          obstacle_range: 2.5
+          raytrace_range: 3.0
+          observation_persistence: 0.0
+          data_type: "PointCloud2"
+          marking: True
+          clearing: True
+        # observation_sources: scan
+        # scan:
+        #   topic: /scan
+        #   max_obstacle_height: 2.0
+        #   clearing: True
+        #   marking: True
+        #   data_type: "LaserScan"
+        #   raytrace_max_range: 3.0
+        #   raytrace_min_range: 0.0
+        #   obstacle_max_range: 2.5
+        #   obstacle_min_range: 0.0
+      always_send_full_costmap: true
+
+# GPS WPF CHANGE: Remove static layer
+global_costmap:
+  global_costmap:
+    ros__parameters:
+      use_sim_time: True
+      update_frequency: 1.0
+      publish_frequency: 1.0
+      global_frame: map
+      robot_base_frame: base_link
+      robot_radius: 0.22
+      resolution: 0.25
+      # When using GPS navigation you will potentially traverse huge environments which are not practical to
+      # fit on a big static costmap. Thus it is recommended to use a rolling global costmap large enough to
+      # contain each pair of successive waypoints. See: https://github.com/ros-planning/navigation2/issues/2174
+      rolling_window: True
+      width: 30
+      height: 30
+      # origin_x: 0.0
+      # origin_y: 0.0
+      track_unknown_space: false
+      # no static map
+      plugins: ["obstacle_layer", "inflation_layer"]
+      obstacle_layer:
+        plugin: "nav2_costmap_2d::ObstacleLayer"
+        enabled: false
+        observation_sources: pointcloud
+        pointcloud:
+          topic: /cloud_map
+          max_obstacle_height: 2.0
+          min_obstacle_height: 0.0
+          obstacle_range: 2.5
+          raytrace_range: 3.0
+          observation_persistence: 0.0
+          data_type: "PointCloud2"
+          marking: True
+          clearing: True
+        # observation_sources: scan
+        # scan:
+        #   topic: /scan
+        #   max_obstacle_height: 2.0
+        #   clearing: True
+        #   marking: True
+        #   data_type: "LaserScan"
+        #   raytrace_max_range: 3.0
+        #   raytrace_min_range: 0.0
+        #   obstacle_max_range: 2.5
+        #   obstacle_min_range: 0.0
+        #   # outdoors there will probably be more inf points
+        #   inf_is_valid: true
+      inflation_layer:
+        plugin: "nav2_costmap_2d::InflationLayer"
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.55
+      always_send_full_costmap: true
+
+# The yaml_filename does not need to be specified since it going to be set by defaults in launch.
+# If you'd rather set it in the yaml, remove the default "map" value in the tb3_simulation_launch.py
+# file & provide full path to map below. If CLI map configuration or launch default is provided, that will be used.
+# map_server:
+#   ros__parameters:
+#     yaml_filename: ""
+
+map_saver:
+  ros__parameters:
+    save_map_timeout: 5.0
+    free_thresh_default: 0.25
+    occupied_thresh_default: 0.65
+    map_subscribe_transient_local: True
+    service_introspection_mode: "disabled"
+
+planner_server:
+  ros__parameters:
+    use_sim_time: True
+    expected_planner_frequency: 20.0
+    planner_plugins: ["GridBased"]
+    costmap_update_timeout: 1.0
+    service_introspection_mode: "disabled"
+    GridBased:
+      plugin: "nav2_navfn_planner/NavfnPlanner"
+      tolerance: 0.5
+      use_astar: false
+      allow_unknown: true
+
+smoother_server:
+  ros__parameters:
+    use_sim_time: True
+    smoother_plugins: ["simple_smoother"]
+    simple_smoother:
+      plugin: "nav2_smoother::SimpleSmoother"
+      tolerance: 1.0e-10
+      max_its: 1000
+      refinement_num: 2
+      # True for Hybrid A* or State Lattice to not smooth over directional changes
+      enforce_path_inversion: True
+      do_refinement: True
+
+behavior_server:
+  ros__parameters:
+    use_sim_time: True
+    local_costmap_topic: local_costmap/costmap_raw
+    global_costmap_topic: global_costmap/costmap_raw
+    local_footprint_topic: local_costmap/published_footprint
+    global_footprint_topic: global_costmap/published_footprint
+    cycle_frequency: 10.0
+    behavior_plugins:
+      ["spin", "backup", "drive_on_heading", "assisted_teleop", "wait"]
+    spin:
+      plugin: "nav2_behaviors/Spin"
+    backup:
+      plugin: "nav2_behaviors/BackUp"
+      acceleration_limit: 2.5
+      deceleration_limit: -2.5
+      minimum_speed: 0.10
+    drive_on_heading:
+      plugin: "nav2_behaviors/DriveOnHeading"
+      acceleration_limit: 2.5
+      deceleration_limit: -2.5
+      minimum_speed: 0.10
+    wait:
+      plugin: "nav2_behaviors/Wait"
+    assisted_teleop:
+      plugin: "nav2_behaviors/AssistedTeleop"
+    local_frame: odom
+    global_frame: map
+    robot_base_frame: base_link
+    transform_tolerance: 0.2
+    simulate_ahead_time: 2.0
+    max_rotational_vel: 1.0
+    min_rotational_vel: 0.4
+    rotational_acc_lim: 3.2
+
+waypoint_follower:
+  ros__parameters:
+    use_sim_time: True
+    loop_rate: 20
+    stop_on_failure: false
+    service_introspection_mode: "disabled"
+    waypoint_task_executor_plugin: "wait_at_waypoint"
+    wait_at_waypoint:
+      plugin: "nav2_waypoint_follower::WaitAtWaypoint"
+      enabled: True
+      waypoint_pause_duration: 200
+
+velocity_smoother:
+  ros__parameters:
+    use_sim_time: True
+    smoothing_frequency: 20.0
+    scale_velocities: False
+    feedback: "OPEN_LOOP"
+    max_velocity: [1.0, 0.0, 2.0]
+    min_velocity: [-0.5, 0.0, -2.0]
+    max_accel: [2.5, 0.0, 3.2]
+    max_decel: [-2.5, 0.0, -3.2]
+    odom_topic: "odom"
+    odom_duration: 0.1
+    deadband_velocity: [0.0, 0.0, 0.0]
+    velocity_timeout: 1.0
+
+# collision_monitor:
+#   ros__parameters:
+#     base_frame_id: "base_footprint"
+#     odom_frame_id: "odom"
+#     cmd_vel_in_topic: "cmd_vel_smoothed"
+#     cmd_vel_out_topic: "cmd_vel"
+#     state_topic: "collision_monitor_state"
+#     transform_tolerance: 0.2
+#     source_timeout: 1.0
+#     base_shift_correction: True
+#     stop_pub_timeout: 2.0
+#     # Polygons represent zone around the robot for "stop", "slowdown" and "limit" action types,
+#     # and robot footprint for "approach" action type.
+#     polygons: ["FootprintApproach"]
+#     FootprintApproach:
+#       type: "polygon"
+#       action_type: "approach"
+#       footprint_topic: "/local_costmap/published_footprint"
+#       time_before_collision: 2.0
+#       simulation_time_step: 0.1
+#       min_points: 6
+#       visualize: False
+#       enabled: True
+#     observation_sources: ["scan"]
+#     scan:
+#       type: "scan"
+#       topic: "scan"
+#       min_height: 0.15
+#       max_height: 2.0
+#       enabled: True
+
+# docking_server:
+#   ros__parameters:
+#     controller_frequency: 50.0
+#     initial_perception_timeout: 5.0
+#     wait_charge_timeout: 5.0
+#     dock_approach_timeout: 30.0
+#     undock_linear_tolerance: 0.05
+#     undock_angular_tolerance: 0.1
+#     max_retries: 3
+#     base_frame: "base_link"
+#     fixed_frame: "odom"
+#     dock_prestaging_tolerance: 0.5
+#     service_introspection_mode: "disabled"
+
+#     # Types of docks
+#     dock_plugins: ["simple_charging_dock"]
+#     simple_charging_dock:
+#       plugin: "opennav_docking::SimpleChargingDock"
+#       docking_threshold: 0.05
+#       staging_x_offset: -0.7
+#       use_external_detection_pose: true
+#       use_battery_status: false # true
+#       use_stall_detection: false # true
+#       dock_direction: "forward"
+
+#       external_detection_timeout: 1.0
+#       external_detection_translation_x: -0.18
+#       external_detection_translation_y: 0.0
+#       external_detection_rotation_roll: -1.57
+#       external_detection_rotation_pitch: -1.57
+#       external_detection_rotation_yaw: 0.0
+#       filter_coef: 0.1
+
+#     # Dock instances
+#     # The following example illustrates configuring dock instances.
+#     # docks: ['home_dock']  # Input your docks here
+#     # home_dock:
+#     #   type: 'simple_charging_dock'
+#     #   frame: map
+#     #   pose: [0.0, 0.0, 0.0]
+
+#     controller:
+#       k_phi: 3.0
+#       k_delta: 2.0
+#       v_linear_min: 0.15
+#       v_linear_max: 0.15
+#       use_collision_detection: true
+#       costmap_topic: "/local_costmap/costmap_raw"
+#       footprint_topic: "/local_costmap/published_footprint"
+#       transform_tolerance: 0.1
+#       projection_time: 5.0
+#       simulation_step: 0.1
+#       dock_collision_threshold: 0.3
+
+# loopback_simulator:
+#   ros__parameters:
+#     base_frame_id: "base_footprint"
+#     odom_frame_id: "odom"
+#     map_frame_id: "map"
+#     scan_frame_id: "base_scan" # tb4_loopback_simulator.launch.py remaps to 'rplidar_link'
+#     update_duration: 0.02
+#     scan_range_min: 0.05
+#     scan_range_max: 30.0
+#     scan_angle_min: -3.1415
+#     scan_angle_max: 3.1415
+#     scan_angle_increment: 0.02617
+#     scan_use_inf: true

experiments/rtabmap/params/odom.txt

@@ -0,0 +1,321 @@
+Param: BRIEF/Bytes = "32"                                  [Bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.]
+Param: BRISK/Octaves = "3"                                 [Detection octaves. Use 0 to do single scale.]
+Param: BRISK/PatternScale = "1"                            [Apply this scale to the pattern used for sampling the neighbourhood of a keypoint.]
+Param: BRISK/Thresh = "30"                                 [FAST/AGAST detection threshold score.]
+Param: FAST/CV = "0"                                       [Enable FastCV implementation if non-zero (and RTAB-Map is built with FastCV support). Values should be 9 and 10.]
+Param: FAST/Gpu = "false"                                  [GPU-FAST: Use GPU version of FAST. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.]
+Param: FAST/GpuKeypointsRatio = "0.05"                     [Used with FAST GPU.]
+Param: FAST/GridCols = "0"                                 [Grid cols (0 to disable). Adapts the detector to partition the source image into a grid and detect points in each cell.]
+Param: FAST/GridRows = "0"                                 [Grid rows (0 to disable). Adapts the detector to partition the source image into a grid and detect points in each cell.]
+Param: FAST/MaxThreshold = "200"                           [Maximum threshold. Used only when FAST/GridRows and FAST/GridCols are set.]
+Param: FAST/MinThreshold = "7"                             [Minimum threshold. Used only when FAST/GridRows and FAST/GridCols are set.]
+Param: FAST/NonmaxSuppression = "true"                     [If true, non-maximum suppression is applied to detected corners (keypoints).]
+Param: FAST/Threshold = "20"                               [Threshold on difference between intensity of the central pixel and pixels of a circle around this pixel.]
+Param: FREAK/NOctaves = "4"                                [Number of octaves covered by the detected keypoints.]
+Param: FREAK/OrientationNormalized = "true"                [Enable orientation normalization.]
+Param: FREAK/PatternScale = "22"                           [Scaling of the description pattern.]
+Param: FREAK/ScaleNormalized = "true"                      [Enable scale normalization.]
+Param: GFTT/BlockSize = "3"                                []
+Param: GFTT/Gpu = "false"                                  [GPU-GFTT: Use GPU version of GFTT. This option is enabled only if OpenCV>=3 is built with CUDA and GPUs are detected.]
+Param: GFTT/K = "0.04"                                     []
+Param: GFTT/MinDistance = "7"                              []
+Param: GFTT/QualityLevel = "0.001"                         []
+Param: GFTT/UseHarrisDetector = "false"                    []
+Param: GMS/ThresholdFactor = "6.0"                         [The higher, the less matches.]
+Param: GMS/WithRotation = "false"                          [Take rotation transformation into account.]
+Param: GMS/WithScale = "false"                             [Take scale transformation into account.]
+Param: GTSAM/IncRelinearizeSkip = "1"                      [Only relinearize any variables every X calls to ISAM2::update(). See GTSAM::ISAM2 doc for more info.]
+Param: GTSAM/IncRelinearizeThreshold = "0.01"              [Only relinearize variables whose linear delta magnitude is greater than this threshold. See GTSAM::ISAM2 doc for more info.]
+Param: GTSAM/Incremental = "false"                         [Do graph optimization incrementally (iSAM2) to increase optimization speed on loop closures. Note that only GaussNewton and Dogleg optimization algorithms are supported (GTSAM/Optimizer) in this mode.]
+Param: GTSAM/Optimizer = "1"                               [0=Levenberg 1=GaussNewton 2=Dogleg]
+Param: KAZE/Diffusivity = "1"                              [Diffusivity type: 0=DIFF_PM_G1, 1=DIFF_PM_G2, 2=DIFF_WEICKERT or 3=DIFF_CHARBONNIER.]
+Param: KAZE/Extended = "false"                             [Set to enable extraction of extended (128-byte) descriptor.]
+Param: KAZE/NOctaveLayers = "4"                            [Default number of sublevels per scale level.]
+Param: KAZE/NOctaves = "4"                                 [Maximum octave evolution of the image.]
+Param: KAZE/Threshold = "0.001"                            [Detector response threshold to accept keypoint.]
+Param: KAZE/Upright = "false"                              [Set to enable use of upright descriptors (non rotation-invariant).]
+Param: Kp/ByteToFloat = "false"                            [For Kp/NNStrategy=1, binary descriptors are converted to float by converting each byte to float instead of converting each bit to float. When converting bytes instead of bits, less memory is used and search is faster at the cost of slightly less accurate matching.]
+Param: ORB/EdgeThreshold = "19"                            [This is size of the border where the features are not detected. It should roughly match the patchSize parameter.]
+Param: ORB/FirstLevel = "0"                                [It should be 0 in the current implementation.]
+Param: ORB/Gpu = "false"                                   [GPU-ORB: Use GPU version of ORB. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.]
+Param: ORB/NLevels = "3"                                   [The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels).]
+Param: ORB/PatchSize = "31"                                [size of the patch used by the oriented BRIEF descriptor. Of course, on smaller pyramid layers the perceived image area covered by a feature will be larger.]
+Param: ORB/ScaleFactor = "2"                               [Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.]
+Param: ORB/ScoreType = "0"                                 [The default HARRIS_SCORE=0 means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE=1 is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute.]
+Param: ORB/WTA_K = "2"                                     [The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).]
+Param: Odom/AlignWithGround = "false"                      [Align odometry with the ground on initialization.]
+Param: Odom/Deskewing = "true"                             [Lidar deskewing. If input lidar has time channel, it will be deskewed with a constant motion model (with IMU orientation and/or guess if provided).]
+Param: Odom/FillInfoData = "true"                          [Fill info with data (inliers/outliers features).]
+Param: Odom/FilteringStrategy = "0"                        [0=No filtering 1=Kalman filtering 2=Particle filtering. This filter is used to smooth the odometry output.]
+Param: Odom/GuessMotion = "true"                           [Guess next transformation from the last motion computed.]
+Param: Odom/GuessSmoothingDelay = "0"                      [Guess smoothing delay (s). Estimated velocity is averaged based on last transforms up to this maximum delay. This can help to get smoother velocity prediction. Last velocity computed is used directly if "Odom/FilteringStrategy" is set or the delay is below the odometry rate.]
+Param: Odom/Holonomic = "true"                             [If the robot is holonomic (strafing commands can be issued). If not, y value will be estimated from x and yaw values (y=x*tan(yaw)).]
+Param: Odom/ImageBufferSize = "1"                          [Data buffer size (0 min inf).]
+Param: Odom/ImageDecimation = "1"                          [Decimation of the RGB image before registration. If depth size is larger than decimated RGB size, depth is decimated to be always at most equal to RGB size. If Vis/DepthAsMask is true and if depth is smaller than decimated RGB, depth may be interpolated to match RGB size for feature detection.]
+Param: Odom/KalmanMeasurementNoise = "0.01"                [Process measurement covariance value.]
+Param: Odom/KalmanProcessNoise = "0.001"                   [Process noise covariance value.]
+Param: Odom/KeyFrameThr = "0.3"                            [[Visual] Create a new keyframe when the number of inliers drops under this ratio of features in last frame. Setting the value to 0 means that a keyframe is created for each processed frame.]
+Param: Odom/ParticleLambdaR = "100"                        [Lambda of rotational components (roll,pitch,yaw).]
+Param: Odom/ParticleLambdaT = "100"                        [Lambda of translation components (x,y,z).]
+Param: Odom/ParticleNoiseR = "0.002"                       [Noise (rad) of rotational components (roll,pitch,yaw).]
+Param: Odom/ParticleNoiseT = "0.002"                       [Noise (m) of translation components (x,y,z).]
+Param: Odom/ParticleSize = "400"                           [Number of particles of the filter.]
+Param: Odom/ResetCountdown = "0"                           [Automatically reset odometry after X consecutive images where odometry cannot be computed (a value of 0 disables auto-reset). When a reset occurs, odometry resumes from the last successfully computed pose with large covariance to trigger a new map. If external odometry is used, it will also be reset based on the motion estimated relative to the last computed pose but no large covariance will be received, so that a new map won't be triggered.]
+Param: Odom/ScanKeyFrameThr = "0.9"                        [[Geometry] Create a new keyframe when the number of ICP inliers drops under this ratio of points in last frame's scan. Setting the value to 0 means that a keyframe is created for each processed frame.]
+Param: Odom/Strategy = "0"                                 [0=Frame-to-Map (F2M) 1=Frame-to-Frame (F2F) 2=Fovis 3=viso2 4=DVO-SLAM 5=ORB_SLAM 6=OKVIS 7=LOAM 8=MSCKF_VIO 9=VINS-Fusion 10=OpenVINS 11=FLOAM 12=Open3D 13=cuVSLAM]
+Param: Odom/VisKeyFrameThr = "150"                         [[Visual] Create a new keyframe when the number of inliers drops under this threshold. Setting the value to 0 means that a keyframe is created for each processed frame.]
+Param: OdomF2M/BundleAdjustment = "1"                      [Local bundle adjustment: 0=disabled, 1=g2o, 2=cvsba, 3=Ceres.]
+Param: OdomF2M/BundleAdjustmentMaxFrames = "10"            [Maximum frames used for bundle adjustment (0=inf or all current frames in the local map).]
+Param: OdomF2M/BundleAdjustmentMaxKeyFramesPerFeature = "0" [Maximum keyframes per feature for bundle adjustment. 0 means not limit.]
+Param: OdomF2M/BundleAdjustmentMinMotion = "0.0"           [To create a new keyframe with bundle adjustment, a minimum motion (in pixels) can be required. The motion is computed by the average distance between inliers of the previous keyframe and new frame.]
+Param: OdomF2M/BundleUpdateFeatureMapOnAllFrames = "false" [Update 3D local feature map on every frame with bundle adjustment. Recommended if Vis/DepthAsMask=false and Mem/UseOdomFeatures=true so that features without depth are better triangulated on every frame (not only on keyframes). If disabled, the feature map is updated only when a new keyframe is added (legacy approach).]
+Param: OdomF2M/FloorThreshold = "0.0"                      [[Visual] Only track features in 3D feature map that are over this threshold (height in base frame). Can be useful to ignore reflections on the floor. 0 means disabled.]
+Param: OdomF2M/InitDepthFactor = "0.05"                    [[Visual] Depth factor used to initialize depth of features without depth. Depth = Factor * fx.]
+Param: OdomF2M/MaxNewFeatures = "0"                        [[Visual] Maximum features (sorted by keypoint response) added to local map from a new key-frame. 0 means no limit.]
+Param: OdomF2M/MaxSize = "2000"                            [[Visual] Local map size: If > 0 (example 5000), the odometry will maintain a local map of X maximum words.]
+Param: OdomF2M/ScanMaxSize = "2000"                        [[Geometry] Maximum local scan map size.]
+Param: OdomF2M/ScanRange = "0"                             [[Geometry] Distance Range used to filter points of local map (when > 0). 0 means local map is updated using time and not range.]
+Param: OdomF2M/ScanSubtractAngle = "45"                    [[Geometry] Max angle (degrees) used to filter points of a new added scan to local map (when "OdomF2M/ScanSubtractRadius">0). 0 means any angle.]
+Param: OdomF2M/ScanSubtractRadius = "0.05"                 [[Geometry] Radius used to filter points of a new added scan to local map. This could match the voxel size of the scans.]
+Param: OdomF2M/ValidDepthRatio = "0.75"                    [If a new frame has points without valid depth, they are added to local feature map only if points with valid depth on total points is over this ratio. Setting to 1 means no points without valid depth are added to local feature map.]
+Param: OdomFovis/BucketHeight = "80"                       []
+Param: OdomFovis/BucketWidth = "80"                        []
+Param: OdomFovis/CliqueInlierThreshold = "0.1"             [See Howard's greedy max-clique algorithm for determining the maximum set of mutually consisten feature matches. This specifies the compatibility threshold, in meters.]
+Param: OdomFovis/FastThreshold = "20"                      [FAST threshold.]
+Param: OdomFovis/FastThresholdAdaptiveGain = "0.005"       [FAST threshold adaptive gain.]
+Param: OdomFovis/FeatureSearchWindow = "25"                [Specifies the size of the search window to apply when searching for feature matches across time frames.  The search is conducted around the feature location predicted by the initial rotation estimate.]
+Param: OdomFovis/FeatureWindowSize = "9"                   [The size of the n x n image patch surrounding each feature, used for keypoint matching.]
+Param: OdomFovis/InlierMaxReprojectionError = "1.5"        [The maximum image-space reprojection error (in pixels) a feature match is allowed to have and still be considered an inlier in the set of features used for motion estimation.]
+Param: OdomFovis/MaxKeypointsPerBucket = "25"              []
+Param: OdomFovis/MaxMeanReprojectionError = "10.0"         [Maximum mean reprojection error over the inlier feature matches for the motion estimate to be considered valid.]
+Param: OdomFovis/MaxPyramidLevel = "3"                     [The maximum Gaussian pyramid level to process the image at. Pyramid level 1 corresponds to the original image.]
+Param: OdomFovis/MinFeaturesForEstimate = "20"             [Minimum number of features in the inlier set for the motion estimate to be considered valid.]
+Param: OdomFovis/MinPyramidLevel = "0"                     [The minimum pyramid level.]
+Param: OdomFovis/StereoMaxDisparity = "128"                []
+Param: OdomFovis/StereoMaxDistEpipolarLine = "1.5"         []
+Param: OdomFovis/StereoMaxRefinementDisplacement = "1.0"   []
+Param: OdomFovis/StereoRequireMutualMatch = "true"         []
+Param: OdomFovis/TargetPixelsPerFeature = "250"            [Specifies the desired feature density as a ratio of input image pixels per feature detected.  This number is used to control the adaptive feature thresholding.]
+Param: OdomFovis/UpdateTargetFeaturesWithRefined = "false" [When subpixel refinement is enabled, the refined feature locations can be saved over the original feature locations.  This has a slightly negative impact on frame-to-frame visual odometry, but is likely better when using this library as part of a visual SLAM algorithm.]
+Param: OdomFovis/UseAdaptiveThreshold = "true"             [Use FAST adaptive threshold.]
+Param: OdomFovis/UseBucketing = "true"                     []
+Param: OdomFovis/UseHomographyInitialization = "true"      [Use homography initialization.]
+Param: OdomFovis/UseImageNormalization = "false"           []
+Param: OdomFovis/UseSubpixelRefinement = "true"            [Specifies whether or not to refine feature matches to subpixel resolution.]
+Param: OdomLOAM/AngVar = "0.01"                            [Angular output variance.]
+Param: OdomLOAM/LinVar = "0.01"                            [Linear output variance.]
+Param: OdomLOAM/LocalMapping = "true"                      [Local mapping. It adds more time to compute odometry, but accuracy is significantly improved.]
+Param: OdomLOAM/Resolution = "0.2"                         [Map resolution]
+Param: OdomLOAM/ScanPeriod = "0.1"                         [Scan period (s)]
+Param: OdomLOAM/Sensor = "2"                               [Velodyne sensor: 0=VLP-16, 1=HDL-32, 2=HDL-64E]
+Param: OdomMSCKF/FastThreshold = "10"                      []
+Param: OdomMSCKF/GridCol = "5"                             []
+Param: OdomMSCKF/GridMaxFeatureNum = "4"                   []
+Param: OdomMSCKF/GridMinFeatureNum = "3"                   []
+Param: OdomMSCKF/GridRow = "4"                             []
+Param: OdomMSCKF/InitCovAccBias = "0.01"                   []
+Param: OdomMSCKF/InitCovExRot = "0.00030462"               []
+Param: OdomMSCKF/InitCovExTrans = "0.000025"               []
+Param: OdomMSCKF/InitCovGyroBias = "0.01"                  []
+Param: OdomMSCKF/InitCovVel = "0.25"                       []
+Param: OdomMSCKF/MaxCamStateSize = "20"                    []
+Param: OdomMSCKF/MaxIteration = "30"                       []
+Param: OdomMSCKF/NoiseAcc = "0.05"                         []
+Param: OdomMSCKF/NoiseAccBias = "0.01"                     []
+Param: OdomMSCKF/NoiseFeature = "0.035"                    []
+Param: OdomMSCKF/NoiseGyro = "0.005"                       []
+Param: OdomMSCKF/NoiseGyroBias = "0.001"                   []
+Param: OdomMSCKF/OptTranslationThreshold = "0"             []
+Param: OdomMSCKF/PatchSize = "15"                          []
+Param: OdomMSCKF/PositionStdThreshold = "8.0"              []
+Param: OdomMSCKF/PyramidLevels = "3"                       []
+Param: OdomMSCKF/RansacThreshold = "3"                     []
+Param: OdomMSCKF/RotationThreshold = "0.2618"              []
+Param: OdomMSCKF/StereoThreshold = "5"                     []
+Param: OdomMSCKF/TrackPrecision = "0.01"                   []
+Param: OdomMSCKF/TrackingRateThreshold = "0.5"             []
+Param: OdomMSCKF/TranslationThreshold = "0.4"              []
+Param: OdomMono/InitMinFlow = "100"                        [Minimum optical flow required for the initialization step.]
+Param: OdomMono/InitMinTranslation = "0.1"                 [Minimum translation required for the initialization step.]
+Param: OdomMono/MaxVariance = "0.01"                       [Maximum variance to add new points to local map.]
+Param: OdomMono/MinTranslation = "0.02"                    [Minimum translation to add new points to local map. On initialization, translation x 5 is used as the minimum.]
+Param: OdomOKVIS/ConfigPath = ""                           [Path of OKVIS config file.]
+Param: OdomORBSLAM/AccNoise = "0.1"                        [IMU accelerometer "white noise".]
+Param: OdomORBSLAM/AccWalk = "0.0001"                      [IMU accelerometer "random walk".]
+Param: OdomORBSLAM/Bf = "0.076"                            [Fake IR projector baseline (m) used only when stereo is not used.]
+Param: OdomORBSLAM/Fps = "0.0"                             [Camera FPS (0 to estimate from input data).]
+Param: OdomORBSLAM/GyroNoise = "0.01"                      [IMU gyroscope "white noise".]
+Param: OdomORBSLAM/GyroWalk = "0.000001"                   [IMU gyroscope "random walk".]
+Param: OdomORBSLAM/Inertial = "false"                      [Enable IMU. Only supported with ORB_SLAM3.]
+Param: OdomORBSLAM/MapSize = "3000"                        [Maximum size of the feature map (0 means infinite). Only supported with ORB_SLAM2.]
+Param: OdomORBSLAM/MaxFeatures = "1000"                    [Maximum ORB features extracted per frame.]
+Param: OdomORBSLAM/SamplingRate = "0"                      [IMU sampling rate (0 to estimate from input data).]
+Param: OdomORBSLAM/ThDepth = "40.0"                        [Close/Far threshold. Baseline times.]
+Param: OdomORBSLAM/VocPath = ""                            [Path to ORB vocabulary (*.txt).]
+Param: OdomOpen3D/MaxDepth = "3.0"                         [Maximum depth.]
+Param: OdomOpen3D/Method = "0"                             [Registration method: 0=PointToPlane, 1=Intensity, 2=Hybrid.]
+Param: OdomOpenVINS/AccelerometerNoiseDensity = "0.01"     [[m/s^2/sqrt(Hz)] (accel "white noise")]
+Param: OdomOpenVINS/AccelerometerRandomWalk = "0.001"      [[m/s^3/sqrt(Hz)] (accel bias diffusion)]
+Param: OdomOpenVINS/CalibCamExtrinsics = "false"           [Bool to determine whether or not to calibrate imu-to-camera pose]
+Param: OdomOpenVINS/CalibCamIntrinsics = "false"           [Bool to determine whether or not to calibrate camera intrinsics]
+Param: OdomOpenVINS/CalibCamTimeoffset = "false"           [Bool to determine whether or not to calibrate camera to IMU time offset]
+Param: OdomOpenVINS/CalibIMUGSensitivity = "false"         [Bool to determine whether or not to calibrate the Gravity sensitivity]
+Param: OdomOpenVINS/CalibIMUIntrinsics = "false"           [Bool to determine whether or not to calibrate the IMU intrinsics]
+Param: OdomOpenVINS/DtSLAMDelay = "0.0"                    [Delay, in seconds, that we should wait from init before we start estimating SLAM features]
+Param: OdomOpenVINS/FeatRepMSCKF = "0"                     [What representation our features are in (msckf features)]
+Param: OdomOpenVINS/FeatRepSLAM = "4"                      [What representation our features are in (slam features)]
+Param: OdomOpenVINS/FiMaxBaseline = "40"                   [Max baseline ratio to accept triangulated features]
+Param: OdomOpenVINS/FiMaxCondNumber = "10000"              [Max condition number of linear triangulation matrix accept triangulated features]
+Param: OdomOpenVINS/FiMaxRuns = "5"                        [Max runs for Levenberg-Marquardt]
+Param: OdomOpenVINS/FiRefineFeatures = "true"              [If we should perform Levenberg-Marquardt refinement]
+Param: OdomOpenVINS/FiTriangulate1d = "false"              [If we should perform 1d triangulation instead of 3d]
+Param: OdomOpenVINS/GravityMag = "9.81"                    [Gravity magnitude in the global frame (i.e. should be 9.81 typically)]
+Param: OdomOpenVINS/GyroscopeNoiseDensity = "0.001"        [[rad/s/sqrt(Hz)] (gyro "white noise")]
+Param: OdomOpenVINS/GyroscopeRandomWalk = "0.0001"         [[rad/s^2/sqrt(Hz)] (gyro bias diffusion)]
+Param: OdomOpenVINS/InitDynInflationBa = "100.0"           [What to inflate the recovered bias_a covariance by]
+Param: OdomOpenVINS/InitDynInflationBg = "10.0"            [What to inflate the recovered bias_g covariance by]
+Param: OdomOpenVINS/InitDynInflationOri = "10.0"           [What to inflate the recovered q_GtoI covariance by]
+Param: OdomOpenVINS/InitDynInflationVel = "100.0"          [What to inflate the recovered v_IinG covariance by]
+Param: OdomOpenVINS/InitDynMLEMaxIter = "50"               [How many iterations the MLE refinement should use (zero to skip the MLE)]
+Param: OdomOpenVINS/InitDynMLEMaxThreads = "6"             [How many threads the MLE should use]
+Param: OdomOpenVINS/InitDynMLEMaxTime = "0.05"             [How many seconds the MLE should be completed in]
+Param: OdomOpenVINS/InitDynMLEOptCalib = "false"           [If we should optimize calibration during intialization (not recommended)]
+Param: OdomOpenVINS/InitDynMinDeg = "10.0"                 [Orientation change needed to try to init]
+Param: OdomOpenVINS/InitDynMinRecCond = "1e-15"            [Reciprocal condition number thresh for info inversion]
+Param: OdomOpenVINS/InitDynNumPose = "6"                   [Number of poses to use within our window time (evenly spaced)]
+Param: OdomOpenVINS/InitDynUse = "false"                   [If dynamic initialization should be used]
+Param: OdomOpenVINS/InitIMUThresh = "1.0"                  [Variance threshold on our acceleration to be classified as moving]
+Param: OdomOpenVINS/InitMaxDisparity = "10.0"              [Max disparity to consider the platform stationary (dependent on resolution)]
+Param: OdomOpenVINS/InitMaxFeatures = "50"                 [How many features to track during initialization (saves on computation)]
+Param: OdomOpenVINS/InitWindowTime = "2.0"                 [Amount of time we will initialize over (seconds)]
+Param: OdomOpenVINS/Integration = "1"                      [0=discrete, 1=rk4, 2=analytical (if rk4 or analytical used then analytical covariance propagation is used)]
+Param: OdomOpenVINS/LeftMaskPath = ""                      [Mask for left image]
+Param: OdomOpenVINS/MaxClones = "11"                       [Max clone size of sliding window]
+Param: OdomOpenVINS/MaxMSCKFInUpdate = "50"                [Max number of MSCKF features we will use at a given image timestep.]
+Param: OdomOpenVINS/MaxSLAM = "50"                         [Max number of estimated SLAM features]
+Param: OdomOpenVINS/MaxSLAMInUpdate = "25"                 [Max number of SLAM features we allow to be included in a single EKF update.]
+Param: OdomOpenVINS/MinPxDist = "15"                       [Eistance between features (features near each other provide less information)]
+Param: OdomOpenVINS/NumPts = "200"                         [Number of points (per camera) we will extract and try to track]
+Param: OdomOpenVINS/RightMaskPath = ""                     [Mask for right image]
+Param: OdomOpenVINS/TryZUPT = "true"                       [If we should try to use zero velocity update]
+Param: OdomOpenVINS/UpMSCKFChi2Multiplier = "1.0"          [Chi2 multiplier for MSCKF features]
+Param: OdomOpenVINS/UpMSCKFSigmaPx = "1.0"                 [Pixel noise for MSCKF features]
+Param: OdomOpenVINS/UpSLAMChi2Multiplier = "1.0"           [Chi2 multiplier for SLAM features]
+Param: OdomOpenVINS/UpSLAMSigmaPx = "1.0"                  [Pixel noise for SLAM features]
+Param: OdomOpenVINS/UseFEJ = "true"                        [If first-estimate Jacobians should be used (enable for good consistency)]
+Param: OdomOpenVINS/UseKLT = "true"                        [If true we will use KLT, otherwise use a ORB descriptor + robust matching]
+Param: OdomOpenVINS/UseStereo = "true"                     [If we have more than 1 camera, if we should try to track stereo constraints between pairs]
+Param: OdomOpenVINS/ZUPTChi2Multiplier = "0.0"             [Chi2 multiplier for zero velocity]
+Param: OdomOpenVINS/ZUPTMaxDisparity = "0.5"               [Max disparity we will consider to try to do a zupt (i.e. if above this, don't do zupt)]
+Param: OdomOpenVINS/ZUPTMaxVelodicy = "0.1"                [Max velocity we will consider to try to do a zupt (i.e. if above this, don't do zupt)]
+Param: OdomOpenVINS/ZUPTNoiseMultiplier = "10.0"           [Multiplier of our zupt measurement IMU noise matrix (default should be 1.0)]
+Param: OdomOpenVINS/ZUPTOnlyAtBeginning = "false"          [If we should only use the zupt at the very beginning static initialization phase]
+Param: OdomVINSFusion/ConfigPath = ""                      [Path of VINS-Fusion config file.]
+Param: OdomViso2/BucketHeight = "50"                       [Height of bucket.]
+Param: OdomViso2/BucketMaxFeatures = "2"                   [Maximal number of features per bucket.]
+Param: OdomViso2/BucketWidth = "50"                        [Width of bucket.]
+Param: OdomViso2/InlierThreshold = "2.0"                   [Fundamental matrix inlier threshold.]
+Param: OdomViso2/MatchBinsize = "50"                       [Matching bin width/height (affects efficiency only).]
+Param: OdomViso2/MatchDispTolerance = "2"                  [Disparity tolerance for stereo matches (in pixels).]
+Param: OdomViso2/MatchHalfResolution = "true"              [Match at half resolution, refine at full resolution.]
+Param: OdomViso2/MatchMultiStage = "true"                  [Multistage matching (denser and faster).]
+Param: OdomViso2/MatchNmsN = "3"                           [Non-max-suppression: min. distance between maxima (in pixels).]
+Param: OdomViso2/MatchNmsTau = "50"                        [Non-max-suppression: interest point peakiness threshold.]
+Param: OdomViso2/MatchOutlierDispTolerance = "5"           [Outlier removal: disparity tolerance (in pixels).]
+Param: OdomViso2/MatchOutlierFlowTolerance = "5"           [Outlier removal: flow tolerance (in pixels).]
+Param: OdomViso2/MatchRadius = "200"                       [Matching radius (du/dv in pixels).]
+Param: OdomViso2/MatchRefinement = "1"                     [Refinement (0=none,1=pixel,2=subpixel).]
+Param: OdomViso2/RansacIters = "200"                       [Number of RANSAC iterations.]
+Param: OdomViso2/Reweighting = "true"                      [Lower border weights (more robust to calibration errors).]
+Param: Optimizer/Epsilon = "0.00001"                       [Stop optimizing when the error improvement is less than this value.]
+Param: Optimizer/GravitySigma = "0.3"                      [Gravity sigma value (>=0, typically between 0.1 and 0.3). Optimization is done while preserving gravity orientation of the poses. This should be used only with visual/lidar inertial odometry approaches, for which we assume that all odometry poses are aligned with gravity. Set to 0 to disable gravity constraints. Currently supported only with g2o and GTSAM optimization strategies (see Optimizer/Strategy).]
+Param: Optimizer/Iterations = "20"                         [Optimization iterations.]
+Param: Optimizer/LandmarksIgnored = "false"                [Ignore landmark constraints while optimizing. Currently only g2o and gtsam optimization supports this.]
+Param: Optimizer/PriorsIgnored = "true"                    [Ignore prior constraints (global pose or GPS) while optimizing. Currently only g2o and gtsam optimization supports this.]
+Param: Optimizer/Robust = "false"                          [Robust graph optimization using Vertigo (only work for g2o and GTSAM optimization strategies).]
+Param: Optimizer/Strategy = "2"                            [Graph optimization strategy: 0=TORO, 1=g2o, 2=GTSAM and 3=Ceres.]
+Param: Optimizer/VarianceIgnored = "false"                 [Ignore constraints' variance. If checked, identity information matrix is used for each constraint. Otherwise, an information matrix is generated from the variance saved in the links.]
+Param: PyDetector/Cuda = "true"                            [Use cuda.]
+Param: PyDetector/Path = ""                                [Path to python script file (see available ones in rtabmap/corelib/src/python/*). See the header to see where the script should be copied.]
+Param: PyMatcher/Cuda = "true"                             [Used by SuperGlue.]
+Param: PyMatcher/Iterations = "20"                         [Sinkhorn iterations. Used by SuperGlue.]
+Param: PyMatcher/Model = "indoor"                          [For SuperGlue, set only "indoor" or "outdoor". For OANet, set path to one of the pth file (e.g., "OANet/model/gl3d/sift-4000/model_best.pth").]
+Param: PyMatcher/Path = ""                                 [Path to python script file (see available ones in rtabmap/corelib/src/python/*). See the header to see where the script should be copied.]
+Param: PyMatcher/Threshold = "0.2"                         [Used by SuperGlue.]
+Param: Reg/Force3DoF = "false"                             [Force 3 degrees-of-freedom transform (3Dof: x,y and yaw). Parameters z, roll and pitch will be set to 0.]
+Param: Reg/RepeatOnce = "true"                             [Do a second registration with the output of the first registration as guess. Only done if no guess was provided for the first registration (like on loop closure). It can be useful if the registration approach used can use a guess to get better matches.]
+Param: Reg/Strategy = "0"                                  [0=Vis, 1=Icp, 2=VisIcp]
+Param: Rtabmap/ImagesAlreadyRectified = "true"             [Images are already rectified. By default RTAB-Map assumes that received images are rectified. If they are not, they can be rectified by RTAB-Map if this parameter is false.]
+Param: Rtabmap/PublishRAMUsage = "false"                   [Publishing RAM usage in statistics (may add a small overhead to get info from the system).]
+Param: SIFT/ContrastThreshold = "0.04"                     [The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector. Not used by CudaSift (see SIFT/GaussianThreshold instead).]
+Param: SIFT/EdgeThreshold = "10"                           [The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).]
+Param: SIFT/GaussianThreshold = "2.0"                      [CudaSift: Threshold on difference of Gaussians for feature pruning. The higher the threshold, the less features are produced by the detector.]
+Param: SIFT/Gpu = "false"                                  [CudaSift: Use GPU version of SIFT. This option is enabled only if RTAB-Map is built with CudaSift dependency and GPUs are detected.]
+Param: SIFT/NOctaveLayers = "3"                            [The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution. Not used by CudaSift, the number of octaves is still computed automatically.]
+Param: SIFT/PreciseUpscale = "false"                       [Whether to enable precise upscaling in the scale pyramid (OpenCV >= 4.8).]
+Param: SIFT/RootSIFT = "false"                             [Apply RootSIFT normalization of the descriptors.]
+Param: SIFT/Sigma = "1.6"                                  [The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.]
+Param: SIFT/Upscale = "false"                              [CudaSift: Whether to enable upscaling.]
+Param: SURF/Extended = "false"                             [Extended descriptor flag (true - use extended 128-element descriptors; false - use 64-element descriptors).]
+Param: SURF/GpuKeypointsRatio = "0.01"                     [Used with SURF GPU.]
+Param: SURF/GpuVersion = "false"                           [GPU-SURF: Use GPU version of SURF. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.]
+Param: SURF/HessianThreshold = "500"                       [Threshold for hessian keypoint detector used in SURF.]
+Param: SURF/OctaveLayers = "2"                             [Number of octave layers within each octave.]
+Param: SURF/Octaves = "4"                                  [Number of pyramid octaves the keypoint detector will use.]
+Param: SURF/Upright = "false"                              [Up-right or rotated features flag (true - do not compute orientation of features; false - compute orientation).]
+Param: SuperPoint/Cuda = "true"                            [Use Cuda device for Torch, otherwise CPU device is used by default.]
+Param: SuperPoint/ModelPath = ""                           [[Required] Path to pre-trained weights Torch file of SuperPoint (*.pt).]
+Param: SuperPoint/NMS = "true"                             [If true, non-maximum suppression is applied to detected keypoints.]
+Param: SuperPoint/NMSRadius = "4"                          [[SuperPoint/NMS=true] Minimum distance (pixels) between keypoints.]
+Param: SuperPoint/Threshold = "0.010"                      [Detector response threshold to accept keypoint.]
+Param: SuperPointRpautrat/Cuda = "true"                    [Use Cuda device for Torch, otherwise CPU device is used by default.]
+Param: SuperPointRpautrat/ModelPath = ""                   [[Required] SuperPoint python model file (superpoint_pytorch.py).]
+Param: SuperPointRpautrat/NMS = "true"                     [If true, non-maximum suppression is applied to detected keypoints.]
+Param: SuperPointRpautrat/NMSRadius = "4"                  [[SuperPointRpautrat/NMS=true] Minimum distance (pixels) between keypoints.]
+Param: SuperPointRpautrat/Threshold = "0.005"              [Detector response threshold to accept keypoint.]
+Param: SuperPointRpautrat/WeightsPath = ""                 [[Required] SuperPoint weights file (*.pth).]
+Param: Vis/BundleAdjustment = "1"                          [Optimization with bundle adjustment: 0=disabled, 1=g2o, 2=cvsba, 3=Ceres.]
+Param: Vis/CorFlowEps = "0.01"                             [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorFlowGpu = "false"                            [[Vis/CorType=1] Enable GPU version of the optical flow approach (only available if OpenCV is built with CUDA).]
+Param: Vis/CorFlowIterations = "30"                        [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorFlowMaxLevel = "3"                           [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorFlowWinSize = "16"                           [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorGuessMatchToProjection = "false"             [[Vis/CorType=0] Match frame's corners to source's projected points (when guess transform is provided) instead of projected points to frame's corners.]
+Param: Vis/CorGuessWinSize = "40"                          [[Vis/CorType=0] Matching window size (pixels) around projected points when a guess transform is provided to find correspondences. 0 means disabled.]
+Param: Vis/CorNNDR = "0.8"                                 [[Vis/CorType=0] NNDR: nearest neighbor distance ratio. Used for knn features matching approach.]
+Param: Vis/CorNNType = "1"                                 [[Vis/CorType=0] kNNFlannNaive=0, kNNFlannKdTree=1, kNNFlannLSH=2, kNNBruteForce=3, kNNBruteForceGPU=4, BruteForceCrossCheck=5, SuperGlue=6, GMS=7. Used for features matching approach.]
+Param: Vis/CorType = "0"                                   [Correspondences computation approach: 0=Features Matching, 1=Optical Flow]
+Param: Vis/DepthAsMask = "true"                            [Use depth image as mask when extracting features.]
+Param: Vis/DepthMaskFloorThr = "0.0"                       [Filter floor from depth mask below specified threshold (m) before extracting features. 0 means disabled, negative means remove all objects above the floor threshold instead. Ignored if Vis/DepthAsMask is false.]
+Param: Vis/EpipolarGeometryVar = "0.1"                     [[Vis/EstimationType = 2] Epipolar geometry maximum variance to accept the transformation.]
+Param: Vis/EstimationType = "1"                            [Motion estimation approach: 0:3D->3D, 1:3D->2D (PnP), 2:2D->2D (Epipolar Geometry)]
+Param: Vis/FeatureType = "8"                               [0=SURF 1=SIFT 2=ORB 3=FAST/FREAK 4=FAST/BRIEF 5=GFTT/FREAK 6=GFTT/BRIEF 7=BRISK 8=GFTT/ORB 9=KAZE 10=ORB-OCTREE 11=SuperPoint 12=SURF/FREAK 13=GFTT/DAISY 14=SURF/DAISY 15=PyDetector 16=SuperPoint-Rpautrat]
+Param: Vis/GridCols = "1"                                  [Number of columns of the grid used to extract uniformly "Vis/MaxFeatures / grid cells" features from each cell.]
+Param: Vis/GridRows = "1"                                  [Number of rows of the grid used to extract uniformly "Vis/MaxFeatures / grid cells" features from each cell.]
+Param: Vis/InlierDistance = "0.1"                          [[Vis/EstimationType = 0] Maximum distance for feature correspondences. Used by 3D->3D estimation approach.]
+Param: Vis/Iterations = "300"                              [Maximum iterations to compute the transform.]
+Param: Vis/MaxDepth = "0"                                  [Max depth of the features (0 means no limit).]
+Param: Vis/MaxFeatures = "1000"                            [0 no limits.]
+Param: Vis/MeanInliersDistance = "0.0"                     [Maximum distance (m) of the mean distance of inliers from the camera to accept the transformation. 0 means disabled.]
+Param: Vis/MinDepth = "0"                                  [Min depth of the features (0 means no limit).]
+Param: Vis/MinInliers = "20"                               [Minimum feature correspondences to compute/accept the transformation.]
+Param: Vis/MinInliersDistribution = "0.0"                  [Minimum distribution value of the inliers in the image to accept the transformation. The distribution is the second eigen value of the PCA (Principal Component Analysis) on the keypoints of the normalized image [-0.5, 0.5]. The value would be between 0 and 0.5. 0 means disabled.]
+Param: Vis/PnPFlags = "0"                                  [[Vis/EstimationType = 1] PnP flags: 0=Iterative, 1=EPNP, 2=P3P]
+Param: Vis/PnPMaxVariance = "0.0"                          [[Vis/EstimationType = 1] Max linear variance between 3D point correspondences after PnP. 0 means disabled.]
+Param: Vis/PnPRefineIterations = "0"                       [[Vis/EstimationType = 1] Refine iterations. Set to 0 if "Vis/BundleAdjustment" is also used.]
+Param: Vis/PnPReprojError = "2"                            [[Vis/EstimationType = 1] PnP reprojection error.]
+Param: Vis/PnPSamplingPolicy = "1"                         [[Vis/EstimationType = 1] Multi-camera random sampling policy: 0=AUTO, 1=ANY, 2=HOMOGENEOUS. With HOMOGENEOUS policy, RANSAC will be done uniformly against all cameras, so at least 2 matches per camera are required. With ANY policy, RANSAC is not constraint to sample on all cameras at the same time. AUTO policy will use HOMOGENEOUS if there are at least 2 matches per camera, otherwise it will fallback to ANY policy.]
+Param: Vis/PnPSplitLinearCovComponents = "false"           [[Vis/EstimationType = 1] Compute variance for each linear component instead of using the combined XYZ variance for all linear components.]
+Param: Vis/PnPVarianceMedianRatio = "4"                    [[Vis/EstimationType = 1] Ratio used to compute variance of the estimated transformation if 3D correspondences are provided (should be > 1). The higher it is, the smaller the covariance will be. With accurate depth estimation, this could be set to 2. For depth estimated by stereo, 4 or more maybe used to ignore large errors of very far points.]
+Param: Vis/RefineIterations = "5"                          [[Vis/EstimationType = 0] Number of iterations used to refine the transformation found by RANSAC. 0 means that the transformation is not refined.]
+Param: Vis/RoiRatios = "0.0 0.0 0.0 0.0"                   [Region of interest ratios [left, right, top, bottom].]
+Param: Vis/SSC = "false"                                   [If true, SSC (Suppression via Square Covering) is applied to limit keypoints.]
+Param: Vis/SubPixEps = "0.02"                              [See cv::cornerSubPix().]
+Param: Vis/SubPixIterations = "0"                          [See cv::cornerSubPix(). 0 disables sub pixel refining.]
+Param: Vis/SubPixWinSize = "3"                             [See cv::cornerSubPix().]
+Param: g2o/Baseline = "0.075"                              [When doing bundle adjustment with RGB-D data, we can set a fake baseline (m) to do stereo bundle adjustment (if 0, mono bundle adjustment is done). For stereo data, the baseline in the calibration is used directly.]
+Param: g2o/Optimizer = "0"                                 [0=Levenberg 1=GaussNewton]
+Param: g2o/PixelVariance = "1.0"                           [Pixel variance used for bundle adjustment.]
+Param: g2o/RobustKernelDelta = "8"                         [Robust kernel delta used for bundle adjustment (0 means don't use robust kernel). Observations with chi2 over this threshold will be ignored in the second optimization pass.]
+Param: g2o/Solver = "0"                                    [0=csparse 1=pcg 2=cholmod 3=Eigen]
+[ WARN] (2026-04-02 12:44:52.093) RGBDOdometryNode.cpp:58::main() Node will now exit after showing default odometry parameters because argument "--params" is detected!

experiments/rtabmap/params/route.yaml

@@ -0,0 +1,421 @@
+waypoints:
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 0.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 1.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 2.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 3.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 4.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 5.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 6.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 7.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 8.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.0
+    position:
+      x: 9.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.031415926535897046
+    position:
+      x: 10.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 0.09424777960769377
+    position:
+      x: 10.156976298823285
+      y: 0.0049331789293209916
+- pose:
+    orientation:
+      theta: 0.15707963267949113
+    position:
+      x: 10.313333083910761
+      y: 0.019713246713805255
+- pose:
+    orientation:
+      theta: 0.21991148575128608
+    position:
+      x: 10.468453286464312
+      y: 0.044281873178278364
+- pose:
+    orientation:
+      theta: 0.2827433388230835
+    position:
+      x: 10.621724717912137
+      y: 0.07854209717842231
+- pose:
+    orientation:
+      theta: 0.34557519189487673
+    position:
+      x: 10.772542485937368
+      y: 0.12235870926211634
+- pose:
+    orientation:
+      theta: 0.4084070449666701
+    position:
+      x: 10.920311381711695
+      y: 0.17555878527937185
+- pose:
+    orientation:
+      theta: 0.4712388980384709
+    position:
+      x: 11.064448228912681
+      y: 0.23793236883495084
+- pose:
+    orientation:
+      theta: 0.5340707511102667
+    position:
+      x: 11.204384185254288
+      y: 0.3092332998903409
+- pose:
+    orientation:
+      theta: 0.596902604182055
+    position:
+      x: 11.33956698744749
+      y: 0.3891801862449622
+- pose:
+    orientation:
+      theta: 0.6597344572538617
+    position:
+      x: 11.469463130731183
+      y: 0.47745751406263137
+- pose:
+    orientation:
+      theta: 0.7225663103256492
+    position:
+      x: 11.593559974371724
+      y: 0.573716893060527
+- pose:
+    orientation:
+      theta: 0.7853981633974443
+    position:
+      x: 11.711367764821722
+      y: 0.677578431446471
+- pose:
+    orientation:
+      theta: 0.848230016469254
+    position:
+      x: 11.82242156855353
+      y: 0.7886322351782784
+- pose:
+    orientation:
+      theta: 0.9110618695410353
+    position:
+      x: 11.926283106939472
+      y: 0.9064400256282759
+- pose:
+    orientation:
+      theta: 0.9738937226128352
+    position:
+      x: 12.022542485937368
+      y: 1.0305368692688168
+- pose:
+    orientation:
+      theta: 1.036725575684632
+    position:
+      x: 12.110819813755038
+      y: 1.1604330125525086
+- pose:
+    orientation:
+      theta: 1.0995574287564258
+    position:
+      x: 12.19076670010966
+      y: 1.2956158147457122
+- pose:
+    orientation:
+      theta: 1.162389281828222
+    position:
+      x: 12.26206763116505
+      y: 1.4355517710873185
+- pose:
+    orientation:
+      theta: 1.2252211349000215
+    position:
+      x: 12.324441214720629
+      y: 1.579688618288305
+- pose:
+    orientation:
+      theta: 1.2880529879718174
+    position:
+      x: 12.377641290737884
+      y: 1.7274575140626314
+- pose:
+    orientation:
+      theta: 1.3508848410436078
+    position:
+      x: 12.421457902821578
+      y: 1.8782752820878632
+- pose:
+    orientation:
+      theta: 1.4137166941154133
+    position:
+      x: 12.455718126821722
+      y: 2.0315467135356884
+- pose:
+    orientation:
+      theta: 1.4765485471871949
+    position:
+      x: 12.480286753286194
+      y: 2.186666916089239
+- pose:
+    orientation:
+      theta: 1.5393804002590021
+    position:
+      x: 12.49506682107068
+      y: 2.3430237011767163
+- pose:
+    orientation:
+      theta: 1.602212253330791
+    position:
+      x: 12.5
+      y: 2.5
+- pose:
+    orientation:
+      theta: 1.6650441064025985
+    position:
+      x: 12.49506682107068
+      y: 2.6569762988232837
+- pose:
+    orientation:
+      theta: 1.7278759594743793
+    position:
+      x: 12.480286753286194
+      y: 2.8133330839107606
+- pose:
+    orientation:
+      theta: 1.7907078125461848
+    position:
+      x: 12.455718126821722
+      y: 2.9684532864643116
+- pose:
+    orientation:
+      theta: 1.8535396656179774
+    position:
+      x: 12.421457902821578
+      y: 3.1217247179121372
+- pose:
+    orientation:
+      theta: 1.9163715186897716
+    position:
+      x: 12.377641290737884
+      y: 3.272542485937368
+- pose:
+    orientation:
+      theta: 1.9792033717615685
+    position:
+      x: 12.324441214720629
+      y: 3.4203113817116946
+- pose:
+    orientation:
+      theta: 2.0420352248333673
+    position:
+      x: 12.26206763116505
+      y: 3.564448228912682
+- pose:
+    orientation:
+      theta: 2.1048670779051704
+    position:
+      x: 12.19076670010966
+      y: 3.7043841852542885
+- pose:
+    orientation:
+      theta: 2.1676989309769525
+    position:
+      x: 12.110819813755036
+      y: 3.8395669874474923
+- pose:
+    orientation:
+      theta: 2.230530784048755
+    position:
+      x: 12.022542485937368
+      y: 3.969463130731183
+- pose:
+    orientation:
+      theta: 2.2933626371205498
+    position:
+      x: 11.926283106939472
+      y: 4.093559974371725
+- pose:
+    orientation:
+      theta: 2.356194490192345
+    position:
+      x: 11.822421568553528
+      y: 4.211367764821722
+- pose:
+    orientation:
+      theta: 2.4190263432641324
+    position:
+      x: 11.711367764821722
+      y: 4.322421568553528
+- pose:
+    orientation:
+      theta: 2.4818581963359407
+    position:
+      x: 11.593559974371725
+      y: 4.426283106939473
+- pose:
+    orientation:
+      theta: 2.544690049407734
+    position:
+      x: 11.469463130731183
+      y: 4.522542485937368
+- pose:
+    orientation:
+      theta: 2.6075219024795273
+    position:
+      x: 11.339566987447492
+      y: 4.610819813755037
+- pose:
+    orientation:
+      theta: 2.6703537555513224
+    position:
+      x: 11.204384185254288
+      y: 4.690766700109659
+- pose:
+    orientation:
+      theta: 2.733185608623123
+    position:
+      x: 11.064448228912681
+      y: 4.762067631165049
+- pose:
+    orientation:
+      theta: 2.796017461694914
+    position:
+      x: 10.920311381711695
+      y: 4.824441214720628
+- pose:
+    orientation:
+      theta: 2.8588493147667124
+    position:
+      x: 10.772542485937368
+      y: 4.877641290737884
+- pose:
+    orientation:
+      theta: 2.9216811678385044
+    position:
+      x: 10.621724717912137
+      y: 4.921457902821578
+- pose:
+    orientation:
+      theta: 2.9845130209103106
+    position:
+      x: 10.468453286464312
+      y: 4.955718126821722
+- pose:
+    orientation:
+      theta: 3.047344873982091
+    position:
+      x: 10.313333083910761
+      y: 4.980286753286194
+- pose:
+    orientation:
+      theta: 3.110176727053899
+    position:
+      x: 10.156976298823285
+      y: 4.9950668210706795
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 10.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 9.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 8.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 7.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 6.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 5.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 4.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 3.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 2.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 3.141592653589793
+    position:
+      x: 1.0
+      y: 5.0

experiments/rtabmap/params/route2.yaml

@@ -0,0 +1,68 @@
+waypoints:
+  - pose:
+      position:
+        x: 3
+        y: 0
+      orientation:
+        z: 0
+        w: 1
+  - pose:
+      position:
+        x: 6
+        y: 0
+      orientation:
+        z: 0
+        w: 1
+  - pose:
+      position:
+        x: 9
+        y: 0
+      orientation:
+        z: 0
+        w: 1
+  - pose:
+      position:
+        x: 11
+        y: -1
+      orientation:
+        z: -0.7071068
+        w: 0.7071068
+  - pose:
+      position:
+        x: 11
+        y: -2
+      orientation:
+        z: -0.9489846
+        w: 0.3153224
+  - pose:
+      position:
+        x: 9
+        y: -3
+      orientation:
+        z: 1
+        w: 0
+  - pose:
+      position:
+        x: 6
+        y: -3
+      orientation:
+        z: 1
+        w: 0
+  - pose:
+      position:
+        x: 3
+        y: -3
+      orientation:
+        z: 1
+        w: 0
+  - pose:
+      position:
+        x: 0
+        y: -3
+      orientation:
+        z: 1
+        w: 0
+
+
+
+

experiments/rtabmap/params/slam.txt

@@ -0,0 +1,398 @@
+jaco@A70i:~/ws$ ros2 run rtabmap_slam rtabmap --params
+Param: BRIEF/Bytes = "32"                                  [Bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.]
+Param: BRISK/Octaves = "3"                                 [Detection octaves. Use 0 to do single scale.]
+Param: BRISK/PatternScale = "1"                            [Apply this scale to the pattern used for sampling the neighbourhood of a keypoint.]
+Param: BRISK/Thresh = "30"                                 [FAST/AGAST detection threshold score.]
+Param: Bayes/FullPredictionUpdate = "false"                [Regenerate all the prediction matrix on each iteration (otherwise only removed/added ids are updated).]
+Param: Bayes/PredictionLC = "0.1 0.36 0.30 0.16 0.062 0.0151 0.00255 0.000324 2.5e-05 1.3e-06 4.8e-08 1.2e-09 1.9e-11 2.2e-13 1.7e-15 8.5e-18 2.9e-20 6.9e-23" [Prediction of loop closures (Gaussian-like, here with sigma=1.6) - Format: {VirtualPlaceProb, LoopClosureProb, NeighborLvl1, NeighborLvl2, ...}.]
+Param: Bayes/VirtualPlacePriorThr = "0.9"                  [Virtual place prior]
+Param: Db/TargetVersion = ""                               [Target database version for backward compatibility purpose. Only Major and minor versions are used and should be set (e.g., 0.19 vs 0.20 or 1.0 vs 2.0). Patch version is ignored (e.g., 0.20.1 and 0.20.3 will generate a 0.20 database).]
+Param: DbSqlite3/CacheSize = "10000"                       [Sqlite cache size (default is 2000).]
+Param: DbSqlite3/InMemory = "false"                        [Using database in the memory instead of a file on the hard disk.]
+Param: DbSqlite3/JournalMode = "3"                         [0=DELETE, 1=TRUNCATE, 2=PERSIST, 3=MEMORY, 4=OFF (see sqlite3 doc : "PRAGMA journal_mode")]
+Param: DbSqlite3/Synchronous = "0"                         [0=OFF, 1=NORMAL, 2=FULL (see sqlite3 doc : "PRAGMA synchronous")]
+Param: DbSqlite3/TempStore = "2"                           [0=DEFAULT, 1=FILE, 2=MEMORY (see sqlite3 doc : "PRAGMA temp_store")]
+Param: FAST/CV = "0"                                       [Enable FastCV implementation if non-zero (and RTAB-Map is built with FastCV support). Values should be 9 and 10.]
+Param: FAST/Gpu = "false"                                  [GPU-FAST: Use GPU version of FAST. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.]
+Param: FAST/GpuKeypointsRatio = "0.05"                     [Used with FAST GPU.]
+Param: FAST/GridCols = "0"                                 [Grid cols (0 to disable). Adapts the detector to partition the source image into a grid and detect points in each cell.]
+Param: FAST/GridRows = "0"                                 [Grid rows (0 to disable). Adapts the detector to partition the source image into a grid and detect points in each cell.]
+Param: FAST/MaxThreshold = "200"                           [Maximum threshold. Used only when FAST/GridRows and FAST/GridCols are set.]
+Param: FAST/MinThreshold = "7"                             [Minimum threshold. Used only when FAST/GridRows and FAST/GridCols are set.]
+Param: FAST/NonmaxSuppression = "true"                     [If true, non-maximum suppression is applied to detected corners (keypoints).]
+Param: FAST/Threshold = "20"                               [Threshold on difference between intensity of the central pixel and pixels of a circle around this pixel.]
+Param: FREAK/NOctaves = "4"                                [Number of octaves covered by the detected keypoints.]
+Param: FREAK/OrientationNormalized = "true"                [Enable orientation normalization.]
+Param: FREAK/PatternScale = "22"                           [Scaling of the description pattern.]
+Param: FREAK/ScaleNormalized = "true"                      [Enable scale normalization.]
+Param: GFTT/BlockSize = "3"                                []
+Param: GFTT/Gpu = "false"                                  [GPU-GFTT: Use GPU version of GFTT. This option is enabled only if OpenCV>=3 is built with CUDA and GPUs are detected.]
+Param: GFTT/K = "0.04"                                     []
+Param: GFTT/MinDistance = "7"                              []
+Param: GFTT/QualityLevel = "0.001"                         []
+Param: GFTT/UseHarrisDetector = "false"                    []
+Param: GMS/ThresholdFactor = "6.0"                         [The higher, the less matches.]
+Param: GMS/WithRotation = "false"                          [Take rotation transformation into account.]
+Param: GMS/WithScale = "false"                             [Take scale transformation into account.]
+Param: GTSAM/IncRelinearizeSkip = "1"                      [Only relinearize any variables every X calls to ISAM2::update(). See GTSAM::ISAM2 doc for more info.]
+Param: GTSAM/IncRelinearizeThreshold = "0.01"              [Only relinearize variables whose linear delta magnitude is greater than this threshold. See GTSAM::ISAM2 doc for more info.]
+Param: GTSAM/Incremental = "false"                         [Do graph optimization incrementally (iSAM2) to increase optimization speed on loop closures. Note that only GaussNewton and Dogleg optimization algorithms are supported (GTSAM/Optimizer) in this mode.]
+Param: GTSAM/Optimizer = "1"                               [0=Levenberg 1=GaussNewton 2=Dogleg]
+Param: Grid/3D = "true"                                    [A 3D occupancy grid is required if you want an OctoMap (3D ray tracing). Set to false if you want only a 2D map, the cloud will be projected on xy plane. A 2D map can be still generated if checked, but it requires more memory and time to generate it. Ignored if laser scan is 2D and "Grid/Sensor" is 0.]
+Param: Grid/CellSize = "0.05"                              [Resolution of the occupancy grid.]
+Param: Grid/ClusterRadius = "0.1"                          [[Grid/NormalsSegmentation=true] Cluster maximum radius.]
+Param: Grid/DepthDecimation = "4"                          [[Grid/DepthDecimation=true] Decimation of the depth image before creating cloud.]
+Param: Grid/DepthRoiRatios = "0.0 0.0 0.0 0.0"             [[Grid/Sensor>=1] Region of interest ratios [left, right, top, bottom].]
+Param: Grid/FlatObstacleDetected = "true"                  [[Grid/NormalsSegmentation=true] Flat obstacles detected.]
+Param: Grid/FootprintHeight = "0.0"                        [Footprint height used to filter points over the footprint of the robot. Footprint length and width should be set.]
+Param: Grid/FootprintLength = "0.0"                        [Footprint length used to filter points over the footprint of the robot.]
+Param: Grid/FootprintWidth = "0.0"                         [Footprint width used to filter points over the footprint of the robot. Footprint length should be set.]
+Param: Grid/GroundIsObstacle = "false"                     [[Grid/3D=true] Ground segmentation (Grid/NormalsSegmentation) is ignored, all points are obstacles. Use this only if you want an OctoMap with ground identified as an obstacle (e.g., with an UAV).]
+Param: Grid/MapFrameProjection = "false"                   [Projection in map frame. On a 3D terrain and a fixed local camera transform (the cloud is created relative to ground), you may want to disable this to do the projection in robot frame instead.]
+Param: Grid/MaxGroundAngle = "45"                          [[Grid/NormalsSegmentation=true] Maximum angle (degrees) between point's normal to ground's normal to label it as ground. Points with higher angle difference are considered as obstacles.]
+Param: Grid/MaxGroundHeight = "0.0"                        [Maximum ground height (0=disabled). Should be set if "Grid/NormalsSegmentation" is false.]
+Param: Grid/MaxObstacleHeight = "0.0"                      [Maximum obstacles height (0=disabled).]
+Param: Grid/MinClusterSize = "10"                          [[Grid/NormalsSegmentation=true] Minimum cluster size to project the points.]
+Param: Grid/MinGroundHeight = "0.0"                        [Minimum ground height (0=disabled).]
+Param: Grid/NoiseFilteringMinNeighbors = "5"               [Noise filtering minimum neighbors.]
+Param: Grid/NoiseFilteringRadius = "0.0"                   [Noise filtering radius (0=disabled). Done after segmentation.]
+Param: Grid/NormalK = "20"                                 [[Grid/NormalsSegmentation=true] K neighbors to compute normals.]
+Param: Grid/NormalsSegmentation = "true"                   [Segment ground from obstacles using point normals, otherwise a fast passthrough is used.]
+Param: Grid/PreVoxelFiltering = "true"                     [Input cloud is downsampled by voxel filter (voxel size is "Grid/CellSize") before doing segmentation of obstacles and ground.]
+Param: Grid/RangeMax = "5.0"                               [Maximum range from sensor. 0=inf.]
+Param: Grid/RangeMin = "0.0"                               [Minimum range from sensor.]
+Param: Grid/RayTracing = "false"                           [Ray tracing is done for each occupied cell, filling unknown space between the sensor and occupied cells. If Grid/3D=true, RTAB-Map should be built with OctoMap support, otherwise 3D ray tracing is ignored.]
+Param: Grid/Scan2dUnknownSpaceFilled = "false"             [Unknown space filled. Only used with 2D laser scans. Use Grid/RangeMax to set maximum range if laser scan max range is to set.]
+Param: Grid/ScanDecimation = "1"                           [[Grid/Sensor=0 or 2] Decimation of the laser scan before creating cloud.]
+Param: Grid/Sensor = "1"                                   [Create occupancy grid from selected sensor: 0=laser scan, 1=depth image(s) or 2=both laser scan and depth image(s).]
+Param: GridGlobal/AltitudeDelta = "0"                      [Assemble only nodes that have the same altitude of +-delta meters of the current pose (0=disabled). This is used to generate 2D occupancy grid based on the current altitude (e.g., multi-floor building).]
+Param: GridGlobal/Eroded = "false"                         [Erode obstacle cells.]
+Param: GridGlobal/FloodFillDepth = "0"                     [Flood fill filter (0=disabled), used to remove empty cells outside the map. The flood fill is done at the specified depth (between 1 and 16) of the OctoMap.]
+Param: GridGlobal/FootprintRadius = "0.0"                  [Footprint radius (m) used to clear all obstacles under the graph.]
+Param: GridGlobal/MaxNodes = "0"                           [Maximum nodes assembled in the map starting from the last node (0=unlimited).]
+Param: GridGlobal/MinSize = "0.0"                          [Minimum map size (m).]
+Param: GridGlobal/OccupancyThr = "0.5"                     [Occupancy threshold (value between 0 and 1).]
+Param: GridGlobal/ProbClampingMax = "0.971"                [Probability clamping maximum (value between 0 and 1).]
+Param: GridGlobal/ProbClampingMin = "0.1192"               [Probability clamping minimum (value between 0 and 1).]
+Param: GridGlobal/ProbHit = "0.7"                          [Probability of a hit (value between 0.5 and 1).]
+Param: GridGlobal/ProbMiss = "0.4"                         [Probability of a miss (value between 0 and 0.5).]
+Param: GridGlobal/UpdateError = "0.01"                     [Graph changed detection error (m). Update map only if poses in new optimized graph have moved more than this value.]
+Param: Icp/CCFilterOutFarthestPoints = "false"             [If true, the algorithm will automatically ignore farthest points from the reference, for better convergence.]
+Param: Icp/CCMaxFinalRMS = "0.2"                           [Maximum final RMS error.]
+Param: Icp/CCSamplingLimit = "50000"                       [Maximum number of points per cloud (they are randomly resampled below this limit otherwise).]
+Param: Icp/CorrespondenceRatio = "0.1"                     [Ratio of matching correspondences to accept the transform.]
+Param: Icp/DebugExportFormat = ""                          [Export scans used for ICP in the specified format (a warning on terminal will be shown with the file paths used). Supported formats are "pcd", "ply" or "vtk". If logger level is debug, from and to scans will stamped, so previous files won't be overwritten.]
+Param: Icp/DownsamplingStep = "1"                          [Downsampling step size (1=no sampling). This is done before uniform sampling.]
+Param: Icp/Epsilon = "0"                                   [Set the transformation epsilon (maximum allowable difference between two consecutive transformations) in order for an optimization to be considered as having converged to the final solution.]
+Param: Icp/FiltersEnabled = "3"                            [Flag to enable filters: 1="from" cloud only, 2="to" cloud only, 3=both.]
+Param: Icp/Force4DoF = "false"                             [Limit ICP to x, y, z and yaw DoF. Available if Icp/Strategy > 0.]
+Param: Icp/Iterations = "30"                               [Max iterations.]
+Param: Icp/MaxCorrespondenceDistance = "0.1"               [Max distance for point correspondences.]
+Param: Icp/MaxRotation = "0.78"                            [Maximum ICP rotation correction accepted (rad).]
+Param: Icp/MaxTranslation = "0.2"                          [Maximum ICP translation correction accepted (m).]
+Param: Icp/OutlierRatio = "0.85"                           [Outlier ratio used with Icp/Strategy>0. For libpointmatcher, this parameter set TrimmedDistOutlierFilter/ratio for convenience when configuration file is not set. For CCCoreLib, this parameter set the "finalOverlapRatio". The value should be between 0 and 1.]
+Param: Icp/PMConfig = ""                                   [Configuration file (*.yaml) used by libpointmatcher. Note that data filters set for libpointmatcher are done after filtering done by rtabmap (i.e., Icp/VoxelSize, Icp/DownsamplingStep), so make sure to disable those in rtabmap if you want to use only those from libpointmatcher. Parameters Icp/Iterations, Icp/Epsilon and Icp/MaxCorrespondenceDistance are also ignored if configuration file is set.]
+Param: Icp/PMMatcherEpsilon = "0.0"                        [KDTreeMatcher/epsilon: approximation to use for the nearest-neighbor search. For convenience when configuration file is not set.]
+Param: Icp/PMMatcherIntensity = "false"                    [KDTreeMatcher:  among nearest neighbors, keep only the one with the most similar intensity. This only work with Icp/PMMatcherKnn>1.]
+Param: Icp/PMMatcherKnn = "1"                              [KDTreeMatcher/knn: number of nearest neighbors to consider it the reference. For convenience when configuration file is not set.]
+Param: Icp/PointToPlane = "true"                           [Use point to plane ICP.]
+Param: Icp/PointToPlaneGroundNormalsUp = "0.0"             [Invert normals on ground if they are pointing down (useful for ring-like 3D LiDARs). 0 means disabled, 1 means only normals perfectly aligned with -z axis. This is only done with 3D scans.]
+Param: Icp/PointToPlaneK = "5"                             [Number of neighbors to compute normals for point to plane if the cloud doesn't have already normals.]
+Param: Icp/PointToPlaneLowComplexityStrategy = "1"         [If structural complexity is below Icp/PointToPlaneMinComplexity: set to 0 to so that the transform is automatically rejected, set to 1 to limit ICP correction in axes with most constraints (e.g., for a corridor-like environment, the resulting transform will be limited in y and yaw, x will taken from the guess), set to 2 to accept "as is" the transform computed by PointToPoint.]
+Param: Icp/PointToPlaneMinComplexity = "0.02"              [Minimum structural complexity (0.0=low, 1.0=high) of the scan to do PointToPlane registration, otherwise PointToPoint registration is done instead and strategy from Icp/PointToPlaneLowComplexityStrategy is used. This check is done only when Icp/PointToPlane=true.]
+Param: Icp/PointToPlaneRadius = "0.0"                      [Search radius to compute normals for point to plane if the cloud doesn't have already normals.]
+Param: Icp/RangeMax = "0"                                  [Maximum range filtering (0=disabled).]
+Param: Icp/RangeMin = "0"                                  [Minimum range filtering (0=disabled).]
+Param: Icp/ReciprocalCorrespondences = "true"              [To be a valid correspondence, the corresponding point in target cloud to point in source cloud should be both their closest closest correspondence.]
+Param: Icp/Strategy = "1"                                  [ICP implementation: 0=Point Cloud Library, 1=libpointmatcher, 2=CCCoreLib (CloudCompare).]
+Param: Icp/VoxelSize = "0.05"                              [Uniform sampling voxel size (0=disabled).]
+Param: ImuFilter/ComplementaryBiasAlpha = "0.01"           [Bias estimation gain parameter, belongs in [0, 1].]
+Param: ImuFilter/ComplementaryDoAdpativeGain = "true"      [Parameter whether to do adaptive gain or not.]
+Param: ImuFilter/ComplementaryDoBiasEstimation = "true"    [Parameter whether to do bias estimation or not.]
+Param: ImuFilter/ComplementaryGainAcc = "0.01"             [Gain parameter for the complementary filter, belongs in [0, 1].]
+Param: ImuFilter/MadgwickGain = "0.1"                      [Gain of the filter. Higher values lead to faster convergence but more noise. Lower values lead to slower convergence but smoother signal, belongs in [0, 1].]
+Param: ImuFilter/MadgwickZeta = "0.0"                      [Gyro drift gain (approx. rad/s), belongs in [-1, 1].]
+Param: KAZE/Diffusivity = "1"                              [Diffusivity type: 0=DIFF_PM_G1, 1=DIFF_PM_G2, 2=DIFF_WEICKERT or 3=DIFF_CHARBONNIER.]
+Param: KAZE/Extended = "false"                             [Set to enable extraction of extended (128-byte) descriptor.]
+Param: KAZE/NOctaveLayers = "4"                            [Default number of sublevels per scale level.]
+Param: KAZE/NOctaves = "4"                                 [Maximum octave evolution of the image.]
+Param: KAZE/Threshold = "0.001"                            [Detector response threshold to accept keypoint.]
+Param: KAZE/Upright = "false"                              [Set to enable use of upright descriptors (non rotation-invariant).]
+Param: Kp/BadSignRatio = "0.5"                             [Bad signature ratio (less than Ratio x AverageWordsPerImage = bad).]
+Param: Kp/ByteToFloat = "false"                            [For Kp/NNStrategy=1, binary descriptors are converted to float by converting each byte to float instead of converting each bit to float. When converting bytes instead of bits, less memory is used and search is faster at the cost of slightly less accurate matching.]
+Param: Kp/DetectorStrategy = "8"                           [0=SURF 1=SIFT 2=ORB 3=FAST/FREAK 4=FAST/BRIEF 5=GFTT/FREAK 6=GFTT/BRIEF 7=BRISK 8=GFTT/ORB 9=KAZE 10=ORB-OCTREE 11=SuperPoint 12=SURF/FREAK 13=GFTT/DAISY 14=SURF/DAISY 15=PyDetector 16=SuperPoint-Rpautrat]
+Param: Kp/DictionaryPath = ""                              [Path of the pre-computed dictionary]
+Param: Kp/FlannIndexSaved = "false"                        [Save FLANN index during localization session (when Mem/IncrementalMemory=false). The FLANN index will be saved to database after the first time localization mode is used, then on next sessions, the index is reloaded from the database instead of being rebuilt again. This can save significant loading time when the visual word dictionary is big (>1M words). Note that if the dictionary is modified (parameters or data), the index will be rebuilt and saved again on the next session.]
+Param: Kp/FlannRebalancingFactor = "2.0"                   [Factor used when rebuilding the incremental FLANN index (see "Kp/IncrementalFlann"). Set <=1 to disable.]
+Param: Kp/GridCols = "1"                                   [Number of columns of the grid used to extract uniformly "Kp/MaxFeatures / grid cells" features from each cell.]
+Param: Kp/GridRows = "1"                                   [Number of rows of the grid used to extract uniformly "Kp/MaxFeatures / grid cells" features from each cell.]
+Param: Kp/IncrementalDictionary = "true"                   []
+Param: Kp/IncrementalFlann = "true"                        [When using FLANN based strategy, add/remove points to its index without always rebuilding the index (the index is built only when the dictionary increases of the factor "Kp/FlannRebalancingFactor" in size).]
+Param: Kp/MaxDepth = "0"                                   [Filter extracted keypoints by depth (0=inf).]
+Param: Kp/MaxFeatures = "500"                              [Maximum features extracted from the images (0 means not bounded, <0 means no extraction).]
+Param: Kp/MinDepth = "0"                                   [Filter extracted keypoints by depth.]
+Param: Kp/NNStrategy = "1"                                 [kNNFlannNaive=0, kNNFlannKdTree=1, kNNFlannLSH=2, kNNBruteForce=3, kNNBruteForceGPU=4]
+Param: Kp/NewWordsComparedTogether = "true"                [When adding new words to dictionary, they are compared also with each other (to detect same words in the same signature).]
+Param: Kp/NndrRatio = "0.8"                                [NNDR ratio (A matching pair is detected, if its distance is closer than X times the distance of the second nearest neighbor.)]
+Param: Kp/Parallelized = "true"                            [If the dictionary update and signature creation were parallelized.]
+Param: Kp/RoiRatios = "0.0 0.0 0.0 0.0"                    [Region of interest ratios [left, right, top, bottom].]
+Param: Kp/SSC = "false"                                    [If true, SSC (Suppression via Square Covering) is applied to limit keypoints.]
+Param: Kp/SerializeWithChecksum = "true"                   [On serialization of the FLANN index, compute checksum of the data used by the FLANN index. This adds a slight overhead on serialization/deserialization to make sure that the dictionary data correspond to same data used when the index was built.]
+Param: Kp/SubPixEps = "0.02"                               [See cv::cornerSubPix().]
+Param: Kp/SubPixIterations = "0"                           [See cv::cornerSubPix(). 0 disables sub pixel refining.]
+Param: Kp/SubPixWinSize = "3"                              [See cv::cornerSubPix().]
+Param: Kp/TfIdfLikelihoodUsed = "true"                     [Use of the td-idf strategy to compute the likelihood.]
+Param: Marker/CornerRefinementMethod = "0"                 [Corner refinement method (0: None, 1: Subpixel, 2:contour, 3: AprilTag2). For OpenCV <3.3.0, this is "doCornerRefinement" parameter: set 0 for false and 1 for true.]
+Param: Marker/Dictionary = "0"                             [Dictionary to use: DICT_ARUCO_4X4_50=0, DICT_ARUCO_4X4_100=1, DICT_ARUCO_4X4_250=2, DICT_ARUCO_4X4_1000=3, DICT_ARUCO_5X5_50=4, DICT_ARUCO_5X5_100=5, DICT_ARUCO_5X5_250=6, DICT_ARUCO_5X5_1000=7, DICT_ARUCO_6X6_50=8, DICT_ARUCO_6X6_100=9, DICT_ARUCO_6X6_250=10, DICT_ARUCO_6X6_1000=11, DICT_ARUCO_7X7_50=12, DICT_ARUCO_7X7_100=13, DICT_ARUCO_7X7_250=14, DICT_ARUCO_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16, DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20]
+Param: Marker/Length = "0"                                 [The length (m) of the markers' side. 0 means automatic marker length estimation using the depth image (the camera should look at the marker perpendicularly for initialization).]
+Param: Marker/MaxDepthError = "0.01"                       [Maximum depth error between all corners of a marker when estimating the marker length (when Marker/Length is 0). The smaller it is, the more perpendicular the camera should be toward the marker to initialize the length.]
+Param: Marker/MaxRange = "0.0"                             [Maximum range in which markers will be detected. <=0 for unlimited range.]
+Param: Marker/MinRange = "0.0"                             [Miniminum range in which markers will be detected. <=0 for unlimited range.]
+Param: Marker/Priors = ""                                  [World prior locations of the markers. The map will be transformed in marker's world frame when a tag is detected. Format is the marker's ID followed by its position (angles in rad), markers are separated by vertical line ("id1 x y z roll pitch yaw|id2 x y z roll pitch yaw"). Example:  "1 0 0 1 0 0 0|2 1 0 1 0 0 1.57" (marker 2 is 1 meter forward than marker 1 with 90 deg yaw rotation).]
+Param: Marker/PriorsVarianceAngular = "0.001"              [Angular variance to set on marker priors.]
+Param: Marker/PriorsVarianceLinear = "0.001"               [Linear variance to set on marker priors.]
+Param: Marker/VarianceAngular = "0.01"                     [Angular variance to set on marker detections. If Marker/VarianceOrientationIgnored is enabled, it is ignored with Optimizer/Strategy=1 (g2o) and it corresponds to bearing variance with Optimizer/Strategy=2 (GTSAM).]
+Param: Marker/VarianceLinear = "0.001"                     [Linear variance to set on marker detections. If Marker/VarianceOrientationIgnored is enabled and Optimizer/Strategy=2 (GTSAM): it is the variance of the range factor, with 9999 to disable range factor and to do only bearing.]
+Param: Marker/VarianceOrientationIgnored = "false"         [When this setting is false, the landmark's orientation is optimized during graph optimization. When this setting is true, only the position of the landmark is optimized. This can be useful when the landmark's orientation estimation is not reliable. Note that for Optimizer/Strategy=1 (g2o), only Marker/VarianceLinear needs be set if we ignore orientation. For Optimizer/Strategy=2 (GTSAM), instead of optimizing the landmark's position directly, a bearing/range factor is used, with Marker/VarianceLinear as the variance of the range factor (with 9999 to optimize the position with only a bearing factor) and Marker/VarianceAngular as the variance of the bearing factor (pitch/yaw).]
+Param: Mem/BadSignaturesIgnored = "false"                  [Bad signatures are ignored.]
+Param: Mem/BinDataKept = "true"                            [Keep binary data in db.]
+Param: Mem/CompressionParallelized = "true"                [Compression of sensor data is multi-threaded.]
+Param: Mem/CovOffDiagIgnored = "true"                      [Ignore off diagonal values of the covariance matrix.]
+Param: Mem/DepthAsMask = "true"                            [Use depth image as mask when extracting features for vocabulary.]
+Param: Mem/DepthCompressionFormat = ".rvl"                 [Depth image compression format for 16UC1 depth type. It should be ".png" or ".rvl". If depth type is 32FC1, ".png" is used.]
+Param: Mem/DepthMaskFloorThr = "0.0"                       [Filter floor from depth mask below specified threshold (m) before extracting features. 0 means disabled, negative means remove all objects above the floor threshold instead. Ignored if Mem/DepthAsMask is false.]
+Param: Mem/GenerateIds = "true"                            [True=Generate location IDs, False=use input image IDs.]
+Param: Mem/GlobalDescriptorStrategy = "0"                  [Extract global descriptor from sensor data. 0=disabled, 1=PyDescriptor]
+Param: Mem/ImageCompressionFormat = ".jpg"                 [RGB image compression format. It should be ".jpg" or ".png".]
+Param: Mem/ImageKept = "false"                             [Keep raw images in RAM.]
+Param: Mem/ImagePostDecimation = "1"                       [Decimation of the RGB image before saving it to database. If depth size is larger than decimated RGB size, depth is decimated to be always at most equal to RGB size. Decimation is done from the original image. If set to same value than Mem/ImagePreDecimation, data already decimated is saved (no need to re-decimate the image).]
+Param: Mem/ImagePreDecimation = "1"                        [Decimation of the RGB image before visual feature detection. If depth size is larger than decimated RGB size, depth is decimated to be always at most equal to RGB size. If Mem/DepthAsMask is true and if depth is smaller than decimated RGB, depth may be interpolated to match RGB size for feature detection.]
+Param: Mem/IncrementalMemory = "true"                      [SLAM mode, otherwise it is Localization mode.]
+Param: Mem/InitWMWithAllNodes = "false"                    [Initialize the Working Memory with all nodes in Long-Term Memory. When false, it is initialized with nodes of the previous session.]
+Param: Mem/IntermediateNodeDataKept = "false"              [Keep intermediate node data in db.]
+Param: Mem/LaserScanDownsampleStepSize = "1"               [If > 1, downsample the laser scans when creating a signature.]
+Param: Mem/LaserScanNormalK = "0"                          [If > 0 and laser scans don't have normals, normals will be computed with K search neighbors when creating a signature.]
+Param: Mem/LaserScanNormalRadius = "0.0"                   [If > 0 m and laser scans don't have normals, normals will be computed with radius search neighbors when creating a signature.]
+Param: Mem/LaserScanVoxelSize = "0.0"                      [If > 0 m, voxel filtering is done on laser scans when creating a signature. If the laser scan had normals, they will be removed. To recompute the normals, make sure to use "Mem/LaserScanNormalK" or "Mem/LaserScanNormalRadius" parameters.]
+Param: Mem/LoadVisualLocalFeaturesOnInit = "true"          [Load all local visual features (keypoints, descriptors and 3D points) in RAM when loading an existing database. This can add significant time to initialize the memory but the features will be already loaded before computing loop closure transforms. If false, the features are loaded on-demand from the database when a loop closure transformation should be estimated.]
+Param: Mem/LocalizationDataSaved = "false"                 [Save localization data during localization session (when Mem/IncrementalMemory=false). When enabled, the database will then also grow in localization mode. This mode would be used only for debugging purpose.]
+Param: Mem/MapLabelsAdded = "true"                         [Create map labels. The first node of a map will be labeled as "map#" where # is the map ID.]
+Param: Mem/NotLinkedNodesKept = "true"                     [Keep not linked nodes in db (rehearsed nodes and deleted nodes).]
+Param: Mem/RawDescriptorsKept = "true"                     [Raw descriptors kept in memory.]
+Param: Mem/RecentWmRatio = "0.2"                           [Ratio of locations after the last loop closure in WM that cannot be transferred.]
+Param: Mem/ReduceGraph = "false"                           [Reduce graph. Merge nodes when loop closures are added (ignoring those with user data). Note that this approach assumes that 100% of the loop closures accepted are good, so it is highly recommended to enable "RGBD/OptimizeMaxError" at the same time.]
+Param: Mem/RehearsalIdUpdatedToNewOne = "false"            [On merge, update to new id. When false, no copy.]
+Param: Mem/RehearsalSimilarity = "0.6"                     [Rehearsal similarity.]
+Param: Mem/RehearsalWeightIgnoredWhileMoving = "false"     [When the robot is moving, weights are not updated on rehearsal.]
+Param: Mem/RotateImagesUpsideUp = "false"                  [Rotate images so that upside is up if they are not already. This can be useful in case the robots don't have all same camera orientation but are using the same map, so that not rotation-invariant visual features can still be used across the fleet.]
+Param: Mem/STMSize = "10"                                  [Short-term memory size.]
+Param: Mem/SaveDepth16Format = "false"                     [Save depth image into 16 bits format to reduce memory used. Warning: values over ~65 meters are ignored (maximum 65535 millimeters).]
+Param: Mem/StereoFromMotion = "false"                      [Triangulate features without depth using stereo from motion (odometry). It would be ignored if Mem/DepthAsMask is true and the feature detector used supports masking.]
+Param: Mem/TransferSortingByWeightId = "false"             [On transfer, signatures are sorted by weight->ID only (i.e. the oldest of the lowest weighted signatures are transferred first). If false, the signatures are sorted by weight->Age->ID (i.e. the oldest inserted in WM of the lowest weighted signatures are transferred first). Note that retrieval updates the age, not the ID.]
+Param: Mem/UseOdomFeatures = "true"                        [Use odometry features instead of regenerating them.]
+Param: Mem/UseOdomGravity = "false"                        [Use odometry instead of IMU orientation to add gravity links to new nodes created. We assume that odometry is already aligned with gravity (e.g., we are using a VIO approach). Gravity constraints are used by graph optimization only if "Optimizer/GravitySigma" is not zero.]
+Param: ORB/EdgeThreshold = "19"                            [This is size of the border where the features are not detected. It should roughly match the patchSize parameter.]
+Param: ORB/FirstLevel = "0"                                [It should be 0 in the current implementation.]
+Param: ORB/Gpu = "false"                                   [GPU-ORB: Use GPU version of ORB. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.]
+Param: ORB/NLevels = "3"                                   [The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels).]
+Param: ORB/PatchSize = "31"                                [size of the patch used by the oriented BRIEF descriptor. Of course, on smaller pyramid layers the perceived image area covered by a feature will be larger.]
+Param: ORB/ScaleFactor = "2"                               [Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.]
+Param: ORB/ScoreType = "0"                                 [The default HARRIS_SCORE=0 means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE=1 is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute.]
+Param: ORB/WTA_K = "2"                                     [The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).]
+Param: Optimizer/Epsilon = "0.00001"                       [Stop optimizing when the error improvement is less than this value.]
+Param: Optimizer/GravitySigma = "0.3"                      [Gravity sigma value (>=0, typically between 0.1 and 0.3). Optimization is done while preserving gravity orientation of the poses. This should be used only with visual/lidar inertial odometry approaches, for which we assume that all odometry poses are aligned with gravity. Set to 0 to disable gravity constraints. Currently supported only with g2o and GTSAM optimization strategies (see Optimizer/Strategy).]
+Param: Optimizer/Iterations = "20"                         [Optimization iterations.]
+Param: Optimizer/LandmarksIgnored = "false"                [Ignore landmark constraints while optimizing. Currently only g2o and gtsam optimization supports this.]
+Param: Optimizer/PriorsIgnored = "true"                    [Ignore prior constraints (global pose or GPS) while optimizing. Currently only g2o and gtsam optimization supports this.]
+Param: Optimizer/Robust = "false"                          [Robust graph optimization using Vertigo (only work for g2o and GTSAM optimization strategies).]
+Param: Optimizer/Strategy = "2"                            [Graph optimization strategy: 0=TORO, 1=g2o, 2=GTSAM and 3=Ceres.]
+Param: Optimizer/VarianceIgnored = "false"                 [Ignore constraints' variance. If checked, identity information matrix is used for each constraint. Otherwise, an information matrix is generated from the variance saved in the links.]
+Param: PyDescriptor/Dim = "4096"                           [Descriptor dimension.]
+Param: PyDescriptor/Path = ""                              [Path to python script file (see available ones in rtabmap/corelib/src/pydescriptor/*). See the header to see where the script should be used.]
+Param: PyDetector/Cuda = "true"                            [Use cuda.]
+Param: PyDetector/Path = ""                                [Path to python script file (see available ones in rtabmap/corelib/src/python/*). See the header to see where the script should be copied.]
+Param: PyMatcher/Cuda = "true"                             [Used by SuperGlue.]
+Param: PyMatcher/Iterations = "20"                         [Sinkhorn iterations. Used by SuperGlue.]
+Param: PyMatcher/Model = "indoor"                          [For SuperGlue, set only "indoor" or "outdoor". For OANet, set path to one of the pth file (e.g., "OANet/model/gl3d/sift-4000/model_best.pth").]
+Param: PyMatcher/Path = ""                                 [Path to python script file (see available ones in rtabmap/corelib/src/python/*). See the header to see where the script should be copied.]
+Param: PyMatcher/Threshold = "0.2"                         [Used by SuperGlue.]
+Param: RGBD/AggressiveLoopThr = "0.05"                     [Loop closure threshold used (overriding Rtabmap/LoopThr) when a new mapping session is not yet linked to a map of the highest loop closure hypothesis. In localization mode, this threshold is used when there are no loop closure constraints with any map in the cache (RGBD/MaxOdomCacheSize). In all cases, the goal is to aggressively loop on a previous map in the database. Only used when RGBD/Enabled is enabled. Set 1 to disable.]
+Param: RGBD/AngularSpeedUpdate = "0.0"                     [Maximum angular speed (rad/s) to update the map (0 means not limit).]
+Param: RGBD/AngularUpdate = "0.1"                          [Minimum angular displacement (rad) to update the map. Rehearsal is done prior to this, so weights are still updated. To update the map when not moving, both RGBD/LinearUpdate and RGBD/AngularUpdate should be set to 0.]
+Param: RGBD/CreateOccupancyGrid = "true"                   [Create local occupancy grid maps. See "Grid" group for parameters.]
+Param: RGBD/Enabled = "true"                               [Activate metric SLAM. If set to false, classic RTAB-Map loop closure detection is done using only images and without any metric information.]
+Param: RGBD/ForceOdom3DoF = "true"                         [Force odometry pose to be 3DoF if Reg/Force3DoF=true.]
+Param: RGBD/GoalReachedRadius = "0.5"                      [Goal reached radius (m).]
+Param: RGBD/GoalsSavedInUserData = "false"                 [When a goal is received and processed with success, it is saved in user data of the location with this format: "GOAL:#".]
+Param: RGBD/InvertedReg = "false"                          [On loop closure, do registration from the target to reference instead of reference to target.]
+Param: RGBD/LinearSpeedUpdate = "0.0"                      [Maximum linear speed (m/s) to update the map (0 means not limit).]
+Param: RGBD/LinearUpdate = "0.1"                           [Minimum linear displacement (m) to update the map. Rehearsal is done prior to this, so weights are still updated. To update the map when not moving, both RGBD/LinearUpdate and RGBD/AngularUpdate should be set to 0.]
+Param: RGBD/LocalBundleOnLoopClosure = "false"             [Do local bundle adjustment with neighborhood of the loop closure.]
+Param: RGBD/LocalImmunizationRatio = "0.25"                [Ratio of working memory for which local nodes are immunized from transfer.]
+Param: RGBD/LocalRadius = "10"                             [Local radius (m) for nodes selection in the local map. This parameter is used in some approaches about the local map management.]
+Param: RGBD/LocalizationPriorError = "0.001"               [The corresponding variance (error x error) set to priors of the map's poses during localization (when RGBD/MaxOdomCacheSize>0).]
+Param: RGBD/LocalizationSecondTryWithoutProximityLinks = "true" [When localization is rejected by graph optimization validation, try a second time without proximity links if landmark or loop closure links are also present in odometry cache (see RGBD/MaxOdomCacheSize). If it succeeds, the proximity links are removed. This assumes that global loop closure and landmark links are more accurate than proximity links.]
+Param: RGBD/LocalizationSmoothing = "true"                 [Adjust localization constraints based on optimized odometry cache poses (when RGBD/MaxOdomCacheSize>0).]
+Param: RGBD/LoopClosureIdentityGuess = "false"             [Use Identity matrix as guess when computing loop closure transform, otherwise no guess is used, thus assuming that registration strategy selected (Reg/Strategy) can deal with transformation estimation without guess.]
+Param: RGBD/LoopClosureReextractFeatures = "false"         [Extract features even if there are some already in the nodes. Raw features are not saved in database.]
+Param: RGBD/LoopCovLimited = "false"                       [Limit covariance of non-neighbor links to minimum covariance of neighbor links. In other words, if covariance of a loop closure link is smaller than the minimum covariance of odometry links, its covariance is set to minimum covariance of odometry links.]
+Param: RGBD/MarkerDetection = "false"                      [Detect static markers to be added as landmarks for graph optimization. If input data have already landmarks, this will be ignored. See "Marker" group for parameters.]
+Param: RGBD/MaxLocalRetrieved = "2"                        [Maximum local locations retrieved (0=disabled) near the current pose in the local map or on the current planned path (those on the planned path have priority).]
+Param: RGBD/MaxLoopClosureDistance = "0.0"                 [Reject loop closures/localizations if the distance from the map is over this distance (0=disabled).]
+Param: RGBD/MaxOdomCacheSize = "10"                        [Maximum odometry cache size. Used only in localization mode (when Mem/IncrementalMemory=false). This is used to get smoother localizations and to verify localization transforms (when RGBD/OptimizeMaxError!=0) to make sure we don't teleport to a location very similar to one we previously localized on. Set 0 to disable caching.]
+Param: RGBD/NeighborLinkRefining = "false"                 [When a new node is added to the graph, the transformation of its neighbor link to the previous node is refined using registration approach selected (Reg/Strategy).]
+Param: RGBD/NewMapOdomChangeDistance = "0"                 [A new map is created if a change of odometry translation greater than X m is detected (0 m = disabled).]
+Param: RGBD/OptimizeFromGraphEnd = "false"                 [Optimize graph from the newest node. If false, the graph is optimized from the oldest node of the current graph (this adds an overhead computation to detect to oldest node of the current graph, but it can be useful to preserve the map referential from the oldest node). Warning when set to false: when some nodes are transferred, the first referential of the local map may change, resulting in momentary changes in robot/map position (which are annoying in teleoperation).]
+Param: RGBD/OptimizeMaxError = "3.0"                       [Reject loop closures if optimization error ratio is greater than this value (0=disabled). Ratio is computed as absolute error over standard deviation of each link. This will help to detect when a wrong loop closure is added to the graph. If used with "Optimizer/Robust", the disabled loop closure links will be removed.]
+Param: RGBD/PlanAngularVelocity = "0"                      [Angular velocity (rad/sec) used to compute path weights.]
+Param: RGBD/PlanLinearVelocity = "0"                       [Linear velocity (m/sec) used to compute path weights.]
+Param: RGBD/PlanStuckIterations = "0"                      [Mark the current goal node on the path as unreachable if it is not updated after X iterations (0=disabled). If all upcoming nodes on the path are unreachabled, the plan fails.]
+Param: RGBD/ProximityAngle = "45"                          [Maximum angle (degrees) for one-to-one proximity detection.]
+Param: RGBD/ProximityBySpace = "true"                      [Detection over locations (in Working Memory) near in space.]
+Param: RGBD/ProximityByTime = "false"                      [Detection over all locations in STM.]
+Param: RGBD/ProximityGlobalScanMap = "false"               [Create a global assembled map from laser scans for one-to-many proximity detection, replacing the original one-to-many proximity detection (i.e., detection against local paths). Only used in localization mode (Mem/IncrementalMemory=false), otherwise original one-to-many proximity detection is done. Note also that if graph is modified (i.e., memory management is enabled or robot jumps from one disjoint session to another in same database), the global scan map is cleared and one-to-many proximity detection is reverted to original approach.]
+Param: RGBD/ProximityMaxGraphDepth = "50"                  [Maximum depth from the current/last loop closure location and the local loop closure hypotheses. Set 0 to ignore.]
+Param: RGBD/ProximityMaxPaths = "3"                        [Maximum paths compared (from the most recent) for proximity detection. 0 means no limit.]
+Param: RGBD/ProximityMergedScanCovFactor = "100.0"         [Covariance factor for one-to-many proximity detection (when RGBD/ProximityPathMaxNeighbors>0 and scans are used).]
+Param: RGBD/ProximityOdomGuess = "false"                   [Use odometry as motion guess for one-to-one proximity detection.]
+Param: RGBD/ProximityPathFilteringRadius = "1"             [Path filtering radius to reduce the number of nodes to compare in a path in one-to-many proximity detection. The nearest node in a path should be inside that radius to be considered for one-to-one proximity detection.]
+Param: RGBD/ProximityPathMaxNeighbors = "0"                [Maximum neighbor nodes compared on each path for one-to-many proximity detection. Set to 0 to disable one-to-many proximity detection (by merging the laser scans).]
+Param: RGBD/ProximityPathRawPosesUsed = "true"             [When comparing to a local path for one-to-many proximity detection, merge the scans using the odometry poses (with neighbor link optimizations) instead of the ones in the optimized local graph.]
+Param: RGBD/ScanMatchingIdsSavedInLinks = "true"           [Save scan matching IDs from one-to-many proximity detection in link's user data.]
+Param: RGBD/StartAtOrigin = "false"                        [If true, rtabmap will assume the robot is starting from origin of the map. If false, rtabmap will assume the robot is restarting from the last saved localization pose from previous session (the place where it shut down previously). Used only in localization mode (Mem/IncrementalMemory=false).]
+Param: Reg/Force3DoF = "false"                             [Force 3 degrees-of-freedom transform (3Dof: x,y and yaw). Parameters z, roll and pitch will be set to 0.]
+Param: Reg/RepeatOnce = "true"                             [Do a second registration with the output of the first registration as guess. Only done if no guess was provided for the first registration (like on loop closure). It can be useful if the registration approach used can use a guess to get better matches.]
+Param: Reg/Strategy = "0"                                  [0=Vis, 1=Icp, 2=VisIcp]
+Param: Rtabmap/ComputeRMSE = "true"                        [Compute root mean square error (RMSE) and publish it in statistics, if ground truth is provided.]
+Param: Rtabmap/CreateIntermediateNodes = "false"           [Create intermediate nodes between loop closure detection. Only used when Rtabmap/DetectionRate>0.]
+Param: Rtabmap/DetectionRate = "1"                         [Detection rate (Hz). RTAB-Map will filter input images to satisfy this rate.]
+Param: Rtabmap/ImageBufferSize = "1"                       [Data buffer size (0 min inf).]
+Param: Rtabmap/ImagesAlreadyRectified = "true"             [Images are already rectified. By default RTAB-Map assumes that received images are rectified. If they are not, they can be rectified by RTAB-Map if this parameter is false.]
+Param: Rtabmap/LoopGPS = "true"                            [Use GPS to filter likelihood (if GPS is recorded). Only locations inside the local radius "RGBD/LocalRadius" of the current GPS location are considered for loop closure detection.]
+Param: Rtabmap/LoopRatio = "0"                             [The loop closure hypothesis must be over LoopRatio x lastHypothesisValue.]
+Param: Rtabmap/LoopThr = "0.11"                            [Loop closing threshold.]
+Param: Rtabmap/MaxRepublished = "2"                        [Maximum nodes republished when requesting missing data. When RGBD/Enabled=false, only loop closure data is republished, otherwise the closest nodes from the current localization are republished first. Ignored if Rtabmap/PublishLastSignature=false.]
+Param: Rtabmap/MaxRetrieved = "2"                          [Maximum nodes retrieved at the same time from LTM.]
+Param: Rtabmap/MemoryThr = "0"                             [Maximum nodes in the Working Memory (0 means infinity). Similar to "Rtabmap/TimeThr", when the number of nodes in Working Memory (WM) exceeds this treshold, some nodes are transferred to Long-Term Memory to keep WM size fixed.]
+Param: Rtabmap/PublishLastSignature = "true"               [Publishing last signature.]
+Param: Rtabmap/PublishLikelihood = "true"                  [Publishing likelihood.]
+Param: Rtabmap/PublishPdf = "true"                         [Publishing pdf.]
+Param: Rtabmap/PublishRAMUsage = "false"                   [Publishing RAM usage in statistics (may add a small overhead to get info from the system).]
+Param: Rtabmap/PublishStats = "true"                       [Publishing statistics.]
+Param: Rtabmap/RectifyOnlyFeatures = "false"               [If "Rtabmap/ImagesAlreadyRectified" is false and this parameter is true, the whole RGB image will not be rectified, only the features. Warning: As projection of RGB-D image to point cloud is assuming that images are rectified, the generated point cloud map will have wrong colors if this parameter is true.]
+Param: Rtabmap/SaveWMState = "false"                       [Save working memory state after each update in statistics.]
+Param: Rtabmap/StartNewMapOnGoodSignature = "false"        [Start a new map only if the first signature is not bad (i.e., has enough features, see Kp/BadSignRatio).]
+Param: Rtabmap/StartNewMapOnLoopClosure = "false"          [Start a new map only if there is a global loop closure with a previous map.]
+Param: Rtabmap/StatisticLogged = "false"                   [Logging enabled.]
+Param: Rtabmap/StatisticLoggedHeaders = "true"             [Add column header description to log files.]
+Param: Rtabmap/StatisticLogsBufferedInRAM = "true"         [Statistic logs buffered in RAM instead of written to hard drive after each iteration.]
+Param: Rtabmap/TimeThr = "0"                               [Maximum time allowed for map update (ms) (0 means infinity). When map update time exceeds this fixed time threshold, some nodes in Working Memory (WM) are transferred to Long-Term Memory to limit the size of the WM and decrease the update time.]
+Param: Rtabmap/VirtualPlaceLikelihoodRatio = "0"           [Likelihood ratio for virtual place (for no loop closure hypothesis): 0=Mean / StdDev, 1=StdDev / (Max-Mean)]
+Param: Rtabmap/WorkingDirectory = "/home/jaco/.ros"        [Working directory.]
+Param: SIFT/ContrastThreshold = "0.04"                     [The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector. Not used by CudaSift (see SIFT/GaussianThreshold instead).]
+Param: SIFT/EdgeThreshold = "10"                           [The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).]
+Param: SIFT/GaussianThreshold = "2.0"                      [CudaSift: Threshold on difference of Gaussians for feature pruning. The higher the threshold, the less features are produced by the detector.]
+Param: SIFT/Gpu = "false"                                  [CudaSift: Use GPU version of SIFT. This option is enabled only if RTAB-Map is built with CudaSift dependency and GPUs are detected.]
+Param: SIFT/NOctaveLayers = "3"                            [The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution. Not used by CudaSift, the number of octaves is still computed automatically.]
+Param: SIFT/PreciseUpscale = "false"                       [Whether to enable precise upscaling in the scale pyramid (OpenCV >= 4.8).]
+Param: SIFT/RootSIFT = "false"                             [Apply RootSIFT normalization of the descriptors.]
+Param: SIFT/Sigma = "1.6"                                  [The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.]
+Param: SIFT/Upscale = "false"                              [CudaSift: Whether to enable upscaling.]
+Param: SURF/Extended = "false"                             [Extended descriptor flag (true - use extended 128-element descriptors; false - use 64-element descriptors).]
+Param: SURF/GpuKeypointsRatio = "0.01"                     [Used with SURF GPU.]
+Param: SURF/GpuVersion = "false"                           [GPU-SURF: Use GPU version of SURF. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.]
+Param: SURF/HessianThreshold = "500"                       [Threshold for hessian keypoint detector used in SURF.]
+Param: SURF/OctaveLayers = "2"                             [Number of octave layers within each octave.]
+Param: SURF/Octaves = "4"                                  [Number of pyramid octaves the keypoint detector will use.]
+Param: SURF/Upright = "false"                              [Up-right or rotated features flag (true - do not compute orientation of features; false - compute orientation).]
+Param: Stereo/DenseStrategy = "0"                          [0=cv::StereoBM, 1=cv::StereoSGBM]
+Param: Stereo/Eps = "0.01"                                 [[Stereo/OpticalFlow=true] Epsilon stop criterion.]
+Param: Stereo/Gpu = "false"                                [[Stereo/OpticalFlow=true] Enable GPU version of the optical flow approach (only available if OpenCV is built with CUDA).]
+Param: Stereo/Iterations = "30"                            [Maximum iterations.]
+Param: Stereo/MaxDisparity = "128.0"                       [Maximum disparity.]
+Param: Stereo/MaxLevel = "5"                               [Maximum pyramid level.]
+Param: Stereo/MinDisparity = "0.5"                         [Minimum disparity.]
+Param: Stereo/OpticalFlow = "true"                         [Use optical flow to find stereo correspondences, otherwise a simple block matching approach is used.]
+Param: Stereo/SSD = "true"                                 [[Stereo/OpticalFlow=false] Use Sum of Squared Differences (SSD) window, otherwise Sum of Absolute Differences (SAD) window is used.]
+Param: Stereo/WinHeight = "3"                              [Window height.]
+Param: Stereo/WinWidth = "15"                              [Window width.]
+Param: StereoBM/BlockSize = "15"                           [See cv::StereoBM]
+Param: StereoBM/Disp12MaxDiff = "-1"                       [See cv::StereoBM]
+Param: StereoBM/MinDisparity = "0"                         [See cv::StereoBM]
+Param: StereoBM/NumDisparities = "128"                     [See cv::StereoBM]
+Param: StereoBM/PreFilterCap = "31"                        [See cv::StereoBM]
+Param: StereoBM/PreFilterSize = "9"                        [See cv::StereoBM]
+Param: StereoBM/SpeckleRange = "4"                         [See cv::StereoBM]
+Param: StereoBM/SpeckleWindowSize = "100"                  [See cv::StereoBM]
+Param: StereoBM/TextureThreshold = "10"                    [See cv::StereoBM]
+Param: StereoBM/UniquenessRatio = "15"                     [See cv::StereoBM]
+Param: StereoSGBM/BlockSize = "15"                         [See cv::StereoSGBM]
+Param: StereoSGBM/Disp12MaxDiff = "1"                      [See cv::StereoSGBM]
+Param: StereoSGBM/MinDisparity = "0"                       [See cv::StereoSGBM]
+Param: StereoSGBM/Mode = "2"                               [See cv::StereoSGBM]
+Param: StereoSGBM/NumDisparities = "128"                   [See cv::StereoSGBM]
+Param: StereoSGBM/P1 = "2"                                 [See cv::StereoSGBM]
+Param: StereoSGBM/P2 = "5"                                 [See cv::StereoSGBM]
+Param: StereoSGBM/PreFilterCap = "31"                      [See cv::StereoSGBM]
+Param: StereoSGBM/SpeckleRange = "4"                       [See cv::StereoSGBM]
+Param: StereoSGBM/SpeckleWindowSize = "100"                [See cv::StereoSGBM]
+Param: StereoSGBM/UniquenessRatio = "20"                   [See cv::StereoSGBM]
+Param: SuperPoint/Cuda = "true"                            [Use Cuda device for Torch, otherwise CPU device is used by default.]
+Param: SuperPoint/ModelPath = ""                           [[Required] Path to pre-trained weights Torch file of SuperPoint (*.pt).]
+Param: SuperPoint/NMS = "true"                             [If true, non-maximum suppression is applied to detected keypoints.]
+Param: SuperPoint/NMSRadius = "4"                          [[SuperPoint/NMS=true] Minimum distance (pixels) between keypoints.]
+Param: SuperPoint/Threshold = "0.010"                      [Detector response threshold to accept keypoint.]
+Param: SuperPointRpautrat/Cuda = "true"                    [Use Cuda device for Torch, otherwise CPU device is used by default.]
+Param: SuperPointRpautrat/ModelPath = ""                   [[Required] SuperPoint python model file (superpoint_pytorch.py).]
+Param: SuperPointRpautrat/NMS = "true"                     [If true, non-maximum suppression is applied to detected keypoints.]
+Param: SuperPointRpautrat/NMSRadius = "4"                  [[SuperPointRpautrat/NMS=true] Minimum distance (pixels) between keypoints.]
+Param: SuperPointRpautrat/Threshold = "0.005"              [Detector response threshold to accept keypoint.]
+Param: SuperPointRpautrat/WeightsPath = ""                 [[Required] SuperPoint weights file (*.pth).]
+Param: VhEp/Enabled = "false"                              [Verify visual loop closure hypothesis by computing a fundamental matrix. This is done prior to transformation computation when RGBD/Enabled is enabled.]
+Param: VhEp/MatchCountMin = "8"                            [Minimum of matching visual words pairs to accept the loop hypothesis.]
+Param: VhEp/RansacParam1 = "3"                             [Fundamental matrix (see cvFindFundamentalMat()): Max distance (in pixels) from the epipolar line for a point to be inlier.]
+Param: VhEp/RansacParam2 = "0.99"                          [Fundamental matrix (see cvFindFundamentalMat()): Performance of RANSAC.]
+Param: Vis/BundleAdjustment = "1"                          [Optimization with bundle adjustment: 0=disabled, 1=g2o, 2=cvsba, 3=Ceres.]
+Param: Vis/CorFlowEps = "0.01"                             [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorFlowGpu = "false"                            [[Vis/CorType=1] Enable GPU version of the optical flow approach (only available if OpenCV is built with CUDA).]
+Param: Vis/CorFlowIterations = "30"                        [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorFlowMaxLevel = "3"                           [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorFlowWinSize = "16"                           [[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.]
+Param: Vis/CorGuessMatchToProjection = "false"             [[Vis/CorType=0] Match frame's corners to source's projected points (when guess transform is provided) instead of projected points to frame's corners.]
+Param: Vis/CorGuessWinSize = "40"                          [[Vis/CorType=0] Matching window size (pixels) around projected points when a guess transform is provided to find correspondences. 0 means disabled.]
+Param: Vis/CorNNDR = "0.8"                                 [[Vis/CorType=0] NNDR: nearest neighbor distance ratio. Used for knn features matching approach.]
+Param: Vis/CorNNType = "1"                                 [[Vis/CorType=0] kNNFlannNaive=0, kNNFlannKdTree=1, kNNFlannLSH=2, kNNBruteForce=3, kNNBruteForceGPU=4, BruteForceCrossCheck=5, SuperGlue=6, GMS=7. Used for features matching approach.]
+Param: Vis/CorType = "0"                                   [Correspondences computation approach: 0=Features Matching, 1=Optical Flow]
+Param: Vis/DepthAsMask = "true"                            [Use depth image as mask when extracting features.]
+Param: Vis/DepthMaskFloorThr = "0.0"                       [Filter floor from depth mask below specified threshold (m) before extracting features. 0 means disabled, negative means remove all objects above the floor threshold instead. Ignored if Vis/DepthAsMask is false.]
+Param: Vis/EpipolarGeometryVar = "0.1"                     [[Vis/EstimationType = 2] Epipolar geometry maximum variance to accept the transformation.]
+Param: Vis/EstimationType = "1"                            [Motion estimation approach: 0:3D->3D, 1:3D->2D (PnP), 2:2D->2D (Epipolar Geometry)]
+Param: Vis/FeatureType = "8"                               [0=SURF 1=SIFT 2=ORB 3=FAST/FREAK 4=FAST/BRIEF 5=GFTT/FREAK 6=GFTT/BRIEF 7=BRISK 8=GFTT/ORB 9=KAZE 10=ORB-OCTREE 11=SuperPoint 12=SURF/FREAK 13=GFTT/DAISY 14=SURF/DAISY 15=PyDetector 16=SuperPoint-Rpautrat]
+Param: Vis/GridCols = "1"                                  [Number of columns of the grid used to extract uniformly "Vis/MaxFeatures / grid cells" features from each cell.]
+Param: Vis/GridRows = "1"                                  [Number of rows of the grid used to extract uniformly "Vis/MaxFeatures / grid cells" features from each cell.]
+Param: Vis/InlierDistance = "0.1"                          [[Vis/EstimationType = 0] Maximum distance for feature correspondences. Used by 3D->3D estimation approach.]
+Param: Vis/Iterations = "300"                              [Maximum iterations to compute the transform.]
+Param: Vis/MaxDepth = "0"                                  [Max depth of the features (0 means no limit).]
+Param: Vis/MaxFeatures = "1000"                            [0 no limits.]
+Param: Vis/MeanInliersDistance = "0.0"                     [Maximum distance (m) of the mean distance of inliers from the camera to accept the transformation. 0 means disabled.]
+Param: Vis/MinDepth = "0"                                  [Min depth of the features (0 means no limit).]
+Param: Vis/MinInliers = "20"                               [Minimum feature correspondences to compute/accept the transformation.]
+Param: Vis/MinInliersDistribution = "0.0"                  [Minimum distribution value of the inliers in the image to accept the transformation. The distribution is the second eigen value of the PCA (Principal Component Analysis) on the keypoints of the normalized image [-0.5, 0.5]. The value would be between 0 and 0.5. 0 means disabled.]
+Param: Vis/PnPFlags = "0"                                  [[Vis/EstimationType = 1] PnP flags: 0=Iterative, 1=EPNP, 2=P3P]
+Param: Vis/PnPMaxVariance = "0.0"                          [[Vis/EstimationType = 1] Max linear variance between 3D point correspondences after PnP. 0 means disabled.]
+Param: Vis/PnPRefineIterations = "0"                       [[Vis/EstimationType = 1] Refine iterations. Set to 0 if "Vis/BundleAdjustment" is also used.]
+Param: Vis/PnPReprojError = "2"                            [[Vis/EstimationType = 1] PnP reprojection error.]
+Param: Vis/PnPSamplingPolicy = "1"                         [[Vis/EstimationType = 1] Multi-camera random sampling policy: 0=AUTO, 1=ANY, 2=HOMOGENEOUS. With HOMOGENEOUS policy, RANSAC will be done uniformly against all cameras, so at least 2 matches per camera are required. With ANY policy, RANSAC is not constraint to sample on all cameras at the same time. AUTO policy will use HOMOGENEOUS if there are at least 2 matches per camera, otherwise it will fallback to ANY policy.]
+Param: Vis/PnPSplitLinearCovComponents = "false"           [[Vis/EstimationType = 1] Compute variance for each linear component instead of using the combined XYZ variance for all linear components.]
+Param: Vis/PnPVarianceMedianRatio = "4"                    [[Vis/EstimationType = 1] Ratio used to compute variance of the estimated transformation if 3D correspondences are provided (should be > 1). The higher it is, the smaller the covariance will be. With accurate depth estimation, this could be set to 2. For depth estimated by stereo, 4 or more maybe used to ignore large errors of very far points.]
+Param: Vis/RefineIterations = "5"                          [[Vis/EstimationType = 0] Number of iterations used to refine the transformation found by RANSAC. 0 means that the transformation is not refined.]
+Param: Vis/RoiRatios = "0.0 0.0 0.0 0.0"                   [Region of interest ratios [left, right, top, bottom].]
+Param: Vis/SSC = "false"                                   [If true, SSC (Suppression via Square Covering) is applied to limit keypoints.]
+Param: Vis/SubPixEps = "0.02"                              [See cv::cornerSubPix().]
+Param: Vis/SubPixIterations = "0"                          [See cv::cornerSubPix(). 0 disables sub pixel refining.]
+Param: Vis/SubPixWinSize = "3"                             [See cv::cornerSubPix().]
+Param: g2o/Baseline = "0.075"                              [When doing bundle adjustment with RGB-D data, we can set a fake baseline (m) to do stereo bundle adjustment (if 0, mono bundle adjustment is done). For stereo data, the baseline in the calibration is used directly.]
+Param: g2o/Optimizer = "0"                                 [0=Levenberg 1=GaussNewton]
+Param: g2o/PixelVariance = "1.0"                           [Pixel variance used for bundle adjustment.]
+Param: g2o/RobustKernelDelta = "8"                         [Robust kernel delta used for bundle adjustment (0 means don't use robust kernel). Observations with chi2 over this threshold will be ignored in the second optimization pass.]
+Param: g2o/Solver = "0"   

experiments/rtabmap/params/u_route.yaml

@@ -0,0 +1,421 @@
+waypoints:
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 0.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 1.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 2.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 3.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 4.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 6.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 7.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 8.0
+- pose:
+    orientation:
+      theta: 1.5707963267948966
+    position:
+      x: 0.0
+      y: 9.0
+- pose:
+    orientation:
+      theta: 1.5393804002589992
+    position:
+      x: 0.0
+      y: 10.0
+- pose:
+    orientation:
+      theta: 1.476548547187204
+    position:
+      x: 0.0049331789293209916
+      y: 10.156976298823283
+- pose:
+    orientation:
+      theta: 1.4137166941154056
+    position:
+      x: 0.019713246713805255
+      y: 10.313333083910761
+- pose:
+    orientation:
+      theta: 1.3508848410436105
+    position:
+      x: 0.044281873178278364
+      y: 10.468453286464312
+- pose:
+    orientation:
+      theta: 1.288052987971813
+    position:
+      x: 0.07854209717842231
+      y: 10.621724717912137
+- pose:
+    orientation:
+      theta: 1.2252211349000226
+    position:
+      x: 0.12235870926211634
+      y: 10.772542485937368
+- pose:
+    orientation:
+      theta: 1.162389281828224
+    position:
+      x: 0.1755587852793714
+      y: 10.920311381711695
+- pose:
+    orientation:
+      theta: 1.0995574287564258
+    position:
+      x: 0.23793236883495084
+      y: 11.064448228912681
+- pose:
+    orientation:
+      theta: 1.0367255756846356
+    position:
+      x: 0.3092332998903409
+      y: 11.204384185254288
+- pose:
+    orientation:
+      theta: 0.9738937226128352
+    position:
+      x: 0.3891801862449622
+      y: 11.339566987447492
+- pose:
+    orientation:
+      theta: 0.911061869541035
+    position:
+      x: 0.47745751406263137
+      y: 11.469463130731183
+- pose:
+    orientation:
+      theta: 0.8482300164692473
+    position:
+      x: 0.573716893060527
+      y: 11.593559974371724
+- pose:
+    orientation:
+      theta: 0.7853981633974523
+    position:
+      x: 0.677578431446471
+      y: 11.711367764821722
+- pose:
+    orientation:
+      theta: 0.7225663103256436
+    position:
+      x: 0.7886322351782784
+      y: 11.82242156855353
+- pose:
+    orientation:
+      theta: 0.6597344572538605
+    position:
+      x: 0.9064400256282756
+      y: 11.926283106939472
+- pose:
+    orientation:
+      theta: 0.5969026041820613
+    position:
+      x: 1.0305368692688168
+      y: 12.022542485937368
+- pose:
+    orientation:
+      theta: 0.5340707511102645
+    position:
+      x: 1.1604330125525086
+      y: 12.110819813755038
+- pose:
+    orientation:
+      theta: 0.4712388980384715
+    position:
+      x: 1.2956158147457122
+      y: 12.19076670010966
+- pose:
+    orientation:
+      theta: 0.4084070449666747
+    position:
+      x: 1.4355517710873182
+      y: 12.26206763116505
+- pose:
+    orientation:
+      theta: 0.34557519189487457
+    position:
+      x: 1.5796886182883048
+      y: 12.324441214720629
+- pose:
+    orientation:
+      theta: 0.2827433388230792
+    position:
+      x: 1.7274575140626314
+      y: 12.377641290737884
+- pose:
+    orientation:
+      theta: 0.21991148575128946
+    position:
+      x: 1.8782752820878632
+      y: 12.421457902821578
+- pose:
+    orientation:
+      theta: 0.15707963267948274
+    position:
+      x: 2.031546713535688
+      y: 12.455718126821722
+- pose:
+    orientation:
+      theta: 0.0942477796077017
+    position:
+      x: 2.186666916089239
+      y: 12.480286753286194
+- pose:
+    orientation:
+      theta: 0.0314159265358944
+    position:
+      x: 2.3430237011767163
+      y: 12.49506682107068
+- pose:
+    orientation:
+      theta: -0.0314159265358944
+    position:
+      x: 2.5
+      y: 12.5
+- pose:
+    orientation:
+      theta: -0.09424777960770223
+    position:
+      x: 2.6569762988232837
+      y: 12.49506682107068
+- pose:
+    orientation:
+      theta: -0.1570796326794823
+    position:
+      x: 2.81333308391076
+      y: 12.480286753286194
+- pose:
+    orientation:
+      theta: -0.21991148575128824
+    position:
+      x: 2.9684532864643116
+      y: 12.455718126821722
+- pose:
+    orientation:
+      theta: -0.2827433388230816
+    position:
+      x: 3.1217247179121372
+      y: 12.421457902821578
+- pose:
+    orientation:
+      theta: -0.34557519189487507
+    position:
+      x: 3.2725424859373677
+      y: 12.377641290737884
+- pose:
+    orientation:
+      theta: -0.4084070449666719
+    position:
+      x: 3.420311381711694
+      y: 12.324441214720629
+- pose:
+    orientation:
+      theta: -0.47123889803846963
+    position:
+      x: 3.5644482289126818
+      y: 12.26206763116505
+- pose:
+    orientation:
+      theta: -0.5340707511102638
+    position:
+      x: 3.7043841852542885
+      y: 12.19076670010966
+- pose:
+    orientation:
+      theta: -0.5969026041820669
+    position:
+      x: 3.8395669874474923
+      y: 12.110819813755038
+- pose:
+    orientation:
+      theta: -0.659734457253857
+    position:
+      x: 3.9694631307311825
+      y: 12.022542485937368
+- pose:
+    orientation:
+      theta: -0.722566310325653
+    position:
+      x: 4.093559974371725
+      y: 11.926283106939472
+- pose:
+    orientation:
+      theta: -0.7853981633974483
+    position:
+      x: 4.211367764821722
+      y: 11.822421568553528
+- pose:
+    orientation:
+      theta: -0.8482300164692357
+    position:
+      x: 4.322421568553528
+      y: 11.711367764821722
+- pose:
+    orientation:
+      theta: -0.9110618695410441
+    position:
+      x: 4.426283106939473
+      y: 11.593559974371725
+- pose:
+    orientation:
+      theta: -0.9738937226128376
+    position:
+      x: 4.522542485937368
+      y: 11.469463130731183
+- pose:
+    orientation:
+      theta: -1.0367255756846308
+    position:
+      x: 4.610819813755037
+      y: 11.339566987447492
+- pose:
+    orientation:
+      theta: -1.0995574287564307
+    position:
+      x: 4.690766700109659
+      y: 11.204384185254288
+- pose:
+    orientation:
+      theta: -1.1623892818282213
+    position:
+      x: 4.762067631165048
+      y: 11.064448228912681
+- pose:
+    orientation:
+      theta: -1.2252211349000173
+    position:
+      x: 4.824441214720628
+      y: 10.920311381711695
+- pose:
+    orientation:
+      theta: -1.2880529879718159
+    position:
+      x: 4.877641290737884
+      y: 10.772542485937368
+- pose:
+    orientation:
+      theta: -1.3508848410436078
+    position:
+      x: 4.921457902821578
+      y: 10.621724717912137
+- pose:
+    orientation:
+      theta: -1.4137166941154138
+    position:
+      x: 4.955718126821722
+      y: 10.468453286464312
+- pose:
+    orientation:
+      theta: -1.4765485471871944
+    position:
+      x: 4.980286753286194
+      y: 10.313333083910761
+- pose:
+    orientation:
+      theta: -1.5393804002590024
+    position:
+      x: 4.9950668210706795
+      y: 10.156976298823285
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 10.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 9.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 8.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 7.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 6.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 5.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 4.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 3.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 2.0
+- pose:
+    orientation:
+      theta: -1.5707963267948966
+    position:
+      x: 5.0
+      y: 1.0

experiments/rtabmap/rtab_odom.launch.py

@@ -0,0 +1,110 @@
+import os
+from launch import LaunchDescription
+from launch_ros.actions import Node
+from launch.actions import DeclareLaunchArgument
+
+def generate_launch_description():
+    
+    # Parâmetros comuns para Simulação
+    use_sim_time = {'use_sim_time': True}
+
+    # 1. Sincronizador RGB-D
+    sync_node = Node(
+        package='rtabmap_sync',
+        executable='rgbd_sync',
+        name='rgbd_sync',
+        parameters=[{
+            'approx_sync': True, 
+            'approx_sync_max_interval': 0.125,
+            'queue_size': 10,
+            **use_sim_time
+        }],
+        remappings=[
+            ('rgb/image',      '/camera_front/rgb'),
+            ('depth/image',    '/camera_front/depth'),
+            ('rgb/camera_info', '/camera_front/camera_info'),
+            ('rgbd_image',      '/camera_front/rgbd_image')
+        ],
+        output='screen'
+    )
+
+    # 2. Visual Odometry Node
+    # This node computes odometry from the RGB-D stream
+    odom_node = Node(
+        package='rtabmap_odom',
+        executable='rgbd_odometry',
+        name='rgbd_odometry',
+        output='screen',
+        parameters=[{
+            'frame_id': 'base_footprint',
+            'odom_frame_id': 'odom',
+            'publish_tf': False, 
+            'subscribe_rgbd': True,
+            'queue_size': 10,
+            'wait_for_transform': 0.2,
+            # 'wait_imu_to_init': True,
+            **use_sim_time,
+            'Vis/FeatureType': '2',
+            'Vis/RoiRatios': '0.0, 0.0, 0.0, 0.05',
+            'Odom/ResetCountdown': '1',      # Automatically reset odom when lost (prevents total freeze)
+            'Odom/Strategy': '0',            # 0=Frame-to-Map (more stable), 1=Frame-to-Frame
+            'Vis/MinInliers': '10',          # Minimum features to accept a transformation
+            'Vis/MaxFeatures': '1000',       # Increase the search space for features
+                    }],
+        remappings=[
+            ('rgbd_image', '/camera_front/rgbd_image'),
+            ('odom', '/rtabmap_odom')
+        ]
+    )
+
+    # 3. Nó Principal do RTAB-Map (SLAM)
+    rtabmap_node = Node(
+        package='rtabmap_slam',
+        executable='rtabmap',
+        name='rtabmap',
+        output='screen',
+        parameters=[{
+            'subscribe_rgbd': True,
+            'subscribe_depth': False,
+            'subscribe_rgb': False,
+            'frame_id': 'base_footprint',
+            'map_frame_id': 'map',
+            'publish_tf': False,           # RTAB-Map publishes map -> odom
+            'odom_frame_id': 'odom',      
+            'Reg/Strategy': '0',          # 0=Visual, 1=ICP, 2=Visual+ICP
+            'RGBD/ProximityBySpace': 'true',
+            'queue_size': 10,
+            **use_sim_time,
+            'Grid/FromDepth': 'true',
+            'Vis/RoiRatios': '0.0, 0.0, 0.0, 0.2',
+            'Grid/DepthRoiRatios': '0.0, 0.0, 0.0, 0.2',
+        }],
+        remappings=[
+            ('rgbd_image', '/camera_front/rgbd_image'),
+            ('odom', '/rtabmap_odom'),
+        ],
+        arguments=['--delete_db_on_start']
+    )
+
+    # 4. Visualização Opcional (RTAB-Map Viz)
+    rtabmap_viz = Node(
+        package='rtabmap_viz',
+        executable='rtabmap_viz',
+        name='rtabmap_viz',
+        parameters=[{
+            'subscribe_rgbd': True,
+            'frame_id': 'base_footprint',
+            **use_sim_time
+        }],
+        remappings=[
+            ('rgbd_image', '/camera_front/rgbd_image')
+        ],
+        output='screen'
+    )
+
+    return LaunchDescription([
+        sync_node,
+        odom_node,
+        rtabmap_node,
+        # rtabmap_viz
+    ])

experiments/rtabmap/scripts/follow_route.py

@@ -0,0 +1,163 @@
+import rclpy
+from rclpy.node import Node
+from NAME_OF_YOUR_PKG.navigator import Navigator, TaskResult
+from geometry_msgs.msg import PoseStamped
+from visualization_msgs.msg import Marker, MarkerArray
+from rclpy.qos import QoSProfile, DurabilityPolicy
+import yaml
+import math
+import time
+from ament_index_python.packages import get_package_share_directory
+import os
+
+def euler_to_quaternion(yaw, pitch, roll):
+    """Converte ângulos Euler para quaternião."""
+    cy = math.cos(yaw * 0.5)
+    sy = math.sin(yaw * 0.5)
+    cp = math.cos(pitch * 0.5)
+    sp = math.sin(pitch * 0.5)
+    cr = math.cos(roll * 0.5)
+    sr = math.sin(roll * 0.5)
+
+    q = [0.0] * 4
+    q[0] = cy * cp * sr - sy * sp * cr  # x
+    q[1] = sy * cp * sr + cy * sp * cr  # y
+    q[2] = sy * cp * cr - cy * sp * sr  # z
+    q[3] = cy * cp * cr + sy * sp * sr  # w
+    return q
+
+class WaypointFollower(Node):
+    """
+    Nó para carregar uma rota de um arquivo YAML e usar o ScoutNavigator para executá-la.
+    """
+    def __init__(self):
+        super().__init__('waypoint_follower')
+        self.navigator = ScoutNavigator()
+
+        # Define o perfil de QoS para "latched"
+        qos_profile = QoSProfile(
+            depth=1,
+            durability=DurabilityPolicy.TRANSIENT_LOCAL)
+
+        # Publisher para os marcadores dos waypoints
+        self.marker_publisher = self.create_publisher(MarkerArray, 'waypoints', qos_profile)
+
+        # Ativa os nós do Nav2 usando o método simplificado do ScoutNavigator
+        self.navigator.startup()
+
+        # Pequena pausa para garantir que os tópicos estejam prontos após a ativação
+        self.get_logger().info('Aguardando 2 segundos para a inicialização dos tópicos...')
+        time.sleep(2)
+        
+        self.get_logger().info('ScoutNavigator está pronto para uso.')
+
+    def publish_waypoint_markers(self, waypoints):
+        """
+        Publica os waypoints como uma MarkerArray para visualização no RViz.
+        """
+        marker_array = MarkerArray()
+        for i, waypoint in enumerate(waypoints):
+            marker = Marker()
+            marker.header.frame_id = 'map'
+            marker.header.stamp = self.get_clock().now().to_msg()
+            marker.ns = "waypoints"
+            marker.id = i
+            marker.type = Marker.ARROW
+            marker.action = Marker.ADD
+            marker.pose = waypoint.pose
+            marker.scale.x = 0.5  # Comprimento da seta
+            marker.scale.y = 0.1  # Largura da seta
+            marker.scale.z = 0.1  # Altura da seta
+            marker.color.a = 1.0  # Alpha
+            marker.color.r = 0.0  # Red
+            marker.color.g = 1.0  # Green
+            marker.color.b = 0.0  # Blue
+            marker_array.markers.append(marker)
+        
+        self.get_logger().info(f'Publicando {len(waypoints)} marcadores de waypoint.')
+        self.marker_publisher.publish(marker_array)
+
+    def follow_route_from_yaml(self, yaml_path):
+        """
+        Carrega waypoints de um arquivo YAML e os envia para o Nav2.
+        """
+        self.get_logger().info(f"Carregando rota do arquivo: {yaml_path}")
+        
+        try:
+            with open(yaml_path, 'r') as file:
+                route_data = yaml.safe_load(file)
+        except (IOError, yaml.YAMLError) as e:
+            self.get_logger().error(f"Erro ao ler ou processar o arquivo YAML: {e}")
+            return
+
+        if not route_data or 'waypoints' not in route_data:
+            self.get_logger().error("Arquivo YAML não contém a chave 'waypoints' ou está vazio.")
+            return
+
+        waypoints = []
+        for wp_data in route_data['waypoints']:
+            pose_data = wp_data.get('pose', {})
+            position = pose_data.get('position', {})
+            orientation = pose_data.get('orientation', {})
+
+            waypoint = PoseStamped()
+            waypoint.header.frame_id = 'map'
+            waypoint.header.stamp = self.get_clock().now().to_msg()
+            
+            waypoint.pose.position.x = float(position.get('x', 0.0))
+            waypoint.pose.position.y = float(position.get('y', 0.0))
+            
+            if 'theta' in orientation:
+                q = euler_to_quaternion(orientation['theta'], 0, 0)
+                waypoint.pose.orientation.x = q[0]
+                waypoint.pose.orientation.y = q[1]
+                waypoint.pose.orientation.z = q[2]
+                waypoint.pose.orientation.w = q[3]
+            else:
+                waypoint.pose.orientation.x = float(orientation.get('x', 0.0))
+                waypoint.pose.orientation.y = float(orientation.get('y', 0.0))
+                waypoint.pose.orientation.z = float(orientation.get('z', 0.0))
+                waypoint.pose.orientation.w = float(orientation.get('w', 1.0))
+            
+            waypoints.append(waypoint)
+
+        if not waypoints:
+            self.get_logger().info("Nenhum waypoint encontrado para seguir.")
+            return
+
+        # Publica os marcadores dos waypoints
+        self.publish_waypoint_markers(waypoints)
+
+        self.get_logger().info(f"Enviando {len(waypoints)} waypoints para o Nav2.")
+        self.navigator.goThroughPoses(waypoints)
+        
+        # Verifica o status da tarefa
+        while not self.navigator.isTaskComplete():
+            feedback = self.navigator.getFeedback()
+            if feedback:
+                self.get_logger().info(f'Poses restantes: {feedback.number_of_poses_remaining}')
+            time.sleep(1)
+
+        result = self.navigator.getResult()
+        if result == TaskResult.SUCCEEDED:
+            self.get_logger().info("Rota concluída com sucesso!")
+        elif result == TaskResult.CANCELED:
+            self.get_logger().warn("A rota foi cancelada.")
+        elif result == TaskResult.FAILED:
+            self.get_logger().error("A rota falhou.")
+        else:
+            self.get_logger().error("Resultado da rota desconhecido!")
+
+def main(args=None):
+    rclpy.init(args=args)
+    
+    share_dir = get_package_share_directory('NAME_OF_YOUR_PKG')
+    route_yaml_path = os.path.join(share_dir, 'params', 'route.yaml')
+
+    waypoint_follower = WaypointFollower()
+    waypoint_follower.follow_route_from_yaml(route_yaml_path)
+
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

experiments/rtabmap/scripts/generate_route.py

@@ -0,0 +1,121 @@
+
+import yaml
+import argparse
+import numpy as np
+
+def calculate_orientations(points):
+    """Calculate orientations for a list of points."""
+    
+    # Remove consecutive duplicate points
+    unique_points = [points[0]] if points else []
+    for p in points[1:]:
+        # Use a tolerance for float comparison
+        if not np.allclose(p, unique_points[-1]):
+            unique_points.append(p)
+    points = unique_points
+    
+    waypoints = []
+    thetas = []
+    for i in range(len(points) - 1):
+        p1 = points[i]
+        p2 = points[i+1]
+        thetas.append(np.arctan2(p2[1] - p1[1], p2[0] - p1[0]))
+    if len(points) > 1:
+      thetas.append(thetas[-1]) # Last point orientation
+    elif len(points) == 1:
+      thetas.append(0)
+
+    for i in range(len(points)):
+        waypoints.append({'pose': {'position': {'x': float(points[i][0]), 'y': float(points[i][1])}, 'orientation': {'theta': float(thetas[i])}}})
+    return waypoints
+
+def generate_square_route(size=5, step=1):
+    """Generate a square route."""
+    points = []
+    # side 1: from (0,0) to (size,0)
+    points.extend([(x, 0.0) for x in np.arange(0, size, step)])
+    # side 2: from (size,0) to (size,size)
+    points.extend([(size, y) for y in np.arange(0, size, step)])
+    # side 3: from (size,size) to (0,size)
+    points.extend([(x, size) for x in np.arange(size, 0, -step)])
+    # side 4: from (0,size) to (0,0)
+    points.extend([(0.0, y) for y in np.arange(size, 0, -step)])
+    
+    # Close the loop
+    points.append(points[0])
+
+    return calculate_orientations(points)
+
+def generate_u_route(width=5, length=10, step=1, num_points=20):
+    """Generate a U-shaped route with a smooth curve, starting in the X direction."""
+    points = []
+    # Leg 1: along X axis
+    for x in np.arange(0, length, step):
+        points.append((x, 0.0))
+
+    # Smooth curve (half-circle)
+    radius = width / 2.0
+    center_x = length
+    center_y = radius
+    for i in range(num_points + 1):
+        angle = -np.pi/2 + np.pi * i / num_points # angle from -pi/2 to pi/2
+        x = center_x + radius * np.cos(angle)
+        y = center_y + radius * np.sin(angle)
+        points.append((x, y))
+
+    # Leg 2: along X axis (reversed)
+    for x in np.arange(length, 0, -step):
+        points.append((x, width))
+
+    return calculate_orientations(points)
+
+def generate_eighth_route(radius=5, num_points=50):
+    """Generate a figure-eight route."""
+    points = []
+    t = np.linspace(0, 2 * np.pi, num_points)
+    x = radius * np.sin(t)
+    y = radius * np.sin(t) * np.cos(t)
+    for i in range(len(x)):
+        points.append((x[i], y[i]))
+    return calculate_orientations(points)
+
+def generate_sinusoidal_route(length=20, amplitude=5, num_points=50):
+    """Generate a sinusoidal route."""
+    points = []
+    x = np.linspace(0, length, num_points)
+    y = amplitude * np.sin(x)
+    for i in range(len(x)):
+        points.append((x[i], y[i]))
+    return calculate_orientations(points)
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a route for robot navigation.")
+    parser.add_argument('shape', choices=['square', 'u', 'eighth', 'sinusoidal'], help="The shape of the route to generate.")
+    parser.add_argument('-o', '--output', default='params/new_route.yaml', help="The output file name.")
+    parser.add_argument('--size', type=float, default=5, help="Size parameter for the shape (e.g., side length for square).")
+    parser.add_argument('--step', type=float, default=1, help="Step size for generating points.")
+    parser.add_argument('--width', type=float, default=5, help="Width for U-shape.")
+    parser.add_argument('--length', type=float, default=10, help="Length for U-shape or sinusoidal.")
+    parser.add_argument('--amplitude', type=float, default=5, help="Amplitude for sinusoidal.")
+    parser.add_argument('--radius', type=float, default=5, help="Radius for figure-eight.")
+    parser.add_argument('--num_points', type=int, default=50, help="Number of points for curves.")
+
+    args = parser.parse_args()
+
+    waypoints = []
+    if args.shape == 'square':
+        waypoints = generate_square_route(args.size, args.step)
+    elif args.shape == 'u':
+        waypoints = generate_u_route(args.width, args.length, args.step, args.num_points)
+    elif args.shape == 'eighth':
+        waypoints = generate_eighth_route(args.radius, args.num_points)
+    elif args.shape == 'sinusoidal':
+        waypoints = generate_sinusoidal_route(args.length, args.amplitude, args.num_points)
+
+    with open(args.output, 'w') as f:
+        yaml.dump({'waypoints': waypoints}, f, default_flow_style=False)
+
+    print(f"Generated {args.shape} route with {len(waypoints)} waypoints in {args.output}")
+
+if __name__ == '__main__':
+    main()

experiments/rtabmap/scripts/navigator.py

@@ -0,0 +1,150 @@
+import time
+from enum import Enum
+
+from action_msgs.msg import GoalStatus
+from geometry_msgs.msg import PoseStamped
+from nav2_msgs.action import NavigateThroughPoses
+from nav2_msgs.srv import ManageLifecycleNodes
+
+import rclpy
+from rclpy.action import ActionClient
+from rclpy.node import Node
+
+
+class TaskResult(Enum):
+    """Enum for task result."""
+    UNKNOWN = 0
+    SUCCEEDED = 1
+    CANCELED = 2
+    FAILED = 3
+
+
+class Navigator(Node):
+    """
+    Um navegador simplificado para enviar uma lista de poses para o Nav2.
+    Focado para setups sem mapa e sem AMCL.
+    """
+
+    def __init__(self, node_name='navigator', namespace=''):
+        super().__init__(node_name=node_name, namespace=namespace)
+        self.goal_handle = None
+        self.result_future = None
+        self.feedback = None
+        self.status = None
+
+        # Clientes essenciais
+        self.nav_through_poses_client = ActionClient(
+            self, NavigateThroughPoses, 'navigate_through_poses')
+        self.lifecycle_manager_client = self.create_client(
+            ManageLifecycleNodes, 'lifecycle_manager_navigation/manage_nodes')
+
+    def destroy_node(self):
+        self.info('Destruindo o Navigator.')
+        self.nav_through_poses_client.destroy()
+        self.lifecycle_manager_client.destroy()
+        super().destroy_node()
+
+    def startup(self):
+        """
+        Ativa os nós de ciclo de vida do Nav2 enviando um único comando
+        para o gerenciador de ciclo de vida.
+        """
+        self.info('Enviando comando STARTUP para o lifecycle_manager_navigation...')
+        
+        while not self.lifecycle_manager_client.wait_for_service(timeout_sec=1.0):
+            self.info('Serviço do lifecycle_manager_navigation não disponível, aguardando...')
+
+        req = ManageLifecycleNodes.Request()
+        req.command = ManageLifecycleNodes.Request.STARTUP
+        
+        future = self.lifecycle_manager_client.call_async(req)
+        rclpy.spin_until_future_complete(self, future)
+
+        if future.result() and future.result().success:
+            self.info('Nós do Nav2 ativados com sucesso.')
+        else:
+            self.error('Falha ao ativar os nós do Nav2.')
+        return
+
+    def goThroughPoses(self, poses, behavior_tree=''):
+        """
+        Envia uma lista de poses para o Nav2 seguir.
+        """
+        self.info("Aguardando o servidor de ação 'navigate_through_poses'...")
+        while not self.nav_through_poses_client.wait_for_server(timeout_sec=1.0):
+            self.info("'navigate_through_poses' não disponível, aguardando...")
+
+        goal_msg = NavigateThroughPoses.Goal()
+        goal_msg.poses = poses
+        goal_msg.behavior_tree = behavior_tree
+
+        self.info(f'Enviando {len(goal_msg.poses)} waypoints para o Nav2...')
+        send_goal_future = self.nav_through_poses_client.send_goal_async(
+            goal_msg, self._feedbackCallback)
+        
+        rclpy.spin_until_future_complete(self, send_goal_future)
+        self.goal_handle = send_goal_future.result()
+
+        if not self.goal_handle.accepted:
+            self.error('O objetivo de seguir os waypoints foi rejeitado!')
+            return False
+
+        self.result_future = self.goal_handle.get_result_async()
+        self.info('Objetivo aceito, iniciando a navegação...')
+        return True
+
+    def cancelTask(self):
+        """Cancela a tarefa atual."""
+        self.info('Cancelando a tarefa atual.')
+        if self.result_future:
+            future = self.goal_handle.cancel_goal_async()
+            rclpy.spin_until_future_complete(self, future)
+        return
+
+    def isTaskComplete(self):
+        """Verifica se a tarefa foi concluída."""
+        if not self.result_future:
+            return True
+        
+        rclpy.spin_until_future_complete(self, self.result_future, timeout_sec=0.10)
+        
+        if self.result_future.result():
+            self.status = self.result_future.result().status
+            if self.status != GoalStatus.STATUS_SUCCEEDED:
+                return True
+        else:
+            return False
+
+        return True
+
+    def getFeedback(self):
+        """Retorna o feedback da ação atual."""
+        return self.feedback
+
+    def getResult(self):
+        """Retorna o resultado final da tarefa."""
+        if self.status == GoalStatus.STATUS_SUCCEEDED:
+            return TaskResult.SUCCEEDED
+        elif self.status == GoalStatus.STATUS_ABORTED:
+            return TaskResult.FAILED
+        elif self.status == GoalStatus.STATUS_CANCELED:
+            return TaskResult.CANCELED
+        else:
+            return TaskResult.UNKNOWN
+
+    def _feedbackCallback(self, msg):
+        self.feedback = msg.feedback
+        return
+
+    # Funções de logging
+    def info(self, msg):
+        self.get_logger().info(msg)
+
+    def warn(self, msg):
+        self.get_logger().warn(msg)
+
+    def error(self, msg):
+        self.get_logger().error(msg)
+
+    def debug(self, msg):
+        self.get_logger().debug(msg)

experiments/semantic_segmentation/inference_2d_semantic.py

@@ -0,0 +1,143 @@
+"""
+Inference script for 2D Semantic Segmentation using the trained U-Net model.
+This script loads RGB images, performs inference, and visualizes the predictions 
+in a compact grid format optimized for scientific papers.
+"""
+import os
+import torch
+import torch.nn as nn
+import torchvision.transforms.functional as TF
+import numpy as np
+import cv2
+import segmentation_models_pytorch as smp
+import matplotlib.pyplot as plt
+
+# --- CONFIGURATION ---
+CONFIG = {
+    'num_classes': 5,  # Must match training configuration
+    'class_names': {0: "ground", 1: "leaf", 2: "branch", 3: "weed", 4: "obstacle"},
+    'device': torch.device('cuda' if torch.cuda.is_available() else 'cpu'),
+    'model_path': 'unet_efficientnetb3_semantic.pth', 
+    'input_image_path': 'rosario/', 
+    'output_image_path': 'semantic_results/',
+    'inference_size': (480, 640), 
+}
+
+# --- IMAGE LOADING AND PREPROCESSING ---
+def load_and_preprocess_image(image_path, device):
+    if not os.path.exists(image_path):
+        raise FileNotFoundError(f"Input image not found at: {image_path}")
+
+    rgb_img = cv2.imread(image_path)
+    if rgb_img is None:
+        raise IOError(f"Could not read image at: {image_path}")
+        
+    rgb_img = cv2.cvtColor(rgb_img, cv2.COLOR_BGR2RGB)
+    
+    h, w = CONFIG['inference_size']
+    original_img_for_viz = rgb_img.copy()
+    rgb_img = cv2.resize(rgb_img, (w, h), interpolation=cv2.INTER_AREA)
+
+    rgb_tensor = TF.to_tensor(rgb_img)
+    rgb_tensor = rgb_tensor.unsqueeze(0).to(device)
+    
+    return rgb_tensor, original_img_for_viz
+
+# --- MAIN INFERENCE FUNCTION ---
+def main():
+    print(f"Using device: {CONFIG['device']}")
+
+    # --- 1. Load Model ---
+    print("Loading U-Net model with EfficientNet-B3 encoder...")
+    model = smp.Unet(
+        encoder_name="efficientnet-b3",
+        encoder_weights=None, 
+        in_channels=3,
+        classes=CONFIG['num_classes'],
+    )
+    model = model.to(CONFIG['device'])
+
+    if not os.path.exists(CONFIG['model_path']):
+        raise FileNotFoundError(f"Trained model weights not found at: {CONFIG['model_path']}")
+
+    model.load_state_dict(torch.load(CONFIG['model_path'], map_location=CONFIG['device']))
+    model.eval() 
+    print(f"Model weights loaded from {CONFIG['model_path']}")
+
+    # --- 2. Gather Images ---
+    # Coleta e ordena as imagens para garantir consistência
+    image_files = sorted([f for f in os.listdir(CONFIG['input_image_path']) 
+                          if f.endswith(('.jpg', '.png'))])
+    
+    # Limita a 6 imagens como solicitado
+    image_files = image_files[:6]
+    num_images = len(image_files)
+    
+    if num_images == 0:
+        print("Nenhuma imagem encontrada no diretório.")
+        return
+
+    # Listas para armazenar os pares de resultados
+    results_rgb = []
+    results_mask = []
+
+    # --- 3. Perform Inference on All Images ---
+    for image in image_files:
+        img_path = os.path.join(CONFIG['input_image_path'], image)
+        print(f"Processing: {image}...")
+        
+        input_tensor, original_rgb_img = load_and_preprocess_image(img_path, CONFIG['device'])
+        
+        with torch.no_grad():
+            output = model(input_tensor)
+            
+        pred_mask = torch.argmax(output, dim=1).squeeze(0).cpu().numpy()
+        
+        orig_h, orig_w, _ = original_rgb_img.shape
+        pred_mask = cv2.resize(pred_mask.astype(np.uint8), (orig_w, orig_h), interpolation=cv2.INTER_NEAREST)
+        
+        results_rgb.append(original_rgb_img)
+        results_mask.append(pred_mask)
+
+    # --- 4. Visualize and Save Full Grid for Paper ---
+    print("Generating paper-ready figure...")
+    
+    # Define a figura: 2 linhas, N colunas. figsize ajustável dependendo da proporção da imagem
+    # wspace e hspace em 0.02 garantem que quase não haja espaço perdido entre as imagens
+    fig, axes = plt.subplots(2, num_images, figsize=(2.5 * num_images, 4.5), dpi=300, 
+                             gridspec_kw={'wspace': 0.02, 'hspace': 0.02})
+
+    cmap = plt.get_cmap('tab10', CONFIG['num_classes'])
+
+    for i in range(num_images):
+        # Linha 0: Imagens RGB de Entrada
+        axes[0, i].imshow(results_rgb[i])
+        axes[0, i].axis('off') # Remove eixos para economizar espaço
+        
+        # Linha 1: Máscaras Preditas
+        im = axes[1, i].imshow(results_mask[i], cmap=cmap, vmin=0, vmax=CONFIG['num_classes']-1)
+        axes[1, i].axis('off')
+
+    # Ajusta o layout principal e adiciona a barra de cores (Colorbar)
+    # A barra é posicionada na parte inferior (horizontal) para não gastar espaço lateral valioso do artigo
+    plt.subplots_adjust(bottom=0.15) 
+    cbar_ax = fig.add_axes([0.15, 0.05, 0.7, 0.03]) # [left, bottom, width, height]
+    
+    cbar = fig.colorbar(im, cax=cbar_ax, orientation='horizontal', ticks=np.arange(CONFIG['num_classes']))
+    
+    # Configura os nomes das classes na barra de cores
+    class_labels = [CONFIG['class_names'][i] for i in range(CONFIG['num_classes'])]
+    cbar.ax.set_xticklabels(class_labels, fontsize=10)
+    cbar.outline.set_visible(False) # Deixa a barra mais "limpa" visualmente
+
+    # Cria diretório se não existir e salva
+    os.makedirs(CONFIG['output_image_path'], exist_ok=True)
+    final_output_path = os.path.join(CONFIG['output_image_path'], "paper_figure_semantic_grid.png")
+    
+    # bbox_inches='tight' arranca margens em branco excedentes
+    # pad_inches controla o "respiro" nas bordas da imagem final
+    plt.savefig(final_output_path, dpi=300, bbox_inches='tight', pad_inches=0.01)
+    print(f"Final figure saved successfully at: {final_output_path}")
+
+if __name__ == '__main__':
+    main()

experiments/semantic_segmentation/train_2d_semantic.py

@@ -0,0 +1,294 @@
+"""
+Training script for 2D Semantic Segmentation using only RGB and Semantic masks.
+This script uses a pre-trained DeepLabV3 model for a more direct 2D approach.
+"""
+import os
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+import torchvision.transforms as T
+import torchvision.transforms.functional as TF
+import numpy as np
+import cv2
+import glob
+import segmentation_models_pytorch as smp
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+
+# --- CONFIGURATION ---
+CONFIG = {
+    'data_dir': 'data/dataset/soybean',
+    'num_classes': 5,  # ground, leaf, branch, weed, obstacle
+    'class_names': {0: "ground", 1: "leaf", 2: "branch", 3: "weed", 4: "obstacle"},
+    'batch_size': 4,
+    'epochs': 50,
+    'learning_rate': 1e-4,
+    'device': torch.device('cuda' if torch.cuda.is_available() else 'cpu'),
+    'ignore_index': -1, # Value in the semantic mask to be ignored during loss calculation
+    'data_augmentation': True, # Enable/disable data augmentation
+    'model_save_path': 'unet_efficientnetb3_semantic.pth',
+}
+
+# --- DATASET ---
+class ImageSemanticDataset(Dataset):
+    """
+    A simplified dataset that loads only RGB images and their corresponding
+    2D semantic segmentation masks.
+    """
+    def __init__(self, root_dir, num_classes=5, transform=None, data_augmentation=False):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.num_classes = num_classes
+        self.data_augmentation = data_augmentation
+        self.rgb_files = sorted(glob.glob(os.path.join(root_dir, 'rgb', '*.png')))
+        if not self.rgb_files:
+            self.rgb_files = sorted(glob.glob(os.path.join(root_dir, 'rgb', '*.jpg')))
+
+        if not self.rgb_files:
+            raise ValueError(f"No images found in {os.path.join(root_dir, 'rgb')}")
+
+    def __len__(self):
+        return len(self.rgb_files)
+
+    def __getitem__(self, idx):
+        rgb_path = self.rgb_files[idx]
+        base_name = os.path.splitext(os.path.basename(rgb_path))[0]
+
+        # Construct path to semantic mask
+        # The folder name in the original dataset is 'camera_semantic'
+        semantic_path = os.path.join(self.root_dir, 'camera_semantic', f"{base_name}.png")
+
+        # Load RGB Image
+        rgb_img = cv2.imread(rgb_path)
+        rgb_img = cv2.cvtColor(rgb_img, cv2.COLOR_BGR2RGB)
+        rgb_tensor = TF.to_tensor(rgb_img)
+
+        # Load Semantic Mask
+        semantic_mask = cv2.imread(semantic_path, cv2.IMREAD_UNCHANGED)
+        if semantic_mask is None:
+            raise FileNotFoundError(f"Semantic mask not found: {semantic_path}")
+
+        # Ensure mask is single channel
+        if semantic_mask.ndim == 3:
+            semantic_mask = semantic_mask[:, :, 0]
+
+        semantic_tensor = torch.from_numpy(semantic_mask.astype(np.int64))
+
+        # Apply transformations if any
+        if self.transform:
+            rgb_tensor, semantic_tensor = self.transform(rgb_tensor, semantic_tensor)
+
+        # Apply data augmentation if enabled
+        if self.data_augmentation:
+            # Random horizontal flip
+            if torch.rand(1) > 0.5:
+                rgb_tensor = TF.hflip(rgb_tensor)
+                semantic_tensor = TF.hflip(semantic_tensor)
+
+            # Color Jitter (only on RGB)
+            if torch.rand(1) > 0.5:
+                color_jitter = T.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.1)
+                rgb_tensor = color_jitter(rgb_tensor)
+
+            # Noise
+            if torch.rand(1) > 0.5:
+                noise = torch.randn_like(rgb_tensor) * 0.1
+                rgb_tensor = torch.clamp(rgb_tensor + noise, 0, 1)
+
+            # Blur
+            if torch.rand(1) > 0.5:
+                rgb_tensor = TF.gaussian_blur(rgb_tensor, kernel_size=5, sigma=(0.1, 2.0))
+
+
+
+        return {'rgb': rgb_tensor, 'semantic': semantic_tensor, 'frame_id': base_name}
+
+# --- METRICS ---
+def compute_metrics(pred, target, num_classes):
+    """Computes Pixel Accuracy and Mean IoU, ignoring -1 labels."""
+    pred = pred.cpu().numpy()
+    target = target.cpu().numpy()
+    
+    # Create a mask to ignore pixels with the ignore_index value
+    valid_mask = (target != CONFIG['ignore_index'])
+    
+    # Pixel Accuracy
+    correct = np.sum((pred == target) & valid_mask)
+    total = np.sum(valid_mask)
+    pixel_acc = correct / total
+
+    # Mean IoU
+    iou_list = []
+    for c in range(num_classes):
+        tp = np.sum((pred == c) & (target == c))
+        fp = np.sum((pred == c) & (target != c))
+        fn = np.sum((pred != c) & (target == c) & valid_mask) # Only count valid target pixels as false negatives
+        
+        union = tp + fp + fn 
+        if union == 0:
+            iou = 0.0 # Or float('nan')
+        else:
+            iou = tp / union
+        iou_list.append(iou)
+        
+    miou = np.nanmean(iou_list)
+    return pixel_acc, miou
+
+# --- TRAINING AND VALIDATION ---
+def train_one_epoch(model, dataloader, criterion, optimizer, device, num_classes):
+    model.train()
+    total_loss = 0.0
+    total_acc = 0.0
+    total_miou = 0.0
+
+    for batch in tqdm(dataloader, desc="Training"):
+        rgb = batch['rgb'].to(device)
+        semantic = batch['semantic'].to(device)
+
+        optimizer.zero_grad()
+        
+        # DeepLabV3 returns a dictionary
+        output = model(rgb)
+        loss = criterion(output, semantic)
+        
+        loss.backward()
+        optimizer.step()
+
+        total_loss += loss.item()
+        
+        preds = torch.argmax(output, dim=1)
+        acc, miou = compute_metrics(preds, semantic, num_classes)
+        total_acc += acc
+        total_miou += miou
+
+    return total_loss / len(dataloader), total_acc / len(dataloader), total_miou / len(dataloader)
+
+def validate_one_epoch(model, dataloader, criterion, device, num_classes):
+    model.eval()
+    total_loss = 0.0
+    total_acc = 0.0
+    total_miou = 0.0
+
+    with torch.no_grad():
+        for batch in tqdm(dataloader, desc="Validating"):
+            rgb = batch['rgb'].to(device)
+            semantic = batch['semantic'].to(device)
+
+            output = model(rgb)
+            loss = criterion(output, semantic)
+
+            total_loss += loss.item()
+            
+            preds = torch.argmax(output, dim=1)
+            acc, miou = compute_metrics(preds, semantic, num_classes)
+            total_acc += acc
+            total_miou += miou
+
+    return total_loss / len(dataloader), total_acc / len(dataloader), total_miou / len(dataloader)
+
+
+def main():
+    print(f"Using device: {CONFIG['device']}")
+
+    # --- DATA ---
+    # Create separate datasets for training and validation
+    # Augmentation should only be applied to the training set.
+    train_dataset = ImageSemanticDataset(
+        CONFIG['data_dir'], 
+        num_classes=CONFIG['num_classes'],
+        data_augmentation=CONFIG['data_augmentation']
+    )
+    val_dataset = ImageSemanticDataset(
+        CONFIG['data_dir'], 
+        num_classes=CONFIG['num_classes'],
+        data_augmentation=False # No augmentation for validation
+    )
+    
+    # Create a random split of indices, then create subsets
+    indices = torch.randperm(len(train_dataset)).tolist()
+    train_indices = indices[:int(0.8 * len(train_dataset))]
+    val_indices = indices[int(0.8 * len(train_dataset)):]
+    
+    train_dataset = torch.utils.data.Subset(train_dataset, train_indices)
+    val_dataset = torch.utils.data.Subset(val_dataset, val_indices)
+    
+    train_loader = DataLoader(train_dataset, batch_size=CONFIG['batch_size'], shuffle=True, num_workers=2)
+    val_loader = DataLoader(val_dataset, batch_size=CONFIG['batch_size'], shuffle=False, num_workers=2)
+
+    print(f"Training on {len(train_dataset)} samples, validating on {len(val_dataset)} samples.")
+
+    # --- MODEL ---
+    # Load a U-Net model with a pre-trained EfficientNet encoder
+    print("Loading U-Net with EfficientNet encoder...")
+    model = smp.Unet(
+        encoder_name="efficientnet-b3",
+        encoder_weights="imagenet",
+        in_channels=3,
+        classes=CONFIG['num_classes'],
+    )
+    model = model.to(CONFIG['device'])
+
+    # --- LOSS & OPTIMIZER ---
+    # CrossEntropyLoss is standard for multi-class segmentation
+    criterion = nn.CrossEntropyLoss(ignore_index=CONFIG['ignore_index'])
+    optimizer = torch.optim.Adam(model.parameters(), lr=CONFIG['learning_rate'])
+
+    # --- TRAINING LOOP ---
+    best_val_miou = 0.0
+
+    for epoch in range(CONFIG['epochs']):
+        print(f"\n--- Epoch {epoch+1}/{CONFIG['epochs']} ---")
+
+        train_loss, train_acc, train_miou = train_one_epoch(
+            model, train_loader, criterion, optimizer, CONFIG['device'], CONFIG['num_classes']
+        )
+        print(f"Train -> Loss: {train_loss:.4f}, Accuracy: {train_acc:.4f}, mIoU: {train_miou:.4f}")
+
+        val_loss, val_acc, val_miou = validate_one_epoch(
+            model, val_loader, criterion, CONFIG['device'], CONFIG['num_classes']
+        )
+        print(f"Validation -> Loss: {val_loss:.4f}, Accuracy: {val_acc:.4f}, mIoU: {val_miou:.4f}")
+
+        # Save the best model based on validation mIoU
+        if val_miou > best_val_miou:
+            best_val_miou = val_miou
+            torch.save(model.state_dict(), CONFIG['model_save_path'])
+            print(f"✨ New best model saved to {CONFIG['model_save_path']} (mIoU: {best_val_miou:.4f})")
+
+    print("\n--- Training Complete ---")
+    print(f"Best validation mIoU: {best_val_miou:.4f}")
+    print(f"Model saved to {CONFIG['model_save_path']}")
+
+    # --- VISUALIZE A PREDICTION ---
+    model.load_state_dict(torch.load(CONFIG['model_save_path']))
+    model.eval()
+    sample = val_dataset[np.random.randint(len(val_dataset))]
+    rgb_tensor = sample['rgb'].unsqueeze(0).to(CONFIG['device'])
+    
+    with torch.no_grad():
+        pred_mask = model(rgb_tensor)
+        pred_mask = torch.argmax(pred_mask, dim=1).squeeze(0).cpu().numpy()
+
+    rgb_img = sample['rgb'].permute(1, 2, 0).numpy()
+    true_mask = sample['semantic'].numpy()
+
+    fig, axes = plt.subplots(1, 3, figsize=(18, 6))
+    axes[0].imshow(rgb_img)
+    axes[0].set_title("Input RGB")
+    axes[0].axis('off')
+
+    axes[1].imshow(true_mask, cmap='tab10', vmin=0, vmax=CONFIG['num_classes']-1)
+    axes[1].set_title("Ground Truth Mask")
+    axes[1].axis('off')
+
+    axes[2].imshow(pred_mask, cmap='tab10', vmin=0, vmax=CONFIG['num_classes']-1)
+    axes[2].set_title("Predicted Mask")
+    axes[2].axis('off')
+
+    plt.tight_layout()
+    plt.savefig('2d_semantic_prediction_example.png')
+    print("\nSaved a sample prediction to '2d_semantic_prediction_example.png'")
+
+
+if __name__ == '__main__':
+    main()

experiments/semantic_segmentation/unet_efficientnetb3_semantic.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84fcd96ca56f1c8c5bd8936529387cf7b28a552820aea95c5ee97b559b4ab66a
+size 53237515