Skip to content

Features Overview

Introduction

The MINE (MachInNav Engine) is a comprehensive indoor navigation solution designed to provide powerful, accurate, and user-friendly navigation experiences in complex indoor environments. Built with cutting-edge technologies and optimized for performance, MINE delivers enterprise-grade features for applications ranging from shopping malls to airports, hospitals, and corporate campuses.

What Makes MINE Different?

MINE combines advanced 3D rendering, intelligent pathfinding algorithms, real-time positioning, and intuitive UI components to create a seamless indoor navigation experience that works across various devices and deployment scenarios.

Core Features

  • Dynamic 3D/2D Environments

    Seamlessly switch between immersive 3D and efficient 2D map views based on user preferences and device capabilities.

    Learn more

  • Theme Customization

    Fully customizable themes and branding options to match your application's design language and corporate identity.

    Customize themes

  • Advanced Path Finding

    Multi-criteria route optimization considering accessibility, distance, congestion, and user preferences.

    Explore pathfinding

  • Real-time Navigation

    Turn-by-turn guidance with visual and audio cues, supporting Bluetooth beacons, Wi-Fi, and sensor fusion.

    Navigation features

  • Rich UI Components

    Pre-built, customizable UI components including search, floor selection, POI markers, and route preview.

    UI components

  • Multi-floor Support

    Intelligent navigation across multiple building floors with automatic floor detection and transitions.

    Map loading

Feature Deep Dive

🗺️ Dynamic 3D/2D Environment

MINE provides a flexible visualization system that adapts to your application's needs:

3D View Capabilities

  • Immersive Visualization: Photo-realistic 3D rendering powered by Google's Filament engine
  • Interactive Camera: Pan, zoom, rotate, and tilt controls for intuitive exploration
  • Real-time Shadows: Dynamic lighting and shadows for depth perception
  • Model Streaming: Progressive loading of 3D assets for optimal performance
// Example: Switch between 3D and 2D modes
val sceneView = MineSceneView(context)

// Enable 3D mode
sceneView.setViewMode(ViewMode.MODE_3D)
sceneView.apply {
    enablePerspectiveCamera = true
    enableShadows = true
    ambientOcclusionEnabled = true
}

// Switch to 2D mode for better performance
sceneView.setViewMode(ViewMode.MODE_2D)
sceneView.apply {
    enableOrthographicCamera = true
    cameraAngle = 90f // Top-down view
}

2D View Capabilities

  • Vector Maps: Crisp, scalable vector rendering at any zoom level
  • Efficient Rendering: Optimized for lower-end devices and battery conservation
  • Clear Labeling: Enhanced text readability and POI visibility
  • Quick Load Times: Instant map rendering for responsive UX

When to Use Each Mode

  • 3D Mode: Best for complex venues, wayfinding in large spaces, and creating "wow factor"
  • 2D Mode: Ideal for simple layouts, quick navigation, and devices with limited resources

🎨 Theme Customization

Create a branded navigation experience that aligns with your visual identity:

Customization Options

MineTheme.apply {
    primaryColor = Color(0xFF1976D2)
    accentColor = Color(0xFF4CAF50)
    backgroundColor = Color(0xFFF5F5F5)
    pathColor = Color(0xFF2196F3)
    currentLocationColor = Color(0xFFFF5722)
}

MineTheme.typography = Typography(
    headingFont = Typeface.create("Roboto", Typeface.BOLD),
    bodyFont = Typeface.create("Roboto", Typeface.NORMAL),
    headingSize = 18.sp,
    bodySize = 14.sp
)

MineTheme.uiConfig = UIConfig(
    markerStyle = MarkerStyle.MODERN,
    buttonShape = ButtonShape.ROUNDED,
    cardElevation = 4.dp,
    borderRadius = 8.dp
)

Supported Customizations:

  • Primary and accent colors
  • Typography and fonts
  • Icon sets and marker styles
  • Button and card styles
  • Dark/light theme variants
  • Localization support

🧭 Advanced Path Finding

