> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# الخرائط الداخلية Indoor Maps: الطوابق وIMDF وOSM
- URL: https://arabroot.io/articles/الخرائط-الداخلية-indoor-maps-الطوابق-و-imdf-و-osm/
- Published: 2026-11-16T23:25:12.000Z
- Updated: 2026-11-17T00:26:51.000Z
- Description: كيف تصف المبنى من الداخل بطوابقه وغرفه وأبوابه بثلاثة نماذج مفتوحة، مع مختبر يحول مبنى جامعياً حقيقياً من OpenStreetMap إلى خريطة بطوابق وأرشيف IMDF يمر من قواعد التحقق.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, الخرائط ونظم المعلومات الجغرافية, تطبيقات لفريقك, السيادة الرقمية والامتثال, الاستضافة الذاتية

عندما تدخل مستشفى كبيراً أو مطاراً أو جامعة لأول مرة، فإن خريطة الهاتف التي أوصلتك إلى الباب تتوقف عند الجدار الخارجي، فهي تعرف المبنى كمضلع رمادي واحد، ولا تعرف أن في داخله ثلاثة طوابق، وأن العيادة التي تبحث عنها في الطابق الثاني بعد المصعد الشرقي. وإذا كنت المطور الذي طلب منه أن يضيف إلى تطبيق المنشأة صفحة «أين أجد القاعة 214؟»، فأول ما يخطر على بالك أن تأخذ ملف PDF لمخطط الطوابق من إدارة المرافق، وتضعه كصورة فوق الخريطة. وهذا الحل يعمل في العرض الأول، ثم يتوقف عند أول سؤال حقيقي: كيف أبحث عن غرفة بالاسم؟ وكيف أرسم مساراً من الباب إلى الغرفة؟ وكيف أعرف أن الدرج في هذا الطابق هو نفسه الدرج في الطابق الذي فوقه؟

والإجابة أن الخريطة الداخلية Indoor Map ليست صورة، وإنما بيانات: طوابق، ومساحات لكل منها نوع واسم، وأبواب تربط المساحات، ووصلات عمودية تربط الطوابق. وفي هذا المقال من مسار الخرائط ننتقل من الخريطة الخارجية التي بنيناها في المراحل السابقة إلى داخل المبنى، وسوف نناقش ما يلي:

- لماذا لا تكفي صورة المخطط، وما الذي يجب أن تصفه أي خريطة داخلية: المبنى والطوابق والمساحات والأبواب والوصلات العمودية.
- ثلاثة نماذج لوصف المبنى نفسه: وسوم OpenStreetMap المسماة Simple Indoor Tagging، وصيغة Apple المعتمدة في OGC باسم IMDF، ومعيار OGC IndoorGML.
- من ينشر الخرائط الداخلية اليوم، ومن يملك بياناتها.
- مختبر على مبنى جامعي حقيقي مرسوم في OpenStreetMap: طلب واحد من Overpass، وملف GeoJSON لكل طابق، وخريطة MapLibre بزر لكل طابق.
- بناء أرشيف IMDF من البيانات نفسها، وفحصه بقواعد التحقق المنشورة في المعيار، من 1,064 مخالفة إلى مخالفة واحدة.
- الصيانة والأمان: الخريطة الداخلية تتغير كل أسبوع، وبعض الغرف لا يجب أن تظهر على أي خريطة.

وتحديد موقع الهاتف داخل المبنى، أي النقطة الزرقاء التي تتحرك على الخريطة، موضوع المقال التالي في هذه المرحلة، لأن الخريطة الداخلية تأتي أولاً: لا فائدة من معرفة موقعك بدقة متر إذا لم تكن هناك خريطة تعرف ماذا يوجد في ذلك المتر.

## لماذا لا تكفي صورة المخطط؟

لنأخذ الحلول بالترتيب الذي يجربه أغلب الفرق. الحل الأول صورة المخطط فوق الخريطة، أي طبقة Raster مثبتة على أربع زوايا، وهي سريعة وتبدو جميلة، ولكنها لا تحتوي على أي معلومة يقرؤها الكود: كلمة «قاعة 214» في الصورة مجموعة بكسلات، فلا بحث ولا مسار ولا تغيير للطابق إلا بتبديل الصورة كلها. والحل الثاني أن يرسم أحد الفريق المساحات كمضلعات في ملف GeoJSON لكل طابق، مع اسم ونوع لكل مضلع، وهذا أفضل بكثير، فالبحث يعمل والتلوين بحسب النوع يعمل. ولكن بعد شهر يظهر السؤال الذي لم يفكر فيه أحد: هل الطابق «1» في ملفنا هو الطابق الأرضي أم الأول فوقه؟ وهل الباب نقطة أم خط؟ وكيف نعرف أن «STAIR 06» في ملف الطابق 0 هو نفسه في ملف الطابق 2؟ وإذا أرادت المنشأة أن تظهر خريطتها في تطبيق Apple Maps، فبأي صيغة ترسلها؟ وكل فريق يجيب عن هذه الأسئلة بطريقته، فتصبح البيانات غير قابلة للنقل.

والحل الثالث، وهو الأنسب، أن تبني البيانات على نموذج معروف يجيب عن هذه الأسئلة مسبقاً، ويأتي معه قواعد تحقق تكشف الأخطاء قبل أن يراها الزائر. وهذا ما تقدمه النماذج الثلاثة التي سوف نشرحها، والفرق بينها في الصيغة ومن يقرؤها، أما المفهوم فواحد.

## ما الذي تحتاج أن تصفه؟

أي خريطة داخلية، مهما كانت صيغتها، تتكون من خمس طبقات من المعلومات فوق بعضها، والصورة التالية تبينها على مبنى من طابقين:

![مخطط لطابقين مرسومين كمستويين فوق بعضهما، في كل منهما غرف ملونة وممر أبيض ونقاط حمراء للأبواب ومربع بنفسجي للدرج، وخط متقطع بنفسجي يربط الدرج STAIR-06 بين الطابقين، وبجانبه خمس بطاقات: المبنى والمكان Venue وBuilding، والطوابق Levels برقم ترتيب واسم يراه الزائر، والمساحات Spaces أو Units مثل الغرفة والممر، والأبواب Openings، والوصلات العمودية مثل الدرج والمصعد](https://arabroot.io/content/images/2026/11/indoor-maps-01-model.webp)

خمس طبقات من المعلومات، والوصلة العمودية هي ما يجعل الطوابق مبنى واحداً

1. **المكان والمبنى Venue وBuilding:** حدود الأرض التي تملكها المنشأة، والمباني عليها. فالمطار مكان واحد فيه عدة مبان، والجامعة كذلك، ولكل مبنى عدد طوابقه وعنوانه.
2. **الطوابق Levels:** لكل طابق مضلع يمثل امتداده، وترتيب رقمي يحدد ما فوق ماذا.
3. **المساحات Spaces:** الغرف والممرات والقاعات ودورات المياه، كل منها مضلع على طابق، ومعه نوعه واسمه أو رقمه.
4. **الأبواب Openings:** أين تستطيع أن تنتقل من مساحة إلى مساحة، أو من الخارج إلى الداخل، ونوع الباب وعرضه، وهل يحتاج بطاقة.
5. **الوصلات العمودية Vertical Connectors:** الدرج والمصعد والسلم المتحرك، وهي التي تربط مساحة في طابق بمساحة في طابق آخر، وبدونها يصبح كل طابق خريطة مستقلة لا يمكن التنقل بينها.

### الطابق: رقم ترتيب واسم على اللافتة

أكثر خطأ يتكرر في الخرائط الداخلية هو الخلط بين ترتيب الطابق واسمه. فالترتيب رقم صحيح يحدد التراكب: 0 للطابق الذي تدخل إليه من الشارع، و1 فوقه، و-1 تحته، أما الاسم فهو ما كتبته المنشأة على اللافتة وزر المصعد: G أو L أو M للميزانين، أو B1 للقبو، أو «الطابق الأول» الذي قد يكون الأرضي في مبنى والذي فوقه في مبنى آخر. ولهذا السبب فإن النماذج الثلاثة تفصل بينهما: في OpenStreetMap الوسم `level` للترتيب و`level:ref` للاسم المكتوب، وفي IMDF الخاصية `ordinal` للترتيب و`name` و`short_name` للاسم. وفي بعض الدول لا يوجد طابق برقم 13 أو 4، وهنا يقترح [توثيق Simple Indoor Tagging](https://wiki.openstreetmap.org/wiki/Simple%5FIndoor%5FTagging?ref=arabroot.io) الوسم `non_existent_levels` على المبنى، حتى لا يظن البرنامج أن طابقاً ناقصاً في البيانات.

والمشكلة الثانية هي الطوابق النصفية، فالميزانين بين الأرضي والأول يكتب في OpenStreetMap عادة `level=0.5`، وقد رأينا في بيانات المختبر قيماً مثل `0.5` و`1.5` في مبان أخرى في المنطقة، أما IMDF فتشترط أن يكون الترتيب عدداً صحيحاً، فيجب أن تقرر عند التحويل: هل الميزانين طابق 1 وتزيد كل ما فوقه برقم؟ أم تدمجه مع الأرضي؟ وهذا قرار يتخذه من يعرف المبنى، لا الكود.

### الوصلات العمودية

الدرج في الواقع شيء واحد يمتد عبر الطوابق، ولكنه في البيانات يرسم عادة كمساحة منفصلة في كل طابق، ثم يربط بينها بطريقة ما. ففي OpenStreetMap يرسم الدرج كمساحة `indoor=room` مع `room=stairs` في كل طابق، والرابط بين الطوابق هو الرقم المرجعي `ref` نفسه، أو مساحة واحدة بقيمة طوابق متعددة مثل `level=0;1;2`. وفي IMDF تكون المساحات وحدات Units بالفئة `stairs` أو `elevator`، والربط بينها بنوع خاص اسمه Relationship. وفي IndoorGML يصبح الدرج حافة في رسم بياني يربط عقدة الطابق الأول بعقدة الطابق الثاني. وأياً كان النموذج، فإن الربط الصريح هو ما يحتاجه محرك المسار ليقول «اصعد بالمصعد الشرقي إلى الطابق 2»، وقد شرحنا خوارزميات المسار على الرسم البياني في [مقال Dijkstra](https://arabroot.io/articles/%D8%AE%D9%88%D8%A7%D8%B1%D8%B2%D9%85%D9%8A%D8%A7%D8%AA-%D8%A7%D9%84%D8%B1%D8%B3%D9%85-%D8%A7%D9%84%D8%A8%D9%8A%D8%A7%D9%86%D9%8A-bfs-%D9%88-dfs-%D9%88-dijkstra/)، وهي نفسها تعمل هنا بعد أن تبني الرسم من الأبواب والوصلات.

## ثلاثة نماذج لوصف المبنى نفسه

الصورة التالية تضع النماذج الثلاثة جنباً إلى جنب، ثم نشرح كل واحد:

![جدول مقارنة بين ثلاثة نماذج: OpenStreetMap Simple Indoor Tagging بوسوم على عناصر OSM مثل level وindoor=room وdoor وhighway=steps، وApple IMDF 1.0 المعتمد في OGC برقم 20-094 كملف ZIP فيه ملفات GeoJSON مثل level وunit وopening، وOGC IndoorGML بنموذج XML في الإصدار 1.1 ونموذج مفاهيمي في 2.0 بمفاهيم CellSpace وCellSpaceBoundary ورسم بياني Node-Relation Graph للملاحة، مع من يستخدم كل نموذج](https://arabroot.io/content/images/2026/11/indoor-maps-02-standards.webp)

المفهوم واحد: مساحات على طوابق تربطها أبواب، والفرق في الصيغة ومن يقرؤها

### OpenStreetMap: وسوم Simple Indoor Tagging

شرحنا OpenStreetMap ورخصتها في [مقال OpenStreetMap](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%8A-openstreetmap-%D8%A7%D9%84%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D8%B1%D8%AE%D8%B5%D8%A9-%D9%88%D8%A7%D9%84%D9%85%D8%B3%D8%A7%D9%87%D9%85%D8%A9/)، وفيها لا توجد طبقة خاصة للداخل، وإنما مجموعة وسوم على العناصر العادية اسمها [Simple Indoor Tagging](https://wiki.openstreetmap.org/wiki/Simple%5FIndoor%5FTagging?ref=arabroot.io)، بدأت في 2014 وما زالت تتطور، والصفحة تذكر ورش عمل لمطابقتها مع احتياجات مستخدمي البيانات في 2022 و2026\. والفكرة أن تبدأ بالبسيط ثم تزيد التفصيل: نقطة لمحل عليها `level=1` تكفي لعرض تقريبي، ثم مضلعات للغرف، ثم الأبواب، ثم الجدران. وأهم الوسوم:

- `min_level` و`max_level` على مضلع المبنى، حتى يعرف البرنامج أن للمبنى بيانات داخلية وكم طابقاً فيها.
- `indoor=room` لغرفة محاطة بجدران، و`indoor=area` لمساحة بلا جدران كاملة، و`indoor=corridor` للممر، و`indoor=level` لحدود الطابق، وكلها تحتاج `level`، والتوثيق يكتب عنه «إلزامي» MANDATORY.
- الوسم `room=*` يحدد نوع الغرفة: office وclassroom وlaboratory وstairs وغيرها، و`name` و`ref` للاسم والرقم.
- الباب نقطة `door=*` على حدود الغرفة، مشتركة بين الغرفتين اللتين يربطهما، والمدخل من الخارج `entrance=*`.

ونقطة القوة هنا أن البيانات مفتوحة برخصة ODbL، وأن أي شخص يستطيع أن يضيف ويصحح، ونقطة الضعف أن التغطية قليلة جداً ومتفاوتة، وأن الوسوم حرة، فقد تجد مبنى يستخدم `indoor=yes` على ممرات خارجية مسقوفة، وآخر يرسم الغرف بدقة البناء، كما سوف نرى في المختبر.

### Apple IMDF: صيغة التسليم

صيغة IMDF واختصارها Indoor Mapping Data Format طورتها Apple لبرنامج الخرائط الداخلية لديها، ثم اعتمدتها OGC كمعيار مجتمعي Community Standard برقم [20-094](https://docs.ogc.org/cs/20-094/index.html?ref=arabroot.io) في فبراير 2021، والإصدار المعتمد هو 1.0.0\. والمعيار يقول إنه يتوافق مع GeoJSON بحسب RFC 7946، وإنه يصف الحالة المتوقعة للأرشيف عند تسليمه، لا طريقة إنتاج البيانات. وأهم ما فيه بحسب صفحة [المرجع](https://docs.ogc.org/cs/20-094/Reference/index.html?ref=arabroot.io):

- البيانات تسلم كملف ZIP، فيه ملف `manifest.json` بالإصدار وتاريخ الإنشاء واللغة الافتراضية، وملف GeoJSON لكل نوع من الأنواع: `venue` و`building` و`footprint` و`level` و`unit` و`opening` و`address` وغيرها.
- كل عنصر له معرف من نوع UUID بالإصدار 4، ويجب أن يبقى المعرف نفسه للعنصر نفسه في كل تسليم، وهذه نقطة سوف نعود إليها في المختبر.
- المبنى Building ليس له شكل، والخاصية `geometry` فيه يجب أن تكون `null`، أما شكله على الأرض فهو Footprint منفصل، ويمكن أن يكون للمبنى أكثر من Footprint: أرضي ground، وجوي aerial، وتحت الأرض subterranean.
- الطابق Level له `ordinal` عدد صحيح، والوحدة Unit مضلع على طابق بفئة من قائمة محددة، والباب Opening خط LineString لا نقطة، طوله هو عرض المدخل.
- كل الفئات من قوائم مغلقة في صفحة [الفئات Categories](https://docs.ogc.org/cs/20-094/Categories/index.html?ref=arabroot.io): للوحدة مثلاً `office` و`classroom` و`laboratory` و`walkway` و`stairs` و`restroom.female`، وأي قيمة خارجها مرفوضة.

وأهم ما يميز IMDF عن غيرها صفحة [التحقق Validations](https://docs.ogc.org/cs/20-094/Validations/index.html?ref=arabroot.io)، وهي قائمة بمئات القواعد بأسماء ثابتة، لكل قاعدة شدة: مخالفة VIOLATION تمنع قبول الأرشيف، أو تحذير WARNING، أو معلومة INFO. فمثلاً `UnitMustBeCoveredByReferencedLevel` مخالفة إذا خرجت غرفة عن حدود طابقها، و`OpeningIsSuspiciouslySmall` تحذير إذا كان الباب أضيق من 0.8382 متر. وهذه القائمة هي التي سوف نطبق جزءاً منها في المختبر.

### OGC IndoorGML: نموذج للملاحة

معيار [IndoorGML](https://www.ogc.org/standards/indoorgml/?ref=arabroot.io) من OGC يأتي من زاوية مختلفة: هدفه الأول الملاحة لا العرض. والإصدار [1.1](https://docs.ogc.org/is/19-011r4/19-011r4.html?ref=arabroot.io) مبني على GML بصيغة XML، وفي 2.0 نشرت OGC النموذج المفاهيمي في جزء أول مستقل عن الصيغة. والفكرة الأساسية فيه أن المساحة الداخلية خلايا CellSpace بينها حدود CellSpaceBoundary، ثم يحول المعيار هذه الخلايا إلى رسم بياني يسميه Node-Relation Graph، كل خلية فيه عقدة، وكل باب أو اتصال حافة، بتحويل رياضي يذكره المعيار باسم Poincaré Duality. وفيه أيضاً نموذج الطبقات المتعددة Multi-Layered Space Model، فيمكن أن يكون للمبنى نفسه طبقة للغرف، وطبقة لمناطق تغطية Wi-Fi، وطبقة لمناطق الأمن، مع روابط بين الطبقات، وهذا مفيد عندما تريد أن تقول «هذه الغرفة داخل منطقة الأمن B وتغطيها نقطة الوصول 3».

ومن التفاصيل التي يناقشها المعيار ولا تظهر في غيره نموذج الجدار الرقيق Thin Wall والجدار السميك Thick Wall: هل الجدار مجرد خط بين غرفتين، أم مساحة لها سمك والباب خلية داخله؟ وهذا يغير الرسم البياني للملاحة. ونقطة القوة في IndoorGML الدقة في التعامل مع الملاحة والربط مع نماذج البناء BIM وIFC، ونقطة الضعف أن أدوات العرض الشائعة لا تقرؤه مباشرة، فستحتاج غالباً أن تحوله إلى GeoJSON أو IMDF للعرض في التطبيق.

## من ينشر الخرائط الداخلية؟

السؤال الذي يطرحه كل من يبدأ: هل توجد خريطة داخلية لمبنانا في Google أو Apple؟ والإجابة من الصفحات الرسمية:

- **Apple:** برنامج [Indoor Maps Program](https://register.apple.com/indoor?ref=arabroot.io) مفتوح لمالكي ومشغلي المنشآت الكبيرة، والصفحة تذكر المطارات والمجمعات التجارية والملاعب والمستشفيات والجامعات والمباني المكتبية. والبيانات تسلم بصيغة IMDF، وتحديد الموقع في الداخل يعتمد على شبكة Wi-Fi الموجودة بعد مسح للإشارات بتطبيق Indoor Survey، والصفحة تقول إن Apple لا تأخذ رسوماً للتسجيل أو للصيغة أو لخدمة تحديد الموقع. ويمكن عرض ملفات IMDF في تطبيقك عبر [MapKit](https://developer.apple.com/documentation/mapkit/displaying-an-indoor-map?ref=arabroot.io).
- **Google:** صفحة [Indoor Maps availability](https://support.google.com/maps/answer/1685827?hl=en&ref=arabroot.io) تقول إن الخرائط الداخلية متاحة في مواقع مختارة، وتسرد الدول، ومنها الإمارات العربية المتحدة والأردن ولبنان، وعند كتابة هذا المقال لم تكن المملكة في القائمة. ولا توجد في الصفحة طريقة لرفع مخطط مبناك بنفسك.
- **مالك المبنى:** هو المصدر الحقيقي للبيانات في كل الحالات، لأن المخططات المعمارية بصيغة CAD أو نموذج BIM عنده، ومنها تبنى الخرائط عادة بأدوات تحويل، وهو من يعرف أسماء الغرف ومن يشغلها وما الممنوع على الزوار.
- **OpenStreetMap:** مساهمون يرسمون المباني العامة بأنفسهم، والتغطية قليلة ولكنها مفتوحة، وهي ما سوف نستخدمه في المختبر لأنه المصدر الوحيد الذي نستطيع أن نعرضه هنا برخصة واضحة.

والنتيجة العملية: إذا كنت تبني تطبيقاً لمنشأتك، فالبيانات ستأتي من مخططاتها، والنموذج الذي تختاره يحدد أين تستطيع أن ترسلها بعد ذلك. وإذا بنيتها بصيغة IMDF من البداية، فهي جاهزة لبرنامج Apple، وتعرض في MapLibre أو أي مكتبة تقرأ GeoJSON، وتحول إلى غيرها بسكربت.

## التجربة العملية

نأخذ في المختبر مبنى حقيقياً مرسوماً بالتفصيل في OpenStreetMap، ونمر بالخطوات التي يمر بها أي مشروع خريطة داخلية: جلب البيانات، وتقسيمها إلى طوابق، وعرضها، ثم تحويلها إلى IMDF وفحصها. والصورة التالية تلخص المسار بالأرقام التي سوف نراها:

![مخطط من خمس خطوات: Overpass أعاد 3363 عنصراً في طلب واحد، ثم ملف GeoJSON لكل طابق من الطوابق 0 و1 و2 فيها 421 غرفة و494 باباً، ثم أرشيف IMDF فيه 504 وحدات و494 باباً بحجم 69.6 كيلوبايت، ثم التحقق من 1064 مخالفة إلى مخالفة واحدة، ثم خريطة MapLibre بثلاثة طوابق وزر لكل طابق. وتحتها بطاقتان: ما وجدناه في بيانات OSM مثل أبواب وغرف بلا وسم level وغرفة ودرج غير مغلقين و225 غرفة في الطابق 2 منها 70 فقط لها اسم، وما احتاج قراراً مثل نوع كل غرفة وعرض الباب والمعرف الثابت](https://arabroot.io/content/images/2026/11/indoor-maps-05-pipeline.webp)

المختبر من أوله إلى آخره، وكل رقم من مخرج حقيقي

### اختيار المبنى

قبل أن نختار، أردنا أن نعرف أين توجد بيانات داخلية في منطقتنا، فطلبنا من Overpass كل الخطوط التي عليها الوسم `indoor` في مستطيلين يغطيان أغلب المملكة والإمارات وقطر، وجمعناها بحسب الموقع. ووجدنا 3,077 عنصراً، أكبر مجموعة منها، 716 عنصراً، في مجمع تجاري كبير في دبي، ولكنها كلها `indoor=yes` على ممرات مشاة مسقوفة، بلا غرفة واحدة. أما الغرف الحقيقية `indoor=room` مع الممرات وحدود الطوابق فكانت أكثر في مبنى جامعي واحد: «Engeineering and Science Building» في الإمارات، وهو [الخط 867826047](https://www.openstreetmap.org/way/867826047?ref=arabroot.io) في OpenStreetMap، بثلاثة طوابق ومئات الغرف المسماة. ولاحظ الخطأ الإملائي في الاسم الإنجليزي، فهكذا هو في البيانات، ولم نصححه لأننا نعرض ما في المصدر. وهذه الخطوة نفسها درس: معظم ما يحمل الوسم `indoor` في أي منطقة ليس خرائط داخلية بالمعنى الذي نريده، فلا تحكم على التغطية بعدد الوسوم.

### التجهيز وجلب البيانات

نستخدم الـ Image نفسها التي بنيناها لمقال GeoPandas، وهو الملف `lab/Dockerfile`، وفيها Python وShapely وpyproj وcurl:

```dockerfile
FROM python:3.13-slim
RUN apt-get update && apt-get install -y --no-install-recommends osmium-tool gdal-bin postgresql-client curl \
 && rm -rf /var/lib/apt/lists/*
RUN pip install --no-cache-dir geopandas shapely pyproj pyogrio matplotlib arabic-reshaper python-bidi psycopg[binary]
WORKDIR /work
```

```bash
mkdir -p im-lab && cd im-lab     # the lab/ files of this article
docker build -t lab-im .
docker volume create lab-im-data
alias im='docker run --rm -v lab-im-data:/data -v "$PWD:/lab:ro" -w /data lab-im'
```

ثم نطلب كل ما داخل مستطيل المبنى من [Overpass API](https://wiki.openstreetmap.org/wiki/Overpass%5FAPI?ref=arabroot.io) في طلب واحد، والاستعلام في الملف `lab/query.overpassql`:

```text
[out:json][timeout:60];
// everything inside the building's bounding box, plus the ways and relations that use those nodes
(nwr(25.3110,55.4888,25.3137,55.4916);)->.a;
(.a;<;);
out geom;
```

والسطر `(.a;<;);` يضيف إلى العناصر داخل المستطيل الخطوط والعلاقات التي تستخدم نقاطها، حتى لا تصلنا غرفة نصفها خارج المستطيل مقطوعة. و`out geom` يضع الإحداثيات داخل كل خط مباشرة، فلا نحتاج أن نجمع النقاط بأنفسنا. والطلب في الملف `lab/01-fetch.sh`:

```bash
#!/bin/sh
# One Overpass request for one building; a generic User-Agent and no loops.
set -e
curl -fsS -m 120 -A "indoor-lab/1.0" --data-urlencode data@/lab/query.overpassql \
  https://overpass-api.de/api/interpreter -o /data/raw.json
python3 -c "import json; d=json.load(open('/data/raw.json')); print(d['osm3s']['timestamp_osm_base'], len(d['elements']), 'elements')"
```

```bash
im sh /lab/01-fetch.sh
```

```text
2026-11-16T22:56:21Z 3363 elements
```

أي 3,363 عنصراً في ملف حجمه 944 كيلوبايت، وتاريخ البيانات في الخادم 16 نوفمبر 2026\. وفي أول محاولة لنا في اليوم نفسه، لطلب عد بسيط، أعاد الخادم صفحة نصية بدل JSON تقول إن الخادم «at capacity» وإن كل العمال مشغولون، وتطلب إعادة المحاولة بفترات انتظار تتضاعف، وتنصح من يريد استخداماً آلياً كثيراً أن يشغل نسخة خاصة. وهذا سبب الخيار `-f` في curl، فهو يجعل الأمر يفشل برمز خطأ بدل أن يحفظ صفحة الخطأ في `raw.json` ويكمل السكربت عليها. و[توثيق Overpass](https://dev.overpass-api.de/overpass-doc/en/preface/commons.html?ref=arabroot.io) يطلب أن يبقى الاستخدام في حدود 10,000 طلب و1 غيغابايت في اليوم تقريباً، وطلب واحد لمبنى واحد بعيد جداً عن ذلك، ولكن لا تضع هذا الطلب في حلقة على مئات المباني، فلذلك نسخة محلية أو ملف Geofabrik.

### من عناصر OSM إلى ملف لكل طابق

الآن نحول العناصر إلى أشكال، ونصنف كل واحد: غرفة أو ممر أو مساحة أو درج أو مصعد أو باب، ونضعه في ملف طابقه، وهو الملف `lab/02_levels.py`:

```python
# From the Overpass answer to one GeoJSON file per level, following Simple Indoor Tagging.
import json
import re
from collections import Counter, defaultdict
from shapely.geometry import Point, Polygon, LineString, mapping

raw = json.load(open("/data/raw.json", encoding="utf-8"))["elements"]
BUILDING_WAY = 867826047          # building=university, min_level=0, max_level=2

def levels(value):
    """'0' -> [0], '0;1' -> [0, 1], '0-2' (a range) -> [0, 1, 2]. Half levels such as 0.5 stay floats."""
    out = []
    for part in str(value).split(";"):
        part = part.strip()
        m = re.fullmatch(r"(-?\d+)-(-?\d+)", part)
        if m:
            out += list(range(int(m[1]), int(m[2]) + 1))
        elif part:
            out.append(float(part) if "." in part else int(part))
    return out

def kind(t):
    if t.get("highway") == "elevator" or t.get("room") == "elevator": return "elevator"
    if t.get("highway") == "steps" or t.get("room") == "stairs": return "stairs"
    if t.get("indoor") == "corridor": return "corridor"
    if t.get("indoor") == "room": return "room"
    if t.get("indoor") == "area": return "area"
    if t.get("indoor") == "level": return "level"
    return None

per_level = defaultdict(list)
problems = Counter()
building = None
for e in raw:
    t = e.get("tags", {})
    if e["type"] == "way" and e["id"] == BUILDING_WAY:
        building = Polygon([(p["lon"], p["lat"]) for p in e["geometry"]])
        print("building:", t.get("name"), "| levels", t.get("min_level"), "to", t.get("max_level"))
    k = kind(t) if e["type"] == "way" else None
    if e["type"] == "node" and "door" in t:
        k = "door"
    if not k:
        continue
    if "level" not in t:
        problems[f"{k} without level"] += 1
        continue
    if k == "door":
        geom = Point(e["lon"], e["lat"])
    else:
        coords = [(p["lon"], p["lat"]) for p in e["geometry"]]
        if coords[0] != coords[-1]:
            problems[f"{k} not closed (way {e['id']})"] += 1
            continue
        geom = Polygon(coords)
        if not geom.is_valid:
            problems[f"{k} invalid polygon (way {e['id']})"] += 1
    for lv in levels(t["level"]):
        per_level[lv].append({"type": "Feature", "id": f"{e['type']}/{e['id']}", "geometry": mapping(geom),
                              "properties": {"kind": k, "level": lv, "name": t.get("name"), "ref": t.get("ref"),
                                             "room": t.get("room"), "door": t.get("door"), "amenity": t.get("amenity")}})

for lv in sorted(per_level):
    feats = per_level[lv]
    c = Counter(f["properties"]["kind"] for f in feats)
    named = sum(1 for f in feats if f["properties"]["kind"] == "room" and f["properties"]["name"])
    print(f"level {lv}: " + ", ".join(f"{k} {n}" for k, n in sorted(c.items())) + f" | named rooms {named}")
    json.dump({"type": "FeatureCollection", "features": feats},
              open(f"/data/level_{lv}.geojson", "w", encoding="utf-8"), ensure_ascii=False)
json.dump({"type": "Feature", "geometry": mapping(building), "properties": {}},
          open("/data/building.geojson", "w", encoding="utf-8"))
for p, n in problems.items():
    print("problem:", p, n)
```

```bash
im python /lab/02_levels.py
```

```text
building: Engeineering and Science Building | levels 0 to 2
level 0: area 1, corridor 12, door 149, elevator 3, level 1, room 107, stairs 8 | named rooms 105
level 1: corridor 10, door 119, elevator 3, level 1, room 89, stairs 9 | named rooms 89
level 2: area 2, corridor 25, door 226, elevator 3, level 1, room 225, stairs 7 | named rooms 70
problem: door without level 3
problem: room not closed (way 874285713) 1
problem: stairs not closed (way 874285802) 1
problem: room without level 2
```

في المخرج أعلاه لاحظ التالي:

- المبنى يعلن `min_level=0` و`max_level=2`، وهذا ما وجدناه فعلاً: ثلاثة طوابق، لكل منها مضلع `indoor=level`.
- الطابق 2 فيه 225 غرفة، أكثر من ضعف الطابق 0، و70 منها فقط لها اسم، فالطابق مكاتب صغيرة متشابهة رسمها المساهم دون أسماء، بينما الطابق 0 مختبرات وقاعات كل منها مسمى. وهذا يعني أن البحث بالاسم سيجد أغلب غرف الطابق 0 ونحو ثلث غرف الطابق 2 فقط.
- في كل طابق 3 مصاعد، والدرج بين 7 و9 لأن بعض الدرجات تصل طابقين فقط.
- 494 باباً، كل منها نقطة على حدود غرفة، وهذا ما سوف نحوله إلى خطوط في IMDF.
- الأسطر الأخيرة مشكلات حقيقية في البيانات: 3 أبواب وغرفتان بلا وسم `level`، فلا نعرف في أي طابق هي، وغرفة ودرج رسما كخطين مفتوحين لا مضلعين مغلقين. والسكربت لا يخمن، وإنما يستبعد ويطبع السبب، حتى يصلحها أحد في المصدر.

وفي أول تشغيل توقف السكربت بخطأ `ValueError: invalid literal for int() with base 10: '0-1'`، لأن عنصراً في البيانات كتب طابقه كمدى `0-1`، وهي صيغة مقبولة في OpenStreetMap تعني من الطابق 0 إلى 1، وكانت الدالة الأولى تتوقع رقماً أو أرقاماً مفصولة بفاصلة منقوطة فقط. والحل التعبير النمطي الذي تراه في الدالة `levels`، وهذه من الحالات التي تتعلمها من البيانات لا من التوثيق، فاكتب دوال القراءة بحيث تفشل بوضوح عند قيمة لا تفهمها، ولا تتجاهلها.

### الطوابق في MapLibre

للعرض نستخدم [MapLibre GL JS](https://maplibre.org/maplibre-gl-js/docs/?ref=arabroot.io)، وقد شرحنا تشغيلها مع خريطة أساس على سيرفرك في [مقال الخرائط على سيرفرك](https://arabroot.io/articles/%D8%AE%D8%B1%D8%A7%D8%A6%D8%B7%D9%83-%D8%B9%D9%84%D9%89-%D8%B3%D9%8A%D8%B1%D9%81%D8%B1%D9%83-%D9%85%D8%B9-openstreetmap-%D9%88-maplibre/). والفكرة هنا أبسط: مصدر GeoJSON واحد للطابق المعروض، وعند الضغط على زر طابق نستبدل بياناته بـ `setData`، والطبقات نفسها تبقى، وهو الملف `lab/floors.html`:

```html
<!doctype html>
<html lang="ar" dir="rtl">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>طوابق المبنى</title>
<link rel="stylesheet" href="maplibre-gl.css">
<style>
html, body, #map { margin: 0; height: 100%; background: #F4F1EC; }
#levels { position: absolute; top: 16px; right: 16px; display: flex; flex-direction: column; gap: 6px; z-index: 2; }
#levels button { font: 600 16px "Segoe UI", Tahoma, sans-serif; width: 116px; padding: 9px 0; border: 1px solid #C9CDD5;
  border-radius: 10px; background: #fff; cursor: pointer; }
#levels button.on { background: #E95420; color: #fff; border-color: #E95420; }
#legend { position: absolute; bottom: 16px; right: 16px; background: #fff; padding: 10px 14px; border-radius: 10px; z-index: 2;
  font: 500 14px "Segoe UI", Tahoma, sans-serif; line-height: 1.9; box-shadow: 0 2px 10px rgba(0,0,0,.12); }
#legend i { display: inline-block; width: 13px; height: 13px; border-radius: 3px; margin-left: 8px; vertical-align: -2px; }
</style>
</head>
<body>
<div id="map"></div>
<div id="levels"></div>
<div id="legend">
  <div><i style="background:#F7D9A8"></i>مكتب office</div>
  <div><i style="background:#B9D7F2"></i>مختبر أو قاعة دراسية</div>
  <div><i style="background:#FFFFFF;border:1px solid #9AA0AA"></i>ممر corridor</div>
  <div><i style="background:#8E6BBE"></i>درج stairs ومصعد elevator</div>
  <div><i style="background:#D9D4CC"></i>غرف أخرى</div>
  <div><i style="background:#C62828;border-radius:50%"></i>باب door</div>
</div>
<script type="module">
import * as maplibregl from './maplibre-gl.mjs';
const LEVELS = [0, 1, 2];
const data = {};
for (const lv of LEVELS) data[lv] = await (await fetch(`data/level_${lv}.geojson`)).json();
const building = await (await fetch('data/building.geojson')).json();

const map = window.map = new maplibregl.Map({
  container: 'map', center: [55.49019, 25.31237], zoom: 18.6, bearing: 0, attributionControl: { compact: false },
  style: { version: 8, glyphs: 'https://demotiles.maplibre.org/font/{fontstack}/{range}.pbf',
           sources: {}, layers: [{ id: 'bg', type: 'background', paint: { 'background-color': '#F4F1EC' } }] },
});
map.on('load', () => {
  map.addSource('building', { type: 'geojson', data: building, attribution: '© OpenStreetMap contributors (ODbL)' });
  map.addSource('floor', { type: 'geojson', data: data[0] });
  map.addLayer({ id: 'building', type: 'fill', source: 'building', paint: { 'fill-color': '#ECE8E1', 'fill-outline-color': '#5F6470' } });
  const area = ['in', ['get', 'kind'], ['literal', ['room', 'corridor', 'area', 'stairs', 'elevator']]];
  map.addLayer({ id: 'spaces', type: 'fill', source: 'floor', filter: area, paint: {
    'fill-color': ['match', ['get', 'kind'], 'corridor', '#FFFFFF', 'area', '#FFFFFF', 'stairs', '#8E6BBE', 'elevator', '#8E6BBE',
      ['match', ['get', 'room'], 'office', '#F7D9A8', ['laboratory', 'classroom', 'auditorium'], '#B9D7F2', '#D9D4CC']] } });
  map.addLayer({ id: 'walls', type: 'line', source: 'floor', filter: area, paint: { 'line-color': '#4A4E57', 'line-width': 1.2 } });
  map.addLayer({ id: 'doors', type: 'circle', source: 'floor', filter: ['==', ['get', 'kind'], 'door'],
    paint: { 'circle-radius': 3, 'circle-color': '#C62828', 'circle-stroke-color': '#fff', 'circle-stroke-width': 1 } });
  map.addLayer({ id: 'labels', type: 'symbol', source: 'floor', filter: ['all', area, ['has', 'name']],
    layout: { 'text-field': ['coalesce', ['get', 'ref'], ['get', 'name']], 'text-font': ['Open Sans Semibold'], 'text-size': 10,
              'text-max-width': 7 },
    paint: { 'text-color': '#17111A', 'text-halo-color': 'rgba(255,255,255,.8)', 'text-halo-width': 1 } });
  const box = document.getElementById('levels');
  for (const lv of [...LEVELS].reverse()) {
    const b = document.createElement('button');
    b.textContent = `الطابق ${lv}`; b.dataset.level = lv;
    b.onclick = () => window.showLevel(lv);
    box.appendChild(b);
  }
  window.showLevel = (lv) => {
    map.getSource('floor').setData(data[lv]);
    for (const b of box.children) b.classList.toggle('on', +b.dataset.level === lv);
  };
  window.showLevel(0);
  map.once('idle', () => { window.ready = true; });
});
</script>
</body>
</html>
```

في الملف أعلاه لاحظ التالي:

- لا توجد خريطة أساس، فالخلفية لون واحد ومضلع المبنى، لأن الخريطة الداخلية لا تحتاج الشوارع، وإذا أردتها فأضف مصدر مربعاتك من سيرفرك تحت طبقة المبنى.
- تلوين الغرف بالتعبير `match` على الخاصية `room`، فالمكاتب لون والمختبرات والقاعات لون، والممرات بيضاء، والدرج والمصاعد بنفسجي.
- العناوين تأخذ `ref` أولاً ثم `name` بالتعبير `coalesce`، والخطوط من خادم الخطوط التجريبي لـ MapLibre، وفي الإنتاج ضع ملفات الخطوط على سيرفرك.
- الأزرار مرتبة من الأعلى إلى الأسفل كأزرار المصعد، وهذه عادة واجهات الخرائط الداخلية، فالطابق الأعلى في الأعلى.

والصفحة تحتاج سيرفر ملفات، لأن المتصفح لا يحمل وحدات JavaScript من `file://`، ونحتاج أن نضع بجانبها ملفات MapLibre 6.13.0 وملفات الطوابق:

```bash
mkdir -p web/data
for f in maplibre-gl.mjs maplibre-gl-worker.mjs maplibre-gl.css; do
  curl -fsSLo web/$f https://unpkg.com/maplibre-gl@6.13.0/dist/$f; done
cp floors.html web/
docker run --rm -v lab-im-data:/data -v "$PWD/web/data:/out" lab-im sh -c 'cp /data/level_*.geojson /data/building.geojson /out/'
node serve.mjs web 8080
```

وفي أول تجربة استخدمنا `python -m http.server`، فظهرت صفحة فارغة تماماً بلا أي رسالة في الصفحة نفسها. والسبب أن Python على Windows يأخذ أنواع الملفات من إعدادات النظام، فأرسل الملف `maplibre-gl.mjs` بالنوع `text/plain`، والمتصفح يرفض تشغيل وحدة JavaScript بنوع غير JavaScript، ويكتب السبب في الـ Console فقط. لذلك كتبنا سيرفراً صغيراً يحدد الأنواع بنفسه، وهو الملف `lab/serve.mjs`:

```javascript
// A static server for floors.html with the MIME types module scripts need: node serve.mjs [folder] [port]
import { createServer } from 'node:http';
import { readFileSync } from 'node:fs';
import { extname, join } from 'node:path';

const root = process.argv[2] || '.';
const port = Number(process.argv[3] || 8080);
const TYPES = { '.html': 'text/html; charset=utf-8', '.mjs': 'text/javascript', '.js': 'text/javascript',
                '.css': 'text/css', '.geojson': 'application/geo+json' };
createServer((req, res) => {
  try {
    let path = decodeURIComponent(req.url.split('?')[0]);
    if (path === '/') path = '/floors.html';
    const body = readFileSync(join(root, path));
    res.writeHead(200, { 'content-type': TYPES[extname(path)] || 'application/octet-stream' });
    res.end(body);
  } catch { res.writeHead(404); res.end(); }
}).listen(port, '127.0.0.1', () => console.log(`http://127.0.0.1:${port}/`));
```

ثم فتحنا الصفحة في Chrome بلا واجهة Headless وأخذنا لقطة لكل طابق، وهذا الطابق 0:

![لقطة حقيقية من صفحة MapLibre للطابق 0 من المبنى الجامعي: مستطيل مائل فيه مختبرات زرقاء كثيرة بأسماء مثل MATERIAL SCIENCE وFLUIDS MECHANICS وPOWER SYSTEM LAB، وممر أبيض طويل في الوسط وممرات فرعية، ودرج بنفسجي في الأطراف بأسماء STAIR 04 وSTAIR 05 وSTAIR 06، ومداخل ENTRANCE LOBBY، ونقاط حمراء للأبواب على حدود الغرف، وأزرار الطوابق 2 و1 و0 في الأعلى والطابق 0 مفعل، ودليل الألوان بالعربية في الأسفل](https://arabroot.io/content/images/2026/11/indoor-maps-03-level-0.webp)

الطابق 0: مختبرات وقاعات، وكل غرفة تقريباً لها اسم

وهذا الطابق 2 بعد الضغط على زره، ولاحظ الفرق في التقسيم والألوان:

![لقطة حقيقية للطابق 2 من المبنى نفسه: صفوف من المكاتب الصغيرة البرتقالية الفاتحة على طول الجدران وحول ممرات بيضاء متوازية، وغرف رمادية كبيرة في الوسط، ودرج بنفسجي في الزوايا، وأسماء قليلة مثل DEAN'S OFFICE وMEETING ROOM وADMIN ASSISTANT، وعلى الجانب الأيسر غرف تخرج قليلاً عن حدود المبنى الرمادية، وزر الطابق 2 مفعل](https://arabroot.io/content/images/2026/11/indoor-maps-04-level-2.webp)

الطابق 2: مكاتب كثيرة أغلبها بلا اسم، وبعضها يخرج عن حدود المبنى

وإذا نظرت إلى الجانب الأيسر من صورة الطابق 2 فستجد صفاً من المكاتب يخرج قليلاً عن حدود المبنى الرمادية، وهذا ليس خطأ في الرسم عندنا، وإنما في البيانات، وسوف يكشفه التحقق بالرقم بعد قليل. وهنا فائدة العرض قبل التحقق: العين تلتقط ما لم تكتب له قاعدة.

### بناء أرشيف IMDF

الآن نحول الملفات نفسها إلى أرشيف IMDF، وهذا هو الجزء الذي يحتاج قرارات، والملف `lab/03_imdf.py`:

```python
# Build an IMDF-shaped archive (OGC 20-094, IMDF 1.0.0) from the per-level GeoJSON files.
#   python 03_imdf.py            first attempt: OSM ids as feature ids
#   python 03_imdf.py --uuid     stable version-4 UUIDs derived from the OSM ids
#   python 03_imdf.py --uuid --fixes   plus the fixes the validator asked for (category, door width, level extent)
import glob, hashlib, json, os, sys, uuid, zipfile
from datetime import datetime, timezone
from shapely.geometry import shape, mapping, LineString, Point
from shapely.ops import nearest_points, unary_union
from pyproj import Geod, Transformer

USE_UUID = "--uuid" in sys.argv
FIXES = "--fixes" in sys.argv
OUT = "/data/imdf"
os.makedirs(OUT, exist_ok=True)
geod = Geod(ellps="WGS84")
to_m = Transformer.from_crs(4326, 32640, always_xy=True)
to_deg = Transformer.from_crs(32640, 4326, always_xy=True)

def fid(key):
    """Same OSM element -> same id in every delivery (IMDF asks ids to be kept across deliveries)."""
    if not USE_UUID:
        return key
    return str(uuid.UUID(bytes=hashlib.sha1(key.encode()).digest()[:16], version=4))

UNIT_CATEGORY = {"office": "office", "store": "storage", "laboratory": "laboratory", "classroom": "classroom",
                 "lobby": "lobby", "auditorium": "auditorium", "kitchen": "kitchen", "lounge": "lounge",
                 "entrance": "foyer", "toilets": "restroom", "stairs": "stairs", "elevator": "elevator",
                 "corridor": "walkway"}
if FIXES:
    UNIT_CATEGORY["entrance"] = "lobby"           # "foyer" is not in the IMDF unit categories

def unit_category(p):
    if p["kind"] in ("stairs", "elevator", "corridor"):
        return UNIT_CATEGORY[p["kind"]]
    if p.get("amenity") == "toilets":
        return "restroom"
    return UNIT_CATEGORY.get(p.get("room") or "", "room")

def label(text):
    return {"en": text} if text else None

def fc(features):
    return {"type": "FeatureCollection", "features": features}

building_poly = shape(json.load(open("/data/building.geojson"))["geometry"])
files = sorted(glob.glob("/data/level_*.geojson"), key=lambda f: float(f.split("_")[1][:-8]))

address_id, venue_id, building_id, footprint_id = fid("address/1"), fid("venue/1"), fid("building/867826047"), fid("footprint/867826047")
levels, units, openings, everything = [], [], [], [building_poly]
for f in files:
    feats = json.load(open(f, encoding="utf-8"))["features"]
    ordinal = feats[0]["properties"]["level"]
    if not isinstance(ordinal, int):
        continue                                   # IMDF ordinals are integers; half levels need a decision
    outline = [x for x in feats if x["properties"]["kind"] == "level"]
    level_geom = shape(outline[0]["geometry"]) if outline else building_poly
    level_id = fid(outline[0]["id"] if outline else f"level/{ordinal}")
    levels.append({"type": "Feature", "id": level_id, "feature_type": "level", "geometry": mapping(level_geom),
                   "properties": {"category": "unspecified", "restriction": None, "outdoor": False, "ordinal": ordinal,
                                  "name": label(f"Level {ordinal}"), "short_name": label(str(ordinal)),
                                  "display_point": None, "address_id": None, "building_ids": [building_id]}})
    rooms = []
    for x in feats:
        p = x["properties"]
        if p["kind"] in ("room", "corridor", "area", "stairs", "elevator"):
            g = shape(x["geometry"])
            rooms.append(g)
            units.append({"type": "Feature", "id": fid(f"{x['id']}@{ordinal}"), "feature_type": "unit",
                          "geometry": mapping(g),
                          "properties": {"category": unit_category(p), "restriction": None, "accessibility": None,
                                         "name": label(p.get("name")), "alt_name": None, "display_point": None,
                                         "level_id": level_id}})
    if FIXES:                                      # the floor is at least as large as the rooms drawn on it
        level_geom = unary_union([level_geom] + rooms)
        levels[-1]["geometry"] = mapping(level_geom)
    walls = unary_union([r.boundary for r in rooms])
    for x in feats:
        p = x["properties"]
        if p["kind"] != "door":
            continue
        pt = shape(x["geometry"])
        # a door is a node on the wall; IMDF wants a short line along the wall, about one metre wide
        on_wall = nearest_points(walls, pt)[0]
        seg = None
        for line in getattr(walls, "geoms", [walls]):
            if line.distance(on_wall) < 1e-9:
                d = line.project(on_wall)
                if FIXES:
                    # direction of the wall at the door in metres (UTM 40N), then 0.5 m to each side of the node
                    a, b = line.interpolate(max(d - 1e-6, 0)), line.interpolate(min(d + 1e-6, line.length))
                    (ax, bx), (ay, by) = to_m.transform([a.x, b.x], [a.y, b.y])
                    cx, cy = to_m.transform(on_wall.x, on_wall.y)
                    n = ((bx - ax) ** 2 + (by - ay) ** 2) ** 0.5
                    ux, uy = (bx - ax) / n, (by - ay) / n
                    lon, lat = to_deg.transform([cx - ux * 0.5, cx + ux * 0.5], [cy - uy * 0.5, cy + uy * 0.5])
                    seg = LineString(zip(lon, lat))
                else:
                    a, b = line.interpolate(max(d - 0.0000047, 0)), line.interpolate(min(d + 0.0000047, line.length))
                    seg = LineString([a, b])
                break
        if seg is None or seg.length == 0:
            continue
        door = {"type": p["door"] if p["door"] in ("sliding", "hinged", "revolving") else None, "automatic": None, "material": None}
        openings.append({"type": "Feature", "id": fid(f"{x['id']}@{ordinal}"), "feature_type": "opening",
                         "geometry": mapping(seg),
                         "properties": {"category": "pedestrian", "accessibility": None, "access_control": None,
                                        "door": door, "name": label(p.get("ref")), "alt_name": None,
                                        "display_point": None, "level_id": level_id}})
    everything += rooms

venue_geom = unary_union(everything).convex_hull.buffer(0.00005)
venue = {"type": "Feature", "id": venue_id, "feature_type": "venue", "geometry": mapping(venue_geom),
         "properties": {"category": "university", "restriction": None, "name": label("Engineering and Science Building"),
                        "alt_name": None, "hours": None, "phone": None, "website": None,
                        "display_point": mapping(venue_geom.representative_point()), "address_id": address_id}}
address = {"type": "Feature", "id": address_id, "feature_type": "address", "geometry": None,
           "properties": {"address": None, "unit": None, "locality": "Sharjah", "province": "AE-SH",
                          "country": "AE", "postal_code": None, "postal_code_ext": None, "postal_code_vanity": None}}
building = {"type": "Feature", "id": building_id, "feature_type": "building", "geometry": None,
            "properties": {"name": label("Engineering and Science Building"), "alt_name": None, "category": "unspecified",
                           "restriction": None, "display_point": mapping(building_poly.representative_point()),
                           "address_id": None}}
footprint = {"type": "Feature", "id": footprint_id, "feature_type": "footprint", "geometry": mapping(building_poly),
             "properties": {"category": "ground", "name": None, "building_ids": [building_id]}}

data = {"address": [address], "venue": [venue], "building": [building], "footprint": [footprint],
        "level": levels, "unit": units, "opening": openings}
for name, feats in data.items():
    json.dump(fc(feats), open(f"{OUT}/{name}.geojson", "w", encoding="utf-8"), ensure_ascii=False)
json.dump({"version": "1.0.0", "created": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
           "generated_by": "arabroot indoor lab 03_imdf.py", "language": "en", "extensions": None},
          open(f"{OUT}/manifest.json", "w"))
with zipfile.ZipFile("/data/imdf.zip", "w", zipfile.ZIP_DEFLATED) as z:
    for fn in sorted(os.listdir(OUT)):
        z.write(f"{OUT}/{fn}", fn)
print({k: len(v) for k, v in data.items()}, "| zip", os.path.getsize("/data/imdf.zip"), "bytes")
widths = [geod.geometry_length(shape(o["geometry"])) for o in openings]
print(f"opening width: min {min(widths):.2f} m, max {max(widths):.2f} m")
```

في الكود أعلاه لاحظ التالي:

- الجدول `UNIT_CATEGORY` هو قرار التحويل من قيم `room=*` الحرة إلى فئات IMDF المغلقة، فالمخزن `store` أصبح `storage`، والممر `walkway`، وما لا نعرفه `room`.
- الطابق في IMDF عدد صحيح، فالسكربت يتجاهل أي طابق نصفي، ولا توجد طوابق نصفية في هذا المبنى، ولكن السطر موجود حتى لا يمر الميزانين في مبنى آخر بصمت.
- الباب في OSM نقطة على الجدار، ونحوله إلى خط على اتجاه الجدار بعرض متر تقريباً، وهذا افتراض منا، لأن عرض الأبواب غير مسجل في البيانات.
- العنوان فيه المدينة والإمارة والدولة من وسوم المبنى، أما سطر العنوان نفسه `address` فغير موجود في OSM، فتركناه فارغاً، ولم نخترع عنواناً.
- في الوضع الأول المعرفات هي معرفات OSM كما هي، مثل `way/874285683@0`، وهذا ما يفعله أغلب من يكتب التحويل لأول مرة.

### التحقق بقواعد المعيار

لا توجد أداة تحقق رسمية مفتوحة المصدر في صفحة المعيار، فكتبنا مدققاً يطبق جزءاً من قواعد صفحة Validations، بأسمائها نفسها، حتى يكون كل سطر في المخرج قابلاً للبحث في المعيار. وهو الملف `lab/04_validate.py`:

```python
# Check an IMDF archive against a subset of the rules in "IMDF Validations 1.0.3" (OGC 20-094).
# Rule names are the spec's own, so a failure can be looked up there.
import json, re, sys, zipfile
from collections import Counter, defaultdict
from shapely.geometry import shape
from shapely.strtree import STRtree
from pyproj import Geod

ARCHIVE = sys.argv[1] if len(sys.argv) > 1 else "/data/imdf.zip"
REQUIRED = ["address", "building", "footprint", "level", "unit", "venue"]
UUID4 = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$")
CATS = {
    "unit": set("""auditorium brick classroom column concrete conferenceroom drywall elevator escalator fieldofplay firstaid
        fitnessroom foodservice footbridge glass huddleroom kitchen laboratory library lobby lounge mailroom mothersroom
        movietheater movingwalkway nonpublic office opentobelow parking phoneroom platform privatelounge ramp recreation
        restroom restroom.family restroom.female restroom.female.wheelchair restroom.male restroom.male.wheelchair
        restroom.transgender restroom.transgender.wheelchair restroom.unisex restroom.unisex.wheelchair restroom.wheelchair
        road room serverroom shower smokingarea stairs steps storage structure terrace theater unenclosedarea unspecified
        vegetation waitingroom walkway walkway.island wood""".split()),
    "level": {"arrivals", "arrivals.domestic", "arrivals.intl", "departures", "departures.domestic", "departures.intl",
              "parking", "transit", "unspecified"},
    "opening": {"automobile", "bicycle", "emergencyexit", "pedestrian", "pedestrian.principal", "pedestrian.transit", "service"},
    "venue": {"airport", "airport.intl", "aquarium", "businesscampus", "casino", "communitycenter", "conventioncenter",
              "governmentfacility", "healthcarefacility", "hotel", "museum", "parkingfacility", "resort", "retailstore",
              "shoppingcenter", "stadium", "stripmall", "theater", "themepark", "trainstation", "transitstation", "university"},
}
DOOR_TYPES = {"door", "movablepartition", "open", "revolving", "shutter", "sliding", "swinging", "turnstile",
              "turnstile.fullheight", "turnstile.waistheight", "unspecified"}
geod = Geod(ellps="WGS84")
found = defaultdict(list)        # (severity, rule) -> feature ids

def report(sev, rule, fid="-"):
    found[(sev, rule)].append(fid)

z = zipfile.ZipFile(ARCHIVE)
names = set(z.namelist())
if "manifest.json" not in names:
    report("VIOLATION", "ManifestFileMustBePresent")
else:
    m = json.loads(z.read("manifest.json"))
    if m.get("version") != "1.0.0":
        report("VIOLATION", "ManifestVersionMustBeValid")
data = {}
for n in sorted(names - {"manifest.json"}):
    doc = json.loads(z.read(n))
    if doc.get("type") != "FeatureCollection":
        report("VIOLATION", "FileMustContainFeatureCollection", n)
        continue
    data[n[:-8]] = doc["features"]
for ft in REQUIRED:
    if ft not in data:
        report("VIOLATION", f"MissingRequiredFile:{ft}.geojson")

ids = Counter()
by_id = {}
for ft, feats in data.items():
    for f in feats:
        if "id" not in f:
            report("VIOLATION", "FeatureMustHaveId", ft); continue
        ids[f["id"]] += 1
        by_id[f["id"]] = f
        if not UUID4.match(str(f["id"])):
            report("VIOLATION", "InvalidFeatureID", f["id"])
        if f.get("feature_type") != ft:
            report("VIOLATION", "FeatureMustHaveFeatureType", f["id"])
for i, n in ids.items():
    if n > 1:
        report("VIOLATION", "FeatureIdMustBeUnique", i)

def ref(f, key, rule):
    v = f["properties"].get(key)
    for x in (v if isinstance(v, list) else [v]):
        if x is not None and x not in by_id:
            report("VIOLATION", "ReferencedFeatureIDMustBeResolvable", f"{f['id']}.{key}")

if len(data.get("venue", [])) != 1:
    report("VIOLATION", "VenueCountMustBeExactlyOne")
for a in data.get("address", []):
    p = a["properties"]
    if not p.get("address"): report("VIOLATION", "AddressMustHaveAddressLine", a["id"])
    if not p.get("country"): report("VIOLATION", "AddressMustHaveCountryCode", a["id"])
    if not p.get("locality"): report("VIOLATION", "AddressMustHaveLocality", a["id"])
venue_geom = None
for v in data.get("venue", []):
    p = v["properties"]
    venue_geom = shape(v["geometry"])
    if not p.get("address_id"): report("VIOLATION", "VenueMustHaveAddress", v["id"])
    if p.get("category") not in CATS["venue"]: report("VIOLATION", "VenueCategoryMustBeValid", v["id"])
    if not p.get("name"): report("VIOLATION", "VenueMustHaveName", v["id"])
    ref(v, "address_id", "")
    if not p.get("hours"): report("WARNING", "VenueShouldHaveHours", v["id"])
    if not p.get("phone"): report("WARNING", "VenueShouldHavePhone", v["id"])
    if not p.get("website"): report("WARNING", "VenueShouldHaveWebsite", v["id"])
if not data.get("building"):
    report("VIOLATION", "VenueMustHaveAtLeastOneBuilding")
for b in data.get("building", []):
    if not any(b["id"] in (f["properties"].get("building_ids") or []) for f in data.get("footprint", [])):
        report("VIOLATION", "BuildingMustHaveAtLeastOneFootprint", b["id"])
    if not any(b["id"] in (f["properties"].get("building_ids") or []) for f in data.get("level", [])):
        report("VIOLATION", "BuildingHasNoLevel", b["id"])
    if not b["properties"].get("address_id"): report("WARNING", "BuildingHasNoAddress", b["id"])
for fp in data.get("footprint", []):
    if not fp["properties"].get("building_ids"): report("VIOLATION", "FootprintMustReferenceBuilding", fp["id"])
    ref(fp, "building_ids", "")

level_geom = {}
for lv in data.get("level", []):
    p, g = lv["properties"], shape(lv["geometry"])
    level_geom[lv["id"]] = g
    if g.geom_type not in ("Polygon", "MultiPolygon"): report("VIOLATION", "LevelMustHavePolygonalGeometry", lv["id"])
    if not p.get("name"): report("VIOLATION", "LevelMustHaveName", lv["id"])
    if not p.get("short_name"): report("VIOLATION", "LevelMustHaveShortName", lv["id"])
    if not isinstance(p.get("ordinal"), int): report("VIOLATION", "LevelOrdinalMustBeInteger", lv["id"])
    if p.get("category") not in CATS["level"]: report("VIOLATION", "LevelCategoryMustBeValid", lv["id"])
    if not any(u["properties"].get("level_id") == lv["id"] for u in data.get("unit", [])):
        report("VIOLATION", "LevelMustBeReferencedByUnit", lv["id"])
    if not any(o["properties"].get("level_id") == lv["id"] for o in data.get("opening", [])):
        report("WARNING", "LevelShouldBeReferencedByOpening", lv["id"])
    ref(lv, "building_ids", "")

units_by_level = defaultdict(list)
for u in data.get("unit", []):
    p, g = u["properties"], shape(u["geometry"])
    if g.geom_type not in ("Polygon", "MultiPolygon"): report("VIOLATION", "UnitMustHavePolygonalGeometry", u["id"])
    if not p.get("category"): report("VIOLATION", "UnitMustHaveCategory", u["id"])
    elif p["category"] not in CATS["unit"]: report("VIOLATION", "UnitCategoryMustBeValid", f"{u['id']} ({p['category']})")
    if p.get("level_id") not in level_geom:
        report("VIOLATION", "UnitMustReferenceLevel", u["id"]); continue
    if not level_geom[p["level_id"]].buffer(1e-7).covers(g):
        report("VIOLATION", "UnitMustBeCoveredByReferencedLevel", u["id"])
    if not g.is_valid:
        report("VIOLATION", "FileMustBeValidGeoJSON(self-intersection)", u["id"])
    units_by_level[p["level_id"]].append((u["id"], g))
for lid, items in units_by_level.items():
    geoms = [g for _, g in items]
    tree = STRtree(geoms)
    for i, j in zip(*tree.query(geoms, predicate="intersects")):
        if i < j and geoms[i].intersection(geoms[j]).area > 1e-11:      # more than ~0.1 m2 shared
            report("WARNING", "UnitsMustNotOverlap", f"{items[i][0]} x {items[j][0]}")

for o in data.get("opening", []):
    p, g = o["properties"], shape(o["geometry"])
    if g.geom_type != "LineString": report("VIOLATION", "OpeningMustHaveLineStringGeometry", o["id"])
    if p.get("category") not in CATS["opening"]: report("VIOLATION", "OpeningCategoryMustBeValid", o["id"])
    if p.get("level_id") not in level_geom:
        report("VIOLATION", "OpeningMustReferenceLevel", o["id"]); continue
    door = p.get("door") or {}
    if door.get("type") is not None and door["type"] not in DOOR_TYPES:
        report("VIOLATION", "OpeningDoorTypeMustBeValid", o["id"])
    if not level_geom[p["level_id"]].buffer(1e-7).covers(g):
        report("VIOLATION", "OpeningMustBeCoveredByReferencedLevel", o["id"])
    length = geod.geometry_length(g)
    if length <= 0.8382: report("WARNING", "OpeningIsSuspiciouslySmall", o["id"])
    if length > 45: report("WARNING", "OpeningIsSuspiciouslyLarge", o["id"])

if venue_geom is not None:
    outside = [f["id"] for ft, feats in data.items() if ft not in ("venue", "address", "building")
               for f in feats if f.get("geometry") and not venue_geom.covers(shape(f["geometry"]))]
    for i in outside:
        report("VIOLATION", "VenueMustCoverAllChildFeatures", i)

print("features:", {k: len(v) for k, v in data.items()})
for (sev, rule), fids in sorted(found.items()):
    print(f"{sev:9} {rule:42} {len(fids):5}   e.g. {fids[0]}")
v = sum(len(x) for (s, _), x in found.items() if s == "VIOLATION")
w = sum(len(x) for (s, _), x in found.items() if s == "WARNING")
print(f"result: {v} violations, {w} warnings")
sys.exit(1 if v else 0)
```

والجولة الأولى على الأرشيف بمعرفات OSM:

```bash
im sh -c 'python /lab/03_imdf.py && python /lab/04_validate.py'
```

```text
{'address': 1, 'venue': 1, 'building': 1, 'footprint': 1, 'level': 3, 'unit': 504, 'opening': 494} | zip 44016 bytes
opening width: min 0.01 m, max 1.02 m
features: {'address': 1, 'building': 1, 'footprint': 1, 'level': 3, 'opening': 494, 'unit': 504, 'venue': 1}
VIOLATION AddressMustHaveAddressLine                     1   e.g. address/1
VIOLATION InvalidFeatureID                            1005   e.g. address/1
VIOLATION UnitCategoryMustBeValid                        1   e.g. way/874285791@0 (foyer)
VIOLATION UnitMustBeCoveredByReferencedLevel            57   e.g. way/882909593@2
WARNING   BuildingHasNoAddress                           1   e.g. building/867826047
WARNING   OpeningIsSuspiciouslySmall                   173   e.g. node/8139201720@0
WARNING   UnitsMustNotOverlap                          457   e.g. way/874285675@0 x way/874285750@0
WARNING   VenueShouldHaveHours                           1   e.g. venue/1
WARNING   VenueShouldHavePhone                           1   e.g. venue/1
WARNING   VenueShouldHaveWebsite                         1   e.g. venue/1
result: 1064 violations, 634 warnings
```

1,064 مخالفة، وأغلبها 1,005 من قاعدة واحدة: `InvalidFeatureID`، لأن المعيار يشترط أن يكون كل معرف UUID من الإصدار 4، ومعرفات OSM ليست كذلك. والحل البسيط أن تولد UUID عشوائياً لكل عنصر في كل تشغيل، وهذا يمر من القاعدة، ولكنه يخالف شرطاً آخر في المعيار: المعرف يجب أن يبقى نفسه للعنصر نفسه في كل تسليم، فإذا تغير معرف الغرفة في كل تحديث، ضاع كل ما ربطه به أحد: المحل الذي يشغلها Occupant، والإعلان في التطبيق، والإحصاءات. لذلك نشتق المعرف من معرف OSM بدالة هاش SHA-1، ونأخذ أول 16 بايت، ونضع فيها علامة الإصدار 4، فيصبح المعرف بشكل UUID صالح، ويبقى نفسه ما دام معرف OSM نفسه، وهذا ما يفعله الخيار `--uuid`:

```bash
im sh -c 'python /lab/03_imdf.py --uuid && python /lab/04_validate.py'
```

```text
{'address': 1, 'venue': 1, 'building': 1, 'footprint': 1, 'level': 3, 'unit': 504, 'opening': 494} | zip 67407 bytes
opening width: min 0.01 m, max 1.02 m
features: {'address': 1, 'building': 1, 'footprint': 1, 'level': 3, 'opening': 494, 'unit': 504, 'venue': 1}
VIOLATION AddressMustHaveAddressLine                     1   e.g. ccd84718-03f0-4ead-9cb6-60c4020644b7
VIOLATION UnitCategoryMustBeValid                        1   e.g. 3cae5464-7db5-407c-a219-632f922b78b7 (foyer)
VIOLATION UnitMustBeCoveredByReferencedLevel            57   e.g. 42e150d6-ddfe-4d5a-9155-8c6962dcfa52
WARNING   BuildingHasNoAddress                           1   e.g. a3f0db9b-c975-4302-88d9-87179639142d
WARNING   OpeningIsSuspiciouslySmall                   173   e.g. 78101344-1350-48e1-9128-64945a342708
WARNING   UnitsMustNotOverlap                          457   e.g. 77d414cc-057e-4352-9200-f6682a9a9059 x a065ea44-9127-4d63-a054-3aaeec84b8c7
WARNING   VenueShouldHaveHours                           1   e.g. 5f631417-1379-4bc4-9ddc-87e5b17eb794
WARNING   VenueShouldHavePhone                           1   e.g. 5f631417-1379-4bc4-9ddc-87e5b17eb794
WARNING   VenueShouldHaveWebsite                         1   e.g. 5f631417-1379-4bc4-9ddc-87e5b17eb794
result: 59 violations, 634 warnings
```

بقيت 59 مخالفة، ولكي نفهمها كتبنا فحصاً إضافياً على الأرشيف الأول، يحسب كم يخرج كل غرفة عن طابقها، وأي الفئات تتداخل، وهو الملف `lab/05_inspect.py`:

```python
# Where the first archive breaks the rules: units outside their level, and which unit categories overlap.
import json, zipfile
from collections import Counter
from shapely.geometry import shape
from shapely.strtree import STRtree
from pyproj import Geod

geod = Geod(ellps="WGS84")
z = zipfile.ZipFile("/data/imdf.zip")
levels = {f["id"]: (f["properties"]["ordinal"], shape(f["geometry"]))
          for f in json.loads(z.read("level.geojson"))["features"]}
units = json.loads(z.read("unit.geojson"))["features"]

outside, per_level = [], Counter()
for u in units:
    ordinal, lg = levels[u["properties"]["level_id"]]
    g = shape(u["geometry"])
    if not lg.buffer(1e-7).covers(g):
        per_level[ordinal] += 1
        outside.append(abs(geod.geometry_area_perimeter(g.difference(lg))[0]))
outside.sort()
print("units not covered, per level:", dict(per_level),
      f"| area outside: max {outside[-1]:.1f} m2, median {outside[len(outside) // 2]:.1f} m2")
for ordinal, lg in levels.values():
    print(f"level {ordinal} outline: {abs(geod.geometry_area_perimeter(lg)[0]):,.0f} m2")

pairs = Counter()
by_level = {}
for u in units:
    by_level.setdefault(u["properties"]["level_id"], []).append(u)
for us in by_level.values():
    gs = [shape(u["geometry"]) for u in us]
    for i, j in zip(*STRtree(gs).query(gs, predicate="intersects")):
        if i < j and gs[i].intersection(gs[j]).area > 1e-11:
            pairs[tuple(sorted((us[i]["properties"]["category"], us[j]["properties"]["category"])))] += 1
print("overlapping pairs by category:")
for (a, b), n in pairs.most_common(8):
    print(f"  {a:10} x {b:10} {n}")
```

```text
units not covered, per level: {2: 57} | area outside: max 9.3 m2, median 1.1 m2
level 0 outline: 8,234 m2
level 1 outline: 8,234 m2
level 2 outline: 8,234 m2
overlapping pairs by category:
  office     x walkway    126
  laboratory x office     38
  laboratory x storage    37
  laboratory x walkway    35
  office     x room       34
  office     x office     29
  storage    x walkway    26
  walkway    x walkway    22
```

في المخرج أعلاه لاحظ التالي:

- كل الوحدات الـ 57 الخارجة عن طابقها في الطابق 2، وهي ما رأيناه بالعين في اللقطة: أكبرها يخرج 9.3 متر مربع، والوسيط 1.1 متر مربع.
- مضلعات الطوابق الثلاثة بالمساحة نفسها تماماً، 8,234 متراً مربعاً، أي أن المساهم نسخ حدود الطابق نفسها لكل طابق، بينما الطابق 2 أوسع قليلاً في الواقع أو في رسم الغرف.
- التداخل بين الوحدات أغلبه بين المكاتب والممرات، 126 زوجاً، لأن الممرات رسمت كمضلعات تمتد تحت حدود الغرف، وهذا شائع في OSM لأن المساهم يرسم الممر بخطوط مستقيمة سريعة، ثم يرسم الغرف فوقه.

والقاعدة `UnitMustBeCoveredByReferencedLevel` مخالفة لا تحذير، فلا يقبل الأرشيف بها. وأمامنا خياران: أن نصغر الغرف لتدخل في حدود الطابق، وهذا تغيير لبيانات لا نعرف أيها الصحيح، أو أن نوسع حدود الطابق لتشمل ما رسم عليه، وهذا ما اخترناه، لأن الطابق في IMDF يمثل امتداد الأرضية فعلاً، والغرف المرسومة دليل على أن الأرضية هناك. والصورة التالية تبين الإصلاح الثاني في الأبواب:

![مخطط من جزأين: في الأول غرفتان بينهما جدار، وباب عند زاوية الجدار تحول إلى خط طوله 0.01 متر لأن خط الجدار قطع عند نقطة الباب، وباب آخر في منتصف الجدار بطول 1.02 متر، مع ملاحظة أن 173 باباً كانت أصغر من 0.84 متر. وفي الثاني الإصلاح: حساب اتجاه الجدار عند الباب ثم نصف متر على كل جانب في نظام UTM 40 شمالاً بالمتر، فكل الأبواب الـ 494 بعرض 1.00 متر](https://arabroot.io/content/images/2026/11/indoor-maps-07-door.webp)

الباب عند طرف خط الجدار قص إلى سنتيمتر واحد، والحل أن تأخذ الاتجاه ثم تقيس بالمتر

والتحذير `OpeningIsSuspiciouslySmall` ظهر في 173 باباً، أي أكثر من ثلث الأبواب، وأصغرها 0.01 متر. والسبب في طريقتنا الأولى: جمعنا حدود كل الغرف في شكل واحد، فقسم Shapely الحدود عند كل نقطة تلتقي فيها غرفتان، وكثير من الأبواب يقع تماماً على هذه النقاط، فإذا أخذنا نصف متر قبل الباب وبعده على الخط نفسه، قطع طرف الخط أحد النصفين. وأيضاً كنا نقيس نصف المتر بالدرجات، 0.0000047 درجة، وهي ليست نصف متر في الاتجاهين. والإصلاح في الخيار `--fixes`: نأخذ اتجاه الجدار عند الباب فقط، ثم نحول إلى UTM 40 شمالاً، وهي المنطقة التي يقع فيها المبنى، ونمد نصف متر على كل جانب بالمتر، ثم نعود إلى 4326\. ومع الإصلاحين، والفئة `foyer` التي ليست في قائمة IMDF فأصبحت `lobby`:

```bash
im sh -c 'python /lab/03_imdf.py --uuid --fixes && python /lab/04_validate.py'
```

```text
{'address': 1, 'venue': 1, 'building': 1, 'footprint': 1, 'level': 3, 'unit': 504, 'opening': 494} | zip 69659 bytes
opening width: min 1.00 m, max 1.00 m
features: {'address': 1, 'building': 1, 'footprint': 1, 'level': 3, 'opening': 494, 'unit': 504, 'venue': 1}
VIOLATION AddressMustHaveAddressLine                     1   e.g. ccd84718-03f0-4ead-9cb6-60c4020644b7
WARNING   BuildingHasNoAddress                           1   e.g. a3f0db9b-c975-4302-88d9-87179639142d
WARNING   UnitsMustNotOverlap                          457   e.g. 77d414cc-057e-4352-9200-f6682a9a9059 x a065ea44-9127-4d63-a054-3aaeec84b8c7
WARNING   VenueShouldHaveHours                           1   e.g. 5f631417-1379-4bc4-9ddc-87e5b17eb794
WARNING   VenueShouldHavePhone                           1   e.g. 5f631417-1379-4bc4-9ddc-87e5b17eb794
WARNING   VenueShouldHaveWebsite                         1   e.g. 5f631417-1379-4bc4-9ddc-87e5b17eb794
result: 1 violations, 461 warnings
```

![ثلاث بطاقات لجولات التحقق: الأولى 1064 مخالفة و634 تحذيراً منها InvalidFeatureID في 1005 عنصر وUnitMustBeCoveredByReferencedLevel في 57 وفئة foyer غير صالحة وسطر عنوان ناقص، والثانية بعد المعرفات الثابتة 59 مخالفة، والثالثة بعد الإصلاحات مخالفة واحدة و461 تحذيراً والباقي سطر العنوان من مالك المبنى. وتحتها التحذير الأكبر الباقي: تداخل الوحدات في 457 زوجاً، منها مكتب مع ممر 126 ومختبر مع مكتب 38 ومختبر مع مخزن 37 ومكتب مع مكتب 29](https://arabroot.io/content/images/2026/11/indoor-maps-06-validation.webp)

من 1,064 مخالفة إلى واحدة، والباقي يحتاج مالك المبنى لا الكود

بقيت مخالفة واحدة: `AddressMustHaveAddressLine`، وهي لا تصلح بالكود، لأن سطر العنوان غير موجود في البيانات، والحل الصحيح أن تأخذه من مالك المبنى، لا أن تكتب شيئاً يمر من القاعدة. وبقي 461 تحذيراً، أغلبها 457 تداخلاً بين الوحدات، وإصلاحها يحتاج أن يعاد رسم الحدود المشتركة بين الغرف والممرات بحيث تشترك في النقاط نفسها، وهذا عمل رسم في المصدر لا تحويل، لأن قص الممر بحدود الغرف آلياً قد يفصل ممراً إلى قطع لا يصل بينها شيء. وأخيراً هذه محتويات الأرشيف:

```text
     337 address.geojson
     394 building.geojson
     763 footprint.geojson
    4218 level.geojson
     143 manifest.json
  240241 opening.geojson
  280180 unit.geojson
    3568 venue.geojson
```

ولاحظ أن الأرشيف كله أقل من 70 كيلوبايت بعد الضغط، لمبنى فيه 504 مساحات و494 باباً، فحجم البيانات ليس مشكلة في الخرائط الداخلية حتى لمطار كبير، والمشكلة في دقتها وتحديثها.

💡

المدقق في المختبر يطبق جزءاً من قواعد IMDF Validations 1.0.3، ومرور الأرشيف منه لا يعني قبوله في برنامج Apple، فهناك قواعد لم نكتبها مثل تطابق الطابق الأرضي مع Footprint، وقواعد المشغلين Occupants والمراسي Anchors. فاستخدم الفكرة نفسها: اكتب القواعد التي تحتاجها بأسمائها في المعيار، وشغلها مع كل تحديث للبيانات.

### تنظيف المختبر

```bash
docker volume rm lab-im-data
docker image rm lab-im
rm -rf web
```

## الخريطة الداخلية تتغير كل أسبوع

الشوارع تتغير ببطء، أما داخل المبنى فالمحل يغلق ويفتح غيره، والقسم ينتقل إلى طابق آخر، والقاعة تقسم إلى مكتبين. لذلك فإن السؤال الأهم في أي مشروع خريطة داخلية ليس كيف نرسمها، وإنما كيف تبقى صحيحة. وهناك ثلاثة مبادئ تقلل الألم:

- **افصل الشكل عن الشاغل:** الغرفة شكل ثابت تقريباً، ومن يشغلها معلومة تتغير. وهذا ما تفعله IMDF بفصل الوحدة Unit عن المشغل Occupant الذي يرتبط بنقطة Anchor داخل الوحدة، فإذا انتقل المحل لم تتغير الوحدة.
- **معرفات ثابتة:** كما رأينا في المختبر، المعرف المشتق من مصدر ثابت يجعل كل ما ربط بالعنصر يبقى بعد التحديث، والمعرف العشوائي في كل تشغيل يكسر الروابط كلها.
- **التحقق مع كل تحديث:** شغل المدقق في Pipeline عند كل تغيير، وارفض التحديث إذا زادت المخالفات، فالغرفة التي خرجت عن طابقها اليوم ستصبح مساراً يمر عبر جدار غداً.

ومن المفيد أن تتابع أرقاماً بسيطة مع كل تحديث، كما فعلنا في مخرج السكربت الثاني: عدد الغرف في كل طابق، ونسبة الغرف التي لها اسم، وعدد الأبواب، وعدد العناصر المستبعدة بسبب نقص الطابق أو شكل غير مغلق. فإذا نزلت نسبة الغرف المسماة في الطابق 0 من 105 من 107 إلى النصف بعد تحديث، فهذا ليس تغييراً في المبنى، وإنما خطأ في التحويل أو في المصدر، وتعرفه قبل أن يشتكي زائر من أن البحث لم يجد القاعة.

والمصدر الأفضل للتحديث هو المخططات المعمارية نفسها عند مالك المبنى، بصيغة CAD أو BIM، مع أداة تحويل إلى IMDF أو GeoJSON، لأن الرسم اليدوي من صورة يتراكم فيه الخطأ مع كل تعديل.

## من الخريطة إلى المسار داخل المبنى

بعد أن أصبحت المساحات والأبواب بيانات، يصبح السؤال «كيف أصل من المدخل إلى القاعة 214؟» مسألة رسم بياني Graph، وهي الفكرة نفسها التي يبني عليها IndoorGML نموذجه. والطريقة المعتادة: كل مساحة يمكن المشي فيها عقدة، وكل باب بين مساحتين حافة بينهما، ووزن الحافة المسافة من مركز المساحة الأولى إلى الباب ثم إلى مركز الثانية. ثم تضيف حافات الوصلات العمودية: الدرج في الطابق 0 مع الدرج الذي يحمل الرقم المرجعي نفسه في الطابق 1، والمصعد كذلك، ولكل منها تكلفة تختلف بحسب المستخدم، فمن يدفع كرسياً متحركاً لا يمر في الدرج أصلاً، ولذلك فإن خاصية الإتاحة `accessibility` في IMDF ليست زينة، وإنما شرط في حساب المسار.

وهنا يظهر أثر كل خطأ رأيناه في التحقق. فالباب الذي لا يقع على حدود غرفتين لا يصبح حافة، فتنفصل الغرفة عن الرسم البياني ولا يصل إليها أي مسار. والممر المتداخل مع المكاتب يجعل البرنامج يظن أن المكتب جزء من الممر، فيرسم المسار عبر الجدار. والدرج غير المربوط بين الطوابق يجعل كل طابق جزيرة مستقلة، فيقول التطبيق إن القاعة في الطابق 2 لا يمكن الوصول إليها من المدخل في الطابق 0\. لذلك فإن أفضل اختبار للخريطة الداخلية بعد قواعد المعيار أن تحسب المسار من كل مدخل إلى كل غرفة مسماة، وتعد الغرف التي لا يصل إليها مسار، فكل غرفة منها خطأ في البيانات لا في الخوارزمية.

وقد يتساءل البعض: لماذا لا يكفي مركز الممر كعقدة واحدة؟ والإجابة أن الممر الطويل، مثل الممر الأبيض في وسط الطابق 0 في المختبر، يمتد عشرات الأمتار، فإذا اعتبرته نقطة واحدة فإن المسار من باب في طرفه إلى باب في الطرف نفسه سيذهب إلى المنتصف ويعود. والحل أن تقسم الممرات الطويلة إلى أجزاء، أو أن تبني شبكة مشي داخل الممر من خطوط وسطه، وهذا ما يفعله رسامو OpenStreetMap عندما يضيفون خطوط `highway=corridor` مع `level` داخل الممرات، وقد وجدنا منها 56 خطاً في مبنى المختبر نفسه.

## ماذا لا تنشر؟

الخريطة الداخلية تكشف ما لا تكشفه الخريطة الخارجية: أين غرفة الخوادم، وأين غرفة المراقبة، وأي أبواب تحتاج بطاقة. وفي بيانات المختبر نفسها، وهي منشورة للعالم في OpenStreetMap، تجد غرفاً بأسماء مثل «SECURITY CONTROL ROOM» و«IDF ROOM»، وهذه غرف شبكة تحتوي عادة على Switches وتوصيلات المبنى. ولهذا السبب فإن IMDF فيها خاصية القيد `restriction` على الوحدة والطابق، بقيم مثل `restricted` و`employeesonly`، والفئة `nonpublic` للوحدات، ولكن القيد يخبر التطبيق ألا يرسل الزائر إليها، ولا يخفي وجودها من الملف نفسه. فالقاعدة: قبل أن تنشر أي خريطة داخلية، راجعها مع فريق الأمن في المنشأة، واحذف من النسخة العامة ما لا يحتاجه الزائر أصلاً، واجعل الأسماء التشغيلية عامة: «غرفة فنية» بدل اسم يصف ما بداخلها. وإذا كانت المنشأة جهة حكومية أو صحية، فراجع أيضاً ما تشترطه أنظمتها على نشر مخططات المباني.

## أي نموذج تختار؟

| حالتك                                   | النموذج                      | والسبب                                                                   |
| --------------------------------------- | ---------------------------- | ------------------------------------------------------------------------ |
| تطبيق لمنشأتك تريده أيضاً في Apple Maps | IMDF                         | الصيغة التي يستقبلها برنامج Apple، وتعرض في MapLibre أيضاً لأنها GeoJSON |
| مبنى عام وتريد أن يستفيد منه الجميع     | OSM Simple Indoor Tagging    | بيانات مفتوحة يصححها المجتمع، مع الانتباه لما لا يجب نشره                |
| ملاحة معقدة، روبوتات، ربط مع BIM        | IndoorGML                    | رسم بياني صريح للملاحة، وطبقات متعددة للمعنى نفسه                        |
| نموذج أولي سريع لصفحة «أين أجد»         | GeoJSON لكل طابق بخصائص IMDF | ابدأ بأسماء الفئات والخصائص من IMDF، فيصبح التحويل لاحقاً بسيطاً         |
| مخطط PDF فقط ولا وقت للرسم              | صورة فوق الخريطة             | مقبول للعرض فقط، واعرف أنه لا بحث ولا مسار                               |

## أخطاء شائعة وحلولها

- **خلط ترتيب الطابق باسمه:** احفظهما في خاصيتين منفصلتين، `ordinal` و`short_name`، ولا تشتق أحدهما من الآخر.
- **معرفات تتغير مع كل تشغيل:** اشتق المعرف من مصدر ثابت، فالمعيار نفسه يطلب ثباته بين التسليمات.
- **الباب كنقطة في IMDF:** الباب خط بعرض المدخل، وقسه بالمتر في إسقاط محلي، لا بالدرجات.
- **غرف خارج حدود طابقها:** قرر أيهما الصحيح، ولا تقص الغرف آلياً دون مراجعة.
- **ممرات تحت الغرف:** ارسم الحدود المشتركة بنقاط مشتركة، وإلا تداخلت المساحات وظهر المسار عبر الجدران.
- **قيم `level` غير متوقعة:** مدى مثل `0-1` وقيم نصفية مثل `0.5`، فاكتب القراءة بحيث تفشل بوضوح على ما لا تفهمه.
- **صفحة فارغة في المتصفح:** افتح الـ Console، فغالباً السيرفر يرسل ملف `.mjs` بنوع خاطئ.
- **Overpass في حلقة:** طلب واحد لكل مبنى، ونسخة محلية أو ملف Geofabrik لأي عمل أكبر.
- **نشر غرف حساسة:** راجع الخريطة مع فريق الأمن قبل النشر، والقيد في البيانات لا يخفي الغرفة.

## قائمة تحقق قبل أن تطلق الخريطة الداخلية

- هل لكل طابق ترتيب صحيح واسم كما على اللافتة؟ وهل الطوابق النصفية لها قرار مكتوب؟
- هل كل مساحة مضلع مغلق صالح على طابق، ولها فئة من قائمة محددة؟
- هل كل باب على حدود مساحتين، وبعرض معقول؟
- هل الدرج والمصاعد مربوطة بين الطوابق، لا مرسومة فقط؟
- هل المعرفات ثابتة بين التحديثات؟
- هل تشغل التحقق مع كل تحديث، وتعرف عدد المخالفات والتحذيرات؟
- هل راجع فريق الأمن ما سيظهر للعامة؟
- هل البحث بالاسم يجد الغرف المهمة للزائر، أم أن نصف الغرف بلا أسماء؟

## تدريب عملي

- أضف إلى `03_imdf.py` ملف `relationship.geojson` يربط وحدات الدرج التي لها الرقم المرجعي نفسه `ref` في الطوابق المختلفة، ثم أضف إلى المدقق قاعدة تتحقق أن كل درج في الطابق 0 مربوط بدرج في طابق آخر.
- غير `floors.html` بحيث يبحث في أسماء الغرف في الطوابق الثلاثة، وعند اختيار نتيجة ينتقل إلى طابقها ويقرب الخريطة إليها.

## الخلاصة

وصلنا لنهاية الموضوع، وأهم ما فيه:

- الخريطة الداخلية بيانات لا صورة: مبنى وطوابق ومساحات وأبواب ووصلات عمودية، والصورة تعرض فقط ولا تبحث ولا ترسم مساراً.
- ترتيب الطابق شيء واسمه على اللافتة شيء آخر، والنماذج الثلاثة تفصل بينهما.
- OSM Simple Indoor Tagging مفتوحة ويحررها المجتمع، وIMDF صيغة تسليم بقواعد تحقق مكتوبة واعتمدتها OGC، وIndoorGML نموذج للملاحة برسم بياني صريح.
- Apple تستقبل الخرائط الداخلية من مالكي المنشآت بصيغة IMDF، وGoogle تعرضها في دول مختارة لم تكن المملكة منها عند كتابة المقال، ومالك المبنى هو المصدر الحقيقي في كل الحالات.
- في المختبر جلبنا مبنى من ثلاثة طوابق في طلب واحد من 3,363 عنصراً، وعرضناه في MapLibre، وحولناه إلى IMDF، وأنزلنا المخالفات من 1,064 إلى واحدة.
- أكبر مخالفة كانت المعرفات، والحل معرف UUID ثابت مشتق من المصدر لا عشوائي، والمخالفة الأخيرة سطر عنوان لا يأتي إلا من مالك المبنى.
- قبل النشر راجع الخريطة مع فريق الأمن، فبعض الغرف لا يجب أن تظهر لأحد.

[![](https://arabroot.io/content/images/2026/11/indoor-positioning-cover-cover.webp)دليلتحديد الموقع داخل المباني: Wi-Fi RTT وBLE وUWBلماذا يضيع GPS داخل المبنى، وما الدقة الحقيقية لبصمة Wi-Fi ومنارات BLE وقياس الزمن بـ RTT وUWB، بأرقام من بيانات UJIIndoorLoc ومحاكاة بنموذج ITU-R P.1238.](https://arabroot.io/articles/%D8%AA%D8%AD%D8%AF%D9%8A%D8%AF-%D8%A7%D9%84%D9%85%D9%88%D9%82%D8%B9-%D8%AF%D8%A7%D8%AE%D9%84-%D8%A7%D9%84%D9%85%D8%A8%D8%A7%D9%86%D9%8A-wi-fi-rtt-%D9%88-ble-%D9%88-uwb/)[![](https://arabroot.io/content/images/2026/11/osm-basics-cover-cover.webp)دليلما هي OpenStreetMap؟ البيانات والرخصة والمساهمةكيف تبنى أكبر قاعدة بيانات جغرافية مفتوحة من نقاط وطرق ووسوم، وما الذي تلزمك به رخصتها، وكيف تفحص جودتها في مدينتك قبل أن تبني عليها.](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%8A-openstreetmap-%D8%A7%D9%84%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D8%B1%D8%AE%D8%B5%D8%A9-%D9%88%D8%A7%D9%84%D9%85%D8%B3%D8%A7%D9%87%D9%85%D8%A9/)[![](https://arabroot.io/content/images/2026/11/self-hosted-maps-cover-cover.webp)دليلخرائطك على سيرفرك مع OpenStreetMap وMapLibreكيف تعرض خريطة تفاعلية لمدينتك من سيرفرك ببيانات OpenStreetMap، بالعربية والإنجليزية ودون مفتاح API أو مزود خارجي.](https://arabroot.io/articles/%D8%AE%D8%B1%D8%A7%D8%A6%D8%B7%D9%83-%D8%B9%D9%84%D9%89-%D8%B3%D9%8A%D8%B1%D9%81%D8%B1%D9%83-%D9%85%D8%B9-openstreetmap-%D9%88-maplibre/)[![](https://arabroot.io/content/images/2026/11/web-map-maplibre-cover-cover.webp)دليلأول خريطة تفاعلية في موقعك مع MapLibre GL JSخريطة تفاعلية في صفحتك خطوة بخطوة بمكتبة MapLibre: طبقات وعلامات ونوافذ وأسماء عربية وتجميع لآلاف الأماكن، مع الأعطال التي ستقابلها وحلها.](https://arabroot.io/articles/%D8%A7%D9%88%D9%84-%D8%AE%D8%B1%D9%8A%D8%B7%D8%A9-%D8%AA%D9%81%D8%A7%D8%B9%D9%84%D9%8A%D8%A9-%D9%81%D9%8A-%D9%85%D9%88%D9%82%D8%B9%D9%83-%D9%85%D8%B9-maplibre/)[![](https://arabroot.io/content/images/2026/10/build-map-app-cover-cover.webp)دليلكيف تبني تطبيق خرائط وملاحة مثل هدهد وGoogle Maps؟ما الذي يقف خلف كل ميزة في تطبيقات الخرائط، وكيف تبني نسخة أولى منها بأدوات مفتوحة المصدر وبيانات مرخصة بشكل صحيح.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%AA%D8%A8%D9%86%D9%8A-%D8%AA%D8%B7%D8%A8%D9%8A%D9%82-%D8%AE%D8%B1%D8%A7%D8%A6%D8%B7-%D9%88%D9%85%D9%84%D8%A7%D8%AD%D8%A9-%D9%85%D8%AB%D9%84-%D9%87%D8%AF%D9%87%D8%AF-%D9%88-google-maps/)[![](https://arabroot.io/content/images/2026/11/gis-postgis-cover-cover.webp)دليلالبيانات الجغرافية GIS في PostgreSQL مع PostGISكيف تخزن الأحياء والطرق والفروع في PostgreSQL وتسألها بالمتر الصحيح وبفهرس يعمل فعلاً، بمختبر على بيانات OpenStreetMap لمدينة كاملة.](https://arabroot.io/articles/%D8%A7%D9%84%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA-%D8%A7%D9%84%D8%AC%D8%BA%D8%B1%D8%A7%D9%81%D9%8A%D8%A9-gis-%D9%81%D9%8A-postgresql-%D9%85%D8%B9-postgis/)[![](https://arabroot.io/content/images/2026/11/geopandas-python-cover-cover.webp)دليلتحليل البيانات الجغرافية في Python مع GeoPandasكيف تجيب بكود Python يعاد تشغيله عن أسئلة مثل كم مستشفى في كل منطقة وما القرى البعيدة عن أقرب مستشفى، ببيانات OpenStreetMap حقيقية للمملكة وأرقام مقارنة مع PostGIS.](https://arabroot.io/articles/%D8%AA%D8%AD%D9%84%D9%8A%D9%84-%D8%A7%D9%84%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA-%D8%A7%D9%84%D8%AC%D8%BA%D8%B1%D8%A7%D9%81%D9%8A%D8%A9-%D9%81%D9%8A-python-%D9%85%D8%B9-geopandas/)[![](https://arabroot.io/content/images/2026/10/live-location-cover-cover.webp)دليلتتبع مواقع المندوبين لحظياً: من الهاتف إلى الخريطةكيف تستقبل مواقع آلاف المندوبين كل بضع ثوان، وتحفظ آخر موقع لكل منهم، وتوصله إلى العميل الذي ينتظر طلبه.](https://arabroot.io/articles/%D8%AA%D8%AA%D8%A8%D8%B9-%D9%85%D9%88%D8%A7%D9%82%D8%B9-%D8%A7%D9%84%D9%85%D9%86%D8%AF%D9%88%D8%A8%D9%8A%D9%86-%D9%84%D8%AD%D8%B8%D9%8A%D8%A7/)

## سجل التحديثات

- 17 نوفمبر 2026: كتابة المقال وتنفيذ المختبر على بيانات OpenStreetMap من Overpass API بتاريخ 16 نوفمبر 2026، وPython 3.13.18 وShapely 2.2.0 وpyproj 3.8.0 على Debian 13، وMapLibre GL JS 6.13.0 في Chrome، والتحقق بقواعد IMDF Validations 1.0.3 من المعيار OGC 20-094.