メニュー
Extract quantities from IFC/Revit models for quantity takeoff. Uses DDC converters to get element counts, areas, volumes, lengths with grouping and reporting.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/johnalbertini14-glitch/openclaw-skills --skill ifc-qto-extractionコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SOC 職業分類に基づく
SKILL.md を表示中
| 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. |
Extract structured quantity data from BIM models (IFC, Revit) for cost estimation, material ordering, and progress tracking.
Problem: Manual quantity takeoff is:
Solution: Automated QTO from BIM that:
ROI: 90% reduction in QTO time, near-zero counting errors
┌──────────────────────────────────────────────────────────────────────┐
│ 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 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────┘
# 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
# Extract IFC data
IfcExporter.exe "C:\Models\Building.ifc"
# Output: Building.xlsx with all IFC entities
# Extract DWG blocks and areas
DwgExporter.exe "C:\Drawings\FloorPlan.dwg"
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: , options: [] = ) -> Path:
model = Path(model_path)
options = options [, ]
ext = model.suffix.lower()
converters = {
: ,
: ,
: ,
: ,
:
}
converter = .converter_path / converters.get(ext, )
cmd = [(converter), (model)] + options
result = subprocess.run(cmd, capture_output=, text=)
result.returncode != :
RuntimeError()
xlsx_path = model.with_suffix()
xlsx_path
() -> pd.DataFrame:
xlsx = Path(xlsx_path)
xlsx.exists():
FileNotFoundError()
df = pd.read_excel(xlsx, sheet_name=)
df.columns = df.columns..strip()
df
() -> [QuantityItem]:
include_categories df.columns:
df = df[df[].isin(include_categories)]
quantities = []
(category, type_name), group df.groupby([, group_by]):
item = QuantityItem(
category=(category),
type_name=(type_name),
count=(group)
)
area_cols = [, , , ]
col area_cols:
col group.columns:
item.area = group[col].()
vol_cols = [, , ]
col vol_cols:
col group.columns:
item.volume = group[col].()
len_cols = [, , ]
col len_cols:
col group.columns:
item.length = group[col].()
group.columns:
levels = group[].dropna().unique()
item.level = .join((l) l levels)
quantities.append(item)
quantities
() -> [, [QuantityItem]]:
result = {}
df.columns:
result[] = .extract_quantities(df, group_by)
result
level, level_df df.groupby():
level_name = (level) pd.notna(level)
result[level_name] = .extract_quantities(level_df, group_by)
result
() -> :
concrete_categories = [
, ,
, ,
, ,
, ,
,
]
concrete_df = df[df[].isin(concrete_categories)]
{
: concrete_df[].() concrete_df.columns ,
: concrete_df.groupby()[].().to_dict() concrete_df.columns {},
: (concrete_df)
}
() -> :
wall_categories = [, , ]
walls = df[df[].isin(wall_categories)]
result = {
: ,
: ,
: {}
}
walls.columns:
result[] = walls[].()
walls.columns:
result[] = walls[].()
walls.columns:
type_name, group walls.groupby():
result[][type_name] = {
: (group),
: group[].() group.columns ,
: group[].() group.columns
}
result
() -> :
records = []
q quantities:
records.append({
: q.category,
: q.type_name,
: q.count,
: (q.area, ),
: (q.volume, ),
: (q.length, ),
: q.level
})
df = pd.DataFrame(records)
df = df.sort_values([, ])
pd.ExcelWriter(output_path, engine=) writer:
summary = df.groupby().agg({
: ,
: ,
: ,
:
}).()
summary.to_excel(writer, sheet_name=)
df.to_excel(writer, sheet_name=, index=)
df.columns df[].notna().():
level_summary = df.groupby([, ]).agg({
: ,
: ,
:
}).()
level_summary.to_excel(writer, sheet_name=)
output_path
() -> :
by_category = {}
q quantities:
q.category by_category:
by_category[q.category] = []
by_category[q.category].append(q)
total_count = (q.count q quantities)
total_area = (q.area q quantities)
total_volume = (q.volume q quantities)
html =
category, items (by_category.items()):
cat_count = (i.count i items)
cat_area = (i.area i items)
cat_volume = (i.volume i items)
html +=
item (items, key= x: x.type_name):
html +=
html +=
(output_path, , encoding=) f:
f.write(html)
output_path
() -> :
datetime datetime
extractor = BIMQuantityExtractor(converter_path)
()
xlsx_path = extractor.convert_model(model_path, [, ])
()
df = extractor.load_bim_data(xlsx_path)
quantities = extractor.extract_quantities(df)
output_dir = output_dir Path(model_path).parent
timestamp = datetime.now().strftime()
excel_path = Path(output_dir) /
html_path = Path(output_dir) /
extractor.generate_qto_report(quantities, (excel_path))
extractor.generate_html_report(quantities, (html_path))
concrete = extractor.calculate_concrete_quantities(df)
walls = extractor.calculate_wall_quantities(df)
{
: (excel_path),
: (html_path),
: {
: (df),
: df[].nunique() df.columns ,
: df[].nunique() df.columns
},
: concrete,
: walls
}
__name__ == :
result = extract_qto_from_model(
model_path=,
converter_path=,
output_dir=
)
()
()
()
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]) {
[] {
,
,
}
}
[]
[] []
[] []
}
# 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."