MINE's intelligent pathfinding engine calculates optimal routes based on multiple criteria:

Pathfinding Algorithms

  • A* Algorithm: Efficient shortest path calculation
  • Dijkstra's Algorithm: Multi-destination optimization
  • Dynamic Weights: Real-time route adjustment based on congestion
  • Accessibility Routes: Wheelchair-friendly and elevator-prioritized paths
// Example: Calculate accessible route
val navigationManager = MineNavigationManager()

val routeRequest = RouteRequest(
    origin = currentLocation,
    destination = targetPOI,
    preferences = RoutePreferences(
        avoidStairs = true,
        preferElevators = true,
        considerWheelchairAccess = true,
        optimizeFor = OptimizationCriteria.ACCESSIBILITY
    )
)

navigationManager.calculateRoute(routeRequest) { result ->
    when (result) {
        is RouteResult.Success -> {
            displayRoute(result.route)
            startNavigation(result.route)
        }
        is RouteResult.Error -> {
            showError(result.message)
        }
    }
}

Multi-Criteria Optimization

Routes can be optimized for:

Criteria Description Use Case
Shortest Distance Minimum walking distance Quick navigation
Fastest Route Considers walking speed and congestion Time-sensitive scenarios
Accessibility Elevator access, ramps, wide corridors Wheelchair users, strollers
Scenic Route Passes by interesting POIs Tourist applications
Emergency Exit Fastest evacuation path Safety and emergency

🚶 Real-time Navigation

Provide users with accurate, real-time guidance throughout their journey:

Positioning Technologies

MINE supports multiple positioning systems for maximum accuracy:

  • Accuracy: 1-3 meters
  • Setup: Requires beacon deployment
  • Best For: Retail, museums, airports
val beaconPositioning = BeaconPositioningProvider(
    scanInterval = 1000L,
    rssiThreshold = -80
)
navigationManager.setPositioningProvider(beaconPositioning)
  • Accuracy: 1-2 meters
  • Setup: Requires Wi-Fi RTT capable APs
  • Best For: Corporate offices, hospitals
val wifiPositioning = WiFiRTTProvider(
    scanFrequency = 2000L,
    minAccessPoints = 3
)
navigationManager.setPositioningProvider(wifiPositioning)
  • Accuracy: 2-5 meters
  • Setup: No infrastructure needed
  • Best For: Quick deployment, PDR
val sensorFusion = SensorFusionProvider(
    useAccelerometer = true,
    useGyroscope = true,
    useMagnetometer = true
)
navigationManager.setPositioningProvider(sensorFusion)
  • Turn-by-Turn Directions: Voice and visual instructions
  • Distance to Destination: Real-time updates
  • Floor Change Notifications: Automatic detection and guidance
  • Rerouting: Automatic recalculation when off-path
  • ETA Calculation: Estimated time of arrival
// Example: Start turn-by-turn navigation
navigationManager.startNavigation(route) { event ->
    when (event) {
        is NavigationEvent.InstructionUpdate -> {
            showInstruction(event.instruction)
            playVoiceGuidance(event.instruction)
        }
        is NavigationEvent.FloorChange -> {
            showFloorChangeAlert(event.fromFloor, event.toFloor)
        }
        is NavigationEvent.Rerouting -> {
            showReroutingIndicator()
        }
        is NavigationEvent.DestinationReached -> {
            showArrivalDialog()
        }
    }
}

🎯 Rich UI Components

Pre-built, production-ready UI components that accelerate development:

Available Components

Search & Discovery

// Location search component
MineSearchBar(
    modifier = Modifier.fillMaxWidth(),
    onLocationSelected = { poi ->
        navigateTo(poi)
    },
    placeholder = "Search locations...",
    showRecentSearches = true,
    showCategories = true
)

Floor Selector

// Floor selection component
MineFloorSelector(
    floors = buildingFloors,
    currentFloor = activeFloor,
    onFloorSelected = { floor ->
        sceneView.switchToFloor(floor)
    },
    orientation = Orientation.VERTICAL
)

Route Preview Card

