Skill: datadrivenconstruction/ifc-qto-extraction (version 2.0.0)

--- name: "ifc-qto-extraction" description: "Extract quantities from IFC/Revit models for quantity takeoff. Uses DDC converters to get element counts, areas, volumes, lengths with grouping and reporting." --- # IFC Quantity Takeoff Extraction Extract structured quantity data from BIM models (IFC, Revit) for cost estimation, material ordering, and progress tracking. ## Business Case **Problem**: Manual quantity takeoff is: - Time-consuming (40-80 hours for medium project) - Error-prone (human counting mistakes) - Not repeatable (changes require full rework) - Disconnected from design (no live updates) **Solution**: Automated QTO from BIM that: - Extracts all quantities in minutes - Groups by type, level, zone - Updates instantly with model changes - Exports to Excel for pricing **ROI**: 90% reduction in QTO time, near-zero counting errors ## DDC Tools Used ``` ┌──────────────────────────────────────────────────────────────────────┐ │ QTO EXTRACTION PIPELINE │ ├──────────────────────────────────────────────────────────────────────┤ │ │ │ INPUT CONVERT ANALYZE │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ .rvt │ │ DDC │ │ Python │ │ │ │ .ifc │─────────►│Converter│───────────►│ pandas │ │ │ │ .dwg │ │ │ │ │ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │ │ │ │ ▼ ▼ │ │ ┌─────────┐ ┌─────────┐ │ │ │ .xlsx │ │ Grouped │ │ │ │ raw data│ │ QTO │ │ │ └─────────┘ └─────────┘ │ │ │ │ │ OUTPUT ▼ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │ QTO Report │ │ │ │ • Element counts by type │ │ │ │ • Areas (m², ft²) │ │ │ │ • Volumes (m³, ft³) │ │ │ │ • Lengths (m, ft) │ │ │ │ • Weights (kg, tons) │ │ │ │ • Grouped by level/zone/system │ │ │ └─────────────────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────────────────┘ ``` ## CLI Commands ### Revit to Excel (with BBox for volumes) ```bash # Basic extraction RvtExporter.exe "C:\Models\Building.rvt" # Full extraction with bounding boxes (for volume calculations) RvtExporter.exe "C:\Models\Building.rvt" complete bbox # Include schedules (Revit's built-in QTO) RvtExporter.exe "C:\Models\Building.rvt" complete bbox schedule ``` ### IFC to Excel ```bash # Extract IFC data IfcExporter.exe "C:\Models\Building.ifc" # Output: Building.xlsx with all IFC entities ``` ### DWG to Excel (2D areas) ```bash # Extract DWG blocks and areas DwgExporter.exe "C:\Drawings\FloorPlan.dwg" ``` ## Python Implementation ```python import pandas as pd import numpy as np from pathlib import Path import subprocess from typing import List, Dict, Optional from dataclasses import dataclass @dataclass class QuantityItem: """Single quantity line item""" category: str type_name: str count: int area: float = 0.0 volume: float = 0.0 length: float = 0.0 weight: float = 0.0 unit_area: str = "m²" unit_volume: str = "m³" unit_length: str = "m" level: str = "" zone: str = "" class BIMQuantityExtractor: """Extract quantities from BIM models using DDC converters""" def __init__(self, converter_path: str): self.converter_path = Path(converter_path) def convert_model(self, model_path: str, options: List[str] = None) -> Path: """Convert BIM model to Excel""" model = Path(model_path) options = options or ["complete", "bbox"] # Determine converter ext = model.suffix.lower() converters = { '.rvt': 'RvtExporter.exe', '.rfa': 'RvtExporter.exe', '.ifc': 'IfcExporter.exe', '.dwg': 'DwgExporter.exe', '.dgn': 'DgnExporter.exe' } converter = self.converter_path / converters.get(ext, 'RvtExporter.exe') # Build command cmd = [str(converter), str(model)] + options # Execute result = subprocess.run(cmd, capture_output=True, text=True) if result.returncode != 0: raise RuntimeError(f"Conversion failed: {result.stderr}") # Return path to generated Excel xlsx_path = model.with_suffix('.xlsx') return xlsx_path def load_bim_data(self, xlsx_path: str) -> pd.DataFrame: """Load converted BIM data from Excel""" xlsx = Path(xlsx_path) if not xlsx.exists(): raise FileNotFoundError(f"Excel file not found: {xlsx}") # Read main data sheet df = pd.read_excel(xlsx, sheet_name=0) # Clean column names df.columns = df.columns.str.strip() return df def extract_quantities( self, df: pd.DataFrame, group_by: str = "Type Name", include_categories: List[str] = None ) -> List[QuantityItem]: """Extract quantities grouped by type""" # Filter categories if specified if include_categories and 'Category' in df.columns: df = df[df['Category'].isin(include_categories)] # Group and aggregate quantities = [] for (category, type_name), group in df.groupby(['Category', group_by]): item = QuantityItem( category=str(category), type_name=str(type_name), count=len(group) ) # Extract area area_cols = ['Area', 'Surface Area', 'Gross Area', 'Net Area'] for col in area_cols: if col in group.columns: item.area = group[col].sum() break # Extract volume vol_cols = ['Volume', 'Gross Volume', 'Net Volume'] for col in vol_cols: if col in group.columns: item.volume = group[col].sum() break # Extract length len_cols = ['Length', 'Curve Length', 'Unconnected Height'] for col in len_cols: if col in group.columns: item.length = group[col].sum() break # Extract level if available if 'Level' in group.columns: levels = group['Level'].dropna().unique() item.level = ', '.join(str(l) for l in levels) quantities.append(item) return quantities def extract_by_level( self, df: pd.DataFrame, group_by: str = "Type Name" ) -> Dict[str, List[QuantityItem]]: """Extract quantities grouped by level""" result = {} if 'Level' not in df.columns: result['All Levels'] = self.extract_quantities(df, group_by) return result for level, level_df in df.groupby('Level'): level_name = str(level) if pd.notna(level) else 'Unassigned' result[level_name] = self.extract_quantities(level_df, group_by) return result def calculate_concrete_quantities(self, df: pd.DataFrame) -> dict: """Calculate concrete quantities for typical elements""" concrete_categories = [ 'Floors', 'Structural Floors', 'Walls', 'Structural Walls', 'Structural Foundations', 'Foundation', 'Structural Columns', 'Columns', 'Structural Framing', 'Beams' ] concrete_df = df[df['Category'].isin(concrete_categories)] return { 'total_volume_m3': concrete_df['Volume'].sum() if 'Volume' in concrete_df.columns else 0, 'by_category': concrete_df.groupby('Category')['Volume'].sum().to_dict() if 'Volume' in concrete_df.columns else {}, 'element_count': len(concrete_df) } def calculate_wall_quantities(self, df: pd.DataFrame) -> dict: """Calculate wall quantities""" wall_categories = ['Walls', 'Basic Wall', 'Curtain Wall'] walls = df[df['Category'].isin(wall_categories)] result = { 'total_area_m2': 0, 'total_length_m': 0, 'by_type': {} } if 'Area' in walls.columns: result['total_area_m2'] = walls['Area'].sum() if 'Length' in walls.columns: result['total_length_m'] = walls['Length'].sum() if 'Type Name' in walls.columns: for type_name, group in walls.groupby('Type Name'): result['by_type'][type_name] = { 'count': len(group), 'area': group['Area'].sum() if 'Area' in group.columns else 0, 'length': group['Length'].sum() if 'Length' in group.columns else 0 } return result def generate_qto_report( self, quantities: List[QuantityItem], output_path: str, project_name: str = "Project" ) -> str: """Generate QTO Excel report""" # Convert to DataFrame records = [] for q in quantities: records.append({ 'Category': q.category, 'Type': q.type_name, 'Count': q.count, 'Area (m²)': round(q.area, 2), 'Volume (m³)': round(q.volume, 3), 'Length (m)': round(q.length, 2), 'Level': q.level }) df = pd.DataFrame(records) # Sort by category and type df = df.sort_values(['Category', 'Type']) # Write to Excel with formatting with pd.ExcelWriter(output_path, engine='openpyxl') as writer: # Summary sheet summary = df.groupby('Category').agg({ 'Count': 'sum', 'Area (m²)': 'sum', 'Volume (m³)': 'sum', 'Length (m)': 'sum' }).round(2) summary.to_excel(writer, sheet_name='Summary') # Detail sheet df.to_excel(writer, sheet_name='Detail', index=False) # By Level sheet if 'Level' in df.columns and df['Level'].notna().any(): level_summary = df.groupby(['Level', 'Category']).agg({ 'Count': 'sum', 'Area (m²)': 'sum', 'Volume (m³)': 'sum' }).round(2) level_summary.to_excel(writer, sheet_name='By Level') return output_path def generate_html_report( self, quantities: List[QuantityItem], output_path: str, project_name: str = "Project" ) -> str: """Generate interactive HTML QTO report""" # Group by category by_category = {} for q in quantities: if q.category not in by_category: by_category[q.category] = [] by_category[q.category].append(q) # Calculate totals total_count = sum(q.count for q in quantities) total_area = sum(q.area for q in quantities) total_volume = sum(q.volume for q in quantities) html = f""" <!DOCTYPE html> <html> <head> <title>QTO Report - {project_name}</title> <style> body {{ font-family: Arial, sans-serif; margin: 20px; }} .header {{ background: #2c3e50; color: white; padding: 20px; margin-bottom: 20px; }} .summary {{ display: flex; gap: 20px; margin-bottom: 20px; }} .summary-card {{ background: #ecf0f1; padding: 15px; border-radius: 5px; flex: 1; }} .summary-card h3 {{ margin: 0 0 10px 0; color: #7f8c8d; font-size: 14px; }} .summary-card .value {{ font-size: 24px; font-weight: bold; color: #2c3e50; }} table {{ width: 100%; border-collapse: collapse; margin-bottom: 20px; }} th {{ background: #34495e; color: white; padding: 10px; text-align: left; }} td {{ padding: 8px; border-bottom: 1px solid #ddd; }} tr:hover {{ background: #f5f5f5; }} .category-header {{ background: #3498db; color: white; font-weight: bold; }} .number {{ text-align: right; }} </style> </head> <body> <div class="header"> <h1>Quantity Takeoff Report</h1> <p>Project: {project_name}</p> </div> <div class="summary"> <div class="summary-card"> <h3>Total Elements</h3> <div class="value">{total_count:,}</div> </div> <div class="summary-card"> <h3>Total Area</h3> <div class="value">{total_area:,.2f} m²</div> </div> <div class="summary-card"> <h3>Total Volume</h3> <div class="value">{total_volume:,.3f} m³</div> </div> <div class="summary-card"> <h3>Categories</h3> <div class="value">{len(by_category)}</div> </div> </div> <table> <thead> <tr> <th>Category / Type</th> <th class="number">Count</th> <th class="number">Area (m²)</th> <th class="number">Volume (m³)</th> <th class="number">Length (m)</th> </tr> </thead> <tbody> """ for category, items in sorted(by_category.items()): cat_count = sum(i.count for i in items) cat_area = sum(i.area for i in items) cat_volume = sum(i.volume for i in items) html += f""" <tr class="category-header"> <td>{category}</td> <td class="number">{cat_count:,}</td> <td class="number">{cat_area:,.2f}</td> <td class="number">{cat_volume:,.3f}</td> <td class="number">-</td> </tr> """ for item in sorted(items, key=lambda x: x.type_name): html += f""" <tr> <td>&nbsp;&nbsp;&nbsp;{item.type_name}</td> <td class="number">{item.count:,}</td> <td class="number">{item.area:,.2f}</td> <td class="number">{item.volume:,.3f}</td> <td class="number">{item.length:,.2f}</td> </tr> """ html += """ </tbody> </table> </body> </html> """ with open(output_path, 'w', encoding='utf-8') as f: f.write(html) return output_path # Usage Example def extract_qto_from_model( model_path: str, converter_path: str, output_dir: str = None ) -> dict: """Complete QTO extraction workflow""" from datetime import datetime extractor = BIMQuantityExtractor(converter_path) # Convert model print(f"Converting: {model_path}") xlsx_path = extractor.convert_model(model_path, ["complete", "bbox"]) # Load data print(f"Loading data from: {xlsx_path}") df = extractor.load_bim_data(xlsx_path) # Extract quantities quantities = extractor.extract_quantities(df) # Generate reports output_dir = output_dir or Path(model_path).parent timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") excel_path = Path(output_dir) / f"QTO_{timestamp}.xlsx" html_path = Path(output_dir) / f"QTO_{timestamp}.html" extractor.generate_qto_report(quantities, str(excel_path)) extractor.generate_html_report(quantities, str(html_path)) # Calculate specific quantities concrete = extractor.calculate_concrete_quantities(df) walls = extractor.calculate_wall_quantities(df) return { 'excel_report': str(excel_path), 'html_report': str(html_path), 'summary': { 'total_elements': len(df), 'categories': df['Category'].nunique() if 'Category' in df.columns else 0, 'types': df['Type Name'].nunique() if 'Type Name' in df.columns else 0 }, 'concrete': concrete, 'walls': walls } if __name__ == "__main__": result = extract_qto_from_model( model_path=r"C:\Projects\Building.rvt", converter_path=r"C:\DDC\Converters", output_dir=r"C:\Projects\QTO" ) print(f"Excel: {result['excel_report']}") print(f"HTML: {result['html_report']}") print(f"Concrete Volume: {result['concrete']['total_volume_m3']:.2f} m³") ``` ## n8n Workflow Integration ```yaml name: BIM QTO Extraction trigger: type: webhook path: /qto-extract steps: - convert_model: node: Execute Command command: | "C:\DDC\RvtExporter.exe" "{{$json.model_path}}" complete bbox schedule - load_excel: node: Spreadsheet File operation: read file: "={{$json.model_path.replace('.rvt', '.xlsx')}}" - group_quantities: node: Code code: | const grouped = {}; items.forEach(item => { const type = item.json['Type Name']; if (!grouped[type]) { grouped[type] = { count: 0, area: 0, volume: 0 }; } grouped[type].count++; grouped[type].area += parseFloat(item.json['Area'] || 0); grouped[type].volume += parseFloat(item.json['Volume'] || 0); }); return Object.entries(grouped).map(([type, data]) => ({ type, ...data })); - generate_report: node: Code code: | // Generate HTML report return generateHTMLReport(items); - save_report: node: Write Binary File path: "={{$json.output_path}}" ``` ## Best Practices 1. **Model Quality**: Ensure BIM model has proper levels and types assigned 2. **Units**: Verify model units match expected output units 3. **Categories**: Use consistent category naming for grouping 4. **Updates**: Re-run QTO after design changes 5. **Validation**: Cross-check totals against manual spot checks ## Common Quantity Formulas ```python # Concrete formwork area (approximate) formwork_area = concrete_volume * 6 # m² per m³ of concrete # Rebar quantity (approximate) rebar_weight = concrete_volume * 100 # kg per m³ (typical) # Paint area from wall area paint_area = wall_area * 2 # both sides # Ceiling area from floor area ceiling_area = floor_area * 0.95 # typical ratio ``` --- *"Measure twice, cut once. Or better yet, measure automatically from the model."*

path: claw.json
content: {
  "name": "ifc-qto-extraction",
  "version": "2.0.0",
  "description": "Extract quantities from IFC/Revit models for quantity takeoff. Uses DDC converters to get element counts, areas, volumes, lengths with grouping and reporting.",
  "author": "datadrivenconstruction",
  "license": "MIT",
  "permissions": ["filesystem"],
  "entry": "instructions.md",
  "tags": ["construction", "IFC", "BIM", "quantity-takeoff", "QTO", "Revit", "estimation"],
  "models": ["claude-*", "gpt-*"],
  "minOpenClawVersion": "0.8.0"
}


path: instructions.md
content: You are a BIM quantity takeoff assistant. You extract structured quantity data from BIM models (IFC, Revit) for cost estimation, material ordering, and progress tracking.

When the user asks to extract quantities from a BIM model:
1. Identify the model format (.ifc or .rvt) and conversion method
2. For IFC: use IfcOpenShell to parse elements and extract properties
3. For Revit: use DDC RvtExporter to convert to structured data
4. Extract key quantities: count, area (m2), volume (m3), length (m), weight (kg)
5. Group results by category, type, level, and material
6. Export to Excel or CSV with pivot-ready structure

When the user asks to analyze QTO results:
1. Summarize totals by element category (walls, floors, columns, etc.)
2. Show material breakdown (concrete volume, steel weight, etc.)
3. Compare quantities across building levels
4. Flag elements with missing or zero quantities

## Input Format
- BIM model file path (.ifc or .rvt)
- Optional: specific element categories to extract
- Optional: grouping preferences (by level, category, material)

## Output Format
- QTO table: category, type, level, count, area, volume, length, material
- Summary by category with totals
- Material summary (total concrete, steel, etc.)
- Excel export with multiple sheets (Summary, Detail, By Level, By Material)

## Supported Properties
| Property | Unit | Source |
|----------|------|--------|
| Count | pcs | Element instances |
| Area | m2 | Surface/floor area |
| Volume | m3 | Solid geometry |
| Length | m | Linear elements |
| Weight | kg | Material density x volume |
| Perimeter | m | Floor/wall perimeter |

## Constraints
- Filesystem permission required for reading BIM files and writing exports
- IFC parsing uses IfcOpenShell (Python library, no external services)
- Revit conversion uses DDC RvtExporter CLI tool via subprocess
- Always validate that extracted quantities are non-negative
- Flag elements with no geometry or zero quantities


Security scan verdicts — ClawScan: suspicious | static analysis:  | VirusTotal: suspicious | SkillSpector: suspicious (MEDIUM)