RVT to IFC Conversion
Note: RVT is the file format. IFC is an open standard by buildingSMART International.
Business Case
Problem Statement
IFC is the open BIM standard for interoperability, but:
- Native Revit IFC export requires Autodesk license
- Export settings significantly affect data quality
- Batch processing is manual and time-consuming
Solution
RVT2IFCconverter.exe converts Revit files to IFC offline, without licenses, with full control over export settings.
Business Value
- No license required - Works without Autodesk software
- Multiple IFC versions - IFC2x3, IFC4, IFC4.3 support
- Batch processing - Convert thousands of files
- Consistent quality - Standardized export settings
Technical Implementation
CLI Syntax
RVT2IFCconverter.exe <input.rvt> [<output.ifc>] [preset=<name>] [config="..."]IFC Versions
| Version | Use Case |
|---|---|
| IFC2x3 | Legacy compatibility, most software |
| IFC4 | Enhanced properties, modern BIM |
| IFC4.3 | Infrastructure, latest standard |
Export Presets
| Preset | Description |
|---|---|
standard | Default balanced export |
extended | Maximum detail and properties |
custom | User-defined configuration |
Examples
# Standard IFC export
RVT2IFCconverter.exe "C:\Projects\Building.rvt"
# IFC4 with extended settings
RVT2IFCconverter.exe "C:\Projects\Building.rvt" preset=extended
# Custom output path
RVT2IFCconverter.exe "C:\Projects\Building.rvt" "D:\Export\model.ifc"
# Custom configuration
RVT2IFCconverter.exe "C:\Projects\Building.rvt" config="ExportBaseQuantities=true; SitePlacement=Shared"Python Integration
import subprocess
from pathlib import Path
from typing import List, Optional, Dict, Any
from dataclasses import dataclass
from enum import Enum
class IFCVersion(Enum):
"""IFC schema versions."""
IFC2X3 = "IFC2x3"
IFC4 = "IFC4"
IFC4X3 = "IFC4x3"
class ExportPreset(Enum):
"""Export presets."""
STANDARD = "standard"
EXTENDED = "extended"
CUSTOM = "custom"
@dataclass
class IFCExportConfig:
"""IFC export configuration."""
ifc_version: IFCVersion = IFCVersion.IFC4
export_base_quantities: bool = True
site_placement: str = "Shared"
split_walls_and_columns: bool = False
include_steel_elements: bool = True
export_2d_elements: bool = False
export_linked_files: bool = False
export_rooms: bool = True
export_schedules: bool = True
def to_config_string(self) -> str:
"""Convert to CLI config string."""
parts = [
f"ExportBaseQuantities={str(self.export_base_quantities).lower()}",
f"SitePlacement={self.site_placement}",
f"SplitWallsAndColumns={str(self.split_walls_and_columns).lower()}",
f"IncludeSteelElements={str(self.include_steel_elements).lower()}",
f"Export2DElements={str(self.export_2d_elements).lower()}",
f"ExportLinkedFiles={str(self.export_linked_files).lower()}",
f"ExportRooms={str(self.export_rooms).lower()}"
]
return "; ".join(parts)
class RevitToIFCConverter:
"""Convert Revit files to IFC format."""
def __init__(self, converter_path: str = "RVT2IFCconverter.exe"):
self.converter = Path(converter_path)
if not self.converter.exists():
raise FileNotFoundError(f"Converter not found: {converter_path}")
def convert(self, rvt_file: str,
output_path: Optional[str] = None,
preset: ExportPreset = ExportPreset.STANDARD,
config: Optional[IFCExportConfig] = None) -> Path:
"""Convert Revit file to IFC."""
rvt_path = Path(rvt_file)
if not rvt_path.exists():
raise FileNotFoundError(f"Revit file not found: {rvt_file}")
# Build command
cmd = [str(self.converter), str(rvt_path)]
# Add output path if specified
if output_path:
cmd.append(output_path)
# Add preset
cmd.append(f"preset={preset.value}")
# Add custom config if provided
if config:
cmd.append(f'config="{config.to_config_string()}"')
# Execute
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode != 0:
raise RuntimeError(f"Conversion failed: {result.stderr}")
# Return output path
if output_path:
return Path(output_path)
return rvt_path.with_suffix('.ifc')
def batch_convert(self, folder: str,
output_folder: Optional[str] = None,
preset: ExportPreset = ExportPreset.STANDARD,
config: Optional[IFCExportConfig] = None) -> List[Dict[str, Any]]:
"""Convert all Revit files in folder."""
folder_path = Path(folder)
results = []
for rvt_file in folder_path.glob("**/*.rvt"):
try:
# Determine output path
if output_folder:
out_dir = Path(output_folder)
out_dir.mkdir(parents=True, exist_ok=True)
output_path = str(out_dir / rvt_file.with_suffix('.ifc').name)
else:
output_path = None
ifc_path = self.convert(str(rvt_file), output_path, preset, config)
results.append({
'input': str(rvt_file),
'output': str(ifc_path),
'status': 'success'
})
print(f"✓ Converted: {rvt_file.name}")
except Exception as e:
results.append({
'input': str(rvt_file),
'output': None,
'status': 'failed',
'error': str(e)
})
print(f"✗ Failed: {rvt_file.name} - {e}")
return results
def validate_output(self, ifc_file: str) -> Dict[str, Any]:
"""Basic validation of generated IFC."""
ifc_path = Path(ifc_file)
if not ifc_path.exists():
return {'valid': False, 'error': 'File not found'}
# Basic file checks
file_size = ifc_path.stat().st_size
if file_size < 1000:
return {'valid': False, 'error': 'File too small'}
# Read header
with open(ifc_file, 'r', errors='ignore') as f:
header = f.read(1000)
# Check IFC format
if 'ISO-10303-21' not in header:
return {'valid': False, 'error': 'Not a valid IFC file'}
# Detect version
version = 'Unknown'
if 'IFC4X3' in header:
version = 'IFC4.3'
elif 'IFC4' in header:
version = 'IFC4'
elif 'IFC2X3' in header:
version = 'IFC2x3'
return {
'valid': True,
'file_size': file_size,
'ifc_version': version
}
class IFCQualityChecker:
"""Check quality of IFC exports."""
def __init__(self, converter: RevitToIFCConverter):
self.converter = converter
def compare_presets(self, rvt_file: str) -> Dict[str, Any]:
"""Compare different export presets."""
results = {}
for preset in [ExportPreset.STANDARD, ExportPreset.EXTENDED]:
try:
output = Path(rvt_file).with_suffix(f'.{preset.value}.ifc')
self.converter.convert(rvt_file, str(output), preset)
validation = self.converter.validate_output(str(output))
results[preset.value] = {
'file_size': validation.get('file_size', 0),
'valid': validation.get('valid', False)
}
except Exception as e:
results[preset.value] = {'error': str(e)}
return results
# Convenience functions
def convert_revit_to_ifc(rvt_file: str,
converter_path: str = "RVT2IFCconverter.exe") -> str:
"""Quick conversion of Revit to IFC."""
converter = RevitToIFCConverter(converter_path)
output = converter.convert(rvt_file)
return str(output)
def batch_convert_to_ifc(folder: str,
converter_path: str = "RVT2IFCconverter.exe") -> List[str]:
"""Batch convert all Revit files to IFC."""
converter = RevitToIFCConverter(converter_path)
results = converter.batch_convert(folder)
return [r['output'] for r in results if r['status'] == 'success']Quick Start
# Initialize converter
converter = RevitToIFCConverter("C:/DDC/RVT2IFCconverter.exe")
# Basic conversion
ifc = converter.convert("building.rvt")
print(f"Created: {ifc}")
# With custom config
config = IFCExportConfig(
ifc_version=IFCVersion.IFC4,
export_base_quantities=True,
export_rooms=True
)
ifc = converter.convert("building.rvt", preset=ExportPreset.CUSTOM, config=config)Common Use Cases
1. Batch Processing
converter = RevitToIFCConverter()
results = converter.batch_convert(
folder="C:/Projects",
output_folder="C:/IFC_Export",
preset=ExportPreset.EXTENDED
)
print(f"Converted {len([r for r in results if r['status'] == 'success'])} files")2. Quality Check
validation = converter.validate_output("model.ifc")
print(f"Valid: {validation['valid']}, Version: {validation['ifc_version']}")3. Compare Presets
checker = IFCQualityChecker(converter)
comparison = checker.compare_presets("building.rvt")
print(comparison)Resources
- GitHub: cad2data Pipeline
- buildingSMART IFC: https://www.buildingsmart.org/standards/bsi-standards/industry-foundation-classes/