diff --git a/.gitignore b/.gitignore index 66d447b..14e513d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,3 @@ -s2v/* -s5/* PyRATP/pyratp_wralea/* PyRATP/__pycache__/* PyRATP/__init__.py @@ -26,8 +24,6 @@ LightVegeManager_Singularity.egg-info build dist PyRATP/pyratp/pyratp.pyd -s2v -s5 .vscode runscripts/legume/debug_tests.py Run-tmp diff --git a/doc/_img/paraview_example.png b/doc/_img/paraview_example.png new file mode 100644 index 0000000..773f798 Binary files /dev/null and b/doc/_img/paraview_example.png differ diff --git a/doc/_img/tesselation_voxels.png b/doc/_img/tesselation_voxels.png new file mode 100644 index 0000000..78d72aa Binary files /dev/null and b/doc/_img/tesselation_voxels.png differ diff --git a/doc/_img/transform_geo.png b/doc/_img/transform_geo.png new file mode 100644 index 0000000..59a3c14 Binary files /dev/null and b/doc/_img/transform_geo.png differ diff --git a/examples/plaque_ratp-caribu.py b/examples/plaque_ratp-caribu.py index b34e8f1..335e8ca 100644 --- a/examples/plaque_ratp-caribu.py +++ b/examples/plaque_ratp-caribu.py @@ -34,7 +34,7 @@ def simulation(geom, hour, situation, direct, diffus, ratp_mu, dv, folderout): ratp_parameters["soil reflectance"] = [0., 0.] ratp_parameters["reflectance coefficients"] = [[0.1, 0.05]] ratp_parameters["mu"] = ratp_mu - ratp_parameters["tesselation level"] = 7 + ratp_parameters["tesselation level"] = 5 ratp_parameters["angle distrib algo"] = "compute global" ratp_parameters["nb angle classes"] = 45 @@ -53,7 +53,7 @@ def simulation(geom, hour, situation, direct, diffus, ratp_mu, dv, folderout): # VTK de la scène avec x+ = North path_out = folderout+"caribu_"+str(day)+"_"+str(hour)+"h"+"_"+situation - lghtcaribu.VTK_light(path_out) + # lghtcaribu.VTK_light(path_out) # RATP print("\n\t R A T P") @@ -66,11 +66,11 @@ def simulation(geom, hour, situation, direct, diffus, ratp_mu, dv, folderout): # VTK de la scène avec x+ = North path_out = folderout+"ratp_"+str(day)+"_"+str(hour)+"h"+"_"+situation - lghtratp.VTK_light(path_out) + # lghtratp.VTK_light(path_out) # ligne du soleil (rotation de 180° autour de z pour se mettre dans l'espace x+ = North) - lghtcaribu.VTK_sun(folderout+"sun_day"+str(day)+"_"+str(hour)) + # lghtcaribu.VTK_sun(folderout+"sun_day"+str(day)+"_"+str(hour)) print("\n") if __name__ == "__main__": diff --git a/examples/quick_test.py b/examples/quick_test.py index 4e5c576..6066caa 100644 --- a/examples/quick_test.py +++ b/examples/quick_test.py @@ -13,10 +13,22 @@ # compute lighting energy = 500 -hour = 15 +hour = 12 day = 264 # 21st september -lighting.run(energy, hour, day) +lighting.run(energy=energy, hour=hour, day=day) # output print(lighting.elements_outputs) + +# initialize the instance +lighting = LightVegeManager(lightmodel="ratp") + +# build the scene +lighting.build(geometry=triangle_vertices) + +# compute the lighting +lighting.run(energy=energy, hour=hour, day=day) + +# print the outputs +print(lighting.elements_outputs) print("--- END") \ No newline at end of file diff --git a/examples/quick_test2.py b/examples/quick_test2.py new file mode 100644 index 0000000..8d62c7b --- /dev/null +++ b/examples/quick_test2.py @@ -0,0 +1,34 @@ +from lightvegemanager.tool import LightVegeManager +import openalea.plantgl.all as pgl + +print("--- START") + +# one triangle as a geometric element +triangle_vertices_1 = [[(0.,0.,0.), (1.,0.,0.), (1.,1.,1.)]] +triangle_vertices_2 = [[(0.,2.,0.), (1.,2.,0.), (1.,3.,1.)]] +stems = [(0,1)] +geometry = { + "scenes" : [triangle_vertices_1, triangle_vertices_2], + "stems id" : stems +} + +# surfacic lighting with CARIBU +lighting = LightVegeManager(lightmodel="caribu") + +# build the scene +lighting.build(geometry=geometry) + +# compute lighting +energy = 500 +hour = 15 +day = 264 # 21st september +lighting.run(energy, hour, day) + +# output +print(lighting.elements_outputs) + +# visualisation +pglscene = lighting.plantGL_light() +pgl.Viewer.display(pglscene) + +print("--- END") \ No newline at end of file diff --git a/examples/quick_test3.py b/examples/quick_test3.py new file mode 100644 index 0000000..b620f27 --- /dev/null +++ b/examples/quick_test3.py @@ -0,0 +1,33 @@ +# import the class tool +from lightvegemanager.tool import LightVegeManager +from lightvegemanager.trianglesmesh import random_triangle_generator +import openalea.plantgl.all as pgl +import random + +spheres = [] + +for i in range(255): + x, y, z = [random.choice([-1, 1]) * random.randrange(0, int(255/2)) for i in range(3)] + m = pgl.Material(ambient=(x+int(255/2), y+int(255/2), z+int(255/2)), shininess=0.1, diffuse=1) + spheres.append(pgl.Shape(pgl.Translated(x, y, z, pgl.Sphere(random.randrange(1, 20), 20, 20)), m)) + +nb_triangles = 500 +spheresize = (10., 2.) +triangles = [] +for i in range(nb_triangles): + triangles.append(random_triangle_generator(spheresize=spheresize)) + +# initialize the instance +lighting = LightVegeManager(lightmodel="caribu") + +# build the scene +lighting.build(geometry=triangles) + +# compute the lighting +energy = 500. +hour = 15 +day = 264 +lighting.run(energy=energy, hour=hour, day=day) + +pglscene = lighting.plantGL_light() +pgl.Viewer.display(pglscene) \ No newline at end of file diff --git a/examples/quick_test4.py b/examples/quick_test4.py new file mode 100644 index 0000000..31b7adb --- /dev/null +++ b/examples/quick_test4.py @@ -0,0 +1,67 @@ +import os +from lightvegemanager.tool import LightVegeManager +from openalea.plantgl.all import Scene, Viewer + +fet_fgeom = os.path.join(os.path.abspath(""), "data", "Fet-LD-F2.bgeom") +luz_fgeom = os.path.join(os.path.abspath(""), "data", "LD-F1.bgeom") +bgeom_files = [fet_fgeom, luz_fgeom] + +# setup environment +environment = {} +environment["coordinates"] = [48.8 ,2.3 ,1] # latitude, longitude, timezone + +# we compute only sun light in a finite scene +environment["diffus"] = False +environment["direct"] = True +environment["reflected"] = False +environment["infinite"] = False + +# CARIBU parameters +caribu_parameters = {} +caribu_parameters["sun algo"] = "caribu" +caribu_parameters["caribu opt"] = {} +caribu_parameters["caribu opt"]["par"] = (0.10, 0.05) + +# inputs values for lighting +energy=500 +day=264 +hour=15 + +# scene generation parameters +nplants = 10 +plant_density=130 +var_plant_position=110 + +from lightvegemanager.trianglesmesh import create_heterogeneous_canopy + +# Initializing the tool +lighting = LightVegeManager(lightmodel="caribu", + environment=environment, + lightmodel_parameters=caribu_parameters) + +# generate random canopy from plant examples +if not isinstance(bgeom_files, list): bgeom_files = [bgeom_files] +scenes = [] +for f in bgeom_files : + plant_scene = Scene() + plant_scene.read(f, 'BGEOM') + + # multiply a plant with variations + canopy, domain = create_heterogeneous_canopy(plant_scene, + nplants=nplants, + plant_density=plant_density, + var_plant_position=var_plant_position) + + scenes.append(canopy) + +# build the scene +geometry = {"scenes" : scenes } + +lighting.build(geometry) + +# compute lighting +lighting.run(energy=energy, hour=hour, day=day) + +s = lighting.plantGL_light(printtriangles=True, printvoxels=False) + +Viewer.display(s) \ No newline at end of file diff --git a/examples/quick_test5.py b/examples/quick_test5.py new file mode 100644 index 0000000..ac25551 --- /dev/null +++ b/examples/quick_test5.py @@ -0,0 +1,28 @@ +from lightvegemanager.tool import LightVegeManager +from lightvegemanager.trianglesmesh import random_triangle_generator +from openalea.plantgl.all import Viewer + +# grid dimensions +dxyz = [1.] * 3 +nxyz = [5, 5, 7] +orig = [0.] * 3 + +# random triangles +nb_triangles = 50 +spheresize = (1., 0.3) # vertices of triangles are the sphere surface +triangles = [] +for i in range(nb_triangles) : + triangles.append(random_triangle_generator(worldsize=(0., 5.), spheresize=spheresize)) + +caribu_args = { "sensors" : ["grid", dxyz, nxyz, orig] } + +lighting = LightVegeManager(lightmodel="caribu", lightmodel_parameters=caribu_args, environment={"infinite":True}) +lighting.build(geometry={"scenes" : [triangles]}) + +energy = 500. +hour = 15 +day = 264 +lighting.run(energy=energy, hour=hour, day=day) + +s = lighting.plantGL_sensors(light=True) +Viewer.display(s) \ No newline at end of file diff --git a/examples/quick_test6.py b/examples/quick_test6.py new file mode 100644 index 0000000..8779878 --- /dev/null +++ b/examples/quick_test6.py @@ -0,0 +1,44 @@ +from lightvegemanager.tool import LightVegeManager +from lightvegemanager.trianglesmesh import random_triangle_generator +import numpy + +# grid dimensions +dxyz = [1.] * 3 +nxyz = [7, 7, 7] +orig = [-1., -1., 0.] + +spheresize = (1., 0.3) # vertices of triangles are the sphere surface +worldsize = (0., 5.) + +nb_triangles = 10 +triangles1 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)] + +nb_triangles = 9 +triangles2 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)] + +nb_triangles = 8 +triangles3 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)] + +scene = {0: triangles1, 1: triangles2, 2: triangles3} + + +ratp_parameters = { "voxel size" : dxyz, + "origin" : orig, + "number voxels" : nxyz, + "full grid" : True} + +lighting = LightVegeManager(lightmodel="ratp", lightmodel_parameters=ratp_parameters) +lighting.build(geometry={"scenes" : [scene] }) + +energy = 500. +hour = 15 +day = 264 +lighting.run(energy=energy, hour=hour, day=day) + +m_lais = numpy.zeros([1] + nxyz) +for row in lighting.voxels_outputs.itertuples(): + m_lais[int(row.VegetationType)-1][row.Nz-1][row.Nx-1][row.Ny-1] = row.Area +res_abs_i, res_trans = lighting.to_l_egume(m_lais=m_lais) + +print(res_abs_i[0]) +print(res_trans) \ No newline at end of file diff --git a/notebooks/environment_parameters.ipynb b/notebooks/environment_parameters.ipynb new file mode 100644 index 0000000..fb5d6d0 --- /dev/null +++ b/notebooks/environment_parameters.ipynb @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "164dd004", + "metadata": {}, + "source": [ + "# Environment parameters\n", + "\n", + "## Content\n", + "- First\n", + "- sky\n", + " - turtle of 46 directions\n", + " - file\n", + " - custom number of sky directions\n", + "\n", + "## Introduction\n", + "Environment parameters are stored in a dict and transferred as an input argument for a LightVegeManager instance. It defines all static parameters during a simulation, such the sky type, radiative options etc...\n", + "\n", + "```python\n", + "environment = {\n", + " \"coordinates\" : [latitude, longitude, timezone] ,\n", + "\n", + " \"sky\" : \"turtle46\" ,\n", + " \"sky\" : [\"file\", filepath] ,\n", + " \"sky\" : [nb_azimut, nb_zenith, \"soc\" or \"uoc\"] ,\n", + "\n", + " \"direct\" : bool, # sun radiations\n", + " \"diffus\" : bool, # sky radiations\n", + " \"reflected\" : bool, # reflected radiation in the canopy\n", + " \"infinite\" : bool, # infinitisation of the scene\n", + " }\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8cabb25", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget" + ] + }, + { + "cell_type": "markdown", + "id": "a951e939", + "metadata": {}, + "source": [ + "As a geometric example, we will use a random set of 3D triangles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f37d299", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.trianglesmesh import random_triangle_generator\n", + "\n", + "nb_triangles = 50\n", + "spheresize = (10., 2.) # vertices of triangles are the sphere surface\n", + "triangles = []\n", + "for i in range(nb_triangles):\n", + " triangles.append(random_triangle_generator(spheresize=spheresize))" + ] + }, + { + "cell_type": "markdown", + "id": "1eb888dc", + "metadata": {}, + "source": [ + "## First options\n", + "\n", + "- `\"coordinates\"`: sets the coordinates of the simulation, this matters if you want direct radiations\n", + "- `\"infinite\"`: sets if you want an infinite reproduction\n", + "- `\"reflected\"`: activates or not the reflections in the scene\n", + "- `\"direct\"`: activates or not the direct radiations (sun)\n", + "- `\"diffuse\"`: activates or not the diffuse radiations (sky)" + ] + }, + { + "cell_type": "markdown", + "id": "2d74bc78", + "metadata": {}, + "source": [ + "An example of use" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d3ea6e8", + "metadata": {}, + "outputs": [], + "source": [ + "longitude = 2.\n", + "latitude = 46.\n", + "timezone = 1\n", + "coordinates = [latitude, longitude, timezone]\n", + "infinite = False\n", + "reflected = False\n", + "direct = False\n", + "diffuse = True\n", + "\n", + "environment = {\n", + " \"coordinates\": coordinates ,\n", + " \"infinite\": infinite\n", + " \"reflected\": reflected,\n", + " \"direct\": False,\n", + " \"diffuse\": True\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c16d6a23", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=triangles)\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "fdf646c2", + "metadata": {}, + "source": [ + "## Different ways to set a sky" + ] + }, + { + "cell_type": "markdown", + "id": "625b9a25", + "metadata": {}, + "source": [ + "### Turtle46\n", + "This options creates a sky in a turtle of 46 directions. It is the default sky in the tool." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a39681ea", + "metadata": {}, + "outputs": [], + "source": [ + "sky = \"turtle46\" \n", + "environment.update({\"sky\": sky})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "039321e4", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=triangles)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "2a98da17", + "metadata": {}, + "source": [ + "### File\n", + "You can set sky directions in a file. It needs azimut, zenit, weight and solid angle of each direction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2c5c662", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "datafile = os.path.join(os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\"), \"sky_5.data\")\n", + "datafile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86958bd3", + "metadata": {}, + "outputs": [], + "source": [ + "sky = [\"file\", datafile]\n", + "environment.update({\"sky\": sky})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7626d4e9", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=triangles)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "f4e17619", + "metadata": {}, + "source": [ + "### Custom number of directions\n", + "You can directly precise the number of directions for each spherical axis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1622b9ed", + "metadata": {}, + "outputs": [], + "source": [ + "nazimuts = 5\n", + "nzenits = 5\n", + "skytype = \"soc\"\n", + "sky = [nazimuts, nzenits, skytype]\n", + "environment.update({\"sky\": sky})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "653e163c", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=triangles)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "4ae8f61d", + "metadata": {}, + "source": [ + "### And RATP ?\n", + "All the skies defined above are available with RATP as the light model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a565276b", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"ratp\", environment=environment)\n", + "lighting.build(geometry=triangles)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.triangles_outputs)" + ] + } + ], + "metadata": { + "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": 5 +} diff --git a/notebooks/example_canopy.ipynb b/notebooks/example_canopy.ipynb new file mode 100644 index 0000000..618b93b --- /dev/null +++ b/notebooks/example_canopy.ipynb @@ -0,0 +1,245 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cbde3745", + "metadata": {}, + "source": [ + "# Example of use\n", + "Here is an example with a more \"realistic\" canopy. We start from a single fescue and alfafa in a `.bgeom` file, then we will generate copies and random positions in order to make a canopy." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a08c5c2f", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget\n", + "from openalea.plantgl.all import Scene" + ] + }, + { + "cell_type": "markdown", + "id": "9f47c2cf", + "metadata": {}, + "source": [ + "## Canopy generation\n", + "\n", + "Load the `.bgeom` files" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8a256e07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['C:\\\\Users\\\\mwoussen\\\\cdd\\\\codes\\\\dev\\\\lightvegemanager\\\\data\\\\Fet-LD-F2.bgeom',\n", + " 'C:\\\\Users\\\\mwoussen\\\\cdd\\\\codes\\\\dev\\\\lightvegemanager\\\\data\\\\LD-F1.bgeom']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fet_fgeom = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\", \"Fet-LD-F2.bgeom\")\n", + "luz_fgeom = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\", \"LD-F1.bgeom\")\n", + "bgeom_files = [fet_fgeom, luz_fgeom]\n", + "bgeom_files" + ] + }, + { + "cell_type": "markdown", + "id": "1cd43c24", + "metadata": {}, + "source": [ + "Generate copies in random position" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4748bbba", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.trianglesmesh import create_heterogeneous_canopy\n", + "\n", + "# scene generation parameters\n", + "nplants = 50\n", + "plant_density=130 \n", + "var_plant_position=110\n", + "\n", + "# generate random canopy from plant examples\n", + "if not isinstance(bgeom_files, list): bgeom_files = [bgeom_files]\n", + "scenes = []\n", + "for f in bgeom_files :\n", + " plant_scene = Scene()\n", + " plant_scene.read(f, 'BGEOM')\n", + "\n", + " # multiply a plant with variations\n", + " canopy, domain = create_heterogeneous_canopy(plant_scene, \n", + " nplants=nplants, \n", + " plant_density=plant_density, \n", + " var_plant_position=var_plant_position)\n", + "\n", + " scenes.append(canopy)" + ] + }, + { + "cell_type": "markdown", + "id": "6d7ebdf6", + "metadata": {}, + "source": [ + "## Lighting simulation\n", + "Set simulation parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6079d47a", + "metadata": {}, + "outputs": [], + "source": [ + "# setup environment\n", + "environment = {}\n", + "environment[\"coordinates\"] = [48.8 ,2.3 ,1] # latitude, longitude, timezone\n", + "\n", + "# we compute only sun light in an infinite scene\n", + "environment[\"diffus\"] = False\n", + "environment[\"direct\"] = True\n", + "environment[\"reflected\"] = False\n", + "environment[\"infinite\"] = True\n", + "\n", + "# CARIBU parameters\n", + "caribu_parameters = {\n", + " \"sun algo\": \"caribu\",\n", + " \"caribu opt\" : { \"par\": (0.10, 0.05) }\n", + "}\n", + "\n", + "# inputs values for lighting\n", + "energy=500\n", + "day=264\n", + "hour=15\n" + ] + }, + { + "cell_type": "markdown", + "id": "7cd1baa4", + "metadata": {}, + "source": [ + "Run the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d0a11760", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Organ VegetationType Area par Eabs par Ei\n", + "0 264 15 825510368 0 83.332180 68.469279 80.552093\n", + "1 264 15 825501440 0 75.958035 174.799148 205.646057\n", + "2 264 15 825503168 0 4.520565 71.441463 84.048780\n", + "3 264 15 825503824 0 57.771363 75.469741 88.787931\n", + "4 264 15 825498448 0 5.711880 113.087842 133.044520\n", + ".. ... ... ... ... ... ... ...\n", + "321 264 15 825485200 1 2.625990 266.464178 313.487268\n", + "322 264 15 825485904 1 18.000312 119.617531 140.726507\n", + "323 264 15 825486976 1 12.152513 93.015484 109.429981\n", + "324 264 15 825488784 1 9.200676 594.787384 699.749863\n", + "325 264 15 825489120 1 9.200676 419.272837 493.262162\n", + "\n", + "[326 rows x 7 columns]\n" + ] + } + ], + "source": [ + "# Initializing the tool\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", \n", + " environment=environment, \n", + " lightmodel_parameters=caribu_parameters) \n", + "\n", + "\n", + "\n", + "# build the scene\n", + "geometry = {\"scenes\" : scenes }\n", + "\n", + "lighting.build(geometry)\n", + "\n", + "# compute lighting\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "# print results gathered by elements (Shapes in the plantGL Scene)\n", + "print(lighting.elements_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "89796080", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f0ea148ac54849e680a6906f47acf159", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'iscrYkj7jZcxvvYDWDY2BWYsh', 'data': b'x\\xda\\x94}\\t\\x98%E\\x95n\\xa…" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# visualisation\n", + "SceneWidget(lighting.plantGL_light(printtriangles=True, printvoxels=False), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + } + ], + "metadata": { + "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": 5 +} diff --git a/notebooks/input_scenes.ipynb b/notebooks/input_scenes.ipynb new file mode 100644 index 0000000..a17e21c --- /dev/null +++ b/notebooks/input_scenes.ipynb @@ -0,0 +1,983 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2712967b", + "metadata": {}, + "source": [ + "# Geometric inputs\n", + "\n", + "## Content\n", + "- input formats\n", + " - dict\n", + " - plantGL\n", + " - fichier VGX\n", + " - grille de voxels\n", + " - table MTG de adelwheat\n", + "- organization levels: species and organs\n", + "- stems management\n", + "- geometric transformations\n", + "\n", + "## Introduction\n", + "The main purpose of this tool was to merge several geometric scenes in various formats and apply a radiative modelling on it. Here, we will precise the different possiblities to an input geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "533d5d6d", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d60e30fc", + "metadata": {}, + "outputs": [], + "source": [ + "longitude = 2.\n", + "latitude = 46.\n", + "timezone = 1\n", + "coordinates = [latitude, longitude, timezone]\n", + "infinite = False\n", + "reflected = False\n", + "direct = False\n", + "diffuse = True\n", + "sky = \"turtle46\" \n", + "\n", + "environment = {\n", + " \"coordinates\": coordinates ,\n", + " \"infinite\": infinite\n", + " \"reflected\": reflected,\n", + " \"direct\": False,\n", + " \"diffuse\": True,\n", + " \"sky\": sky\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "3b713261", + "metadata": {}, + "source": [ + "## Inputs Formats\n", + "In this section, we won't present single triangle and list of triangles as input geometry, as they were present in the tool_basics notebook. Also, these two formats can be direct inputs of the `geometry` argument of the `build` method, unlike the following formats which needs to be included in a list, such as:\n", + "\n", + "```python\n", + "geometry = { \"scenes\": [scene1, scene2, ...] }\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "8c40dd23", + "metadata": {}, + "source": [ + "### dict of triangles\n", + "A mesh of triangles can be represented as a dict, where each key is an organ ID and its value, a list of triangles belonging to the organ. A triangle is a list of a 3 vertices represented by `(x,y,z)`points.\n", + "\n", + "In this example, we will generate random 3D triangles for 3 differents organs." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1ce4b2f8", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.trianglesmesh import random_triangle_generator\n", + "\n", + "spheresize = (10., 2.)\n", + "organized_triangles = {\n", + " 111: [random_triangle_generator(spheresize=spheresize, worldsize=(0,20)) for i in range(20)],\n", + " 222: [random_triangle_generator(spheresize=spheresize, worldsize=(20,50)) for i in range(30)],\n", + " 333: [random_triangle_generator(spheresize=spheresize, worldsize=(50,100)) for i in range(10)],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "6368552b", + "metadata": {}, + "source": [ + "Input geometry looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c029f0db", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [organized_triangles]\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "e8dfb4e6", + "metadata": {}, + "source": [ + "Then, we compute lighting and run a visualization of the scene.\n", + "\n", + "Note: `elements_outputs` method will return a Dataframe where results are integrated on each organ." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "458d90b0", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=geometry)\n", + "\n", + "# compute the lighting\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b26d8e8a", + "metadata": {}, + "source": [ + "### PlantGL scene\n", + "A plantGL Scene is a list of plantGL Shape which can be considered as organ. The ID of the plantGL Shape are stored as organs ID." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51870eda", + "metadata": {}, + "outputs": [], + "source": [ + "import openalea.plantgl.all as pgl\n", + "\n", + "pgl_scene = pgl.Scene([pgl.Shape(pgl.Box(), pgl.Material(), 888), \n", + " pgl.Shape(pgl.Translated((0,0,1), pgl.Cylinder()), pgl.Material(), 999)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "933b9683", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [pgl_scene]\n", + "}\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=geometry)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 5, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "cc11d7e3", + "metadata": {}, + "source": [ + "### VGX file\n", + "\n", + "The tool can read a VGX file as an input entry. It extracts triangles which are considered as leaves, following its colors, if Red != 42 . All triangles are stored in the same organ, where its ID is set to 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8c9d8fe", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "vgx_path = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\", \"NICatObs1P2.vgx\")\n", + "vgx_path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a3fb580", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [vgx_path]\n", + "}\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=geometry)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 5, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "0f1213f4", + "metadata": {}, + "source": [ + "### Grid of voxels\n", + "\n", + "A voxel grid is represented as a dict of two entries:\n", + "- `\"LA\"` corresponding to leaf area, is a table (`numpy.array`) of dimension $\\text{number of species} \\times \\text{number of z layers} \\times \\text{number of x layers} \\times \\text{number of y layers} $\n", + "- `\"distrib\"` corresponding to leaf angle distribution, is a list of list, where is entered a leaf angle distribution for each specy\n", + "\n", + "Grid dimensions and voxel size are set in the input parameters of RATP." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5baed34", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "\n", + "l_scene = {\"LA\": numpy.ones([2, 3, 4, 4]), \"distrib\": [[0.5, 0.5], [0.3, 0.7]]}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54448444", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [vgx_path]\n", + "}\n", + "ratp_parameters = {\n", + " \"voxel size\" : [20.] * 3\n", + "}\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", environment=environment, lightmodel_parameters=ratp_parameters)\n", + "lighting.build(geometry=geometry)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(printtriangles=False, printvoxels=True), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 5, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "db5111f0", + "metadata": {}, + "source": [ + "### MTG object from adelwheat\n", + "\n", + "Finally, you can also give a MTG object with a `\"scene\"` property. The package adelwheat offers such objects." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "228bf66a", + "metadata": {}, + "outputs": [], + "source": [ + "from alinea.adel.adel_dynamic import AdelDyn\n", + "from alinea.adel.echap_leaf import echap_leaves\n", + "INPUTS_DIRPATH = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\")\n", + "adel_wheat = AdelDyn(seed=1, scene_unit=\"m\", leaves=echap_leaves(xy_model=\"Soissons_byleafclass\"))\n", + "g = adel_wheat.load(dir=INPUTS_DIRPATH)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a73780f", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [g]\n", + "}\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", environment=environment)\n", + "lighting.build(geometry=geometry)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 0.1, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6530bd77", + "metadata": {}, + "source": [ + "### RATP inputs\n", + "All the above scenes can be geometric inputs if the lightmodel argument is set to `\"ratp\"`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbd0394a", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [g]\n", + "}\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", environment=environment)\n", + "lighting.build(geometry=geometry)\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 0.1, \n", + " axes_helper=True)" + ] + }, + { + "attachments": { + "indices.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "5c4a17a0", + "metadata": {}, + "source": [ + "## Organizing the inputs\n", + "\n", + "They are two levels of possible organization:\n", + "- species\n", + "- organs\n", + "\n", + "Each triangle are bound to a specy ID and a organ ID. Each specy is represented as a input scene. The organs ID are set inside each scene depending on its format.\n", + "\n", + "![indices.png](attachment:indices.png)" + ] + }, + { + "cell_type": "markdown", + "id": "0af94bb6", + "metadata": {}, + "source": [ + "An example with several scenes with the same organs ID and CARIBU." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c5fd41ea", + "metadata": {}, + "outputs": [], + "source": [ + "scene1 = {\n", + " 111: [random_triangle_generator(spheresize=spheresize) for i in range(20)],\n", + " 222: [random_triangle_generator(spheresize=spheresize) for i in range(30)],\n", + " 333: [random_triangle_generator(spheresize=spheresize) for i in range(10)],\n", + "}\n", + "\n", + "scene2 = {\n", + " 111: [random_triangle_generator(spheresize=spheresize) for i in range(20)],\n", + " 222: [random_triangle_generator(spheresize=spheresize) for i in range(30)],\n", + " 333: [random_triangle_generator(spheresize=spheresize) for i in range(10)],\n", + "}\n", + "\n", + "scene3 = {\n", + " 111: [random_triangle_generator(spheresize=spheresize) for i in range(20)],\n", + " 222: [random_triangle_generator(spheresize=spheresize) for i in range(30)],\n", + " 333: [random_triangle_generator(spheresize=spheresize) for i in range(10)],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "bd4bb72f", + "metadata": {}, + "source": [ + "We have 3 species" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9e07c536", + "metadata": {}, + "outputs": [], + "source": [ + "scenes = [scene1, scene2, scene3]\n", + "geometry = { \"scenes\": scenes }" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3c7fb334", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Organ VegetationType Area par Eabs par Ei\n", + "0 264 15 111 0 768.419509 338.824686 398.617277\n", + "1 264 15 222 0 909.148236 356.214248 419.075585\n", + "2 264 15 333 0 516.913303 347.591562 408.931249\n", + "3 264 15 111 1 752.373340 369.581197 434.801409\n", + "4 264 15 222 1 1170.981330 338.908282 398.715625\n", + "5 264 15 333 1 328.802211 367.175307 431.970949\n", + "6 264 15 111 2 455.953087 355.148363 417.821603\n", + "7 264 15 222 2 1058.844077 366.936675 431.690206\n", + "8 264 15 333 2 349.412007 343.960266 404.659136\n" + ] + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=geometry)\n", + "\n", + "# compute the lighting\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "345141f9", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "de90ddedb48d4aedb4fcc83c6e1d5d1a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'ts5kLc3m4n2jAYkyy7Brmkdi3', 'data': b'x\\xda\\xed\\x9d\\t\\xdcM\\xd5\\x…" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_light(), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b22cca2d", + "metadata": {}, + "source": [ + "The two level organization are also kept with RATP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ceea8138", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"ratp\")\n", + "lighting.build(geometry=geometry)\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "b7aa82d0", + "metadata": {}, + "source": [ + "## Stems\n", + "\n", + "If there are stems elements in the inputs, you can precise their ID and the tool will manage depending on the lightmodel:\n", + "- with CARIBU, the optical parameters associated to the organ won't have a transmission value (rays won't cross the triangle)\n", + "- with RATP, stems are separated in a new specy with its own leaf angle distribution and their leaf area is divied by 2" + ] + }, + { + "cell_type": "markdown", + "id": "7e67a4d7", + "metadata": {}, + "source": [ + "We reuse the wheat geometry given by adelwheat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "867c73bf", + "metadata": {}, + "outputs": [], + "source": [ + "geometry = {\n", + " \"scenes\": [g]\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "bfef5e1a", + "metadata": {}, + "source": [ + "stems are stored in list where each element is a 2-tuple `(organ ID, specy ID)`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6782b2a5", + "metadata": {}, + "outputs": [], + "source": [ + "stems = [(19, 0), (34, 0)]\n", + "geometry.update({\"stems id\": stems})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3efcb4c", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=geometry)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 0.1, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e700495", + "metadata": {}, + "outputs": [], + "source": [ + "lighting.run(energy=energy, hour=hour, day=day)\n", + "print(lighting.elements_outputs)\n", + "SceneWidget(lighting.plantGL_light(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 0.1, \n", + " axes_helper=True)" + ] + }, + { + "attachments": { + "transform_geo.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "37db8bea", + "metadata": {}, + "source": [ + "## Geometric transformations\n", + "\n", + "You can apply geometric transformations on some of the inputs scenes. We have currently 3 available transformations\n", + "- translation by a vector\n", + "- rescale by a factor or following scenes metric unit\n", + "- rotation on the xy plane\n", + "\n", + "![transform_geo.png](attachment:transform_geo.png)\n", + "\n", + "Transformations are stored in a dict, which is stored at key `\"transformations\"` in the geometry entry. Structure of transformations :\n", + "\n", + "```python\n", + "transformations = {\n", + " \"scenes unit\": { specy ID: \"metric unit\", ...},\n", + " \"rescale\": { specy ID: float, ...},\n", + " \"translate\": { specy ID: 3-tuple (x,y,z), ...},\n", + " \"xyz orientation\": { specy ID: \"x+ = NEWS\", ...},\n", + "}\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "589b61d1", + "metadata": {}, + "source": [ + "#### Main scenes" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9c6cf24b", + "metadata": {}, + "outputs": [], + "source": [ + "spheresize = (2., 1.)\n", + "scene1 = {\n", + " 0: [random_triangle_generator(spheresize=spheresize, worldsize=(0,10)) for i in range(20)]\n", + "}\n", + "scene2 = {\n", + " 0: [random_triangle_generator(spheresize=spheresize, worldsize=(10,20)) for i in range(20)]\n", + "}\n", + "\n", + "geometry = {\"scenes\": [scene1, scene2] }" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "83d85602", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d495f93c647d4f9aadd61b9a9baaeb31", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'EUvjRViqmWGdaRiY3dfvYnlbc', 'data': b'x\\xda\\x8d\\x99\\tX\\x95e\\x16\\…" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=geometry)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 50., \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "eeff47a1", + "metadata": {}, + "source": [ + "### Translate\n", + "\n", + "The translation vector is a 3-tuple (x,y,z). Transformations is a dict in the geometry dict." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "49b01ec1", + "metadata": {}, + "outputs": [], + "source": [ + "tvec = (10., -10., 10.)\n", + "transformations = {\n", + " \"translate\": {\n", + " 0: tvec\n", + " }\n", + "}\n", + "geometry = {\"scenes\": [scene1, scene2] , \"transformations\": transformations}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3217bce8", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dfe6d3a060484984887d3b760255ceb3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'XoPLZUSCWYRmPc6rCaQu4rIAG', 'data': b'x\\xda\\x8d\\x99\\x0bXUU\\x1a\\x…" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=geometry)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 50., \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "3b6efd1e", + "metadata": {}, + "source": [ + "### Rescale following metric unit\n", + "\n", + "You can precise the metric unit of each scene from this list: `\"mm\", \"cm\", \"dm\", \"m\", \"dam\", \"hm\", \"km\"`. By default the merged scene is in m but you can change its unit when you create an instance." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e8a3c8fd", + "metadata": {}, + "outputs": [], + "source": [ + "transformations = {\n", + " \"scenes unit\": {\n", + " 0: \"dm\"\n", + " }\n", + "}\n", + "geometry = {\"scenes\": [scene1, scene2] , \"transformations\": transformations}" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cb13af72", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6621a63d8bec4d4f92e0ee6932a85c2f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'tzqYZWHLS1bM2sROjizKhZxr5', 'data': b'x\\xda\\x8d\\x99yXWe\\x16\\xc7\\…" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\", main_unit=\"m\")\n", + "lighting.build(geometry=geometry)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 50., \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e58c7d97", + "metadata": {}, + "source": [ + "### Rescale by a scalar factor" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b50c27e6", + "metadata": {}, + "outputs": [], + "source": [ + "transformations = {\n", + " \"rescale\": {\n", + " 0: 2.,\n", + " }\n", + "}\n", + "geometry = {\"scenes\": [scene1, scene2] , \"transformations\": transformations}" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f1244a12", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb98511d642046518610b2f0dd5d20dc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'YOo3Dgy30xLCUA3kFElJWr1wI', 'data': b'x\\xda\\x8d\\x98yT\\x95\\xd5\\x1…" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=geometry)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 50., \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "847e5020", + "metadata": {}, + "source": [ + "### Rotate\n", + "\n", + "Finally, you can also rotate the scene around the z axis, in order to match the x+ convention for each input scene. You have the choice between:\n", + "- `\"x+ = N\"`\n", + "- `\"x+ = S\"`\n", + "- `\"x+ = E\"`\n", + "- `\"x+ = W\"`\n", + "\n", + "The merged scene convention is x+ = N, which the convention in RATP and CARIBU." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "f9bdfded", + "metadata": {}, + "outputs": [], + "source": [ + "transformations = {\n", + " \"xyz orientation\": {\n", + " 0: \"x+ = S\",\n", + " 1: \"x+ = E\",\n", + " }\n", + "}\n", + "geometry = {\"scenes\": [scene1, scene2] , \"transformations\": transformations}" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cce4df98", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "af16b80e950949a6947282a86fc3ff32", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'X2rN4Srd09U9mo3a5w4ruLkfw', 'data': b'x\\xda\\x8d\\x99\\x0bXUU\\x16\\x…" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=geometry)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(0.0, 0.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 50., \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48962e24", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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": 5 +} diff --git a/notebooks/lightmodels_functionnalities.ipynb b/notebooks/lightmodels_functionnalities.ipynb new file mode 100644 index 0000000..e6069e1 --- /dev/null +++ b/notebooks/lightmodels_functionnalities.ipynb @@ -0,0 +1,802 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "971cb814", + "metadata": {}, + "source": [ + "# Light models options\n", + "\n", + "## Content\n", + "\n", + "- CARIBU\n", + " - sun algo\n", + " - virtual sensors\n", + " - autres parametre\n", + "- RATP\n", + " - distribution angles foliaires\n", + " - tesselation sur la grille\n", + " - autre paramètres\n", + " \n", + "## Introduction\n", + "\n", + "During our use of lightvegemanager, we added special features for each known light models. Here is a little introduction to them." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "293a40d2", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget\n", + "from lightvegemanager.trianglesmesh import random_triangle_generator" + ] + }, + { + "cell_type": "markdown", + "id": "232237fe", + "metadata": {}, + "source": [ + "## CARIBU\n", + "\n", + "You can provide parameters according to the light model. The parameters are stored in a dict. This is the complete parameters you can provide with CARIBU: \n", + "\n", + "```python\n", + "caribu_args = {\n", + " \"sun algo\" : \"ratp\",\n", + " \"sun algo\" : \"caribu\",\n", + "\n", + " \"caribu opt\" : {\n", + " band0 = (reflectance, transmittance),\n", + " band1 = (reflectance, transmittance),\n", + " ...\n", + " },\n", + " \"debug\" : bool,\n", + " \"soil mesh\" : bool,\n", + " \"sensors\" : [\"grid\", dxyz, nxyz, orig, vtkpath, \"vtk\"]\n", + " }\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "7a847443", + "metadata": {}, + "source": [ + "### Computing the sun position\n", + "\n", + "In order to compute the sun position, you can use either the algorithm from RATP or CARIBU. The (x, y, z) output is formatted in CARIBU format." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "00259bc9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.33506553253259913, -0.8798617206271511, -0.3370080733212115)\n" + ] + } + ], + "source": [ + "caribu_args = { \"sun algo\" : \"caribu\" }\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", lightmodel_parameters=caribu_args)\n", + "lighting.build(geometry=[(0., 0., 0.), (1., 0., 0.), (1., 1., 1.)])\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "sun_caribu = lighting.sun\n", + "print(sun_caribu)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "20273c93", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.33241183146897624, -0.8800565622452903, -0.3391206592769639)\n" + ] + } + ], + "source": [ + "caribu_args = { \"sun algo\" : \"ratp\" }\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", lightmodel_parameters=caribu_args)\n", + "lighting.build(geometry=[(0., 0., 0.), (1., 0., 0.), (1., 1., 1.)])\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "sun_ratp = lighting.sun\n", + "print(sun_ratp)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7b0e119e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "euclidean dist = 0.003397515564596359 m\n" + ] + } + ], + "source": [ + "dist = (sum([ (x-y)**2 for x,y in zip(sun_ratp, sun_caribu) ])) ** (1/2)\n", + "print(\"euclidean dist = \",dist,\" m\")" + ] + }, + { + "cell_type": "markdown", + "id": "b1febd05", + "metadata": {}, + "source": [ + "### Grid of virtual sensors\n", + "\n", + "If you can to match a grid of voxels, you can generate a set of virtual sensors following a 3D grid. You need to precise the dimension of the grid:\n", + "- dxyz: `[dx, dy, dz]` size of one voxel\n", + "- nxyz: `[nx, ny, nz]` number of voxels on each xyz axis\n", + "- orig: `[0x, 0y, 0z]` origin point of the grid\n", + "\n", + "Optionnaly, you can write a geometric visualisation of the sensors in VTK format. You need to provide the file path and the flag `\"vtk\"`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "556e7a16", + "metadata": {}, + "outputs": [], + "source": [ + "# grid dimensions\n", + "dxyz = [1.] * 3\n", + "nxyz = [5, 5, 7]\n", + "orig = [0.] * 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "95967c93", + "metadata": {}, + "outputs": [], + "source": [ + "# random triangles\n", + "nb_triangles = 50\n", + "spheresize = (1., 0.3) # vertices of triangles are the sphere surface\n", + "triangles = []\n", + "for i in range(nb_triangles):\n", + " triangles.append(random_triangle_generator(worldsize=(0., 5.), spheresize=spheresize))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ed022b4c", + "metadata": {}, + "outputs": [], + "source": [ + "caribu_args = { \"sensors\" : [\"grid\", dxyz, nxyz, orig] }\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", lightmodel_parameters=caribu_args, environment={\"infinite\":True})\n", + "lighting.build(geometry=triangles)" + ] + }, + { + "cell_type": "markdown", + "id": "d11f570b", + "metadata": {}, + "source": [ + "You can visualize the grid of sensors with plantGL through the method `plantGL_sensors`" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8c5f06e2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3a795783fa724a46b78a59d52fc5677c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'rpNaRspB7H0J2oKjhBfYykU71', 'data': b'x\\xda\\x85\\x9a\\xf9\\xba\\x15G…" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_sensors(), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "c33fec94", + "metadata": {}, + "source": [ + "The lighting results are stored in `sensors_outputs`" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fcd4be39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'par': {0: 0.51834194067706, 1: 0.5308753998657116, 2: 0.6356410071880358, 3: 0.6280440745835342, 4: 0.7348723244391282, 5: 0.8377871001112634, 6: 0.4617251984176415, 7: 0.495129715697577, 8: 0.6131363817804785, 9: 0.5687714360698057, 10: 0.7322514236236515, 11: 0.8691497441835251, 12: 0.501409869368752, 13: 0.5802620746019611, 14: 0.5684306740502441, 15: 0.5448581816686048, 16: 0.7425834546380425, 17: 0.9448173795583968, 18: 0.48838057941884705, 19: 0.6124255210438949, 20: 0.5122986569042225, 21: 0.5196097528711219, 22: 0.6537519378903659, 23: 0.97910108961367, 24: 0.45924012286835925, 25: 0.5461410549684866, 26: 0.551527499861868, 27: 0.6180217890182801, 28: 0.6108037693496773, 29: 0.9533450759609043, 30: 0.47920650612455634, 31: 0.48509765917006636, 32: 0.4551374400234053, 33: 0.5855859239206206, 34: 0.7597544084095198, 35: 0.8641678490671126, 36: 0.4860121934865708, 37: 0.43959299789620904, 38: 0.43956593364806973, 39: 0.4036644342974864, 40: 0.7638839031112808, 41: 0.9007351905848812, 42: 0.5251419238192803, 43: 0.46126821372044885, 44: 0.41667205111819017, 45: 0.4968340802165048, 46: 0.7948675260827973, 47: 0.9435643107424596, 48: 0.47906967265823486, 49: 0.49778880474951165, 50: 0.4204373489559713, 51: 0.5677638346661975, 52: 0.8022129525509314, 53: 0.9673922133922965, 54: 0.5283510603735843, 55: 0.44551710610975725, 56: 0.49210113391046634, 57: 0.7146955670558728, 58: 0.7356424071887203, 59: 0.9271045254957095, 60: 0.5120418333114727, 61: 0.3596728014228353, 62: 0.37398690002227297, 63: 0.6034948137913889, 64: 0.7336930328783193, 65: 0.8590324029603247, 66: 0.4834097743681514, 67: 0.3910286540349822, 68: 0.3907557306621735, 69: 0.39198401423947576, 70: 0.508504590642667, 71: 0.9416354297249045, 72: 0.4754397848783006, 73: 0.3771805822156766, 74: 0.48198742477852835, 75: 0.40281836559829853, 76: 0.8028721943895224, 77: 0.9700996640514535, 78: 0.4324765007908733, 79: 0.40286405265932684, 80: 0.4517569674397516, 81: 0.5708668477747182, 82: 0.8710161873157761, 83: 0.9559789002347753, 84: 0.4143262511261377, 85: 0.35189874346231115, 86: 0.4504073473488214, 87: 0.6042034732308468, 88: 0.7670304386890762, 89: 0.8370007349434336, 90: 0.46668495886542527, 91: 0.4854025755573592, 92: 0.5345979721002958, 93: 0.62521366369586, 94: 0.651247522500461, 95: 0.8361066859773177, 96: 0.46501102937511973, 97: 0.4923827085324488, 98: 0.5641887632230667, 99: 0.6244764939935656, 100: 0.6782646532084828, 101: 0.9176886772444335, 102: 0.43231267350112107, 103: 0.43287245502849897, 104: 0.5535162151364506, 105: 0.7375322721560529, 106: 0.8536240714978374, 107: 0.9212006440344006, 108: 0.4145466067128266, 109: 0.4810271968225363, 110: 0.5234041338458567, 111: 0.5822987916276953, 112: 0.7415684051648578, 113: 0.816947437440918, 114: 0.3541767811681498, 115: 0.4250647962523507, 116: 0.4917133187582134, 117: 0.5692356324728592, 118: 0.6023285489385215, 119: 0.4528014905789319, 120: 0.5144710738020222, 121: 0.5368482445866736, 122: 0.6732298585703681, 123: 0.6857984441696575, 124: 0.6038900904068507, 125: 0.8493901265405036, 126: 0.4358880212918314, 127: 0.48329446189795555, 128: 0.6598711427288821, 129: 0.6519413545787534, 130: 0.6073208628736244, 131: 0.930992314691149, 132: 0.5067107970636116, 133: 0.524213064318667, 134: 0.6315028079173408, 135: 0.6370967379539592, 136: 0.6800813165981127, 137: 0.9139708890616902, 138: 0.4376666339795125, 139: 0.5281068049896077, 140: 0.5994199029108521, 141: 0.4977449274533771, 142: 0.4408512805419674, 143: 0.8936171526701367, 144: 0.41178392940457, 145: 0.5055553902936644, 146: 0.6188786457511692, 147: 0.6059780088098925, 148: 0.5696229915527733, 149: 0.8506266556565081}}\n" + ] + } + ], + "source": [ + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "print(lighting.sensors_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "028f5975", + "metadata": {}, + "source": [ + "You can also visualize the results in the plantGL scene" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3258001b", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "05f30102f14341ecb4653a8ea0141448", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': '5oUEYlG3YRLDXmFUN2Lt207uh', 'data': b'x\\xda\\x8d\\x9by\\x9f\\x16G\\x1…" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_sensors(light=True), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5f2b40d2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f9145d6171ca4f0bb5bf8d2deb69d5ed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'JRXUARzeztEqD2KcWxWb1bEoI', 'data': b'x\\xda\\x8d\\x9c\\t\\x98\\x16\\xc…" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_sensors(light=True) + lighting.plantGL_nolight(), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "7b4fe6e1", + "metadata": {}, + "source": [ + "### Other parameters\n", + "\n", + "In additional features, you can activate the debug mode in CARIBU, which describe the internal steps." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "494b7ef9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prepare scene 1\n", + "done\n" + ] + }, + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: './caribuscene_3041942304848\\\\cscene.can'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[20], line 9\u001b[0m\n\u001b[0;32m 7\u001b[0m hour \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m15\u001b[39m\n\u001b[0;32m 8\u001b[0m day \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m264\u001b[39m\n\u001b[1;32m----> 9\u001b[0m \u001b[43mlighting\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43menergy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43menergy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhour\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhour\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mday\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mday\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\users\\mwoussen\\cdd\\codes\\dev\\lightvegemanager\\src\\lightvegemanager\\tool.py:477\u001b[0m, in \u001b[0;36mLightVegeManager.run\u001b[1;34m(self, energy, day, hour, parunit, truesolartime, id_sensors)\u001b[0m\n\u001b[0;32m 475\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m sun_sky_option \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmix\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m 476\u001b[0m start \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n\u001b[1;32m--> 477\u001b[0m raw_sun, aggregated_sun \u001b[38;5;241m=\u001b[39m \u001b[43mrun_caribu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43marg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 478\u001b[0m arg[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m c_scene_sky\n\u001b[0;32m 479\u001b[0m raw_sky, aggregated_sky \u001b[38;5;241m=\u001b[39m run_caribu(\u001b[38;5;241m*\u001b[39marg)\n", + "File \u001b[1;32mc:\\users\\mwoussen\\cdd\\codes\\dev\\lightvegemanager\\src\\lightvegemanager\\CARIBUinputs.py:372\u001b[0m, in \u001b[0;36mrun_caribu\u001b[1;34m(c_scene, direct_active, infinite, sensors, energy)\u001b[0m\n\u001b[0;32m 331\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"runs caribu depending on input options\u001b[39;00m\n\u001b[0;32m 332\u001b[0m \n\u001b[0;32m 333\u001b[0m \u001b[38;5;124;03m:param c_scene: instance of CaribuScene containing geometry, light source(s), opt etc...\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 369\u001b[0m \u001b[38;5;124;03m:rtype: dict of dict, dict of dict\u001b[39;00m\n\u001b[0;32m 370\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m \n\u001b[0;32m 371\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m sensors \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m :\n\u001b[1;32m--> 372\u001b[0m raw, aggregated \u001b[38;5;241m=\u001b[39m \u001b[43mc_scene\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect_active\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minfinite\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minfinite\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 373\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m :\n\u001b[0;32m 374\u001b[0m raw, aggregated \u001b[38;5;241m=\u001b[39m c_scene\u001b[38;5;241m.\u001b[39mrun(direct\u001b[38;5;241m=\u001b[39mdirect_active, infinite\u001b[38;5;241m=\u001b[39minfinite, \n\u001b[0;32m 375\u001b[0m sensors\u001b[38;5;241m=\u001b[39msensors)\n", + "File \u001b[1;32m~\\AppData\\Local\\miniconda3\\envs\\mobidivpy37\\lib\\site-packages\\alinea.caribu-8.0.7-py3.8.egg\\alinea\\caribu\\CaribuScene.py:568\u001b[0m, in \u001b[0;36mCaribuScene.run\u001b[1;34m(self, direct, infinite, d_sphere, layers, height, screen_size, screen_resolution, sensors, split_face, simplify)\u001b[0m\n\u001b[0;32m 566\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcanfile \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtempdir,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcscene.can\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m 567\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptfile \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtempdir,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mband0.opt\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m--> 568\u001b[0m \u001b[43mwrite_scene\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtriangles\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmaterials\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcanfile\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptfile\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptfile\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 570\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 571\u001b[0m \u001b[38;5;66;03m# self.materialvalues is a cache for the computation of the material list\u001b[39;00m\n\u001b[0;32m 572\u001b[0m materials \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaterialvalues\n", + "File \u001b[1;32m~\\AppData\\Local\\miniconda3\\envs\\mobidivpy37\\lib\\site-packages\\alinea.caribu-8.0.7-py3.8.egg\\alinea\\caribu\\caribu.py:177\u001b[0m, in \u001b[0;36mwrite_scene\u001b[1;34m(triangles, materials, canfile, optfile)\u001b[0m\n\u001b[0;32m 175\u001b[0m o_string, labels \u001b[38;5;241m=\u001b[39m opt_string_and_labels(materials)\n\u001b[0;32m 176\u001b[0m can_string \u001b[38;5;241m=\u001b[39m triangles_string(triangles, labels)\n\u001b[1;32m--> 177\u001b[0m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcanfile\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mw\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mwrite(can_string)\n\u001b[0;32m 178\u001b[0m \u001b[38;5;28mopen\u001b[39m(optfile,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;241m.\u001b[39mwrite(o_string)\n", + "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './caribuscene_3041942304848\\\\cscene.can'" + ] + } + ], + "source": [ + "caribu_args = { \"debug\" : True }\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", lightmodel_parameters=caribu_args)\n", + "lighting.build(geometry=[(0., 0., 0.), (1., 0., 0.), (1., 1., 1.)])\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "markdown", + "id": "0d638836", + "metadata": {}, + "source": [ + "You can also use the soilmesh option and get the lighting hitting the soil. The method `soilenergy` get you access to its result." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "bf20d164", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Qi': 0.6750540873627096, 'Einc': 0.6750540873627096}\n" + ] + } + ], + "source": [ + "caribu_args = { \"soil mesh\" : True }\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", lightmodel_parameters=caribu_args)\n", + "lighting.build(geometry=[(0., 0., 0.), (1., 0., 0.), (1., 1., 1.)])\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "print(lighting.soilenergy)" + ] + }, + { + "cell_type": "markdown", + "id": "a08a758b", + "metadata": {}, + "source": [ + "## RATP\n", + "\n", + "```python\n", + "ratp_args = {\n", + " # Grid specifications\n", + " \"voxel size\" : [dx, dy, dz],\n", + " \"voxel size\" : \"dynamic\",\n", + " \n", + " \"full grid\" : bool,\n", + "\n", + " \"origin\" : [xorigin, yorigin, zorigin],\n", + " \"origin\" : [xorigin, yorigin],\n", + "\n", + " \"number voxels\" : [nx, ny, nz],\n", + " \"grid slicing\" : \"ground = 0.\"\n", + " \"tesselation level\" : int\n", + "\n", + " # Leaf angle distribution\n", + " \"angle distrib algo\" : \"compute global\",\n", + " \"angle distrib algo\" : \"compute voxel\",\n", + " \"angle distrib algo\" : \"file\",\n", + "\n", + " \"nb angle classes\" : int,\n", + " \"angle distrib file\" : filepath,\n", + "\n", + " # Vegetation type\n", + " \"soil reflectance\" : [reflectance_band0, reflectance_band1, ...],\n", + " \"reflectance coefficients\" : [reflectance_band0, reflectance_band1, ...],\n", + " \"mu\" : [mu_scene0, mu_scene1, ...]\n", + " }\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "063c07d8", + "metadata": {}, + "source": [ + "### Leaf angle distribution\n", + "\n", + "Leaf angle distribution can be generated in 3 ways:\n", + "- from a file, one distribution per specy\n", + "- global and dynamically, it generates a distribution from a triangles mesh for each specy\n", + "- per voxel and dynamically, it generates a distribution from the triangles located in each voxel" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "17d41b51", + "metadata": {}, + "outputs": [], + "source": [ + "# random triangles\n", + "nb_triangles = 50\n", + "spheresize = (1., 0.3) # vertices of triangles are the sphere surface\n", + "worldsize = (0., 5.)\n", + "triangles = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]" + ] + }, + { + "cell_type": "markdown", + "id": "d6755645", + "metadata": {}, + "source": [ + "#### File\n", + "\n", + "You need the flag `\"file\"` and to specify the file path." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "13097ed4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'global': [[0.1382, 0.1664, 0.1972, 0.1925, 0.1507, 0.0903, 0.0425, 0.0172, 0.005]]}\n" + ] + } + ], + "source": [ + "filepath = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\", \"luzerne_angle_distrib.data\")\n", + "ratp_parameters = { \"angle distrib algo\" : \"file\", \"angle distrib file\" : filepath }\n", + "\n", + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=triangles)\n", + "\n", + "print(lighting.leafangledistribution)" + ] + }, + { + "cell_type": "markdown", + "id": "85daaa61", + "metadata": {}, + "source": [ + "#### Global distribution\n", + "\n", + "You need the flag `\"compute global\"` and to specify the number of angle classes you need." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7c882e53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'global': [[0.06155178223916461, 0.12499042395940269, 0.06445789476401936, 0.1187479400647726, 0.21074770572428322, 0.12460435598932129, 0.1405535570495526, 0.01797247992923503, 0.13637386028024864]]}\n" + ] + } + ], + "source": [ + "ratp_parameters = { \"angle distrib algo\" : \"compute global\", \"nb angle classes\" : 9 }\n", + "\n", + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=triangles)\n", + "\n", + "print(lighting.leafangledistribution)" + ] + }, + { + "cell_type": "markdown", + "id": "8a0ea69d", + "metadata": {}, + "source": [ + "#### Local distribution\n", + "\n", + "You need the flag `\"compute voxel\"` and to specify the number of angle classes you need. You will get one distribution for each voxel of your grid and each specy." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "397e12a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Global\n", + "[[0.09035031695555507, 0.08761577143411951, 0.056255001524189746, 0.0753746859951702, 0.27007435951575953, 0.12360752121946102, 0.1302826782705683, 0.113942659680832, 0.05249700540434461]]\n", + "\n", + "\n", + " Local\n", + "[0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + "[0. 0. 1. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + "[0. 0. 1. 0. 0. 0. 0. 0. 0.]\n", + "[0.55943496 0. 0.44056504 0. 0. 0.\n", + " 0. 0. 0. ]\n", + "[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", + "[0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + "[0. 0.81407011 0. 0.18592989 0. 0.\n", + " 0. 0. 0. ]\n", + "[0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + "[0. 0. 1. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + "[0. 0.00742362 0. 0. 0. 0.\n", + " 0.30061391 0.69196247 0. ]\n", + "[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", + "[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + "[1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + "[0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + "[0. 0. 0. 0.60484427 0. 0.39515573\n", + " 0. 0. 0. ]\n", + "[0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + "[0. 0. 1. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + "[0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + "[1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + "[0. 0. 0. 0. 0. 0. 0. 0. 1.]\n" + ] + } + ], + "source": [ + "ratp_parameters = { \n", + " \"voxel size\" : [1., 1., 1.],\n", + " \"angle distrib algo\" : \"compute voxel\", \n", + " \"nb angle classes\" : 9\n", + " }\n", + "\n", + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=triangles)\n", + "\n", + "print(\"Global\")\n", + "print(lighting.leafangledistribution[\"global\"])\n", + "print(\"\\n\\n Local\")\n", + "for a in lighting.leafangledistribution[\"voxel\"]:\n", + " print(a[0])" + ] + }, + { + "cell_type": "markdown", + "id": "00f716c8", + "metadata": {}, + "source": [ + "For visualization of the situation" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9f6ae1ef", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f959c5e51d6f46a2adf4786f7aac29c6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'VXiNJUbqifCr9iQOhQ9okiBdG', 'data': b'x\\xda\\x8d[\\tx\\x14E\\xda\\x1e…" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_nolight(printtriangles=True, printvoxels=True), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "attachments": { + "tesselation_voxels.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "5434504e", + "metadata": {}, + "source": [ + "### Triangles tesselation in a grid\n", + "\n", + "You can reduce the error while transferring a triangle mesh to a voxel mesh by subdividing triangles across multiple voxels.\n", + "\n", + "
\n", + "\n", + "
\n", + "\n", + "You only need to precise how many times you want to subdivide the triangles." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b110d224", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a4d4919bf69441cebd10a56c2a976bde", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'gV833JQsWfuarucHtF2W2o3IM', 'data': b'x\\xda\\x95[\\x0bX\\x15\\xd5\\x1…" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ratp_parameters = { \"tesselation level\" : 7 }\n", + "\n", + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=triangles)\n", + "\n", + "SceneWidget(lighting.plantGL_nolight(printtriangles=True, printvoxels=False), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "f6c2c03b", + "metadata": {}, + "source": [ + "### Other parameters\n", + "\n", + "By default, the number of voxels is dynamically computed following the voxel size and mesh limits, but you can force its number. \n", + "\n", + "Voxel size can also be dynamically computed and is based on 3 times the longest triangle." + ] + } + ], + "metadata": { + "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": 5 +} diff --git a/notebooks/misc_functionnalities.ipynb b/notebooks/misc_functionnalities.ipynb new file mode 100644 index 0000000..022a86e --- /dev/null +++ b/notebooks/misc_functionnalities.ipynb @@ -0,0 +1,730 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "75226374", + "metadata": {}, + "source": [ + "# Misc functionnalities\n", + "\n", + "## Content\n", + "\n", + "- Subdivision of all triangles in the scene\n", + "- Visualisation with VTK\n", + "- External tools for analysing leaf angle distribution from a mesh\n", + "\n", + "## Introduction\n", + "\n", + "We provide more useful tools to help the lighting management" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8fb624d3", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget\n", + "from lightvegemanager.trianglesmesh import random_triangle_generator" + ] + }, + { + "cell_type": "markdown", + "id": "e73d0291", + "metadata": {}, + "source": [ + "## Simple mesh subdivision\n", + "\n", + "If you want to refine the shadowing process in your mesh, you can subdivide all triangles." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4e549342", + "metadata": {}, + "outputs": [], + "source": [ + "# random triangles\n", + "nb_triangles = 50\n", + "spheresize = (1., 0.3) # vertices of triangles are the sphere surface\n", + "worldsize = (0., 5.)\n", + "triangles = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1ee0c915", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6d6d7a0ffa0142ccb3ceb5f63d3d7024", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'oSXyv6iz2DTQz0KoxvgBXntAb', 'data': b'x\\xda\\x8d\\x9a\\tx\\x8c\\xd7\\x…" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=triangles)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "63792b47", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "97d974ceb68348e8a7dedae8cce7ab06", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': '8r1yEjQBEvJuGRFlSzojGn4je', 'data': b'x\\xda\\x94]\\x07x^\\xb5\\xd5\\x…" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "global_scene_tesselate_level = 5\n", + "lighting.build(geometry=triangles, global_scene_tesselate_level=global_scene_tesselate_level)\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(-2.5, -2.5, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "attachments": { + "paraview_example.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "729e225e", + "metadata": {}, + "source": [ + "## Visualisation with VTK\n", + "\n", + "PlantGL offers a good first approach to visualizing scene geometry, but software such as Paraview can take this visualization even further. LightVegeManager lets you export the scene in VTK format for further processing in ParaView.\n", + "\n", + "![paraview_example.png](attachment:paraview_example.png)\n", + "\n", + "There are three method to export VTK files:\n", + "- `VTK_nolight`: exports only the geometric information, organ ID and specy ID\n", + "- `VTK_light`: adds all the information about the scene's sunlight\n", + "- `VTK_sun`: exports sun direction of the current iteration\n" + ] + }, + { + "cell_type": "markdown", + "id": "66a1619c", + "metadata": {}, + "source": [ + "### Triangles exportation" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "605afb2d", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=triangles)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4052f157", + "metadata": {}, + "outputs": [], + "source": [ + "pathfile = \"random_scene\"" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ef74a956", + "metadata": {}, + "outputs": [], + "source": [ + "lighting.VTK_nolight(pathfile)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1d1c669b", + "metadata": {}, + "outputs": [], + "source": [ + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e0cf96cc", + "metadata": {}, + "outputs": [], + "source": [ + "lighting.VTK_light(pathfile)" + ] + }, + { + "cell_type": "markdown", + "id": "c883e837", + "metadata": {}, + "source": [ + "### Voxels exportation\n", + "\n", + "If you use voxels grid, you exports them too. In our example, it will exports the triangles mesh and the voxels mesh specified in the inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9fe64784", + "metadata": {}, + "outputs": [], + "source": [ + "ratp_parameters = {\"voxel size\" : [1., 1., 1.] }\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "lighting.build(geometry=triangles)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a2df84da", + "metadata": {}, + "outputs": [], + "source": [ + "pathfile = \"random_scene_ratp\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "db2dce38", + "metadata": {}, + "outputs": [], + "source": [ + "lighting.VTK_nolight(pathfile, printtriangles=True, printvoxels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b29d2a7f", + "metadata": {}, + "outputs": [], + "source": [ + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "23d31506", + "metadata": {}, + "outputs": [], + "source": [ + "lighting.VTK_light(pathfile, printtriangles=True, printvoxels=True)" + ] + }, + { + "cell_type": "markdown", + "id": "2d372d91", + "metadata": {}, + "source": [ + "## Analyze with s2v and s5\n", + "\n", + "We added the possibility to call s2v and s5, two analysis tools which returns informations in order to convert the triangle mesh in a RATP grid format. Depending on the grid dimensions you specify, it will return leaf area in each voxel (depending on the barycenter position of each triangle in the grid) and leaf angle distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "20ac8017", + "metadata": {}, + "outputs": [], + "source": [ + "# random triangles\n", + "nb_triangles = 5\n", + "spheresize = (1., 0.3) # vertices of triangles are the sphere surface\n", + "worldsize = (0., 5.)\n", + "triangles = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]" + ] + }, + { + "cell_type": "markdown", + "id": "ba5ca7ce", + "metadata": {}, + "source": [ + "### s5 (fortran)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0a249600", + "metadata": {}, + "outputs": [], + "source": [ + "ratp_parameters = {\"voxel size\" : [1., 1., 1.] }\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "lighting.build(geometry=triangles)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4f72e4bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Fin de s5.f\n" + ] + } + ], + "source": [ + "lighting.s5()" + ] + }, + { + "cell_type": "markdown", + "id": "197d6339", + "metadata": {}, + "source": [ + "#### Description of `fort.60`\n", + "\n", + "- xy dimension of the scene\n", + "- statistics per specy\n", + " - Total leaf area\n", + " - Leaf area index\n", + " - Global zenith angle distribution\n", + " - Global azimut angle distribution\n", + "- statistics per voxel\n", + " - #specy #ix #iy ~iz leaf area density\n", + " - zenith angle distribution\n", + " - azimut angle distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a1d0e71b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dimensions de la maquette (x,y): 7.000 6.000\n", + " nombre de repetitions du motif: 1.0\n", + "\n", + " STATISTIQUES GLOBALES DE CHAQUE ESPECE\n", + "\n", + " espece: 1 surface foliaire: .249D+01 lai : 0.0593\n", + " distribution en zenith: 0.0000 0.0000 0.0000 0.0000 0.6634 0.0905 0.0795 0.1666 0.0000\n", + " distribution en azimuth: 0.3231 0.1666 0.3404 0.0795 0.0000 0.0000 0.0000 0.0905 0.0000\n", + "\n", + "\n", + " STATISTIQUES PAR CELLULE\n", + "\n", + " 1 1 1 1 0.122\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 1 2 1 1 0.003\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 1 5 1 1 0.177\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 1 6 1 1 0.002\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 2 1 1 1 0.011\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 2 2 1 1 0.088\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 2 5 1 1 0.672\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 3 2 1 1 0.000\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 3 4 1 1 0.389\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 3 5 1 1 0.010\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 4 2 1 1 0.121\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 4 3 1 1 0.077\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000\n", + " 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 4 4 1 1 0.017\n", + " 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000\n", + " 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 5 4 1 1 0.017\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 6 4 1 1 0.402\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 6 5 1 1 0.168\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 7 4 1 1 0.122\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n", + " 7 5 1 1 0.096\n", + " 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000\n", + " 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000\n" + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s5\", \"fort.60\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "1fe1e6c3", + "metadata": {}, + "source": [ + "#### Description of `leafarea`\n", + "\n", + "- for each specy\n", + " - for each voxel\n", + " - ix | iy | iz | #specy | LAD | zenith angle distribution | azimut angle distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7a38079a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1 2 1 1 0.014 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000\n", + " 2 1 1 1 0.084 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.613 0.000 0.000 0.387 0.000 0.000\n", + " 2 1 2 1 0.002 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000\n", + " 2 2 1 1 0.129 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000\n", + " 3 1 1 1 0.027 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000\n", + " 3 1 4 1 0.030 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000\n", + " 3 2 1 1 0.041 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000\n", + " 3 5 4 1 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000\n", + " 3 6 4 1 0.084 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000\n", + " 4 1 4 1 0.203 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000\n", + " 4 2 1 1 0.286 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 0.000\n" + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s5\", \"leafarea\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "7433d351", + "metadata": {}, + "source": [ + "#### s2v (c++)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "26f525b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fin de s2v.cpp\n" + ] + } + ], + "source": [ + "lighting.s2v()" + ] + }, + { + "cell_type": "markdown", + "id": "6f0fffd5", + "metadata": {}, + "source": [ + "#### Description of `s2v.log`\n", + "\n", + "- Program logs\n", + "- global statistic for each specy\n", + " - total leaf area\n", + " - leaf area index\n", + " - global zenith angle distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "61a5827e", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'os' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m outfile \u001b[38;5;241m=\u001b[39m \u001b[43mos\u001b[49m\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mdirname(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mabspath(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m)), \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ms2v\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ms2v.log\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(outfile, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m fichier:\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m ligne \u001b[38;5;129;01min\u001b[39;00m fichier:\n", + "\u001b[1;31mNameError\u001b[0m: name 'os' is not defined" + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s2v\", \"s2v.log\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "c2619bfe", + "metadata": {}, + "source": [ + "#### Description of `s2v.can`\n", + "\n", + "Copy of each triangle with the z layer in which the triangle belongs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "279e1477", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".\\s2v++.exe \n", + "Lecture du fichier parametre dans fichier : \n", + "nji=9, nja=9, njz=2\n", + "bz[0]=2\n", + "7, 7, 1, 6, 6, 1, 1\n", + "s2v.cpp:530 -> Fin de lecture de fichier\n", + "=> Calcul des distributions\n", + "==> nje rel = 1\n", + "=> Ecriture des resultats : (c|std)err, leafarea, out.dang\n", + "Il y a eu 2583 depassement en z+\n", + "xl=7, yl=6, xymaille=1\n", + "\n", + "STATISTIQUES GLOBALES DE CHAQUE ESPECE\n", + "esp 1 : surfT=2.49261 - Stot=2.49261, LAI=0.0593479 dist d'inclinaison :0 0 0 0 0.66342 0.090495 0.0795048 0.16658 0 \n", + "0.3230560.166580.3403640.07950480000.0904950\n", + "genere le fichier out.dang => entree de sailM pour calculer la BRDF\n", + "\t: xx= 0 ; Uz= 1e-009\n", + "ferrlog stream close() called.\n" + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s2v\", \"s2v.can\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "630f9ad0", + "metadata": {}, + "source": [ + "#### Description of `s2v.area`\n", + "\n", + "each line contains: triangle id | z layer | triangle area" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "87a5a603", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100001001000\t 0\t 0.848395\n", + "100001001000\t 0\t 0.198175\n", + "100001001000\t 0\t 0.415219\n", + "100001001000\t 0\t 0.225569\n", + "100001001000\t 0\t 0.805254\n" + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s2v\", \"s2v.area\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "5b4abbfc", + "metadata": {}, + "source": [ + "#### Description of `out.dang`\n", + "\n", + "File for SAIL model\n", + "- line 1: global leaf area index for specy 1\n", + "- line 2: global zenith angle distribution for specy 1" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cba6b513", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.059348\n", + "0.000000 0.000000 0.000000 0.000000 0.663420 0.090495 0.079505 0.166580 0.000000 " + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s2v\", \"out.dang\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "6551e156", + "metadata": {}, + "source": [ + "#### Description of `leafarea`\n", + "\n", + "File for SAIL model\n", + "each line:\n", + " - 0 idz \"Leaf area index by layer inclination class\" 0 0 \"total leaf area density on the z layer\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b177e1e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1 0.000000 0.000000 0.000000 0.000000 0.663420 0.090495 0.079505 0.166580 0.000000 0 0 2.492611\n", + " 0 2 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0 0 0.000000\n" + ] + } + ], + "source": [ + "outfile = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"s2v\", \"leafarea\")\n", + "with open(outfile, \"r\") as fichier:\n", + " for ligne in fichier:\n", + " print(ligne, end=\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "500a198e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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": 5 +} diff --git a/notebooks/outputs_and_plantmodels_transfer.ipynb b/notebooks/outputs_and_plantmodels_transfer.ipynb new file mode 100644 index 0000000..69b6f1c --- /dev/null +++ b/notebooks/outputs_and_plantmodels_transfer.ipynb @@ -0,0 +1,1077 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7d2ea5d1", + "metadata": {}, + "source": [ + "# Output formats and transfer methods\n", + "\n", + "## Content\n", + "\n", + "- Main light outputs\n", + "- transfer results to l-egume\n", + "- transfer results to CN-Wheat\n", + "\n", + "## Introduction\n", + "\n", + "In this notebook, we will show you which result data you can use for your own purpose. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e5378cea", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget\n", + "from lightvegemanager.trianglesmesh import random_triangle_generator" + ] + }, + { + "cell_type": "markdown", + "id": "fcb1dbc3", + "metadata": {}, + "source": [ + "## Main light outputs: Pandas dataframe\n", + "\n", + "Outputs are stored in at least two different scales, by element, triangle or voxel, and by organs, a group of elements. We will use a set of random triangles as an illustration." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "634d2ae6", + "metadata": {}, + "outputs": [], + "source": [ + "# random triangles\n", + "nb_triangles = 20\n", + "spheresize = (1., 0.3) # vertices of triangles are the sphere surface\n", + "worldsize = (0., 5.)\n", + "triangles = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]" + ] + }, + { + "cell_type": "markdown", + "id": "832306b2", + "metadata": {}, + "source": [ + "We compute one iteration with CARIBU" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9ddbcc11", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry=triangles)\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "markdown", + "id": "f57bcf31", + "metadata": {}, + "source": [ + "Results for each triangle" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7b2105d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "\n", + " Day Hour Triangle Organ VegetationType Area par Eabs \\\n", + "0 264 15 0 0 0 0.887983 333.972320 \n", + "1 264 15 1 0 0 0.064478 359.626762 \n", + "2 264 15 2 0 0 0.453055 467.189797 \n", + "3 264 15 3 0 0 1.221273 357.496425 \n", + "4 264 15 4 0 0 0.458616 475.442657 \n", + "5 264 15 5 0 0 0.280610 247.592121 \n", + "6 264 15 6 0 0 0.566238 352.833692 \n", + "7 264 15 7 0 0 0.058097 423.081287 \n", + "8 264 15 8 0 0 2.767725 334.256459 \n", + "9 264 15 9 0 0 0.374497 451.617079 \n", + "10 264 15 10 0 0 0.379997 336.551922 \n", + "11 264 15 11 0 0 0.606435 363.404537 \n", + "12 264 15 12 0 0 1.029608 342.804865 \n", + "13 264 15 13 0 0 0.418867 440.261801 \n", + "14 264 15 14 0 0 0.368815 308.680462 \n", + "15 264 15 15 0 0 0.583434 463.362150 \n", + "16 264 15 16 0 0 0.026466 276.634522 \n", + "17 264 15 17 0 0 0.456672 305.102063 \n", + "18 264 15 18 0 0 0.155659 345.261097 \n", + "19 264 15 19 0 0 0.105090 423.684444 \n", + "\n", + " par Ei \n", + "0 392.908611 \n", + "1 423.090309 \n", + "2 549.635055 \n", + "3 420.584029 \n", + "4 559.344302 \n", + "5 291.284848 \n", + "6 415.098461 \n", + "7 497.742691 \n", + "8 393.242893 \n", + "9 531.314211 \n", + "10 395.943438 \n", + "11 427.534749 \n", + "12 403.299841 \n", + "13 517.955060 \n", + "14 363.153485 \n", + "15 545.131942 \n", + "16 325.452379 \n", + "17 358.943604 \n", + "18 406.189526 \n", + "19 498.452287 \n" + ] + } + ], + "source": [ + "print(type(lighting.triangles_outputs),\"\\n\")\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "6d8cfd99", + "metadata": {}, + "source": [ + "We can try to group multiple sets of triangles" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b8c92592", + "metadata": {}, + "outputs": [], + "source": [ + "nb_triangles = 10\n", + "triangles1 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]\n", + "\n", + "nb_triangles = 9\n", + "triangles2 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]\n", + "\n", + "nb_triangles = 8\n", + "triangles3 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ad9f5a1c", + "metadata": {}, + "outputs": [], + "source": [ + "scene = {0: triangles1, 1: triangles2, 2: triangles3}\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry={\"scenes\" : [scene] })\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0da3f684", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Triangle Organ VegetationType Area par Eabs \\\n", + "0 264 15 0 0 0 0.302826 323.960353 \n", + "1 264 15 1 0 0 0.209539 425.144306 \n", + "2 264 15 2 0 0 0.197166 362.524398 \n", + "3 264 15 3 0 0 0.039327 362.423338 \n", + "4 264 15 4 0 0 0.545166 299.967366 \n", + "5 264 15 5 0 0 0.135091 479.645681 \n", + "6 264 15 6 0 0 0.096901 409.619188 \n", + "7 264 15 7 0 0 0.982999 361.504997 \n", + "8 264 15 8 0 0 0.922692 312.596716 \n", + "9 264 15 9 0 0 0.088453 356.628718 \n", + "10 264 15 10 1 0 0.435957 394.911941 \n", + "11 264 15 11 1 0 0.407852 368.080426 \n", + "12 264 15 12 1 0 0.634457 348.130774 \n", + "13 264 15 13 1 0 0.260217 380.579577 \n", + "14 264 15 14 1 0 0.214000 471.615547 \n", + "15 264 15 15 1 0 0.097946 333.103578 \n", + "16 264 15 16 1 0 0.179120 459.202360 \n", + "17 264 15 17 1 0 0.633404 382.104684 \n", + "18 264 15 18 1 0 0.441117 389.083206 \n", + "19 264 15 19 2 0 0.442670 319.499395 \n", + "20 264 15 20 2 0 0.330172 299.805634 \n", + "21 264 15 21 2 0 1.268324 442.899621 \n", + "22 264 15 22 2 0 0.024006 382.452618 \n", + "23 264 15 23 2 0 0.317721 362.006044 \n", + "24 264 15 24 2 0 1.344187 386.714779 \n", + "25 264 15 25 2 0 0.204554 348.273943 \n", + "26 264 15 26 2 0 0.039401 371.076266 \n", + "\n", + " par Ei \n", + "0 381.129827 \n", + "1 500.169772 \n", + "2 426.499292 \n", + "3 426.380398 \n", + "4 352.902784 \n", + "5 564.289036 \n", + "6 481.904927 \n", + "7 425.299996 \n", + "8 367.760842 \n", + "9 419.563197 \n", + "10 464.602284 \n", + "11 433.035796 \n", + "12 409.565616 \n", + "13 447.740678 \n", + "14 554.841820 \n", + "15 391.886563 \n", + "16 540.238071 \n", + "17 449.534922 \n", + "18 457.744948 \n", + "19 375.881641 \n", + "20 352.712511 \n", + "21 521.058377 \n", + "22 449.944257 \n", + "23 425.889463 \n", + "24 454.958564 \n", + "25 409.734051 \n", + "26 436.560313 \n" + ] + } + ], + "source": [ + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "698ce3e4", + "metadata": {}, + "source": [ + "And the grouped results" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dda3eb15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Organ VegetationType Area par Eabs par Ei\n", + "0 264 15 0 0 3.520159 345.516439 406.489928\n", + "1 264 15 1 0 3.304070 384.875692 452.794932\n", + "2 264 15 2 0 3.971035 385.802957 453.885832\n" + ] + } + ], + "source": [ + "print(lighting.elements_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "0e2874a2", + "metadata": {}, + "source": [ + "With RATP, you have another output for each voxel" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "55fb9462", + "metadata": {}, + "outputs": [], + "source": [ + "scene = {0: triangles1, 1: triangles2, 2: triangles3}\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"ratp\")\n", + "lighting.build(geometry={\"scenes\" : [scene] })\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "662e17d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Triangle Organ Voxel VegetationType primitive_area Day Hour Nx \\\n", + "0 0 0 1.0 1 0.302826 264.0 15.0 1 \n", + "1 1 0 1.0 1 0.209539 264.0 15.0 1 \n", + "2 2 0 1.0 1 0.197166 264.0 15.0 1 \n", + "3 3 0 1.0 1 0.039327 264.0 15.0 1 \n", + "4 4 0 1.0 1 0.545166 264.0 15.0 1 \n", + "21 5 0 2.0 1 0.135091 264.0 15.0 2 \n", + "5 6 0 1.0 1 0.096901 264.0 15.0 1 \n", + "6 7 0 1.0 1 0.982999 264.0 15.0 1 \n", + "7 8 0 1.0 1 0.922692 264.0 15.0 1 \n", + "22 9 0 2.0 1 0.088453 264.0 15.0 2 \n", + "8 10 1 1.0 1 0.435957 264.0 15.0 1 \n", + "23 11 1 2.0 1 0.407852 264.0 15.0 2 \n", + "9 12 1 1.0 1 0.634457 264.0 15.0 1 \n", + "10 13 1 1.0 1 0.260217 264.0 15.0 1 \n", + "11 14 1 1.0 1 0.214000 264.0 15.0 1 \n", + "24 15 1 2.0 1 0.097946 264.0 15.0 2 \n", + "12 16 1 1.0 1 0.179120 264.0 15.0 1 \n", + "25 17 1 2.0 1 0.633404 264.0 15.0 2 \n", + "13 18 1 1.0 1 0.441117 264.0 15.0 1 \n", + "14 19 2 1.0 1 0.442670 264.0 15.0 1 \n", + "15 20 2 1.0 1 0.330172 264.0 15.0 1 \n", + "26 21 2 2.0 1 1.268324 264.0 15.0 2 \n", + "16 22 2 1.0 1 0.024006 264.0 15.0 1 \n", + "17 23 2 1.0 1 0.317721 264.0 15.0 1 \n", + "18 24 2 1.0 1 1.344187 264.0 15.0 1 \n", + "19 25 2 1.0 1 0.204554 264.0 15.0 1 \n", + "20 26 2 1.0 1 0.039401 264.0 15.0 1 \n", + "\n", + " Ny Nz ShadedPAR SunlitPAR ShadedArea SunlitArea Area \\\n", + "0 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "1 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "2 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "3 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "4 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "21 1 1 369.472687 468.106873 0.06519 2.565879 2.631069 \n", + "5 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "6 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "7 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "22 1 1 369.472687 468.106873 0.06519 2.565879 2.631069 \n", + "8 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "23 1 1 369.472687 468.106873 0.06519 2.565879 2.631069 \n", + "9 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "10 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "11 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "24 1 1 369.472687 468.106873 0.06519 2.565879 2.631069 \n", + "12 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "25 1 1 369.472687 468.106873 0.06519 2.565879 2.631069 \n", + "13 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "14 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "15 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "26 1 1 369.472687 468.106873 0.06519 2.565879 2.631069 \n", + "16 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "17 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "18 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "19 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "20 1 1 357.368713 456.002899 0.45133 7.712864 8.164194 \n", + "\n", + " PARa Intercepted Transmitted \n", + "0 450.550232 7.356759 27.887056 \n", + "1 450.550232 7.356759 27.887056 \n", + "2 450.550232 7.356759 27.887056 \n", + "3 450.550232 7.356759 27.887056 \n", + "4 450.550232 7.356759 27.887056 \n", + "21 465.663025 2.450383 29.358543 \n", + "5 450.550232 7.356759 27.887056 \n", + "6 450.550232 7.356759 27.887056 \n", + "7 450.550232 7.356759 27.887056 \n", + "22 465.663025 2.450383 29.358543 \n", + "8 450.550232 7.356759 27.887056 \n", + "23 465.663025 2.450383 29.358543 \n", + "9 450.550232 7.356759 27.887056 \n", + "10 450.550232 7.356759 27.887056 \n", + "11 450.550232 7.356759 27.887056 \n", + "24 465.663025 2.450383 29.358543 \n", + "12 450.550232 7.356759 27.887056 \n", + "25 465.663025 2.450383 29.358543 \n", + "13 450.550232 7.356759 27.887056 \n", + "14 450.550232 7.356759 27.887056 \n", + "15 450.550232 7.356759 27.887056 \n", + "26 465.663025 2.450383 29.358543 \n", + "16 450.550232 7.356759 27.887056 \n", + "17 450.550232 7.356759 27.887056 \n", + "18 450.550232 7.356759 27.887056 \n", + "19 450.550232 7.356759 27.887056 \n", + "20 450.550232 7.356759 27.887056 \n" + ] + } + ], + "source": [ + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b75e7015", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " VegetationType Day Hour Voxel Nx Ny Nz ShadedPAR SunlitPAR \\\n", + "0 1.0 264.0 15.0 1.0 1 1 1 357.368713 456.002899 \n", + "1 1.0 264.0 15.0 2.0 2 1 1 369.472687 468.106873 \n", + "\n", + " ShadedArea SunlitArea Area PARa Intercepted Transmitted \n", + "0 0.45133 7.712864 8.164194 450.550232 7.356759 27.887056 \n", + "1 0.06519 2.565879 2.631069 465.663025 2.450383 29.358543 \n" + ] + } + ], + "source": [ + "print(lighting.voxels_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "efbb1e3b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Organ VegetationType Area PARa Intercepted \\\n", + "0 264.0 15.0 0 1 3.520159 451.509950 7.045186 \n", + "1 264.0 15.0 1 1 3.304070 455.760934 5.665102 \n", + "2 264.0 15.0 2 1 3.971035 455.377164 5.789693 \n", + "\n", + " Transmitted SunlitPAR SunlitArea ShadedPAR ShadedArea \n", + "0 7.045186 456.771546 7.386012 358.137361 0.426808 \n", + "1 5.665102 460.176198 5.938248 361.542012 0.318194 \n", + "2 5.789693 459.868833 6.068949 361.234647 0.327999 \n" + ] + } + ], + "source": [ + "print(lighting.elements_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "fcc54af5", + "metadata": {}, + "source": [ + "## l-egume results transfer\n", + "\n", + "There are two possible scenarios:\n", + "- with RATP, the tool reformats the data types. Grid specifications must match with l-egume internal grid instance\n", + "- with CARIBU, you need to use virtual sensors following the dimensions of l-egume internal grid.\n", + "\n", + "The id argument is used with you several input scenes but you need to transfer only some of them to your l-egume instance.\n", + "\n", + "In both case, it will return two tables, one with intercepted lighting and another with transmitted lighting in each voxel." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "39bd8bce", + "metadata": {}, + "outputs": [], + "source": [ + "# grid dimensions\n", + "dxyz = [1.] * 3\n", + "nxyz = [7, 7, 7]\n", + "orig = [-1., -1., 0.]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "25b65a64", + "metadata": {}, + "outputs": [], + "source": [ + "spheresize = (1., 0.3) # vertices of triangles are the sphere surface\n", + "worldsize = (0., 5.)\n", + "\n", + "nb_triangles = 10\n", + "triangles1 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]\n", + "\n", + "nb_triangles = 9\n", + "triangles2 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]\n", + "\n", + "nb_triangles = 8\n", + "triangles3 = [random_triangle_generator(worldsize=worldsize, spheresize=spheresize) for i in range(nb_triangles)]\n", + "\n", + "scene = {0: triangles1, 1: triangles2, 2: triangles3}" + ] + }, + { + "cell_type": "markdown", + "id": "ad8f382e", + "metadata": {}, + "source": [ + "#### RATP\n", + "\n", + "Input: l-egume intern grid of leaf area" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2eb81590", + "metadata": {}, + "outputs": [], + "source": [ + "ratp_parameters = { \"voxel size\" : dxyz,\n", + " \"origin\" : orig,\n", + " \"number voxels\" : nxyz,\n", + " \"full grid\" : True}\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "lighting.build(geometry={\"scenes\" : [scene] })\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9e8d468c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f650a9774fa542e2bb5e2ba80595e729", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'eVV4F11s33BPVUjNuulHClHso', 'data': b'x\\xda\\x8d}\\x0b\\x94\\xf5Uu\\x…" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_nolight(printtriangles=True, printvoxels=True), \n", + " position=(0., 0., 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e020532a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "\n", + "m_lais = numpy.zeros([1] + nxyz)\n", + "\n", + "for row in lighting.voxels_outputs.itertuples():\n", + " m_lais[int(row.VegetationType)-1][row.Nz-1][row.Nx-1][row.Ny-1] = row.Area" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f4281a0d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PARa intercepted\n", + "[[[[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]\n", + "\n", + " [[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.91255584e-01 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]\n", + "\n", + " [[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 3.62365872e-01 1.22457137e-03 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.95049897e-01 1.00000000e-14\n", + " 4.01137352e-01 4.10260499e-01 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 2.34853730e-01\n", + " 6.89631641e-01 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.05850622e-01\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]\n", + "\n", + " [[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.07698523e-01\n", + " 1.27102673e+00 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 2.34604865e-01 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 2.00332925e-02 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]\n", + "\n", + " [[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 6.13946058e-02 5.03006637e-01\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 3.54082614e-01\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.38437843e+00\n", + " 1.74996093e-01 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 9.02987361e-01 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.18964568e-01 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]\n", + "\n", + " [[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 2.70237744e-01 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 2.15935960e-01 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 3.86473686e-02 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.36857376e-01\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]\n", + "\n", + " [[1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 5.66032231e-02\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 5.84830046e-01 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]\n", + " [1.00000000e-14 1.00000000e-14 1.00000000e-14 1.00000000e-14\n", + " 1.00000000e-14 1.00000000e-14 1.00000000e-14]]]]\n", + "\n", + "\n", + "PARa transmitted\n", + "[[[1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]]\n", + "\n", + " [[1. 0.99963057 0.99957138 0.99947673 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 1. 1. 1. 1.\n", + " 1. ]\n", + " [1. 1. 0.99926668 1. 1. 1.\n", + " 1. ]\n", + " [0.99970013 0.99676865 0.98825139 0.99629509 0.99986303 1.\n", + " 1. ]\n", + " [0.99902207 0.99121612 0.919734 0.9877432 0.99918234 1.\n", + " 1. ]\n", + " [1. 0.998151 0.99141204 0.99720836 1. 1.\n", + " 1. ]]\n", + "\n", + " [[0.99686068 0.99802268 0.99410558 0.98673284 0.96794111 0.98563504\n", + " 0.99416107]\n", + " [0.99585605 0.99449784 0.97916114 0.95942354 0.80911517 0.93542254\n", + " 0.98531598]\n", + " [0.99475813 0.98461145 0.90690106 0.92244434 0.73988777 0.78323054\n", + " 0.96694493]\n", + " [0.99632591 0.99120426 0.9665345 0.84882689 0.67848641 0.92360383\n", + " 0.98617125]\n", + " [0.99687183 0.99460918 0.98012727 0.96042752 0.9532088 0.98170686\n", + " 0.99605304]\n", + " [0.99543226 0.99152982 0.97064966 0.94378668 0.98623681 0.99440718\n", + " 0.99580491]\n", + " [0.99548972 0.9954195 0.99088526 0.98755527 0.99215525 0.99616665\n", + " 0.99683207]]\n", + "\n", + " [[0.99154222 0.98986703 0.97595549 0.93902242 0.87979883 0.94595563\n", + " 0.98320436]\n", + " [0.98788708 0.97815615 0.93926233 0.82371432 0.40502387 0.8600387\n", + " 0.96764725]\n", + " [0.98203403 0.96068132 0.84095889 0.87493688 0.78784174 0.86833286\n", + " 0.95500243]\n", + " [0.98539996 0.96764213 0.94185394 0.91136855 0.86435711 0.92827505\n", + " 0.9719072 ]\n", + " [0.98689526 0.98537415 0.96861196 0.95374638 0.94034904 0.96856815\n", + " 0.98217195]\n", + " [0.98805183 0.9888103 0.96952713 0.96083057 0.96848112 0.97835684\n", + " 0.98321474]\n", + " [0.99521863 0.99247658 0.98359537 0.97790587 0.97665089 0.98280752\n", + " 0.98712826]]\n", + "\n", + " [[0.97396404 0.97732759 0.95046979 0.90020192 0.8875643 0.93730801\n", + " 0.96813494]\n", + " [0.97440737 0.96788532 0.87619686 0.65420538 0.77308333 0.88455611\n", + " 0.95573801]\n", + " [0.97905767 0.96105552 0.86347568 0.64449 0.798118 0.89461142\n", + " 0.96182084]\n", + " [0.98428118 0.95343912 0.80644536 0.36933419 0.75600612 0.92658126\n", + " 0.97097325]\n", + " [0.98272175 0.92263758 0.59786361 0.84413874 0.93022043 0.96003735\n", + " 0.98030746]\n", + " [0.98167884 0.92343473 0.92852783 0.95988148 0.95882422 0.98353291\n", + " 0.98981279]\n", + " [0.98821801 0.97827053 0.97353882 0.97693914 0.96563995 0.98353904\n", + " 0.98521316]]\n", + "\n", + " [[0.96288335 0.93929774 0.92631412 0.89874583 0.90402168 0.94615626\n", + " 0.95473844]\n", + " [0.95003837 0.84268683 0.86060578 0.81803173 0.82487935 0.90885699\n", + " 0.94603294]\n", + " [0.94327873 0.91743463 0.85111934 0.76143235 0.747778 0.89120042\n", + " 0.94725478]\n", + " [0.97430396 0.92609513 0.82673693 0.73656482 0.78086466 0.90808272\n", + " 0.94624001]\n", + " [0.96516496 0.93356055 0.83229494 0.79863918 0.88125861 0.94769037\n", + " 0.97597754]\n", + " [0.97860146 0.94880772 0.90524018 0.91579521 0.93609023 0.97752261\n", + " 0.98202926]\n", + " [0.9830606 0.96851254 0.94450408 0.93516695 0.93937171 0.95932865\n", + " 0.9740687 ]]\n", + "\n", + " [[0.93367374 0.91789633 0.91964561 0.9338572 0.90871698 0.94616085\n", + " 0.95534593]\n", + " [0.94012743 0.90739971 0.89350057 0.88228625 0.86454254 0.9217149\n", + " 0.94184065]\n", + " [0.92299747 0.89996201 0.8715623 0.81494373 0.83152366 0.87107247\n", + " 0.93528658]\n", + " [0.94811577 0.91303241 0.86293799 0.79458439 0.64303416 0.88547724\n", + " 0.9305917 ]\n", + " [0.94927919 0.92561966 0.88040262 0.87153274 0.84795934 0.9235304\n", + " 0.94650728]\n", + " [0.96347046 0.94701046 0.90630186 0.91416645 0.91751611 0.95114535\n", + " 0.96184111]\n", + " [0.95411432 0.95206857 0.91245848 0.93170208 0.91695338 0.9464457\n", + " 0.95381296]]]\n" + ] + } + ], + "source": [ + "res_abs_i, res_trans = lighting.to_l_egume(m_lais=m_lais)\n", + "\n", + "print(\"PARa intercepted\")\n", + "print(res_abs_i)\n", + "print(\"\\n\")\n", + "print(\"PARa transmitted\")\n", + "print(res_trans)" + ] + }, + { + "cell_type": "markdown", + "id": "9fcffc57", + "metadata": {}, + "source": [ + "#### CARIBU\n", + "\n", + "Input: l-egume intern grid of leaf area" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "00448c53", + "metadata": {}, + "outputs": [], + "source": [ + "caribu_args = { \"sensors\" : [\"grid\", dxyz, nxyz, orig] }\n", + "\n", + "lighting = LightVegeManager(lightmodel=\"caribu\", lightmodel_parameters=caribu_args, environment={\"infinite\":True})\n", + "lighting.build(geometry={\"scenes\" : [scene] })\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "59229231", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "807d4e2d53194fff894c9ed93cf720e8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'MwRlXOaT39UuyymKny87RStKz', 'data': b'x\\xda\\x8d\\x9d\\t\\x98\\x1dE\\x…" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_sensors(light=True) + lighting.plantGL_nolight(), \n", + " position=(-0., -0., 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 10, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9e714349", + "metadata": {}, + "outputs": [], + "source": [ + "# plant parameters, those variables are part of l-egume, here is a simplified version for our example\n", + "list_invar = [{\"Hplante\": [0.0] * 2}]\n", + "list_lstring = [\n", + " {\n", + " 0: [0, 0, 0, 0, 0, 0, 0, 0, 0, \"dev\"],\n", + " 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, \"sen\"],\n", + " 2: [1, 0, 0, 0, 0, 0, 0, 0, 0, \"dev\"],\n", + " }\n", + "]\n", + "list_dicFeuilBilanR = [\n", + " {\"surf\": [0.5, 1e-8]},\n", + "]\n", + "\n", + "import numpy\n", + "\n", + "m_lais = numpy.zeros([1] + nxyz)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "635d93e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "PARa absorbed per plant\n", + "[{'Hplante': [0.0, 0.0], 'parap': array([230.44407642, 98.6702188 ]), 'parip': array([349.22395645, 98.6702188 ])}]\n" + ] + } + ], + "source": [ + "res_trans = lighting.to_l_egume(m_lais=m_lais, \n", + " list_lstring=list_lstring, \n", + " list_dicFeuilBilanR=list_dicFeuilBilanR, \n", + " list_invar=list_invar)\n", + "# print(\"PARa transmitted\")\n", + "# print(res_trans)\n", + "\n", + "print(\"\\n\")\n", + "print(\"PARa absorbed per plant\")\n", + "print(list_invar)" + ] + }, + { + "cell_type": "markdown", + "id": "4f336844", + "metadata": {}, + "source": [ + "## CN-Wheat results transfer\n", + "\n", + "The method `to_MTG` is used to transfer results to Cn-Wheat through a MTG object with the properties `\"PARa\"` and `\"Erel\"`. The `id` argument is used with you several input scenes but you need to transfer only some of them to your MTG instance." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cc377bd4", + "metadata": {}, + "outputs": [], + "source": [ + "# load a MTG instance\n", + "import os\n", + "from alinea.adel.adel_dynamic import AdelDyn\n", + "from alinea.adel.echap_leaf import echap_leaves\n", + "\n", + "INPUTS_DIRPATH = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"data\")\n", + "adel_wheat = AdelDyn(seed=1, scene_unit=\"m\", leaves=echap_leaves(xy_model=\"Soissons_byleafclass\"))\n", + "g = adel_wheat.load(dir=INPUTS_DIRPATH)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "476690b3", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "lighting.build(geometry={\"scenes\" : [g] })\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2ccd1d03", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{19: 183.28839878423275, 34: 88.59510772768847, 813: 458.96763725505764, 814: 392.72942554102866, 51: 350.64417693430573}\n", + "{19: 0.3665767975684655, 34: 0.17719021545537694, 813: 0.9179352745101153, 814: 0.7854588510820574, 51: 0.7012883538686114}\n" + ] + } + ], + "source": [ + "lighting.to_MTG(mtg=g)\n", + "print(g.property(\"PARa\"))\n", + "print(g.property(\"Erel\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "448e2b39", + "metadata": {}, + "outputs": [], + "source": [ + "lighting = LightVegeManager(lightmodel=\"ratp\")\n", + "lighting.build(geometry={\"scenes\" : [g] })\n", + "\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "177fd272", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{19: 468.0222778320313, 34: 468.02227783203136, 813: 468.0222778320312, 814: 473.66244791932104, 51: 468.02227783203125}\n", + "{19: 0.0007445579394698143, 34: 0.0007445579394698143, 813: 0.0007445579394698141, 814: 0.00030915768207336026, 51: 0.0007445579394698143}\n" + ] + } + ], + "source": [ + "lighting.to_MTG(mtg=g)\n", + "print(g.property(\"PARa\"))\n", + "print(g.property(\"Erel\"))" + ] + } + ], + "metadata": { + "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": 5 +} diff --git a/notebooks/tool_basics.ipynb b/notebooks/tool_basics.ipynb new file mode 100644 index 0000000..8eab9cf --- /dev/null +++ b/notebooks/tool_basics.ipynb @@ -0,0 +1,777 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ad713094", + "metadata": {}, + "source": [ + "# Introduction to using the tool\n", + "\n", + "\n", + "## Content:\n", + "- One triangle\n", + " - CARIBU\n", + " - RATP\n", + "- Set of triangles\n", + " - CARIBU\n", + " - RATP \n", + "- The environment variable\n", + "\n", + "## First elements\n", + "The main methods of a LightVegeManager object are :\n", + "- constructor `__init__`: returns an instance and initialize static parameters such as sky and default parameters\n", + "- `build`: build and arrange the geometric scene following the lightmodel input format\n", + "- `run`: compute lighting\n", + "- DataFrame outputs are stored in `triangles_ouputs`, `voxels_ouputs` and `elements_ouputs`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9a585293", + "metadata": {}, + "outputs": [], + "source": [ + "# imports the LightVegeManager object and SceneWidget for visual representation\n", + "from lightvegemanager.tool import LightVegeManager\n", + "from pgljupyter import SceneWidget" + ] + }, + { + "cell_type": "markdown", + "id": "bab44821", + "metadata": {}, + "source": [ + "## One triangle\n", + "\n", + "As a first example, we can compute lighting on a single 3D triangle. \n", + "A triangle is reprented with a list of 3 cartesian points (x, y, z)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5ac06352", + "metadata": {}, + "outputs": [], + "source": [ + "t = [(0., 0., 0.), (1., 0., 0.), (1., 1., 1.)]" + ] + }, + { + "cell_type": "markdown", + "id": "7f6b20c9", + "metadata": {}, + "source": [ + "### CARIBU (surfarcic modelling)" + ] + }, + { + "cell_type": "markdown", + "id": "40d0cd3c", + "metadata": {}, + "source": [ + "1) Initialize the instance. The `lightmodel` must be entered, currently you choose between `\"caribu\"`, `\"ratp\"` and `\"riri5\"`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "87148b50", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"caribu\")" + ] + }, + { + "cell_type": "markdown", + "id": "10991ff2", + "metadata": {}, + "source": [ + "2) Build the geometry. The triangle will be save inside the instance." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2ebe3c2e", + "metadata": {}, + "outputs": [], + "source": [ + "# build the scene\n", + "lighting.build(geometry=t)" + ] + }, + { + "cell_type": "markdown", + "id": "d96cab36", + "metadata": {}, + "source": [ + "In order to visualize the scene in the instance, you can give a plantGL Scene in SceneWidget through two methods:\n", + "- `plantGL_nolight`: plots only geometric elements\n", + "- `plantGL_light`: plots geometric elements and colors the scene according to PAR values" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "28e80db8", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "120f766cdfe1445abf514c99eafecb73", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'vc3yVFvaf9yoybmXm2X7TP8BQ', 'data': b'x\\xdaSLrw\\xf5\\xf7e`Pp\\xe0\\…" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_nolight(), size_display=(600, 400), plane=True, size_world = 4, axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "cfdc7935", + "metadata": {}, + "source": [ + "3) Compute the lighting. By default it will compute direct and diffuse lighting." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2a1e7140", + "metadata": {}, + "outputs": [], + "source": [ + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "markdown", + "id": "75936065", + "metadata": {}, + "source": [ + "Then, you can print the Dataframe outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a3871c84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Triangle Organ VegetationType Area par Eabs \\\n", + "0 264 15 0 0 0 0.707107 397.268686 \n", + "\n", + " par Ei \n", + "0 467.374925 \n" + ] + } + ], + "source": [ + "# print the outputs\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "eab84abf", + "metadata": {}, + "source": [ + "### RATP" + ] + }, + { + "cell_type": "markdown", + "id": "922d32de", + "metadata": {}, + "source": [ + "To use RATP, you need to create a new instance. The others methods can be used in the same as with CARIBU" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2f0f6333", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"ratp\")\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=t)" + ] + }, + { + "cell_type": "markdown", + "id": "5d6a943e", + "metadata": {}, + "source": [ + "With `plantGL_nolight` you can precise if you want to plot the voxels. By default, a voxel side is set as 3 times the longest triangle side." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "234a2715", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "72ea5881f13b4c6a85b9beaf89c72eae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'uajlbqVBofOIFhDuXTLF9qFhF', 'data': b'x\\xdaSLrw\\xf5\\xf7e`Pp\\xe0\\…" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# visualisation\n", + "SceneWidget(lighting.plantGL_nolight(printvoxels=True), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 4, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "068b4b80", + "metadata": {}, + "outputs": [], + "source": [ + "# compute the lighting\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)" + ] + }, + { + "cell_type": "markdown", + "id": "f905455f", + "metadata": {}, + "source": [ + "You can get the outputs of the voxels or the triangles" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "59e6cfc2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " VegetationType Day Hour Voxel Nx Ny Nz ShadedPAR SunlitPAR \\\n", + "0 1.0 264.0 15.0 1.0 1 1 1 380.635895 473.640411 \n", + "\n", + " ShadedArea SunlitArea Area PARa Intercepted Transmitted \n", + "0 0.010761 0.696346 0.707107 472.225067 0.667827 8.742233 \n" + ] + } + ], + "source": [ + "# print the outputs\n", + "print(lighting.voxels_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "bffa7914", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Triangle Organ Voxel VegetationType primitive_area Day Hour Nx \\\n", + "0 0 0 1.0 1 0.707107 264.0 15.0 1 \n", + "\n", + " Ny Nz ShadedPAR SunlitPAR ShadedArea SunlitArea Area \\\n", + "0 1 1 380.635895 473.640411 0.010761 0.696346 0.707107 \n", + "\n", + " PARa Intercepted Transmitted \n", + "0 472.225067 0.667827 8.742233 \n" + ] + } + ], + "source": [ + "# print the outputs\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "markdown", + "id": "838240ed", + "metadata": {}, + "source": [ + "## Set of triangles" + ] + }, + { + "cell_type": "markdown", + "id": "9ee94e4e", + "metadata": {}, + "source": [ + "For this second example, we will generate a set of random 3D triangles. A function is already implemented in the package." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5fe1fa60", + "metadata": {}, + "outputs": [], + "source": [ + "from lightvegemanager.trianglesmesh import random_triangle_generator" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ea867adf", + "metadata": {}, + "outputs": [], + "source": [ + "nb_triangles = 5000\n", + "spheresize = (10., 2.) # vertices of triangles are the sphere surface\n", + "triangles = []\n", + "for i in range(nb_triangles):\n", + " triangles.append(random_triangle_generator(spheresize=spheresize))" + ] + }, + { + "cell_type": "markdown", + "id": "75e9f766", + "metadata": {}, + "source": [ + "### CARIBU\n", + "We repeat the same steps as with one triangle" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a4987150", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3a2f6d31e46149c8ba6fd65ad34057f4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'Sym0YTEGdGGm7GpHUu3Cubc3i', 'data': b'x\\xda\\x8c]\\x07XUG\\xd3&v\\x8…" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"caribu\")\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=triangles)\n", + "\n", + "# visualisation\n", + "SceneWidget(lighting.plantGL_nolight(), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "1b8e873a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Hour Triangle Organ VegetationType Area par Eabs \\\n", + "0 264 15 0 0 0 49.393789 47.050303 \n", + "1 264 15 1 0 0 49.078681 23.093771 \n", + "2 264 15 2 0 0 102.945704 9.974392 \n", + "3 264 15 3 0 0 24.126015 338.869465 \n", + "4 264 15 4 0 0 52.326033 203.833217 \n", + "... ... ... ... ... ... ... ... \n", + "4995 264 15 4995 0 0 72.344270 150.857122 \n", + "4996 264 15 4996 0 0 15.049568 4.357494 \n", + "4997 264 15 4997 0 0 28.560917 262.137311 \n", + "4998 264 15 4998 0 0 28.145749 45.033456 \n", + "4999 264 15 4999 0 0 60.040012 115.592509 \n", + "\n", + " par Ei \n", + "0 55.353298 \n", + "1 27.169143 \n", + "2 11.734579 \n", + "3 398.669959 \n", + "4 239.803784 \n", + "... ... \n", + "4995 177.478967 \n", + "4996 5.126463 \n", + "4997 308.396836 \n", + "4998 52.980537 \n", + "4999 135.991187 \n", + "\n", + "[5000 rows x 8 columns]\n" + ] + } + ], + "source": [ + "# compute the lighting\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "# print the outputs\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "99b7e8e2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7fe06f7b118e472688db4e996f2d7bb6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': '1MLbncOivVoacAyV4ClDvVOBd', 'data': b'x\\xda\\x8c]\\x05x\\x15W\\xd3N\\…" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SceneWidget(lighting.plantGL_light(), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "markdown", + "id": "4984e0e8", + "metadata": {}, + "source": [ + "### RATP\n", + "Now, we will set the voxels size. It needs to be specified in a dict which stores all RATP parameters. Here, you need to precise the length on each axis of one voxel. " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e619909c", + "metadata": {}, + "outputs": [], + "source": [ + "ratp_parameters = { \"voxel size\": [20.] * 3 }" + ] + }, + { + "cell_type": "markdown", + "id": "33f72664", + "metadata": {}, + "source": [ + "Then, the dict is an argument in the instance creation." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0d97938f", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2da2490444464b6dbcc0326b7945ceea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': '2pJ1SCaVVmz6KABMEDZMVuBtf', 'data': b'x\\xda\\x8c}\\x05|\\x16\\xd7\\xf…" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# initialize the instance\n", + "lighting = LightVegeManager(lightmodel=\"ratp\", lightmodel_parameters=ratp_parameters)\n", + "\n", + "# build the scene\n", + "lighting.build(geometry=triangles)\n", + "\n", + "# visualisation\n", + "SceneWidget(lighting.plantGL_nolight(printtriangles=True, printvoxels=True), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "746a5fa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " VegetationType Day Hour Voxel Nx Ny Nz ShadedPAR SunlitPAR \\\n", + "0 1.0 264.0 15.0 1.0 2 5 3 54.428970 150.400497 \n", + "1 1.0 264.0 15.0 2.0 5 6 3 50.428650 146.400192 \n", + "2 1.0 264.0 15.0 3.0 2 4 4 25.016081 120.987617 \n", + "3 1.0 264.0 15.0 4.0 3 5 2 137.027084 232.998642 \n", + "4 1.0 264.0 15.0 5.0 1 6 4 94.889290 190.860825 \n", + ".. ... ... ... ... .. .. .. ... ... \n", + "210 1.0 264.0 15.0 211.0 4 2 7 81.486168 177.457718 \n", + "211 1.0 264.0 15.0 212.0 1 7 4 171.829315 267.800842 \n", + "212 1.0 264.0 15.0 213.0 1 5 7 66.265411 162.236938 \n", + "213 1.0 264.0 15.0 214.0 6 4 7 81.604439 177.575974 \n", + "214 1.0 264.0 15.0 215.0 3 4 1 377.730652 473.702209 \n", + "\n", + " ShadedArea SunlitArea Area PARa Intercepted \\\n", + "0 940.238770 300.895721 1241.134521 77.695923 192.862198 \n", + "1 1056.413818 256.752136 1313.166016 69.193146 181.724167 \n", + "2 1486.096924 89.238495 1575.335449 30.452608 95.946152 \n", + "3 1048.442871 282.894226 1331.337158 157.419952 419.158112 \n", + "4 328.778809 248.748779 577.527588 136.225494 157.347977 \n", + ".. ... ... ... ... ... \n", + "210 21.034737 22.331879 43.366615 130.907242 11.354008 \n", + "211 30.276852 32.065239 62.342091 221.191635 27.579096 \n", + "212 211.458740 224.413452 435.872192 115.677383 100.841103 \n", + "213 69.074570 45.346554 114.421127 119.639183 27.378498 \n", + "214 0.375681 27.028229 27.403910 472.386536 25.890474 \n", + "\n", + " Transmitted \n", + "0 40.667442 \n", + "1 40.337265 \n", + "2 16.455536 \n", + "3 53.644543 \n", + "4 85.096527 \n", + ".. ... \n", + "210 86.211784 \n", + "211 176.470810 \n", + "212 63.874039 \n", + "213 80.683655 \n", + "214 390.410797 \n", + "\n", + "[215 rows x 15 columns]\n" + ] + } + ], + "source": [ + "# compute the lighting\n", + "energy = 500.\n", + "hour = 15\n", + "day = 264\n", + "lighting.run(energy=energy, hour=hour, day=day)\n", + "\n", + "# print the outputs\n", + "print(lighting.voxels_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "838bbb57", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Triangle Organ Voxel VegetationType primitive_area Day Hour Nx \\\n", + "0 0 0 1.0 1 49.393789 264.0 15.0 2 \n", + "27 1 0 2.0 1 49.078681 264.0 15.0 5 \n", + "69 2 0 3.0 1 102.945704 264.0 15.0 2 \n", + "109 3 0 4.0 1 24.126015 264.0 15.0 3 \n", + "146 4 0 5.0 1 52.326033 264.0 15.0 1 \n", + "... ... ... ... ... ... ... ... .. \n", + "4924 4995 0 199.0 1 72.344270 264.0 15.0 1 \n", + "336 4996 0 10.0 1 15.049568 264.0 15.0 4 \n", + "4785 4997 0 187.0 1 28.560917 264.0 15.0 3 \n", + "1290 4998 0 43.0 1 28.145749 264.0 15.0 5 \n", + "1775 4999 0 59.0 1 60.040012 264.0 15.0 2 \n", + "\n", + " Ny Nz ShadedPAR SunlitPAR ShadedArea SunlitArea Area \\\n", + "0 5 3 54.428970 150.400497 940.238770 300.895721 1241.134521 \n", + "27 6 3 50.428650 146.400192 1056.413818 256.752136 1313.166016 \n", + "69 4 4 25.016081 120.987617 1486.096924 89.238495 1575.335449 \n", + "109 5 2 137.027084 232.998642 1048.442871 282.894226 1331.337158 \n", + "146 6 4 94.889290 190.860825 328.778809 248.748779 577.527588 \n", + "... .. .. ... ... ... ... ... \n", + "4924 6 5 88.287605 184.259140 684.410645 155.426743 839.837402 \n", + "336 6 3 36.994896 132.966446 1456.751465 284.425629 1741.177124 \n", + "4785 3 2 182.791809 278.763367 473.721069 319.463074 793.184143 \n", + "1290 4 2 159.442474 255.414017 770.785034 269.372406 1040.157471 \n", + "1775 7 4 91.605270 187.576828 648.480042 74.454109 722.934143 \n", + "\n", + " PARa Intercepted Transmitted \n", + "0 77.695923 192.862198 40.667442 \n", + "27 69.193146 181.724167 40.337265 \n", + "69 30.452608 95.946152 16.455536 \n", + "109 157.419952 419.158112 53.644543 \n", + "146 136.225494 157.347977 85.096527 \n", + "... ... ... ... \n", + "4924 106.048828 178.127563 80.731377 \n", + "336 52.672089 183.422882 28.330009 \n", + "4785 221.445343 351.293884 100.292107 \n", + "1290 184.296478 383.394714 73.595093 \n", + "1775 101.489265 146.740112 72.746109 \n", + "\n", + "[5000 rows x 18 columns]\n" + ] + } + ], + "source": [ + "# print the outputs\n", + "print(lighting.triangles_outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a6786993", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "df4284a48fd44e9d824298c1b13cb2fa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'gky0cmb03EMHc7bv5AesZLLo4', 'data': b'x\\xda\\x8c]\\x05xUG\\xd3N\\x91…" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# visualisation\n", + "SceneWidget(lighting.plantGL_light(printtriangles=True, printvoxels=True), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e4c43fad", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "792d163989d14baa89de66f92cb827c7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "SceneWidget(axes_helper=True, scenes=[{'id': 'TXw7QyMuu2rKBBUoxc20FYmoS', 'data': b'x\\xda\\x95]\\xdboo\\xc7U\\xb6\\…" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# visualisation\n", + "SceneWidget(lighting.plantGL_light(printtriangles=False, printvoxels=True), \n", + " position=(-50.0, -50.0, 0.0), \n", + " size_display=(600, 400), \n", + " plane=True, \n", + " size_world = 100, \n", + " axes_helper=True)" + ] + } + ], + "metadata": { + "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": 5 +} diff --git a/s2v/SORTIES_s2v b/s2v/SORTIES_s2v new file mode 100644 index 0000000..8313705 --- /dev/null +++ b/s2v/SORTIES_s2v @@ -0,0 +1,24 @@ +SORTIES_s2v + + ** s2v.log +* informations sur le déroulement du programme +* statistiques globales pour chaque espèce de la scène : + - LA totale par espèce + - LA totale + - LAI + - distribution zenith globale de l'espèce + + ** s2v.can +copie le triangle en entrée mais avec un attribut en plus : couche en z max auquel appartient le triangle + + ** s2v.area + - chaque ligne : "id du triangle" "couche max en z" "aire du triangle" + + ** out.dang +fichier pour SAIL + - ligne 1 : lai globale pour l'espèce 1 + - ligne 2 : distrib zenith globale pour l'espèce 1 + + ** leafarea +fichier pour SAIL + - chaque ligne : 0 idz "LAI par classe d'inclinaisons dans la couche" 0 0 "LAD sur l'épaisseur" \ No newline at end of file diff --git a/s2v/fort.51 b/s2v/fort.51 new file mode 100644 index 0000000..71ba716 --- /dev/null +++ b/s2v/fort.51 @@ -0,0 +1,5 @@ +p 1 100001001000 3 1.164514 4.472970 4.515880 1.282508 3.524203 4.883970 -0.106773 3.988203 3.570723 +p 1 100001001000 3 2.487949 0.970069 4.303277 2.807932 2.114717 3.015707 2.727567 1.260793 4.176357 +p 1 100001001000 3 2.228481 3.596791 3.425399 2.230021 3.065646 4.904108 2.570435 2.829843 4.365617 +p 1 100001001000 3 0.866265 0.892767 4.264220 -0.190762 -0.629647 4.599549 0.614165 0.780050 4.502412 +p 1 100001001000 3 4.294620 3.054521 4.607150 5.896218 3.271670 3.932476 5.539221 3.942415 3.412786 diff --git a/s2v/leafarea b/s2v/leafarea new file mode 100644 index 0000000..d97b892 --- /dev/null +++ b/s2v/leafarea @@ -0,0 +1,2 @@ + 0 1 0.000000 0.000000 0.000000 0.000000 0.663420 0.090495 0.079505 0.166580 0.000000 0 0 2.492611 + 0 2 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0 0 0.000000 diff --git a/s2v/out.dang b/s2v/out.dang new file mode 100644 index 0000000..e38a03b --- /dev/null +++ b/s2v/out.dang @@ -0,0 +1,2 @@ +0.059348 +0.000000 0.000000 0.000000 0.000000 0.663420 0.090495 0.079505 0.166580 0.000000 \ No newline at end of file diff --git a/s2v/s2v++.exe b/s2v/s2v++.exe new file mode 100644 index 0000000..640bd2b Binary files /dev/null and b/s2v/s2v++.exe differ diff --git a/s2v/s2v.area b/s2v/s2v.area new file mode 100644 index 0000000..b221c45 --- /dev/null +++ b/s2v/s2v.area @@ -0,0 +1,5 @@ +100001001000 0 0.848395 +100001001000 0 0.198175 +100001001000 0 0.415219 +100001001000 0 0.225569 +100001001000 0 0.805254 diff --git a/s2v/s2v.can b/s2v/s2v.can new file mode 100644 index 0000000..f196be9 --- /dev/null +++ b/s2v/s2v.can @@ -0,0 +1,5 @@ +p 2 100001001000 0 3 1.164514 4.472970 4.515880 1.282508 3.524203 4.883970 -0.106773 3.988203 3.570723 +p 2 100001001000 0 3 2.487949 0.970069 4.303277 2.807932 2.114717 3.015707 2.727567 1.260793 4.176357 +p 2 100001001000 0 3 2.228481 3.596791 3.425399 2.230021 3.065646 4.904108 2.570435 2.829843 4.365617 +p 2 100001001000 0 3 0.866265 0.892767 4.264220 -0.190762 -0.629647 4.599549 0.614165 0.780050 4.502412 +p 2 100001001000 0 3 4.294620 3.054521 4.607150 5.896218 3.271670 3.932476 5.539221 3.942415 3.412786 diff --git a/s2v/s2v.cpp b/s2v/s2v.cpp new file mode 100644 index 0000000..8ea6664 --- /dev/null +++ b/s2v/s2v.cpp @@ -0,0 +1,1224 @@ +/* S4 CALCULE LA REPARTITION DANS UNE GRILLE 3D DES SURFACES DES TRIANGLES*/ +/* CONSTITUTIFS D'UNE MAQUETTE, AINSI QUE LA DISTRIBUTION D'ORIENTATION DES*/ +/* NORMALES AUX TRIANGLES. */ +/* Bruno Andrieu */ +/* INRA Bioclimatologie 78850 Thiverval-Grignon */ +/* tel #33 1 30815527 Fax #33 1 30815527 */ +/* Email andrieu@bcgn.inra.fr */ +/* nb1 : Dans la suite on parle indifferement d'inclinaison ou d'angle zenital, ces*/ +/* deux termes represente la meme grandeur. */ +/* nb2 : la maquette peut comprendre plusieurs especes vegetales. */ +/* Dans ce cas l'analyse est faite pour chacune des especes presentes. */ +/* La variable espece est codee via le label associ� a chaque triangle */ +/* (espece= label/10**11) */ +/* nb3 :La structure peut etre de type periodique dans le plan horizontal.*/ +/* (typiquement une periode = un interrang). */ +/* Une maquette periodique est constituee de la repetition d'un motif elementaire.*/ +/* Dans ce cas l'ensemble des triangles est analyse pour calculer les variations*/ +/* moyennes a l'interieur du motif. Dans le plan horizontal, le motif est divise en*/ +/* njx * njy cellules de dimension dx et dy. */ +/* (njx*dx et njy*dy representent la periode en x et y) */ +/* **** **** **** **** */ +/* ****** ****** ****** ****** */ +/* ******** ******** ******** ******** */ +/* ** ** ** ** unite de longueur*/ +/* ** ** ** ** >-----<*/ +/* ** ** ** ** */ +/* ! ! ! ! ! ! ! ! ! ! */ +/* >------------------< ! ! dy = 0.4 et njy = 9*/ +/* longueur = njy*dy */ + +/* >-----------------------------------------------------< */ +/* longueur = yl */ + + +/* nb4 : les dimensions maximales des tableaux sont definis dans le code */ +/* par des commandes parameter. Modifier ces lignes si necessaire pour augmenter*/ +/* le nombre de cellules ou de classes d'angles. */ +/* Donnees en entree: */ +/* ****************** */ +/* Fichier fort.51 contenant les triangles au format can */ +/* (verifier :lecture non formatee ou format libre) */ +/* 1 enregistrement par triangle comprenant */ +/* -type de primitive et attributs. */ +/* On suppose que le premier attribut/1000000 = espece */ +/* -les coordonnees des trois sommets du triangle (reels) */ +/* Fichier de parametres (lecture format libre) */ +/* sur lequel doit etre redirige l'entree standard */ +/* ligne 1 : nji nja */ +/* nji: nombre de classes d'inclinaison */ +/* nja : nombre de classes d'azimuth */ +/* ligne 2 : njz dz(njz) */ +/* njz : nombre de tranches d'altitude */ +/* dz(njz):epaisseur des tranches d'altitude, numerotees du haut */ +/* vers la bas (classe 1= la plus haute) */ +/* ligne 3 : xl,njx,dx,yl,njy,dy,nje */ +/* xl et yl: dimensions totales de la maquette en x et y */ +/* njx njy : nombre de divisions dans un motif en x et en y */ +/* dx, dy : dimensions d'une cellule selon x et y */ +/* nje : nombre d'especes */ +/* ligne 4 : tx, ty, tz */ +/* tx,ty,tz : parametre de translation des sommets tq maq. centree */ +/* Fichier sortie: */ +/* *************** */ +/* Les resultats sont edites dans un fichier fort.60 comprenant */ +/* Dimensions de la maquette */ +/* Nombre de fois ou le motif est repete dans la maquette. */ +/* STATISTIQUES GLOBALES DE CHAQUE ESPECE: */ +/* Statistiques calculees sur toute la maquette: */ +/* Surface foliaire totale et indice foliaire */ +/* Distribution des orientations des normales aux feuilles */ +/* (frequence en zenith et en azimuth ) */ +/* STATISTIQUES PAR CELLULES: */ +/* 1 ligne par cellule et par espece, comprenant: jx,jy,jz,je,u,f(ji) */ +/* jx,jy,jz: numero de cellule en x, y, et z */ +/* je : numero d'espece */ +/* u : densite volumique de surface foliaire */ +/* f(ji) : distribution d'inclinaison dans la cellule */ +/* (c'est a dire frequence en zenith) */ +/* Parametres */ +/* ********** */ +/* levelmax : nombre max de niveaux de subdivision d'un triangle */ +/* njemax */ +/* njxmax */ +/* njymax */ +/* njzmax */ +/* njimax */ +/* njamax */ +/* nattmax */ +/* Compilation et Execution: */ +/* ************************* */ +/* g++ -o s4++ s4.C -I../../bibliotek -I. -lm*/ +/* s4 //.h> +#include //.h> +using namespace std ; + +#include +#include + +#include + + +#include +#ifndef __GNUG__ +#ifndef WIN32 +#include "bool.h" +#endif +#endif + +#include +#include + +#include + +#ifdef WIN32 +#include // Mem partag�e via CerateFileMapping/MapViewOfFile +#endif + +#include + +#define NattMax 10 +#define LevelMax 6 //4:3,6 +// CF 2016 : directly read nje in opt files +//#define NBOPT 10 + +#define max(a,b) ((a>b)?a:b) +#define min(a,b) ((a defini dans transf.h + +/*************** Prototypes ********************/ +double lectri(signed char&,char&,int&,long [],int&,Patch&,FILE *); +int repart(Patch ,char, int); +void calcjp(Patch, int[3][3], char&); +void classe(double, int&); +// BUG multi-specie - MCoct2010 : void affect(Patch,int*); +void affect(Patch,int*, int); +double proscal(double*, double*); +void provec(double*, double*, double*); +void norme(double*, double*); +void normal(Patch&, double&, double&); +double area(Patch &T); +// CF 2016 read number of optical species in opt file +void lect_nopt(int *nopt,char *optname); +void lect_po( Tabdyn &Tpo,int po,char *optname); +int isid(char *name); + +// Secured file close +void Sfclose(FILE ** fic, int line=161) ; // HA nov 2003 + +/**********************************************************/ + +int ji,ja,nbz=0,nbzm=0; +int nbpatc=0; +short je; +int njx,njy,njz; +//int jp[3][3]; +double dx, dy, proscal_to_surf; +double *dz = NULL,*bz = NULL; +int i,j,k,po,npo=0; +Tabdyn xladia; //je, jz, theta, phi +Tabdyn xpo;//je,jz,po,(Rf,Tf) +Tabdyn Tpo; + +double Rs[1000], Stot; +unsigned int nbtt,nbts; +#ifndef WIN32 +extern int errno; +#endif + +#ifndef WIN32 +#ifdef _IPC_SGI +struct shmid_ds info; +#else +// shminfo seginf; +#endif +#else +// AFAIRE ?? +#endif + +// Indice du premier fichier de propri�t�s optiques +#define MIN_ARGC 6 +#define MIN_OPT (MIN_ARGC-1) + +bool segpar=false,genopt=false; + +ferrlog Ferr((char*)"s2v.log") ; + +int s2v(int argc, char **argv){ + //int main(int argc, char **argv){ + int nja,nji,nje, nje_reel=-1, cptr=0; + char ntype,optname[200]; + signed char test; + int natt,nsom; + int jx,jy,jz,il; + double xl,yl,dxdy,zl; + double di,da,xymaille; + Patch *Ts = NULL; + Patch T; // def. Transf.h + long i_att[NattMax]; + FILE *fpar=NULL, *fmlsail=NULL, *fsail=NULL, + *ftri=NULL, *fsurf=NULL ; + Tabdyn xlad;// je, jz + Tabdyn xladi;//jz, jz, ji + Tabdyn disti; + Tabdyn dista; + double *xlai = NULL; + double *surft = NULL, *volume = NULL; + int Nt,it=0, clef; + bool gencan=true; + double id; + +#ifndef WIN32 + int shmid ; // Id du segment de mem. partag�e +#else + char clef_alphanum[12] ; // version char* de la clef numerique + HANDLE hSharedSeg ; // Handle du fichier mapp� + LPVOID lpSharedSeg ; // pointeur LPVOID sur seg. partag� +#endif + + for(i=0;i1 &&argc< MIN_ARGC){ + Ferr<<" Syntax error: "<< argv[0] ; + Ferr<<" [shm_id nz Dz file.8 file_1.opt ... file_n.opt]"<<'\n'; + Ferr << "\t MC2005"<<'\n'; + return -1; + } + + // Initialisation + Stot=nbtt=nbts=0; + fmlsail=fopen("leafarea","w"); + fsail=fopen("out.dang","w"); + if(argc>1){// by shared memory (called by caribu) + genopt=true; + if(isid(argv[1])){//by seg + Ferr<<"Scene coming through a shm_seg"<<'\n'; + clef=atoi(argv[1]); + DecodeClefOut(&Nt, &clef, clef); + /* Nt=clef/100; + clef%=100; */ + segpar=true; +#ifndef WIN32 + shmid=shmget((key_t)clef,SEGSIZE*sizeof(Patch) ,IPC_CREAT|0666); + Ts=(Patch *)shmat(shmid,0,NULL); +#else + sprintf ( clef_alphanum, "%d", clef) ; + assert ((hSharedSeg = OpenFileMapping ( + FILE_MAP_ALL_ACCESS, + FALSE, + clef_alphanum)) != NULL ) ; + + lpSharedSeg = MapViewOfFile ( + hSharedSeg, + FILE_MAP_ALL_ACCESS, + 0, + 0, + SEGSIZE*sizeof(Patch) ) ; + assert ( lpSharedSeg != NULL ) ; + Ts = (Patch *)lpSharedSeg ; +#endif + }else{ + segpar=false; + Ferr<<"Scene coming through the file "< Ouverture de "<=0;i--){ + dz[i]=zl; + if(i==njz-1) + bz[i]=dz[i]; + else + bz[i]=dz[i]+bz[i+1]; + Ferr<<":: bz("< Ouverture de "< Ouverture de fort.51 achoppee..."<<'\n'; + return -2; + }// if ftri + Ferr<<"Lecture du fichier parametre dans fichier : "<<'\n'; + fscanf(fpar,"%d %d %d",&nji,&nja,&njz); + printf("nji=%d, nja=%d, njz=%hd \n",nji,nja,njz); + Ferr <<"nji="< fort.51: old use) + + //alloc des tableaux de resultats + xlai= new double[nje]; + surft=new double[nje]; + for(i=0;i T + T.t=Ts[it].t; + for(char ii=0;ii<3;ii++) + for(char jj=0;jj<3;jj++) + T.P[ii][jj]=Ts[it].P[ii][jj]; + + // Bug MC09: if(T.t<0) + if(T.t > 0) + i_att[0]=1;// Transparent: feuille + else + i_att[0]=0; //Opak: Tige + + if(T.t==0) test=-1; + + je=fabs(double(T.t))-1; + + if(je+1>nje_reel)nje_reel=je+1; + //printf("it=%d/%d :: T.t=%d, je=%d\n",it,Nt,T.t,je); + it++; + + } + else{ + id=lectri(test,ntype,natt,i_att,nsom,T,ftri); + //printf(">dbg apres call lectri, test = %d\n", test); + if(test==1){ + long opak; + nbtri++; + //i_att[0] = label1/1000 + je=(i_att[0]/100000000)-1; //je : de 0 � nje (indice tableau C) + if(je+1>nje_reel)nje_reel=je+1; + // Bug MC09 T.t=je+1; + T.t= - je+1; // default OPak + if(je==-1) test=-2;//Sol + opak= i_att[0] - i_att[0]/1000*1000; + // dbug: printf("i_att=%ld, iatt/1e3=%ld \n",i_att[0],i_att[0]/1000); + // MC09 i_att[0]=i_att[0]%1000; + i_att[0]=T.t=(opak>0)?1:0; + //if(i_att[0]>0) T.t= -T.t; + // i_att[0] = 1 => Transparent: feuille + // i_att[0] = 0 => Opak: Tige + // printf("> s2v: lectri() => id:%.0f, opak=%ld, i_att[0]=%ld, je=%d, T.t=%d\n",id, opak,i_att[0], je, T.t); + } + }//else segpar + + //debug MC2011 + // printf(">>>> Apres lcture fichier fort.51 nje = %d, nje_reel =%d\n", nje, nje_reel) ; + if(test>-1){ + // fprintf(stderr,"label=%d, esp=%d, nbid=%d ,nbs=%d\n",i_att[0],je,natt,nsom); + if((je<0)&&(je>=nje)&&(natt<=0)&&(natt>NattMax)&&(nsom!=3)){ + fprintf(stderr,"*** Incorect data format in fort.51 file -> break\n"); + exit(-1); + } + // feuille ou tige pour le coef de surface + proscal_to_surf=0.5; + if(i_att[0]==0) + proscal_to_surf=0.25; + // Orientation discrete du triangle + double incl,azi; + // for(i=0;i<3;i++)for(j=0;j<3;j++) printf("T(%d,%d) = %lf\n",i,j,T[i][j]); + + normal(T,incl,azi); + ji = (int)(incl/di); + ja = (int)(azi/da); + //ji = min(nji-1,max(0,ji)); + //ja = min(nja-1,max(0,ja)); + ji = min(nji-1, ji); + ja = min(nja-1,ja); + + // printf("inc=%lf, azi=%lf => ji=%d, ja=%d\n",incl,azi,ji,ja); + //calcul recursif des coord discretes du T et du cas cheval + //printf("Repart called 1, je=%d\n", je); + // for(int q=0;q<3;q++) printf("Patch(%d,2)=%g\n",q,T.P[q][2]); + if(je>=0){ + il=repart(T,0, je); + //printf(">>>> apres call repart: je =%d \n",je); + } + if(gencan){ + if(segpar) { + id=(int)T.t; + } + sT=area(T); + fprintf(fsurf,"%.0lf\t %d\t %g\n",id,il,sT); + fprintf(fcan,"p 2 %.0lf %d 3 ",id,il); + + for(char ii=0;ii<3;ii++) + for(char jj=0;jj<3;jj++) + fprintf(fcan,"%lf ", T.P[ii][jj]); + + fprintf(fcan,"\n"); + } + }//if triangle et non sol + + if(test==-2 && gencan){//cas du sol + //printf("==>test=%d\n",test); + sT=area(T); + fprintf(fsurf,"0 \t\t 999\t %g\n",sT); + fprintf(fcan,"p 2 0 999 3 "); + + for(char ii=0;ii<3;ii++) + for(char jj=0;jj<3;jj++) + fprintf(fcan,"%lf ", T.P[ii][jj]); + fprintf(fcan,"\n"); + } + //printf("> dbg: juste avant while(!segpar && feof(ftri): cptr = %d\n", cptr++); + }while((!segpar && !feof(ftri)) || (segpar && (it dbg: juste apres while(!segpar && feof(ftri)\n"); + + printf("\n*** nbtri=%d, nbpatch=%d\n\n",nbtri, nbpatc); + + if(segpar){ +#ifndef WIN32 + shmdt((void*)shmid); //ShMDetach +#else + UnmapViewOfFile(lpSharedSeg) ; // invalidation du ptr sur mem partagee + // Ts = NULL ; // Tester avant + CloseHandle(hSharedSeg) ; // Fermeture du fichier mapp� +#endif + Ferr<< "-> Fin de lecture du segment partage: "< Calcul des distributions"<<'\n'; + }else{ + Sfclose(&ftri,__LINE__); + Ferr<<__FILE__<<":"<<__LINE__<<" -> Fin de lecture de fichier\n"; + Ferr <<"=> Calcul des distributions"<<'\n'; + } + printf(">>>> Apres lcture fichier fort.51 nje = %d, nje_reel =%d\n", nje, nje_reel); + Ferr<<"==> nje rel = "< Error No triangle dealt"<<'\n'; + else{ + for (jz=0; jz debut boucle nje =%d\n\n", nje);fflush(stdout); fflush(stderr); + double tmp; + /* Inversion de l'ordre des boucles en mettant je en 1er pour eviter les cas + ou une couche ne contient pas une espece et pour faire des calculs + especes confondues - MC98 */ + int ii=0; + // bug mai 2011 + jx=jy=0; // jy n'avait pas l'air d'etre init et il n'y a pas de bocle sur x et y + for (jz=0; jz> (jz=%d, je=%d, ji=%d) \n",jz,je,ji); + fflush(stdout);fflush(stderr); + } + tmp=xladia(je,jz,ji,ja); + xladi(je,jz,ji) += tmp; + + disti(je, ji) += tmp; + dista(je, ja) += tmp; + surft[je] += tmp; + }//for ja + xlad(je, jz) +=xladi(je, jz, ji); + // xladi(je, jz, ji)=ii++; //dbug mc 2010 + // dbug: printf(">> xladi(jz=%d, je=%d, ji=%d) =%.0lf\n",jz,je,ji, xladi(je, jz, ji));fflush(stdout);fflush(stderr); + }//for ji + /* passage aux frequences d'angles.... */ + if (xlad(je,jz) > 0) { + tmp=xlad(je, jz); + for (ji=0; ji < nji; ji++) { + xladi(je, jz, ji) /= tmp; //bug fix� - mai 2011 + }//for ji + }//if xlad>0 + }//for je + }//for jz + // dbug: printf("big loop : subT=%lf, surft=%lf\n", nbts/(double)nbtt,surft[0]);fflush(stdout); + + + //dbug + for (jz=0; jz0) + dista(je, ja) /= surft[je]; + } + for (ji=0; ji0) + disti(je, ji) /= surft[je]; + } + }//for je + /* Calcul de l'indice foliaire */ + for (je=0; je Ecriture des resultats : (c|std)err, leafarea, out.dang"<<'\n'; + // stdout + if(nbz>0) + Ferr<<"Il y a eu "<0) + Ferr<<"Il y a eu "< entree de sailM pour calculer la BRDF + Ferr << "genere le fichier out.dang => entree de sailM pour calculer la BRDF"<<'\n' ; + //if (fsail == NULL){Ferr <<"! le FILE *fsail est NULL"<<'\n'; //HA } + + fprintf(fsail,"%lf\n",xlai[0]); + for (ji=0; ji0.){ // -1000 MCoct2010 debug + printf("\n %d %d \t %7.6lf\t ",jz+1,je+1,(xlad(je,jz)/volume[jz])); + for(ji=0;ji-S2EPSILON)) { + Uz = Uz<0 ? -S2EPSILON : S2EPSILON ; + Ferr << "\t: xx= "<< xx<<" ; Uz= "<dbg: genere fichier spectral\n"); + for(po=0;po0){ + xx=xlad(je,jz);// /(double)nje; + x+=xx; + Rf+=xpo(je,jz,po,0); + Tf+=xpo(je,jz,po,1); + //printf("=> po(je=%d/%d)=%g, Rfz=%g, Rft=%g\n",je,nje,xpo(je,0,0,jz,po,0),xpo(je,0,0,jz,po,0)*100./xx, Rf*100./x); + //printf(" => xx=%g,x=%g\n",xx,x); + } + //else printf(" pas de p.o. car lai nul\n"); + }//for je + if(x>0){ + Rf*=100./x; + Tf*=100./x; + } + + fprintf(fpar,"%.3lf %.3lf\n",Rf,Tf); + } + Sfclose(&fpar,__LINE__); + //Genere le fichier CROPCHAR degenere necessaire a MCsail + fpar=fopen("cropchar","w"); + fprintf(fpar,"%d\n %d %lf\n",nji,njz,dz[0]); + Sfclose(&fpar,__LINE__); + }//for po + }//if genopt + }//else pas de triangles a traiter + // Clean up + if(gencan){ + Sfclose(&fcan,__LINE__); + Sfclose(&fsurf,__LINE__); + } + Sfclose(&fsail,__LINE__); + Sfclose(&fmlsail,__LINE__); + + if (xlai!=NULL) + delete [] xlai ; + else + Ferr <<__LINE__<<" : ptr Null"<<'\n'; + + if ( surft != NULL) + delete [] surft; + else + Ferr <<__LINE__<<" : ptr Null"<<'\n'; + + if (dz != NULL) + delete [] dz; + else + Ferr <<__LINE__<<" : ptr Null"<<'\n'; + + if (volume != NULL) + delete [] volume; + else + Ferr <<__LINE__<<" : ptr Null"<<'\n'; + + if (bz != NULL) + delete [] bz; + else + Ferr <<__LINE__<<" : ptr Null"<<'\n'; + + Tpo.free(); + disti.free(); + dista.free(); + xlad.free(); + xladi.free(); + xladia.free(); + xpo.free(); + + Ferr.close(); + return 0; +}//main() + + +/************************* +******* lectri() ******* +**************************/ +double lectri(signed char &test,char &ntype,int &natt,long i_att[],int &nsom,Patch&T,FILE *fichier){ + char fin; + int ent; + double it,p0,p1,p2,lab; + + // Ferr <<"==> lectri() : DEBUT"<<'\n'; + test=fscanf(fichier, "%c",&fin);//ntype); + ntype=fin; + if(ntype!='p') test=-10; + if(test==-10){ return -1;} + fscanf(fichier, "%d", &natt); + for (i=0; i lectri() : FIN"<<'\n'; + return lab; +}// lectri() + +/**************************************************************************/ +int repart(Patch T,char level, int je){ + Patch exT,ssT; + char acv; + int jp[3][3]; + double G[3]; + int il=-10,iln; + //Ferr<<" => repart called"<<'\n'; + // Ferr<<"\t** debut repart "<<'\n'; + //printf(">>> repart(): DEBUT\n"); + level++; + for(i=0;i<3;i++) + for(j=0;j<3;j++){ + exT.P[i][j]=T.P[i][j]; + } + exT.t=T.t; + calcjp(exT,jp,acv); + if (acv==0) { + // T appartient a une seule cell + //printf("Non ACV: T appartient a une seule cell \n"); + + G[2]=(exT.P[0][2]+exT.P[1][2]+exT.P[2][2])/3.; + if(G[2]>=0){ + //printf(">dbg Avant call affect...\n"); + affect(exT,jp[0], je); + il=jp[0][2]; + //printf("Non ACV: level = %d\n",(int)level); + //if(level>1){nbtt++;nbts++;} + }else{ + + nbzm++; + il= -2; + //printf("else Non ACV: il = %d, nbzm=%d\n",(int)il, nbzm); + + } + }else{ + if(level==LevelMax){ + // niveau subdiv max atteint => on stocke dans la cell de G + //printf("ACV mais levalMax: level = %d\n",(int)level); + for(i=0;i<3;i++) + G[i]=(exT.P[0][i]+exT.P[1][i]+exT.P[2][i])/3.; + if(G[2]>=0){ + jp[0][0]=(int)(G[0] / dx); + jp[0][1]=(int)(G[1] / dy); + classe(G[2], jp[0][2]); + affect(exT,jp[0],je); + il=jp[0][2]; + // printf("...> nbt=%d\n",nbtt); + //nbtt++; + } + else{ + nbzm++; + il= -1; + } + } + else{ + //on subdivise le T en 4 + + // calcul les milieux + for (j=0; j<3; j++) + for (i=0; i<3; i++) + ssT.P[j][i]=(exT.P[j][i]+exT.P[(j+1)%3][i])/2.; + + for (i=0; i<3; i++){ + T.P[0][i]=exT.P[0][i]; + T.P[1][i]=ssT.P[0][i]; + T.P[2][i]=ssT.P[2][i]; + } + //for(int q=0;q<3;q++) printf("Sub1(%d,2)=%g\n",q,T.P[q][2]); + iln=repart(T,level,je); + il=max(il,iln); + for (i=0; i<3; i++){ + T.P[0][i]=ssT.P[0][i]; + T.P[1][i]=exT.P[1][i]; + T.P[2][i]=ssT.P[1][i]; + } + // for(int q=0;q<3;q++) printf("Sub2(%d,2)=%g\n",q,T.P[q][2]); + iln=repart(T,level,je); + il=max(il,iln); + for (i=0; i<3; i++){ + T.P[0][i]=ssT.P[1][i]; + T.P[1][i]=ssT.P[2][i]; + T.P[2][i]=exT.P[2][i]; + } + //for(int q=0;q<3;q++) printf("Sub3(%d,2)=%g\n",q,T.P[q][2]); + iln=repart(T,level,je); + il=max(il,iln); + for (i=0; i<3; i++){ + T.P[0][i]=ssT.P[0][i]; + T.P[1][i]=ssT.P[1][i]; + T.P[2][i]=ssT.P[2][i]; + } + // for(int q=0;q<3;q++) printf("Sub4(%d,2)=%g\n",q,T.P[q][2]); + iln=repart(T,level,je); + il=max(il,iln); + } + } + //Ferr<<"\t** sortie repart "<<'\n'; + // printf(">>> repart(): sortie il=%d\n", il); + return il; +}//repart() + + +/**************************************************************************/ +void calcjp(Patch T, int jp[3][3], char &acv){ + /* Calcul des positions en unites dx dy dz */ + /* nb: le mode d'affectation est tel que la position (0,0,1) est centree sur (0, 0, 0.5*bz(njz))*/ + int itest12=0,itest13=0; + + nbtt++; + // Ferr<<"** calcjp() : Debut"<<'\n'; + //Ferr << "dx= "<= bz[0]){ + nbz++; + // printf("=> Depasst en z+: %.3lf >= %.3lf\n",z,bz[0]); + } + if (z <0){ + jz=-10; + }else{ + /* if (z.lt.0.0) print *,"subroutine class : z negatif :",z */ + for (j=1; j bz[j]) { + arret=1; + break; + }//if + }//for + if(arret==1) + jz = j-1; + else + jz = njz-1; + } + // return jz; +}// classe() + +/*******************************************************************/ + // BUG multi-specie - MC oct 2010 + //void affect(Patch T,int *jp){ +void affect(Patch T,int *jp, int je){ + + double a[3], b[3], c[3]; + int jx, jy, jz,po; + double surftri; + + /* mise a jour du tableau xladia avec un triangle dont les 3 sommets appar tiennent a une meme cellule + */ + jz = jp[2]; + /* decalage de 1 et prise en compte de possibles coordonnees negatives */ + + for (i = 0; i < 3; i++) { + a[i] = T.P[1][i] - T.P[0][i]; + b[i] = T.P[2][i] - T.P[0][i]; + } + provec(a, b, c); + surftri = proscal_to_surf * sqrt(proscal(c, c)); + Stot+=surftri; + nbpatc++; + //printf("surftri=%lf\n",surftri); + //printf("affect() je=%d, jx=%d, jy=%d, jz=%d, ji=%d et ja=%d\n",je,jx,jy,jz,ji,ja); + // printf("affect() je=%d, T.t=%d, [%.2lf,%.2lf,%.2lf]\n",je,T.t,Tpo(1,fabs(T.t),0),Tpo(1,fabs(T.t),1),Tpo(1,fabs(T.t),2)); + xladia(je, jz, ji, ja) += surftri; + //printf(">>> affect(): avnt call norme()\n"); + //CF 2016: do not compute norme if triangle area is zero + if (surftri > 0) + norme(c,c); + //printf(">>> affect(): je = %d\n",je); + if(genopt){ + for(po=0;po0 = transparent, T.t<=0 = opak !! + //BUG if(T.t<0){//Transparent + if(T.t>0){//Transparent + xpo(je, jz,po,0)+=surftri*Tpo(po,je,1); //Rf + xpo(je, jz,po,1)+=surftri*Tpo(po,je,2); //Tf + //printf("> affect(): cas transperentt: je=%d, jz=%d :: surftri=%.3g, Tpo(%d,%d,0)=%g\n",je,jz,surftri,po,T.t,Tpo(po,je,0)); + }else{//Opak + printf("> affect() :Cas opak: Tpo(%d,%d,0)=%g\n",po,T.t,Tpo(po,je,0)); + xpo(je, jz,po,0)+=surftri*Tpo(po,je,0); //Rt + } + }//for po + }//if segpar +}// affect() + + +/***********************************/ +double proscal(double *a, double *b){ + double ret_val; + ret_val = 0; + for (i = 0; i < 3; i++) { + ret_val += a[i]*b[i]; + } + return ret_val; +}// proscal() + +/********************************************/ +void provec(double *a, double *b, double *c){ + c[0] = a[1] * b[2] - a[2] * b[1]; + c[1] = -a[0] * b[2] + a[2] * b[0]; + c[2] = a[0] * b[1] - a[1] * b[0]; +}// provec() + +/*****************************************************************/ +void norme(double *x, double *xn){ + double xnor; + + xnor = sqrt(proscal(x, x)); + if (xnor < 1e-20){ + fprintf(stderr, " s2v.cpp: norme() erreur: nombre=%g < 1e-20!! => exit(-1)\n", xnor); + exit(-1); + } + for(i=0; i<3; i++) + xn[i] = x[i] / xnor; +}// norme() + + +/***********************************************************************/ +void normal(Patch &T, double &zen, double &az){ + double u, v, w, r2, r1, p3p2[3]; + + //printf("normal() : Debut\n"); + for (i = 0; i < 3; i++) { + //printf("(%d) :%lf - %lf\n",i,T.P[1][i], T.P[2][i]); + p3p2[i] = T.P[1][i] - T.P[2][i]; + } + u= T.P[0][1]*p3p2[2] - T.P[0][2]*p3p2[1] + T.P[1][1]*T.P[2][2] - T.P[2][1]*T.P[1][2]; + v= -T.P[0][0]*p3p2[2] + T.P[0][2]*p3p2[0] - T.P[1][0]*T.P[2][2] + T.P[2][0]*T.P[1][2]; + w= T.P[0][0]*p3p2[1] - T.P[0][1]*p3p2[0] + T.P[1][0]*T.P[2][1] - T.P[2][0]*T.P[1][1]; + r2 = u*u + v*v; + if (r2 == 0) { + zen = 0; + az = 0; + } + else{ + r1 = sqrt(r2); + zen = acos(fabs(w/sqrt(r2+w*w))) * 57.29577951; + az = atan2(u/r1, v/r1) * 57.29577951; + if (az < 0) { + az += 360; + } + } + // printf("normal() : Fin\n"); +} // normal() +/***********************************************************************/ +double area(Patch &T){ + double a[3], b[3], c[3]; + int i; + for (i = 0; i < 3; i++) { + a[i] = T.P[1][i] - T.P[0][i]; + b[i] = T.P[2][i] - T.P[0][i]; + } + provec(a, b, c); + return proscal_to_surf * sqrt(proscal(c, c)); +} // area() + + +/***********************************************************************/ +void synterr(char * fname,int l){ + Ferr<< " Syntax error in the file "< Error(lect_po) unable to open "<>c; l++; + if(!fopti) break; + switch(c) { + case '#': + case 's': + case 'e': + fopti.getline(line,256); + break; + case 'n': + fopti >> *nopt; + fopti.getline(line,256); + break; + default : + synterr(optname,l); + }//switch c + if (c == 'n') + break; + } while(fopti); + fopti.close(); +}//lect_nopt() + + + +void lect_po( Tabdyn &Tpo,int po,char *optname){ + ifstream fopti(optname,ios::in); + char c, line[256]; + double Rt,Rf,Tf; + int l=0,esp=0; + if (!fopti){ + Ferr << " Error(lect_po) unable to open "<>c; l++; + if(!fopti) break; + switch(c) { + case '#': + case 'n': + fopti.getline(line,256); + break; + case 's': + fopti>>c; if(c!='d') synterr(optname,l); + fopti>>Rs[po]; + fopti.getline(line,256); + break; + case 'e': + //BRDF type : d + fopti>>c; if(c!='d') synterr(optname,l); + Rf=Tf=0; + // stem reflectance + fopti>>Rt; + Tpo(po,esp,0)=Rt; + //BRDF type : d + fopti>>c; if(c!='d') synterr(optname,l); + // upper leaf Rf and Tf + fopti>>Rf>>Tf; + //BRDF type : d + fopti>>c; if(c!='d') synterr(optname,l); + //lower leaf Rf => equivalent Rf + fopti>>Rt; Rf=(Rf+Rt)/2.; + //lower leaf Tf => equivalent Tf + fopti>>Rt; Tf=(Tf+Rt)/2.; + //printf("Rf(%d)=%.4g, Tf=%.4g\n",po,Rf,Tf); + Ferr << "Rf("< +//#include +#include + +FILE *fichier; + +ouvre_(nomfich) +char nomfich[]; +{ fichier=fopen(nomfich, "r"); } + +ferme_() +{ fclose(fichier); } + +lecpol_(test,ntype,natt,i_att,nsom,poly) +char *ntype; +int *natt,*nsom,*test; +double i_att[]; +float poly[]; + +{ +int ib,ic; +char fin; +lecture: + + *test=fscanf(fichier, "%c",ntype); if(*test==-1) return; + + fscanf(fichier, "%d", natt); + for (ib=0; ib<*natt; ib++) fscanf(fichier, "%lf", &i_att[ib]); + fscanf(fichier, "%d", nsom); + ic=0;for (ib=0;ib<*nsom;ib++) {fscanf(fichier, "%f%f%f", &poly[ic],&poly[ic+1],&poly[ic+2]);ic+=3;} + + do { fscanf(fichier, "%c", &fin); } while(fin!='p' && !feof(fichier)); + + if(!feof(fichier)) fseek(fichier,-sizeof(char),SEEK_CUR); + + /* + printf("fichier=%d \n", fichier); + printf("ntype=%c natt=%d\n", *ntype, *natt); + for (ib = 0; ib < *natt; ib++) printf("iatt(%d) = %ld \n",ib, i_att[ib]); + printf("nsom=%d\n", *nsom); + ic=0;for (ib=0;ib<*nsom;ib++) {printf("sommet %d %d %f %f %f\n",ib,ic,poly[ic],&poly[ic+1],&poly[ic+2]);ic+=3;} + */ +} + + + + + + + + diff --git a/s5/lecpol.o b/s5/lecpol.o new file mode 100644 index 0000000..5d170da Binary files /dev/null and b/s5/lecpol.o differ diff --git a/s5/s5.exe b/s5/s5.exe new file mode 100644 index 0000000..2c345c9 Binary files /dev/null and b/s5/s5.exe differ diff --git a/s5/s5.f b/s5/s5.f new file mode 100644 index 0000000..30be46d --- /dev/null +++ b/s5/s5.f @@ -0,0 +1,610 @@ +c S5 CALCULE LA REPARTITION DANS UNE GRILLE 3D DES CARACTERISTIQUES D'UNE MAQUETTE INFORMATIQUE +c DENSITE VOLUMIQUE DES SURFACES DES TRIANGLES +c DISTRIBUTION D'ORIENTATION DES NORMALES AUX TRIANGLES +c DENSITE VOLUMIQUE DES VARIABLES SURFACIQUES ASSOCIEES (ATTRIBUTS). + +c AUTEUR: +c Bruno Andrieu +c INRA Bioclimatologie 78850 Thiverval-Grignon +c tel #33 1 30815527 Fax #33 1 30815527 +c Email andrieu@bcgn.inra.fr + +c nb1: la maquette peut comprendre plusieurs especes vegetales. +c Dans ce cas l'analyse est faite pour chacune des especes presentes. +c La variable espece est codee via le label associ� a chaque triangle +c (espece= label/10**11) + +c nb2: La structure peut etre de type periodique dans le plan horizontal. +c (typiquement une periode = un interrang). +c Une maquette periodique est constituee de la repetition d'un motif elementaire. +c Dans ce cas l'ensemble des triangles est analyse pour calculer les variations +c moyennes a l'interieur du motif. Dans le plan horizontal, le motif est divise en +c njx * njy cellules de dimension dx et dy. +c (njx*dx et njy*dy representent la periode en x et y) + +c **** **** **** **** +c ****** ****** ****** ****** +c ******** ******** ******** ******** +c ** ** ** ** unite de longueur +c ** ** ** ** >-----< +c ** ** ** ** +c ! ! ! ! ! ! ! ! ! ! +c >------------------< ! ! dy = 0.4 et njy = 9 +c longueur = njy*dy +c +c >-----------------------------------------------------< +c longueur = yl +c +c +c nb3: Le label est decode pour determiner si le triangle lu appartient a une +c feuille (element surfacique) ou a une tige (element volumique). Dans ce dernier cas, la +c surface du triangle est ponderee par 0.5 pour les calculs de densite de surface foliaire. +c Ainsi la surface foliaire associee a un volume est la moitie de sa surface developpee. +c Ceci est coherent avec le fait que la surface prise en compte pour une feuille est calculee +c pour une seule face de la feuille. +c +c nb4: Pour ce qui est de la densite volumique des attributs (variables associees aux triangles): +c On suppose que les attributs representent des donnees surfaciques. Si les triangles +c representent la surface englobante d'un volume, le traitement d'attributs relatifs a ce volume +c ne peut se faire que si ces attributs sont presentes comme des variables surfaciques +c reparties sur la surface englobante. +c +c nb5: les dimensions maximales des tableaux sont definies dans le code +c par des commandes parameter. Modifier ces lignes si necessaire pour augmenter +c le nombre de cellules ou de classes d'angles. + + +c Donnees en entree: +c ****************** + +c Fichier fort.51 contenant les triangles au format can +c (verifier :lecture non formatee ou format libre) +c 1 enregistrement par triangle comprenant +c -type de primitive, nombre d'attributs, liste des attributs +c -nombre de sommets et coordonnees des trois sommets du triangle (reels) + +c Fichier de parametres (lecture format libre) +c sur lequel doit etre redirige l'entree standard +c ligne 1 : nje nji nja njz njs +c nje : nombre d'especes +c nji : nombre de classes de zenith +c nja : nombre de classes d'azimuth +c njz : nombre de tranches d'altitude +c njs : nombre d'attributs dont on veut calculer la repartition spatiale +c (en plus du calcul de la repartition de la densite volumique) +c ligne 2 : dz(njz) +c dz(njz):epaisseur des tranches d'altitude, numerotees du haut +c vers la bas (classe 1= la plus haute) +c ligne 3 : lisel(njs) +c lisel(njs): liste des numeros d'attributs dont on veut calculer +c la repartition spatiale (le label est le numero 1) +c ligne 4 : xl,njx,dx,yl,njy,dy +c xl et yl: dimensions totales de la maquette en x et y +c njx njy : nombre de divisions dans un motif en x et en y +c dx, dy : dimensions d'une cellule selon x et y + + +c Fichier sortie: +c *************** + +c Les resultats sont edites dans un fichier fort.60 comprenant + +c Dimensions de la maquette +c Nombre de fois ou le motif est repete dans la maquette. + +c STATISTIQUES GLOBALES DE CHAQUE ESPECE: +c Statistiques calculees sur toute la maquette: +c Surface foliaire totale et indice foliaire +c Distribution des orientations des normales aux feuilles +c (frequence en zenith et en azimuth ) + +c STATISTIQUES PAR CELLULES: +c 3 lignes par cellule et par espece: +c l1 -> je,jx,jy,jz,xvol(,,,,i) +c l2 -> f(ji) +c l3 -> f(ja) +c je : numero d'espece +c jx,jy,jz : numero de cellule en x, y, et z +c xvol(,,,,1) : densite volumique de surface foliaire. +c xvol(,,,,i+1): densite volumique du ieme attribut selectionne par lisel(i) +c f(ji) : distribution d'angle zenital dans la cellule +c f(ja) : distribution d'azimuth dans la cellule + + + +c Parametres +c ********** + +c levelmax: nombre max de niveaux de subdivision d'un triangle +c njemax : nombre max d'especes +c njxmax : nombre max de subdivisions spatiales selon x +c njymax : nombre max de subdivisions spatiales selon y +c njzmax : nombre max de subdivisions spatiales selon z +c njimax : nombre max de classes de zenith +c njamax : nombre max de classes d'azimuth +c nattmax : nombre max d'attributs (le label compte pour 1) + + +c Compilation et Execution: +c ************************* + +c f77 -extend_source -O s5.f lecpol.o -o s5 +c s5 0 : + if plt_cmap == "Greens" : + value = ratpgrid.s_vx[k-1] + elif plt_cmap == "seismic" : + value = outputs[outputs.Voxel==k]["PARa"].values[0] + + mat = colormap(value) + mat.transparency = transparency + + vectrans = (float(ratpgrid.xorig + (0.5 + x) * ratpgrid.dx ), + float(ratpgrid.yorig + (0.5 + y) * ratpgrid.dy ), + float(ratpgrid.dz[z:ratpgrid.njz].sum()-ratpgrid.zorig) - 0.5 * ratpgrid.dz[z] ) + shape = pgl.Shape(pgl.Translated(vectrans, pgl.Box(vsize)), mat) + scene.add(shape) + return scene \ No newline at end of file diff --git a/src/lightvegemanager/stems.py b/src/lightvegemanager/stems.py index b95f157..6cc3e25 100644 --- a/src/lightvegemanager/stems.py +++ b/src/lightvegemanager/stems.py @@ -38,6 +38,9 @@ def manage_stems_for_ratp(stems_id, matching_ids, ratp_parameters) : :raises ValueError: if too many stems elements are identified comparing to the total number of elements cumulated over all species """ + if stems_id is None: + return + if len(stems_id) > len(matching_ids) : raise ValueError("Too many stems elements ") diff --git a/src/lightvegemanager/tool.py b/src/lightvegemanager/tool.py index 1c7dd01..059f500 100644 --- a/src/lightvegemanager/tool.py +++ b/src/lightvegemanager/tool.py @@ -214,8 +214,8 @@ def build(self, geometry={}, global_scene_tesselate_level=0): """ # pre-check of scenes input, if it has only one triangle or one list of triangles if isatriangle(geometry) or all(isatriangle(s) for s in geometry): - geometry = {"scenes" : geometry} - + geometry = {"scenes": geometry} + self.__geometry = geometry # First process of the scenes list, it gathers all triangulations @@ -252,11 +252,27 @@ def build(self, geometry={}, global_scene_tesselate_level=0): "Conversion from voxels grid to triangles \ is not possible yet" ) + if "stems id" not in self.__geometry: + self.__geometry["stems id"] = None + + # build sensors + if "sensors" in self.__lightmodel_parameters and self.__lightmodel_parameters["sensors"][0] == "grid": + dxyz = self.__lightmodel_parameters["sensors"][1] + nxyz = self.__lightmodel_parameters["sensors"][2] + orig = self.__lightmodel_parameters["sensors"][3] + arg = (dxyz, nxyz, orig, self.__pmax, self.__complete_trimesh, self.__matching_ids, None, True) + sensors_caribu, sensors_plantgl, Pmax_capt = create_caribu_legume_sensors(*arg) + + self.__sensors_plantgl = sensors_plantgl # Builds voxels grid from input geometry elif self.__lightmodel == "ratp": # number of input species numberofentities = 0 + + # initialize number of empty layers + self.__nb0 = 0 + if legume_grid: numberofentities = self.__geometry["scenes"][id_legume_scene]["LA"].shape[0] @@ -288,11 +304,15 @@ def build(self, geometry={}, global_scene_tesselate_level=0): self.__environment["infinite"], self.__geometry["stems id"], len(self.__geometry["scenes"]), + self.__lightmodel_parameters["full grid"] ) - self.__complete_voxmesh, self.__matching_tri_vox, self.__angle_distrib = build_RATPscene_from_trimesh( - *arg - ) + ( + self.__complete_voxmesh, + self.__matching_tri_vox, + self.__angle_distrib, + self.__complete_trimesh, + ) = build_RATPscene_from_trimesh(*arg) # creates an empty RATP grid of voxels if geometric inputs are empty else: @@ -356,11 +376,10 @@ def run(self, energy=0.0, day=0, hour=0, parunit="micromol.m-2.s-1", truesolarti if self.__complete_voxmesh.nveg > 0: # Run of RATP - print("debut ratp") start = time.time() res = runRATP.DoIrradiation(self.__complete_voxmesh, vegetation, self.__sky, meteo) self.__time_runmodel = time.time() - start - print("fin ratp") + # output management self.__voxels_outputs = out_ratp_voxels(self.__complete_voxmesh, res, parunit) @@ -560,16 +579,29 @@ def to_MTG(self, energy=1.0, mtg=None, id=None): if id is None: for s in self.__elements_outputs["Organ"]: d = self.__elements_outputs[self.__elements_outputs.Organ == s] - para_dic[s] = d["par Eabs"].values[0] * energy - erel_dic[s] = d["par Eabs"].values[0] / self.__energy + + if self.__lightmodel == "caribu": + para_dic[s] = d["par Eabs"].values[0] * energy + erel_dic[s] = d["par Eabs"].values[0] / self.__energy + + elif self.__lightmodel == "ratp": + para_dic[s] = d["PARa"].values[0] + erel_dic[s] = d["Intercepted"].values[0] elif type(id) == list or type(id) == tuple: for esp in id: df_outputs_esp = self.__elements_outputs[self.__elements_outputs.VegetationType == esp] for s in df_outputs_esp["Organ"]: d = df_outputs_esp[df_outputs_esp.Organ == s] - para_dic[s] = d["par Eabs"].values[0] * energy - erel_dic[s] = d["par Eabs"].values[0] / self.__energy + + if self.__lightmodel == "caribu": + para_dic[s] = d["par Eabs"].values[0] * energy + erel_dic[s] = d["par Eabs"].values[0] / self.__energy + + elif self.__lightmodel == "ratp": + para_dic[s] = d["PARa"].values[0] + erel_dic[s] = d["Intercepted"].values[0] + dico_par["PARa"] = para_dic dico_par["Erel"] = erel_dic @@ -646,6 +678,7 @@ def to_l_egume(self, energy=1.0, m_lais=[], list_lstring=[], list_dicFeuilBilanR return transfer_caribu_legume( energy, skylayer, + id, self.__elements_outputs, self.__sensors_outputs, self.__lightmodel_parameters["sensors"][1], @@ -706,7 +739,7 @@ def s5(self): >>> testofs5.s5() # run of s5, creates input and output files """ - currentfolder = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) + currentfolder = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) s5folder = os.path.join(currentfolder, os.path.normpath("s5")) fort51 = os.path.join(s5folder, os.path.normpath("fort.51")) s5par = os.path.join(s5folder, os.path.normpath("s5.par")) @@ -716,8 +749,9 @@ def s5(self): c_tr = 1 for id, triangles in self.__complete_trimesh.items(): for t in triangles: - if tuple(self.__matching_ids[id]) in self.__geometry["stems id"]: - stem = "000" + if (self.__geometry["stems id"] is not None) : + if (tuple(self.__matching_ids[id]) in self.__geometry["stems id"]) : + stem = "000" else: stem = "001" label = ( @@ -801,7 +835,7 @@ def s2v(self): >>> testofs2v.s2v() # run of s2v, creates input and output files """ - currentfolder = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) + currentfolder = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) s2vfolder = os.path.join(currentfolder, os.path.normpath("s2v")) fort51 = os.path.join(s2vfolder, os.path.normpath("fort.51")) s2vpar = os.path.join(s2vfolder, os.path.normpath("s2v.par")) @@ -811,8 +845,9 @@ def s2v(self): c_tr = 1 for id, triangles in self.__complete_trimesh.items(): for t in triangles: - if tuple(self.__matching_ids[id]) in self.__geometry["stems id"]: - stem = "000" + if self.__geometry["stems id"] is not None: + if tuple(self.__matching_ids[id]) in self.__geometry["stems id"] : + stem = "000" else: stem = "001" label = ( @@ -849,8 +884,8 @@ def s2v(self): f.close() - # exécution de s5 dans un sous process - subprocess.call(".\s2v.exe", shell=True, cwd=s2vfolder) + # exécution de s2v dans un sous process + subprocess.call(".\s2v++.exe", shell=True, cwd=s2vfolder) print("--- Fin de s2v.cpp") @@ -980,6 +1015,78 @@ def VTK_sun(self, path, scale=2, orig=(0, 0, 0), center=True, i=None): VTKline(start, end, filepath) + def plantGL_sensors(self, light=False): + plantGL_sensors = self.__sensors_plantgl + + if light: + var = [v for v in self.__sensors_outputs["par"].values()] + + plt_cmap = "seismic" + minvalue = numpy.min(var) + maxvalue = numpy.max(var) + colormap = pgl.PglMaterialMap(minvalue, maxvalue, plt_cmap) + + for i, s in enumerate(plantGL_sensors): + s.appearance = colormap(var[i]) + + return plantGL_sensors + + def plantGL_nolight(self, printtriangles=True, printvoxels=False): + plantgl_voxscene = pgl.Scene() + plantgl_triscene = pgl.Scene() + if self.__lightmodel == "ratp" and printvoxels: + transparency = 0.0 + if printtriangles: + transparency = 0.35 + plantgl_voxscene = ratpgrid_to_plantGLScene( + self.__complete_voxmesh, transparency=transparency, plt_cmap="Greens" + ) + + if self.__matching_ids and printtriangles: + plantgl_triscene = cscene_to_plantGLScene_stems( + self.__complete_trimesh, stems_id=self.__geometry["stems id"], matching_ids=self.__matching_ids + ) + plantgl_scene = pgl.Scene() + for s in plantgl_triscene: + plantgl_scene.add(s) + for s in plantgl_voxscene: + plantgl_scene.add(s) + return plantgl_scene + + def plantGL_light(self, printtriangles=True, printvoxels=False): + plantgl_voxscene = pgl.Scene() + plantgl_triscene = pgl.Scene() + if self.__lightmodel == "ratp" and printvoxels: + if printtriangles: + transparency = 0.35 + plantgl_voxscene = ratpgrid_to_plantGLScene( + self.__complete_voxmesh, transparency=transparency, plt_cmap="Greens" + ) + else: + transparency = 0.0 + plantgl_voxscene = ratpgrid_to_plantGLScene( + self.__complete_voxmesh, + outputs=self.__voxels_outputs, + plt_cmap="seismic", + transparency=transparency, + ) + + if self.__matching_ids and printtriangles: + if self.__lightmodel == "caribu": + column_name = "par Ei" + elif self.__lightmodel == "ratp": + column_name = "PARa" + plantgl_triscene = cscene_to_plantGLScene_light( + self.__complete_trimesh, outputs=self.__triangles_outputs, column_name=column_name + ) + + plantgl_scene = pgl.Scene() + for s in plantgl_triscene: + plantgl_scene.add(s) + for s in plantgl_voxscene: + plantgl_scene.add(s) + return plantgl_scene + ## GETTERS ## @property def legume_transmitted_light(self): @@ -1102,3 +1209,10 @@ def modelruntime(self): return self.__time_runmodel except AttributeError: return 0.0 + + @property + def leafangledistribution(self): + try: + return self.__angle_distrib + except AttributeError: + return {} diff --git a/src/lightvegemanager/trianglesmesh.py b/src/lightvegemanager/trianglesmesh.py index 71b9cc7..67bc4d5 100644 --- a/src/lightvegemanager/trianglesmesh.py +++ b/src/lightvegemanager/trianglesmesh.py @@ -30,6 +30,8 @@ import numpy import pandas import bisect +import random +import math import openalea.plantgl.all as pgl from alinea.caribu import plantgl_adaptor @@ -537,3 +539,32 @@ def create_heterogeneous_canopy( position_number += 1 return duplicated_scene, domain + +def random_triangle_generator(worldsize=(0,100), + spheresize=(1.,1.), + sigma_angle=(math.pi, math.pi), + theta_angle=(math.pi/4, math.pi/5)): + """Generate a random based on parameters + + Vertices are generated on a surface of a sphere + + Args: + worldsize (tuple, optional): min and max where sphere center can be generated. Defaults to (0,100). + spheresize (tuple, optional): mean and std of the sphere size. Defaults to (1.,1.). + sigma_angle (tuple, optional): mean and std of the spherical angle on xy plane. Defaults to (math.pi, math.pi). + theta_angle (tuple, optional): mean and std of the zenithal angle. Defaults to (math.pi/4, math.pi/5). + + Returns: + list of 3 3-tuples: triangles defined by 3 xyz points + """ + r = random.gauss(spheresize[0], spheresize[1]) + x0, y0, z0 = [random.uniform(worldsize[0], worldsize[1]) for i in range(3)] + triangle = [] + for i in range(3) : + s = random.gauss(sigma_angle[0], sigma_angle[1]) + t = random.gauss(theta_angle[0], theta_angle[1]) + x = x0 + r * math.cos(s) * math.sin(t) + y = y0 + r * math.sin(s) * math.sin(t) + z = z0 + r * math.cos(t) + triangle.append((x,y,z)) + return triangle \ No newline at end of file diff --git a/tests/test_buildRATPscene.py b/tests/test_buildRATPscene.py index f14190a..be1ef42 100644 --- a/tests/test_buildRATPscene.py +++ b/tests/test_buildRATPscene.py @@ -7,6 +7,7 @@ import pytest import numpy import os +import itertools parameters_empty = {} @@ -135,7 +136,7 @@ def test_legumescene_to_RATPscene(): } more_inputs_4 = (None, 2) expected_4 = {} -expected_4["nxyz"] = (2, 1, 1) +expected_4["nxyz"] = (3, 1, 1) expected_4["nveg"] = 2 expected_4["nent"] = 2 expected_4["area"] = 0.47874045 @@ -179,7 +180,7 @@ def test_build_RATPscene_from_trimesh(test_input_1, test_input_2, test_input_3, infinite = True triLmax = 0.5 - ratpgrid, matching_tri_vox, distrib = build_RATPscene_from_trimesh( + ratpgrid, matching_tri_vox, distrib, trimesh = build_RATPscene_from_trimesh( triangles, minmax, triLmax, @@ -190,6 +191,7 @@ def test_build_RATPscene_from_trimesh(test_input_1, test_input_2, test_input_3, infinite, stems_id=test_input_3[0], nb_input_scenes=test_input_3[1], + fullgrid=False ) # vérifie nb vox créé @@ -218,6 +220,7 @@ def test_build_RATPscene_from_trimesh(test_input_1, test_input_2, test_input_3, # vérifie si la tesselation a eu lieu assert len(matching_tri_vox) == expected["nb triangles"] + assert len(list(itertools.chain(*[v for v in trimesh.values()]))) == expected["nb triangles"] # prise en charge du réfléchi numpy.testing.assert_array_equal(ratpgrid.rs, expected["rs"])