ReconstructFull API

ReconstructFull is the simplest and most user-friendly full-process reconstruction interface, ideal for quickly starting projects and for beginner users. It automatically handles image metadata extraction, aerotriangulation, and the complete 3D reconstruction workflow.

🎯 API Features

✅ Highly automated: Automatically reads GPS and camera information from image EXIF data
✅ Simple configuration: Only requires specifying the image path at minimum
✅ One-step process: Directly generates the final results from images
✅ Intelligent optimization: Automatically selects the best processing parameters

📋 Parameter Details

Required Parameters

Parameter Name	Type	Description	Example Value
`license_id`	int	SDK license ID	`9200`
`working_dir`	string	Working directory path	`"C:/Projects/MyProject"`
`gdal_folder`	string	GDAL data directory	`"C:/MipMap/SDK/data"`
`coordinate_system`	object	Input coordinate system	See description below
`image_meta_data`	array	Image list	See description below
`input_image_type`	int	Image type	`1`=RGB, `2`=Multispectral, `3`=Infrared
`resolution_level`	int	Precision level	`1`=High, `2`=Medium, `3`=Low

Optional Parameters - Output Control

Parameter Name	Type	Default	Description
`generate_obj`	bool	false	Generate OBJ format model
`generate_ply`	bool	false	Generate PLY format model
`generate_osgb`	bool	false	Generate OSGB format model (oblique)
`generate_3d_tiles`	bool	false	Generate 3D Tiles (Cesium)
`generate_las`	bool	false	Generate LAS point cloud
`generate_pc_ply`	bool	false	Generate point cloud PLY
`generate_pc_osgb`	bool	false	Generate point cloud OSGB (LOD)
`generate_pc_pnts`	bool	false	Generate point cloud PNTS (3D Tiles)
`generate_geotiff`	bool	false	Generate orthophoto GeoTIFF
`generate_tile_2D`	bool	false	Generate 2D map tiles
`generate_2D_from_3D_model`	bool	false	Generate orthophoto from 3D model

Optional Parameters - Coordinate Systems

Parameter Name	Type	Default	Description
`coordinate_system_3d`	object	Local/LocalENU	Output 3D coordinate system
`coordinate_system_2d`	object	LocalENU	Output 2D coordinate system

Optional Parameters - Advanced Features

Parameter Name	Type	Default	Description
`gcp_path`	string	-	Ground Control Point (GCP) file path
`gcp_coor_sys`	object	-	Coordinate system for GCPs
`use_image_position_constraint`	bool	true	Use image position constraint
`fast_mode`	bool	false	Fast mode (reduces quality for speed)
`min_avali_memory_size`	float	16.0	Minimum available memory (GB)
`output_block_change_xml`	bool	false	Output Block Exchange XML

📝 Data Structure Details

coordinate_system Object

{
  "type": 2,              // 1=Projected, 2=Geographic, 3=Geocentric
  "type_name": "Geographic",
  "label": "WGS 84",      // Coordinate system name
  "epsg_code": 4326       // EPSG code
}

Elements of the image_meta_data Array

Basic Format (EXIF Auto-Detection)

{
  "id": 1,                           // Unique identifier
  "path": "C:/Images/DJI_0001.JPG",  // Image file path
  "group": "camera_1"                // Optional: camera group
}

Full Format (Custom Metadata)

{
  "id": 1,
  "path": "C:/Images/IMG_0001.JPG",
  "group": "nadir",                  // Camera group name
  "meta_data": {                     // Custom metadata
    "width": 6000,                   // Image width (pixels)
    "height": 4000,                  // Image height (pixels)
    "pos": [114.123456, 22.123456, 100.5],  // [Longitude, Latitude, Altitude]
    "pos_sigma": [0.05, 0.05, 0.10], // [X accuracy, Y accuracy, Z accuracy] (meters)
    "focal_length": 24.0,            // Focal length (millimeters)
    "pixel_size": 0.00391            // Pixel size (millimeters)
  }
}

Camera Group (`group`) Parameter

Used in multi-camera systems to process images from different cameras in groups:

"image_meta_data": [
  {"id": 1, "path": "nadir/IMG_001.jpg", "group": "nadir"},
  {"id": 2, "path": "nadir/IMG_002.jpg", "group": "nadir"},
  {"id": 3, "path": "oblique_f/IMG_001.jpg", "group": "oblique_forward"},
  {"id": 4, "path": "oblique_b/IMG_001.jpg", "group": "oblique_backward"},
  {"id": 5, "path": "oblique_l/IMG_001.jpg", "group": "oblique_left"},
  {"id": 6, "path": "oblique_r/IMG_001.jpg", "group": "oblique_right"}
]

Common grouping scenarios:

Five-lens oblique camera: nadir, oblique_forward, oblique_backward, oblique_left, oblique_right
Dual-camera system: wide_angle, telephoto
Multi-drone collaboration: drone_1, drone_2, drone_3
Multi-temporal acquisition: morning, afternoon

Explanation of pos and pos_sigma Parameters

pos parameter:

Format: [longitude, latitude, altitude] or [X, Y, Z] (depending on the coordinate system)
Unit: Degrees and meters for geographic coordinates, meters for projected coordinates
Purpose: Overrides GPS info from EXIF or provides positions for images without GPS data

pos_sigma parameter:

Format: [σ_X, σ_Y, σ_Z]
Unit: meters
Meaning: Standard deviation (1σ) of positional measurements in each direction
Purpose: Used as weights in bundle adjustment; higher precision (smaller σ) means greater weight

Typical values:

Positioning Method	σ_X/σ_Y	σ_Z	Description
RTK fixed	0.02-0.05m	0.05-0.10m	Highest accuracy
PPK post-processing	0.03-0.08m	0.08-0.15m	High accuracy
Standard GPS	2-5m	3-8m	Standard accuracy
Manual estimation	0.5-2m	1-3m	Low accuracy

📝 Configuration Example

Minimal Configuration

{
  "license_id": 9200,
  "working_dir": "C:/Projects/QuickStart",
  "gdal_folder": "C:/MipMap/SDK/data",
  "input_image_type": 1,
  "resolution_level": 2,
  "coordinate_system": {
    "type": 2,
    "label": "WGS 84",
    "epsg_code": 4326
  },
  "image_meta_data": [
    {"id": 1, "path": "C:/Images/DJI_0001.JPG"},
    {"id": 2, "path": "C:/Images/DJI_0002.JPG"},
    {"id": 3, "path": "C:/Images/DJI_0003.JPG"},
    {"id": 4, "path": "C:/Images/DJI_0004.JPG"},
    {"id": 5, "path": "C:/Images/DJI_0005.JPG"}
  ],
  "generate_obj": true,
  "generate_geotiff": true
}

Multi-Camera Group Configuration Example

{
  "license_id": 9200,
  "working_dir": "D:/Projects/MultiCamera",
  "gdal_folder": "D:/MipMap/SDK/data",
  "input_image_type": 1,
  "resolution_level": 1,
  "coordinate_system": {
    "type": 2,
    "label": "WGS 84",
    "epsg_code": 4326
  },
  
  // Multi-camera image grouping
  "image_meta_data": [
    // Nadir camera
    {"id": 1, "path": "nadir/IMG_001.jpg", "group": "nadir"},
    {"id": 2, "path": "nadir/IMG_002.jpg", "group": "nadir"},
    
    // Forward oblique camera
    {"id": 3, "path": "forward/IMG_001.jpg", "group": "oblique_f"},
    {"id": 4, "path": "forward/IMG_002.jpg", "group": "oblique_f"},
    
    // More camera groups...
  ],
  
  "generate_osgb": true,
  "generate_3d_tiles": true
}

Custom POS Configuration Example

{
  "license_id": 9200,
  "working_dir": "D:/Projects/PPK_Project",
  "gdal_folder": "D:/MipMap/SDK/data",
  "input_image_type": 1,
  "resolution_level": 1,
  "coordinate_system": {
    "type": 2,
    "label": "WGS 84",
    "epsg_code": 4326
  },
  
  // Use high-precision positions processed by PPK
  "image_meta_data": [
    {
      "id": 1,
      "path": "images/DJI_0001.JPG",
      "meta_data": {
        "width": 5472,
        "height": 3648,
        "pos": [114.305421, 22.596013, 120.543],  // Precise position processed by PPK
        "pos_sigma": [0.03, 0.03, 0.05]  // PPK accuracy
      }
    },
    {
      "id": 2,
      "path": "images/DJI_0002.JPG",
      "meta_data": {
        "width": 5472,
        "height": 3648,
        "pos": [114.305512, 22.596089, 120.621],
        "pos_sigma": [0.03, 0.03, 0.05]
      }
    }
    // ... more images
  ],
  
  "generate_obj": true,
  "generate_geotiff": true
}

Full Configuration Example (with GCP)

{
  "license_id": 9200,
  "working_dir": "D:/Projects/HighPrecision",
  "gdal_folder": "D:/MipMap/SDK/data",
  "input_image_type": 1,
  "resolution_level": 1,
  
  // Input coordinate system - WGS84
  "coordinate_system": {
    "type": 2,
    "label": "WGS 84",
    "epsg_code": 4326
  },
  
  // Output coordinate system - UTM
  "coordinate_system_3d": {
    "type": 3,
    "label": "WGS 84 / UTM zone 50N",
    "epsg_code": 32650
  },
  
  // Ground Control Points
  "gcp_path": "D:/Projects/HighPrecision/gcps.txt",
  "gcp_coor_sys": {
    "type": 3,
    "label": "WGS 84 / UTM zone 50N",
    "epsg_code": 32650
  },
  
  // Image list
  "image_meta_data": [
    {"id": 1, "path": "D:/Data/flight1/IMG_001.JPG"},
    {"id": 2, "path": "D:/Data/flight1/IMG_002.JPG"},
    // ... more images
  ],
  
  // Output all formats
  "generate_obj": true,
  "generate_osgb": true,
  "generate_3d_tiles": true,
  "generate_las": true,
  "generate_geotiff": true,
  "generate_tile_2D": true
}

💾 Output Directory Structure

After processing, the following directory structure will be generated in the working directory:

working_dir/
├── products/              # Final results
│   ├── models/           # 3D Models
│   │   ├── model.obj    # OBJ format
│   │   ├── model.mtl    # Material file
│   │   ├── textures/    # Texture images
│   │   └── tileset.json # 3D Tiles
│   ├── pointcloud/       # Point clouds
│   │   └── cloud.las    # LAS format
│   └── orthophoto/       # Orthophoto
│       ├── ortho.tif    # GeoTIFF
│       └── tiles/       # Tiles
├── milestones/           # Intermediate results
│   ├── at_result/       # Aerial triangulation result
│   ├── roi.json         # ROI area
│   └── report.html      # Processing report
└── log/                  # Log files
    └── log.txt          # Detailed log

🎯 Recommended Usage Scenarios

Suitable for

✅ Rapid prototyping and testing
✅ Standard aerial photography projects
✅ Automated batch processing
✅ Beginners and learning

Not suitable for

❌ Need for fine parameter control
❌ Need to use control points
❌ Need to check intermediate results
❌ Special cameras or sensors

🔧 Advanced Tips

1. Batch Process Multiple Projects

import json
import subprocess
from pathlib import Path

def batch_process(project_list):
    for project in project_list:
        # Create configuration
        config = {
            "license_id": 9200,
            "working_dir": f"./output/{project['name']}",
            "gdal_folder": "./data",
            "coordinate_system": {"type": 2, "epsg_code": 4326},
            "image_meta_data": [
                {"id": i+1, "path": str(img)} 
                for i, img in enumerate(project['images'])
            ],
            "input_image_type": 1,
            "resolution_level": 2,
            "generate_obj": True,
            "generate_geotiff": True
        }
        
        # Save configuration
        config_path = f"./config_{project['name']}.json"
        with open(config_path, 'w') as f:
            json.dump(config, f, indent=2)
        
        # Run processing
        subprocess.run([
            "reconstruct_full_engine.exe",
            "-reconstruct_type", "0",
            "-task_json", config_path
        ])

2. Automatic Parameter Optimization

def optimize_parameters(image_count, available_memory_gb):
    """Automatically select parameters based on project size"""
    
    # Resolution level
    if image_count < 100:
        resolution_level = 1  # High precision
    elif image_count < 500:
        resolution_level = 2  # Medium precision
    else:
        resolution_level = 3  # Low precision (large project)
    
    # Output formats
    if available_memory_gb > 32:
        formats = {
            "generate_obj": True,
            "generate_osgb": True,
            "generate_3d_tiles": True,
            "generate_las": True
        }
    else:
        formats = {
            "generate_obj": True,
            "generate_las": False
        }
    
    return resolution_level, formats

3. Progress Monitoring

import re
import time
from threading import Thread

def monitor_progress(log_file):
    """Monitor processing progress"""
    
    def read_progress():
        with open(log_file, 'r') as f:
            f.seek(0, 2)  # Go to file end
            while True:
                line = f.readline()
                if line:
                    match = re.search(r'\[PROGRESS\] (\d+)%', line)
                    if match:
                        progress = int(match.group(1))
                        print(f"\rProgress: {'█' * (progress//2)}{'░' * (50-progress//2)} {progress}%", end='')
                time.sleep(0.1)
    
    thread = Thread(target=read_progress, daemon=True)
    thread.start()

❓ Frequently Asked Questions (FAQ)

Q: Why are some images not used?

A: ReconstructFull will automatically filter out low-quality images:

Blurry images
Images with no GPS information
Duplicate or highly similar images

You can check the log for filtered images and reasons.

Q: How to process images without GPS?

A: For images without GPS information, you need to:

Use the ReconstructAT interface (supports images without GPS)
Or manually add GPS info to EXIF
Or use an external POS file

Q: What if there is not enough memory for large projects?

A: Possible solutions:

Lower the resolution_level to 2 or 3
Reduce simultaneous output formats
Use block processing (requires other interfaces)

Coordinate System Details
Image Metadata Instructions
Output Format Comparison
ReconstructAT Interface (more control)

ReconstructFull is the best choice to start using the MipMapEngine SDK. As you gain experience, you can explore other interfaces for more control.

🎯 API Features​

📋 Parameter Details​

Required Parameters​

Optional Parameters - Output Control​

Optional Parameters - Coordinate Systems​

Optional Parameters - Advanced Features​

📝 Data Structure Details​

coordinate_system Object​

Elements of the image_meta_data Array​

Basic Format (EXIF Auto-Detection)​

Full Format (Custom Metadata)​

Camera Group (group) Parameter​

Explanation of pos and pos_sigma Parameters​

📝 Configuration Example​

Minimal Configuration​

Multi-Camera Group Configuration Example​

Custom POS Configuration Example​

Full Configuration Example (with GCP)​

💾 Output Directory Structure​

🎯 Recommended Usage Scenarios​

Suitable for​

Not suitable for​

🔧 Advanced Tips​

1. Batch Process Multiple Projects​

2. Automatic Parameter Optimization​

3. Progress Monitoring​

❓ Frequently Asked Questions (FAQ)​

🔗 Related Links​