// Route information card
MineRouteCard(
    route = calculatedRoute,
    showDistance = true,
    showDuration = true,
    showAccessibilityInfo = true,
    onStartNavigation = { startNavigation(route) },
    onAlternativeRoute = { showAlternatives() }
)

Component Features

  • 🎨 Fully themeable and customizable
  • 📱 Responsive design for all screen sizes
  • ♿ Accessibility-compliant (WCAG 2.1)
  • 🌍 Multi-language support
  • 🔄 Real-time data updates

🏢 Multi-floor Support

Navigate seamlessly across complex multi-level buildings:

Features

  • Automatic Floor Detection: Uses barometric pressure and beacons
  • Floor Transition Visualization: Clear indicators for stairs, elevators, escalators
  • Cross-Floor Routing: Intelligent path calculation across levels
  • Floor Plan Management: Support for hundreds of floors per venue
// Example: Multi-floor navigation
val multiFloorRoute = RouteRequest(
    origin = Location(floor = 1, x = 10.0, y = 20.0),
    destination = Location(floor = 5, x = 50.0, y = 30.0),
    preferences = RoutePreferences(
        preferElevators = true,
        maxStairFlights = 2
    )
)

navigationManager.calculateRoute(multiFloorRoute) { result ->
    // Route includes floor transitions
    result.route.segments.forEach { segment ->
        if (segment is FloorTransitionSegment) {
            println("Use ${segment.transitionType} to floor ${segment.toFloor}")
        }
    }
}

Performance & Optimization

MINE is built for performance across all device types:

Feature Optimization Result
3D Rendering LOD, Frustum culling, Occlusion 60 FPS on mid-range devices
Map Loading Progressive loading, Caching < 2s initial load time
Pathfinding Spatial indexing, A* optimization < 100ms route calculation
Memory Texture compression, Asset streaming < 150MB RAM usage
Battery GPU throttling, Smart positioning Minimal battery impact

Integration & Compatibility

Platform Support

  • ✅ Android: 7.0 (API 24) and above
  • ✅ Kotlin: 1.8.0+
  • ✅ Jetpack Compose: Modern UI toolkit support
  • ✅ ARCore: Optional AR features

Architecture Compatibility

  • MVVM: Model-View-ViewModel pattern
  • Clean Architecture: Separation of concerns
  • Dependency Injection: Dagger/Hilt support
  • Reactive Programming: Coroutines and Flow

Use Cases

MINE powers indoor navigation in diverse environments:

🏬 Shopping Malls

  • Store locator and navigation
  • Promotional POI highlighting
  • Parking spot finder
  • Event navigation

🏥 Hospitals

  • Department and room finding
  • Accessible route guidance
  • Emergency evacuation
  • Visitor navigation

✈️ Airports

  • Gate finding
  • Amenity locator
  • Multi-terminal navigation
  • Time-sensitive routing

🏢 Corporate Offices

  • Meeting room finder
  • Desk navigation
  • Visitor guidance
  • Evacuation planning

🎓 Universities

  • Classroom finder
  • Campus navigation
  • Building directory
  • Event locations

🏛️ Museums & Venues

  • Exhibit navigation
  • Audio tour integration
  • Accessibility support
  • Interactive maps

Getting Started

Ready to implement MINE features in your application?

  • Quick Start

    Get up and running in minutes with our quick start guide

    Quick Start

  • Installation

    Detailed installation and setup instructions

    Installation Guide

  • API Reference

    Complete API documentation and code examples

    API Docs

  • Support

    Get help from our team and community

    Get Support

Feature Roadmap

Coming Soon

We're continuously improving MINE with new features:

  • 🔄 AR Navigation - Augmented reality wayfinding overlays
  • 🤖 AI Route Prediction - Machine learning-based route suggestions
  • 🌐 Web SDK - Browser-based navigation experiences
  • 📊 Analytics Dashboard - Usage insights and heatmaps
  • 🔗 IoT Integration - Smart building and sensor integration

Next Steps

Explore detailed documentation for each feature: