samples/GIS/GIS Visualization Building Footprint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GIS Visualization of Building Footprint\n",
    "This notebook shows how to use C# and Python to visualize a building on a map.\n",
    "Make sure the model has a survey coordinate system defined with real world coordinates.\n",
    "\n",
    "Installation of Jupyter is required. See [here](https://github.com/dotnet/interactive/blob/main/docs/jupyter-in-polyglot-notebooks.md) for options.\n",
    "\n",
    "All python-dependencies are stored in requirements.txt.\n",
    "Create a python cell and run below to install:\n",
    "> pip install -r requirements.txt\n",
    "\n",
    "Run below command to connect to a Python-kernel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "The `#!connect jupyter` feature is in preview. Please report any feedback or issues at https://github.com/dotnet/interactive/issues/new/choose."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Kernel added: #!pythonkernel"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!connect jupyter --kernel-name pythonkernel --kernel-spec python3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once connected, we setup connection to a revit interactive kernel. Run below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: geopandas in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from -r requirements.txt (line 1)) (0.14.3)\n",
      "Requirement already satisfied: shapely in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from -r requirements.txt (line 2)) (2.0.2)\n",
      "Requirement already satisfied: fiona in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from -r requirements.txt (line 3)) (1.9.5)\n",
      "Requirement already satisfied: numpy in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from -r requirements.txt (line 4)) (1.26.3)\n",
      "Requirement already satisfied: packaging in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from geopandas->-r requirements.txt (line 1)) (23.2)\n",
      "Requirement already satisfied: pandas>=1.4.0 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from geopandas->-r requirements.txt (line 1)) (2.2.0)\n",
      "Requirement already satisfied: pyproj>=3.3.0 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from geopandas->-r requirements.txt (line 1)) (3.6.1)\n",
      "Requirement already satisfied: attrs>=19.2.0 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (23.2.0)\n",
      "Requirement already satisfied: certifi in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (2023.11.17)\n",
      "Requirement already satisfied: click~=8.0 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (8.1.7)\n",
      "Requirement already satisfied: click-plugins>=1.0 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (1.1.1)\n",
      "Requirement already satisfied: cligj>=0.5 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (0.7.2)\n",
      "Requirement already satisfied: six in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (1.16.0)\n",
      "Requirement already satisfied: setuptools in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from fiona->-r requirements.txt (line 3)) (65.5.0)\n",
      "Requirement already satisfied: colorama in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from click~=8.0->fiona->-r requirements.txt (line 3)) (0.4.6)\n",
      "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from pandas>=1.4.0->geopandas->-r requirements.txt (line 1)) (2.8.2)\n",
      "Requirement already satisfied: pytz>=2020.1 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from pandas>=1.4.0->geopandas->-r requirements.txt (line 1)) (2023.4)\n",
      "Requirement already satisfied: tzdata>=2022.7 in c:\\users\\sejsau\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from pandas>=1.4.0->geopandas->-r requirements.txt (line 1)) (2023.4)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 23.2.1 -> 24.0\n",
      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#r \"nuget:RevitInteractive\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!connect revit --kernel-name revit --revit-version 2024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#r \"nuget:Revit.RevitApi.x64, 2023.0.0\"\n",
    "#r \"nuget:Revit.RevitApiUi.x64, 2023.0.0\"\n",
    "using Autodesk.Revit.DB;\n",
    "using Autodesk.Revit.UI;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  2 standard systems of units exists: the international one (SI), also known as the metric system, and the imperial system.\n",
    "  Internally, Revit stores in the imperial system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!revit\n",
    "// Assume 'doc' is the current Revit Document you are working with\n",
    "Units units = doc.GetUnits();\n",
    "// Get the FormatOptions for a specific UnitType (e.g., Length)\n",
    "FormatOptions lengthFormatOptions = units.GetFormatOptions(SpecTypeId.Length);\n",
    "\n",
    "// Get the ForgeTypeId for the Length unit\n",
    "ForgeTypeId lengthUnitTypeId = lengthFormatOptions.GetUnitTypeId();\n",
    "\n",
    "// Output the ForgeTypeId to the console or use it as needed\n",
    "lengthUnitTypeId"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shared Coordinates\n",
    "\n",
    "The project location defines the offset from the site location and mesasures in decimal feet.\n",
    "\n",
    "For each location there are two basepoints: project base boint and survey point.\n",
    "\n",
    "We will use the currently active project location. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!revit\n",
    "var projectBasePoint = new FilteredElementCollector(doc).OfClass(typeof(BasePoint))\n",
    "                                                  .Cast<BasePoint>()\n",
    "                                                  .Where(x => x.IsShared!)\n",
    "                                                  .First();\n",
    "\n",
    "var surveyPoint = new FilteredElementCollector(doc).OfClass(typeof(BasePoint))\n",
    "                                                  .Cast<BasePoint>()\n",
    "                                                  .Where(x => x.IsShared)\n",
    "                                                  .First();\n",
    "\n",
    "\n",
    "string prompt1 = \"Displays survey and base point in the active ProjectLocation:\\n\";\n",
    "prompt1 +=  \"\\n\\t\" + $\"Survey point:{surveyPoint.SharedPosition}\";\n",
    "prompt1 +=  \"\\n\\t\" + $\"Project base point:{projectBasePoint.SharedPosition}\";\n",
    "display(prompt1);\n",
    "\n",
    "\n",
    "string prompt2 = \"Displays survey and base point in internal coordinate system:\\n\";\n",
    "prompt2 += \"\\n\\t\" +  $\"Survey point:{surveyPoint.Position}\";\n",
    "prompt2 += \"\\n\\t\" + $\"Project base point:{projectBasePoint.Position}\";\n",
    "display(prompt2);\n",
    "\n",
    "ProjectLocation projectLocation = doc.ActiveProjectLocation;\n",
    "\n",
    "ProjectPosition projectPosition = projectLocation.GetProjectPosition(new XYZ(0,0,0));\n",
    "\n",
    "projectPosition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "#!revit\n",
    "\n",
    "var convertToDisplayUnits = (double valueInFeet) => UnitUtils.ConvertFromInternalUnits(valueInFeet, lengthUnitTypeId);\n",
    "\n",
    "// Format the prompt string to show the message.\n",
    "String prompt = \"Current project location information converted to display units:\\n\";\n",
    "prompt += \"\\n\\t\" + \"Origin point position:\";\n",
    "prompt += \"\\n\\t\\t\" + \"Angle: \" + projectPosition.Angle;\n",
    "prompt += \"\\n\\t\\t\" + \"East to West offset: \" + convertToDisplayUnits(projectPosition.EastWest); //The offset of the project location from the site location in the east/west direction. Measured in decimal feet.\n",
    "prompt += \"\\n\\t\\t\" + \"Elevation: \" + convertToDisplayUnits(projectPosition.Elevation);\n",
    "prompt += \"\\n\\t\\t\" + \"North to South offset: \" + convertToDisplayUnits(projectPosition.NorthSouth);\n",
    "display(prompt);\n",
    "\n",
    "\n",
    "XYZ translationVector = new XYZ(\n",
    "  projectPosition.EastWest,\n",
    "  projectPosition.NorthSouth,\n",
    "  projectPosition.Elevation);\n",
    "\n",
    "Transform translationTransform\n",
    "  = Transform.CreateTranslation(\n",
    "    translationVector);\n",
    "\n",
    "// Create a rotation for the angle about true north\n",
    "\n",
    "Transform rotationTransform\n",
    "  = Transform.CreateRotationAtPoint(XYZ.BasisZ, projectPosition.Angle, XYZ.Zero);\n",
    "// Combine the transforms \n",
    "\n",
    "Transform finalTransform\n",
    "  = translationTransform.Multiply(\n",
    "    rotationTransform);\n",
    "\n",
    "var internalToSurveyTransform = finalTransform;\n",
    "\n",
    "\n",
    "display(internalToSurveyTransform.OfPoint(new XYZ(0,0,0)));\n",
    "// Use the inverse of the survey point transform to convert the point from internal to survey coordinates\n",
    "internalToSurveyTransform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter all floors in active view. If you leave active view out in the collector, it will search the entire database.\n",
    "Also collect solids of the floors and return the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!revit\n",
    "\n",
    "\n",
    "var floorsInActiveView = new FilteredElementCollector(doc, doc.ActiveView.Id)\n",
    "                .WhereElementIsNotElementType()\n",
    "                .WhereElementIsViewIndependent()\n",
    "                .OfClass(typeof(Floor))\n",
    "                .OfType<Floor>();\n",
    "\n",
    "\n",
    "/*\n",
    "var allFloors = new FilteredElementCollector(doc)\n",
    "                .WhereElementIsNotElementType()\n",
    "                .WhereElementIsViewIndependent()\n",
    "                .OfClass(typeof(Floor))\n",
    "                .OfType<Floor>();\n",
    "\n",
    "\n",
    "var floorsNotInActiveView = allFloors.Where(f => !floorsInActiveView.Any(x => x.Id.IntegerValue == f.Id.IntegerValue));\n",
    "*/\n",
    "\n",
    "\n",
    "//display($\"Floors not in active view: {floorsNotInActiveView.Count()}\");\n",
    "//display(floorsNotInActiveView.First().Id);\n",
    "\n",
    "List<Solid> solids = new List<Solid>();\n",
    "foreach (var floor in floorsInActiveView){\n",
    "\n",
    "    GeometryElement geometry = floor.get_Geometry(new Options());\n",
    "\n",
    "    foreach(var g in geometry){\n",
    "\n",
    "        Solid solid = g as Solid;\n",
    "\n",
    "        if (solid != null){\n",
    "            solids.Add(solid);\n",
    "        }\n",
    "\n",
    "    }\n",
    "\n",
    "}\n",
    "display(solids.Count());\n",
    "solids\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In each solid, we pick the lowest face."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!revit\n",
    "\n",
    "List<PlanarFace> planarFaces = new List<PlanarFace>();\n",
    "foreach (var solid in solids){\n",
    "\n",
    "PlanarFace lowest = null;\n",
    "    FaceArray faceArray = solid.Faces;\n",
    "    foreach( Face f in faceArray )\n",
    "    {\n",
    "      PlanarFace pf = f as PlanarFace;\n",
    "      if( null != pf && (pf.FaceNormal.Z==1.0 || pf.FaceNormal.Z==-1.0))\n",
    "      {\n",
    "        if( ( null == lowest )\n",
    "          || ( pf.Origin.Z < lowest.Origin.Z ) )\n",
    "        {\n",
    "          lowest = pf;\n",
    "        }\n",
    "      }\n",
    "    }\n",
    "planarFaces.Add(lowest);\n",
    "\n",
    "}\n",
    "planarFaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the transform will give us coordinates in imperial units we need to convert to display settings if metric system is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!revit\n",
    "\n",
    "var convertToDisplayUnits = (XYZ pt) => new XYZ(UnitUtils.ConvertFromInternalUnits(pt.X, lengthUnitTypeId),\n",
    "                                                UnitUtils.ConvertFromInternalUnits(pt.Y, lengthUnitTypeId),\n",
    "                                                UnitUtils.ConvertFromInternalUnits(pt.Z, lengthUnitTypeId));\n",
    "\n",
    "List<List<XYZ>> polygons = new List<List<XYZ>>();\n",
    "\n",
    "display(planarFaces.Count());\n",
    "\n",
    "foreach (PlanarFace f in planarFaces){\n",
    "//display(f.EdgeLoops);\n",
    "    if (f!=null){\n",
    "    var loops = f.EdgeLoops;\n",
    "    foreach (EdgeArray loop in loops)\n",
    "        {\n",
    "            // Select many flattens the list of lists of points into a single list of points\n",
    "            List<XYZ> vertices = loop.Cast<Edge>()\n",
    "                .SelectMany(e => e.Tessellate(), (e, point) => convertToDisplayUnits(internalToSurveyTransform.OfPoint(point)) )\n",
    "                .ToList();\n",
    "\n",
    "            // Remove last point if it's a duplicate of the first (closed loop assumption)\n",
    "            if (vertices.First().IsAlmostEqualTo(vertices.Last()))\n",
    "            {\n",
    "                vertices.RemoveAt(vertices.Count - 1);\n",
    "            }\n",
    "\n",
    "            polygons.Add(vertices);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "polygons\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cell below sends the polygon data to the python-kernel for processing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [],
   "source": [
    "#!set --value @revit:polygons --name polygons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract the XY-coordinates and build polygons. Order it by area and pick the largest one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [],
   "source": [
    "import shapely\n",
    "from shapely.geometry import Point, Polygon, LineString, GeometryCollection\n",
    "from shapely.ops import unary_union\n",
    "import numpy as      np\n",
    "\n",
    "coords = list(map(lambda p: list(map(lambda pt: (pt[\"X\"],pt[\"Y\"]),p) ),polygons))\n",
    "\n",
    "_polygons = list(map(lambda coords: Polygon(coords),coords))\n",
    "_sorted = sorted(_polygons, key=lambda p: p.area, reverse=True)\n",
    "footprint = _sorted[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute cell below to produce a shape-file in same directory as this notebook.\n",
    "\n",
    "You can use QGIS or other GIS-software to visualize the shape on a map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [],
   "source": [
    "import geopandas as gpd\n",
    "from shapely.geometry import Point, Polygon\n",
    "from fiona.crs import from_epsg\n",
    "\n",
    "# Create an empty geopandas GeoDataFrame\n",
    "newdata = gpd.GeoDataFrame()\n",
    "\n",
    "# Insert the polygon into 'geometry' -column at index 0\n",
    "newdata.loc[0, 'geometry'] = footprint\n",
    "\n",
    "# Set the GeoDataFrame's coordinate system to WGS84 (i.e. epsg code 4326)\n",
    "# https://spatialreference.org/ref/epsg/2272/\n",
    "#newdata.crs = from_epsg(3007)\n",
    "newdata.crs = from_epsg(2272) #Revit 2024 Snowdon Towers CS\n",
    "\n",
    "# Determine the output path for the Shapefile\n",
    "outfp = \"footprint.shp\"\n",
    "\n",
    "# Write the data into that Shapefile\n",
    "newdata.to_file(outfp)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "polyglot-notebook"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     },
     {
      "aliases": [],
      "languageName": "python",
      "name": "pythonkernel"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}