ex7_building_modeling_optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) 2012-2024 Esri R&D Center Zurich\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "you may not use this file except in compliance with the License.\n",
    "You may obtain a copy of the License at\n",
    "\n",
    "  https://www.apache.org/licenses/LICENSE-2.0\n",
    "\n",
    "Unless required by applicable law or agreed to in writing, software\n",
    "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "See the License for the specific language governing permissions and\n",
    "limitations under the License.\n",
    "A copy of the license is available in the repository's LICENSE file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyPRT - Building Modeling Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we are using a CGA rule that allows us to generate modern and sustainable buildings. The architecture of these buildings is focused on the green aspect of the building. Therefore, in addition to be modern and esthetical, the generated building answers also to the actual requirements of the city which are to encourage the integration of greenery on the buildings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Bosco Verticale in Milan](images/bosco_verticale_milan.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bosco Verticale in Milan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "from scipy import optimize\n",
    "import numpy as np\n",
    "import pyvista\n",
    "import trame\n",
    "from vtkmodules.vtkIOImport import vtkGLTFImporter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyprt\n",
    "pyprt.initialize_prt()\n",
    "\n",
    "if(not pyprt.is_prt_initialized()):\n",
    "    raise Exception(\"PRT is not initialized\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization Problem Definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the architectural design of this building (defined by the CGA rule) and the parcel, which value of the **lot coverage**, **tier height** and **building shape** should we choose in order to maximize the building green potential (green area)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Building Parameters](images/green_building_parameters.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, only the previously mentioned variables were taken into account for simplicity purposes. For instance, the building parcel geographical orientation is not known. Therefore, the sun direction could not be derived. The well-being of the plants and greenery is thus not considered."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Given: building architecture (CGA Rule Package) and parcel to redevelop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CWD = os.getcwd()\n",
    "DATA = os.path.join(CWD, 'data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rpk_green = os.path.join(DATA, 'envelope2002.rpk')\n",
    "attrs_green = {'report_but_not_display_green': True, 'seed': 666}\n",
    "shape_geo = pyprt.InitialShape(os.path.join(DATA, 'building_parcel.obj'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Greenery Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 1 : optimize the total green area reported (including the balconies trees). This will be optimized taking into account several parameters:\n",
    "- the shape of the building (1 = orthogonal, 2 = L shape, 3 = U shape, 4 = O shapes)\n",
    "- the lot coverage\n",
    "- the height of the first tier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optimization Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "goal_str_green = 'Greenery Area' + '_sum'\n",
    "\n",
    "input_attr_green = ['lot_coverage_parameter',\n",
    "                    'height_first_tier', 'shape_of_building']\n",
    "x0_green = [float(50), float(9), float(round(2))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = pyprt.ModelGenerator([shape_geo])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fct_green(x):\n",
    "\n",
    "    attrs_green[input_attr_green[0]] = x[0]\n",
    "    attrs_green[input_attr_green[1]] = x[1]\n",
    "    attrs_green[input_attr_green[2]] = float(round(x[2]))\n",
    "    generated_mod_green = m.generate_model([attrs_green], rpk_green,\n",
    "                          'com.esri.pyprt.PyEncoder', {'emitGeometry': False})\n",
    "\n",
    "    if generated_mod_green:\n",
    "        rep_green = generated_mod_green[0].get_report()\n",
    "        return -rep_green[goal_str_green]\n",
    "    else:\n",
    "        print('Error in optimization process.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables boundaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bounds_green = [(0, 100), (8, 13), (1, 4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The SciPy optimization library is extensively used within Python community. However, **any** optimization algorithm works with PyPRT. In this notebook, the optimization problem to solve is complex and highly non linear. The differential evolution algorithm from SciPy is particularly suited to our problem because it is stochastic and, thus, does not need any gradient computation to find the minimum. The choice of optimization algorithm depends on the problem and, in our case, the CGA rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res_green = optimize.differential_evolution(\n",
    "    fct_green, bounds_green, tol=0.15, seed=666)\n",
    "res_green"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Results Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export_file_name = 'ex7_optimalmodel1'\n",
    "enc_options = {'baseName': export_file_name,\n",
    "               'outputPath': os.path.join(CWD, 'ex7_output')}\n",
    "os.makedirs(enc_options['outputPath'], exist_ok=True)\n",
    "\n",
    "attrs_green[input_attr_green[0]] = res_green.x[0]\n",
    "attrs_green[input_attr_green[1]] = res_green.x[1]\n",
    "attrs_green[input_attr_green[2]] = float(round(res_green.x[2]))\n",
    "green_model = m.generate_model(\n",
    "    [attrs_green], rpk_green, 'com.esri.prt.codecs.GLTFEncoder', enc_options)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "raw_mimetype": "text/x-python"
   },
   "outputs": [],
   "source": [
    "importer = vtkGLTFImporter()\n",
    "importer.SetFileName(os.path.join(\n",
    "    enc_options['outputPath'], export_file_name+'_0.glb'))\n",
    "pl = pyvista.Plotter()\n",
    "pl.set_background('white')\n",
    "pl.show_axes()\n",
    "pl.enable_depth_peeling()\n",
    "pl.add_light(pyvista.Light(light_type='scene light'))\n",
    "importer.SetRenderWindow(pl.ren_win)\n",
    "importer.Update()\n",
    "pl.show(cpos='xy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-Objectives Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 2 : optimize the green area reported including the balconies trees AND the floor area in order to avoid thin walls. We will keep O-shape building. This will be optimized taking into account several parameters:\n",
    "\n",
    "- the lot coverage\n",
    "- the height of the first tier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optimization Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "goal_str_green = 'Greenery Area' + '_sum'\n",
    "goal_str_floor = 'Floor area' + '_sum'\n",
    "# this allows having similar range between the green area and the floor area\n",
    "floor_weight = 0.07\n",
    "\n",
    "input_attr_green = ['lot_coverage_parameter', 'height_first_tier']\n",
    "x0_green = [float(50), float(9)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "attrs_green = {'report_but_not_display_green': True, 'seed': 666, 'shape_of_building': 4.0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fct_green(x):\n",
    "\n",
    "    attrs_green[input_attr_green[0]] = x[0]\n",
    "    attrs_green[input_attr_green[1]] = x[1]\n",
    "    generated_mod_green = m.generate_model([attrs_green], rpk_green,\n",
    "                          'com.esri.pyprt.PyEncoder', {'emitGeometry': False})\n",
    "\n",
    "    if generated_mod_green:\n",
    "        rep_green = generated_mod_green[0].get_report()\n",
    "        return -(rep_green[goal_str_green]+floor_weight*rep_green[goal_str_floor])\n",
    "    else:\n",
    "        print('Error in optimization process.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bounds_green = [(0, 100), (8, 13)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res_green = optimize.differential_evolution(\n",
    "    fct_green, bounds_green, tol=0.1, seed=666)\n",
    "res_green"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Results Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export_file_name = 'ex7_optimalmodel2'\n",
    "enc_options['baseName'] = export_file_name\n",
    "\n",
    "attrs_green[input_attr_green[0]] = res_green.x[0]\n",
    "attrs_green[input_attr_green[1]] = res_green.x[1]\n",
    "green_model = m.generate_model(\n",
    "    [attrs_green], rpk_green, 'com.esri.prt.codecs.GLTFEncoder', enc_options)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "importer = vtkGLTFImporter()\n",
    "importer.SetFileName(os.path.join(\n",
    "    enc_options['outputPath'], export_file_name+'_0.glb'))\n",
    "pl = pyvista.Plotter()\n",
    "pl.set_background('white')\n",
    "pl.show_axes()\n",
    "pl.enable_depth_peeling()\n",
    "pl.add_light(pyvista.Light(light_type='scene light'))\n",
    "importer.SetRenderWindow(pl.ren_win)\n",
    "importer.Update()\n",
    "pl.show(cpos='xy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyprt.shutdown_prt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "esriNotebookRuntime": {
   "notebookRuntimeName": "ArcGIS Notebook Python 3 Advanced",
   "notebookRuntimeVersion": "10.7.1"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}