• Structures plissées - Couverture pliable

    Structures plissées - Couverture pliable

    Ce projet a pour objectif de créer des structures plissées.

    Afin de réaliser cette objectif, nous allons étudier un pli extrêmement simple : la base préliminaire de la bombe à eau.

    Nous étudierons ensuite une structure plissée pour l'architecture, d'abord de forme régulière, puis de forme irrégulière. 

    Enfin, nous étudierons la réalisation d'une couverture de 5m*2m entièrement pliable et dépliable.

    PARTIE 1 - SIMPLE PLI

    Pour bien comprendre les structures plissées sous Grasshopper, nous allons débuter avec un simple pli sur une feuille carrée. L'explication est extraite de la Formation à Grasshopper de ce blog, séance 4.

    Pour réaliser des plis, nous les modélisons comme une force qui pousse des lignes ou des faces à adopter un certain angle entre elles. Pour faire cela, nous utilisons Kangaroo, un plug-in de Grasshopper qui simule les lois de la physique.

    I-1 - Préparation sous Rhino

    Il faut d'abord créer un maillage (mesh) sous Rhino.

    Nous réalisons d'abord une polyligne fermée qui représente notre feuille, puis nous la transformons en maillage (menu Maillage > A partir d'une polyligne fermée) :

     

    C'est tout ce qu'il y a à préparer dans Rhino, la suite se fait intégralement sous Grasshopper.

    I-1 - Logigramme Grasshopper

    Kangaroo utilise des composants de forces pour fonctionner. Celui qui commande les angles entre deux facettes s'appelle Hinge. Cette force va permettre de plier la structure selon ce schéma :

    Les points 1 et 2 doivent être ceux du pli et les 3 et 4 les points des coins opposés.

    Une deuxième force importante à connaître est Springs. Elle nous permettra notamment, dans cet exemple, de forcer les lignes à garder leur connectivité et leur longueur initiale (cela permet d'éviter une déformation irréaliste des faces).

    Dans Grasshopper, voici les étapes qui mènent à l'obtention du pli simple :

    • Préparation :
      • On place le maillage créé dans un Mesh
      • Decompose permet d'en extraire (entre autres) les sommets (Vertices) et les faces (Faces)
      • Avec quatre List Item avec pour input 0, 1, 2 et 3 on sort séparément chacun des sommets (output Vertice de Decompose) et on repère les deux qui forment le pli et les deux qui forment les coin opposés
    • Force de pli avec Hinge :
      • On crée un composant Hinge
      • En input Point1 et Point2, il faut rentrer les points sur le pli
      • En input Point3 et Point4, il faut rentrer les points des coins opposés
      • L'input Strenght définie la force du Hinge : en clair plus elle est élevée plus le pli va se faire rapidement, nous mettons ici 0,5 dans un Number Slider
      • Dans l'input RestAngle nous rentrons l'angle de plissure définit par un Number Slider entre 0 et 90 avec Radians pour la conversion, suivi de Negative (permet de définir dans quel sens se fait le pli)
    • Force Springs :
      • Avec Mesh Edges appliqué sur le maillage initial, nous récupérons les arrêtes du maillage
      • On rentre les output non vides (ici E1 et E2) de MeshEdges non nul dans un même composant Line, ce dernier contient donc toutes les arrêtes du maillage
      • On crée un composant Springs et on y rentre ces lignes dans les input Connection et Rest lenght, ce sont les deux conditions que nous souhaitons conserver
    • Finalisation :
      • Le module Kangaroo permet de recueillir toutes les informations et de les traiter comme des données physiques
      • En input Force object, on rentre les outputs de Springs et Hinge
      • En input Anchor Point on rentre les points que nous souhaiter garder fixes, ici j'ai choisi les trois points d'une même face
      • En input Geometry, on rentre la géométrie à modifier, donc le maillage initial
      • Un Boolean Toggle est inséré dans l'input SimulatorReset : en position True, la simulation s'arrête et on observe la géométrie initiale, en position False, la géométrie commence à se modifier en fonction des forces qui agissent sur elle
      • Un Timer doit être relié au composant Kangaroo, il fixe le pas de rafraîchissement de l'affichage (puisque l'on travaille avec des forces, il vient la notion de temps via la loi de Newton)
      • Afin d'observer le résultat final, l'output GemetryOut est relié à un Mesh lui même relié à un Mesh Edges (cela permet de voir le maillage final ainsi que ses arrêtes)

    Ci-dessous le logigramme de l'icosaèdre et la vue du résultat final (cliquez pour voir en grand) :

    Ci-dessous la définition Grasshopper et le fichier Rhino :

      Simple pli.gh

    Grasshopper - Séance 3 Simple pli.3dm

     

    Note : si vous choisissez comme points d'ancrage seulement les deux points du pli, alors chaque côté se pliera de la moitié de l'angle défini afin que la somme des angles de chaque face avec l'horizontale soit égale à l'angle rentré. Par exemple ci-dessous avec un angle rentré de 45° (chaque face se plie de 22,5° par rapport au plan horizontal) :

      

    PARTIE 2 - MOTIF SIMPLE ET UNIQUE 

    Afin d'aborder les plissages complexe, avec la notion de vallées et de montagnes, nous allons aborder un pli extrêmement simple : la base préliminaire de la bombe à eau.

    Source (image de gauche) : le Portail de J.C.

     

    II-1 - Préparation sous Rhino

    Il faut d'abord bien préparer le maillage (mesh) sous Rhino.

    Nous réalisons d'abord une polyligne fermée qui représente un quart de notre feuille de papier :

    Ensuite, nous la transformons en maillage (menu Maillage > A partir d'une polyligne fermée) :

    Ensuite, avec Copier et Rotation, nous en faisons quatre copies en prenant bien soin d'orienter les diagonales dans le sens du pliage. On sélectionne les quatre maillages obtenus et on réalise une union booléenne (menu Maillage > Opérations booléennes sur les maillages > Union) pour obtenir un unique maillage :

    Il faut maintenant à insérer les points qui définissent les faces qui doivent rester planes :

    Enfin, il ne reste qu'à dessiner avec des lignes les plis qui seront les vallées et les montagnes :

    II-2 - Grasshopper sans script

    Il est possible de réaliser le pli de base de la bombe à eau sans utiliser de script. Néanmoins, et nous allons le confirmer, c'est un peu lourd. Surtout, ce ne sera pas une technique "exportable" pour les étapes suivantes, tel la voûte plissée où il y aura une une grande quantité de mailles avec un pliage répétitif. Nous verrons donc dans un second temps comment alléger la méthode avec un script.

    Mais il est intéressant de voir comment cela marche sans script, afin de bien appréhender les tenants et les aboutissants des forces Kangaroo qui ne sont pas toujours évidents. Cela permet également d’appliquer directement les méthodes évoquées à la Partie I.

    La méthode utilise WeaveBird. Bien que tout soit réalisable sans ce plug-in, ses fonctionnalités de manipulation de maillages permettent un grand gain de temps et rendent le logigramme beaucoup plus lisible.

    Dans Grasshopper, voici les étapes qui mènent à l'obtention du pli de la bombe à eau sans script :

    • Préparation de la géométrie :
      • On place le maillage créé dans un Mesh
      • Decompose permet d'en extraire (entre autres) les sommets (Vertices) et les faces (Faces), il va falloir traiter tous les points de façon indépendantes
      • Pour cela, on commence par retirer tous les points en doublon en appliquant Cull Duplicates sur l'output Vertices
      • Afin de les repérer facilement (voir le résultat ci-contre), nous allons les numéroter graphiquement : List Lenght permet de connaître le nombre de points, on l'insère dans l'input Count d'une Series. L'output de Series est placé dans un Integer pour enlever les virgules. Enfin on place le résultat  dans l'input Text d'un Text Tag 3D, l'input Location étant la liste des points (j'ai choisi 0,2 en input Size)
      • Avec neuf List Item avec pour input 0, 1, 2, ..., 7, 8 on extrait séparément chacun des sommets
    • Force de pli avec Hinge :
      • On crée deux composants Hinge, le premier servira pour les vallées (plis en creux), le second pour les montagnes (plis en saillie)
      • Un Number Slider défini l'angle, on le rentre dans l'input RestAngle du second Hinge (celui des montagnes) et, après lui avoir appliqué un Negative, dans celui de l'Hinge des vallées.
      • Pour les vallées on repère les triangles qui doivent être pliés et en ordonne les points dans le bon sens (en input Point1 et Point2, il faut rentrer les points sur les plis et en input Point3 et Point4, ceux sur les coins opposés), cela donne dans l'ordre : 3/5/0/2  -  7/5/8/1
      • Pour les montagnes, cela donne 5/8/6/7 - 5/0/3/6 - 5/2/4/3 - 5/1/7/4
      • Nota : ces listes sont ordonnées ainsi inputs Point1/Point2/Point3/Point4 pour chaque pli, par exemple, l'input Point1 du Hinge des vallées recevra les points du maillage numérotés 3 et 7
    • Maintenir les faces planes avec Planarize :
      • Afin d'éviter que les triangles 5/2/4 et 5/4/1 d'un côté et les triangles 0/6/5 et 6/5/8 de l'autre ne s'articulent et se plient, il faut bien préciser que les faces 2/5/1/4 et 0/6/8/5 doivent rester planer, pour cela on insère une force de Kangaroo Planarize, elle va forcer les deux surfaces à rester planes
      • Input Point1 : les points du maillages numérotés 2 et 0
      • Input Point2 : les points du maillages numérotés 5 et 6
      • Input Point3 : les points du maillages numérotés 1 et 8
      • Input Point4 : les points du maillages numérotés 4 et 5
    • Force Strings :
      • Avec Mesh edges de WeaveBird, on extrait les lignes (arrêtes) du maillage initial
      • On les place en input Connection et Rest length de Springs
    • Finalisation :
      • Le module Kangaroo permet de recueillir toutes les informations et de les traiter comme des données physiques
      • En input Force object, on rentre les outputs de Springs, Planarize et Hinge
      • En input Anchor Point on rentre les points que nous souhaitons garder fixes, ici j'ai choisi les trois points d'une même face
      • En input Geometry, on rentre la géométrie à modifier, donc le maillage initial
      • Un Boolean Toggle est inséré dans l'input SimulatorReset : en position True, la simulation s'arrête et on observe la géométrie initiale, en position False, la géométrie commence à se modifier en fonction des forces qui agissent sur elle
      • Un Timer doit être relié au composant Kangaroo, il fixe le pas de rafraîchissement de l'affichage (puisque l'on travaille avec des forces, la notion de temps va intervenir via la loi de Newton)
      • Afin d'observer le résultat final, l'output GemetryOut est relié à un Mesh lui même relié à un Mesh Edges (cela permet de voir le maillage final ainsi que ses arrêtes)

    Ci-dessous le logigramme du pli de base la bombe à eau sans script et la vue du résultat final (cliquez pour voir en grand) :

    II-3 - Grasshopper avec script

    Si nous voulons réaliser un dôme, il y aura de nombreuses faces, on ne peut donc pas se permettre d'extraire tout les points à la main. On va alors utiliser un script.

    L'original du script se trouve dans le fichier Origami_example.gh fourni par l'éditeur de Kangaroo sur cette page.

    Le script va extraire toutes les arrêtes qui séparent deux faces du maillage, donc des lignes de pliage potentielles. Ensuite, il va associer à chaque ligne de pli potentielle, les points A et B qui se situe sur la ligne de pli et les points C et D qui sont les coins opposés. Ces quatre outputs correspondent donc exactement aux 4 inputs de Hinge.

    Préférant le VisualBasic, je l'ai transcrit et commenté en VB. 

    Private Sub RunScript(ByVal M As Mesh, ByRef A As Object, ByRef B As Object, ByRef C As Object, ByRef D As Object)

    ' Si l'input Maillage est non vide :
    If M IsNot Nothing Then
      ' Définition des listes de points
      Dim EdgeStart As New List(Of Point3d) 'Liste les extrémités initales des arrêtes communes à deux faces
      Dim EdgeEnd As New List(Of Point3d) 'Liste les extrémités finales des arrêtes communes à deux faces
      Dim Tip1 As New List(Of Point3d) 'Liste des coins opposés à une arrête jointive pour la première face 
      Dim Tip2 As New List(Of Point3d) 'Liste des coins opposés à une arrête jointive pour la deuxième face 

       ' Récupration des sommets (vertices) du maillage :
      Dim VertexPts As Point3D() = M.Vertices.ToPoint3dArray

       ' Triangulation du maillage
      M.Faces.ConvertQuadsToTriangles

       ' Boucle sur le nombre d'arrêtes
      Dim i As Integer
      For i = 0 To M.TopologyEdges.Count - 1
        ' On liste les indices des faces jointives à la face l'arrête i
        Dim ConnectedFaces As Int32() = M.TopologyEdges.GetConnectedFaces(i) ' renvoi les indices des faces connectées à l'edge i
        ' S'il y a deux faces connectées à l'arrête i...
        If ConnectedFaces.Length = 2 Then
          ' On récupère dans la liste de points EdgeStart l'extrémité initiale des arrêtes
          EdgeStart.Add(M.TopologyEdges.EdgeLine(i).From)
          ' On récupère dans la liste de points EdgeEnd l'extrémité finale des arrêtes
          EdgeEnd.Add(M.TopologyEdges.EdgeLine(i).To)

           ' On récupère dans deux listes séparées les indices des 3 points au sommet de chacune des faces connectées à l'arrête i
          Dim adjacentface1points As Int32() = M.TopologyVertices.IndicesFromFace(ConnectedFaces(0))
          Dim adjacentface2points As Int32() = M.TopologyVertices.IndicesFromFace(ConnectedFaces(1))

           ' Liste dans EndTopologyVertices les indices des deux pointys aux extrémités de la l'arrête i
          Dim EndTopologyVertices As IndexPair
          EndTopologyVertices = M.TopologyEdges.GetTopologyVertices(i)

           ' On récupère tous les points du maillage connectés topologiquement (via une arrête) à la première extrémité (indicée I) de l'arrête i
          Dim connectedTopVerts As Int32() = M.TopologyVertices.ConnectedTopologyVertices(EndTopologyVertices.I, True)

           ' Boucle sur les points ainsi récupérés
          Dim j As Integer
            For j = 0 To connectedTopVerts.Length - 1
            ' Si le point connecté topologiquement est l'autre extrémité (indicée J) de l'arrête
            If connectedTopVerts(j) = EndTopologyVertices.J Then
              ' Alors les points recherchés sont le précédent et le suivant dans la liste
              Dim Tip1TopologyVertex As Int32 = connectedTopVerts((j - 1 + connectedTopVerts.Length) Mod (connectedTopVerts.Length))
              Dim Tip2TopologyVertex As Int32 = connectedTopVerts((j + 1 + connectedTopVerts.Length) Mod (connectedTopVerts.Length))

               ' On récupère les indices des points du maillage correspondants aux point sélectionnés
              Dim Tip1VertexIndex As Int32() = M.TopologyVertices.MeshVertexIndices(Tip1TopologyVertex)
              Dim Tip2VertexIndex As Int32() = M.TopologyVertices.MeshVertexIndices(Tip2TopologyVertex)

               ' Les coins opposés ainsi récupéré sont rangés dans les listes Tip1 et Tip2
              Tip1.Add(VertexPts(Tip1VertexIndex(0)))
              Tip2.Add(VertexPts(Tip2VertexIndex(0)))
            End If
          Next

         End If

       Next

    A = EdgeStart
    B = EdgeEnd
    C = Tip1
    D = Tip2

    End If

    End Sub

     

    Il reste à adapter le logigramme pour associer les vallées et les montagnes aux bonnes lignes du maillage (sans oublier aussi de redéfinir les points de la force Planarize).

    Dans Grasshopper, voici les étapes pour modifier le pli de la bombe à eau avec script :

    • Force Hinge :
      • On crée une force Hinge et on insère en inputs Point1, Point2, Point3 et Point4 les outputs du VB : respectivement A, B, C et D
      • Avec Line on relie les outputs A et B de VB, cela trace les arrêtes internes du maillage
      • Dans deux familles de Curve on rentre manuellement les vallées et les montagnes tracées sous Rhino
      • On applique aux trois familles de lignes (arrêtes internes du maillage, vallées, montagnes) un Point On Curve à midpoint
      • Deux Closest Points permettent de calculer la distance entre les arrêtes du maillage d'une part et les vallées et montagnes d'autres part.
      • Lorsque qu'une arrête coïncide avec une vallée (par exemple) la distance de ce point à la vallée sera 0, on convertit les distances avec un Boolean, il retournera donc False pour la valeur 0 : la liste de booléens retournera donc False si l'arrête coïncide avec la vallée et True si elle ne coïncide pas (c'est un peu contre-intuitif). Idem pour les montagnes.
      • On crée deux Function if(x,0,-1) pour les vallées (attribuera -1 pour les arrêtes coïncidant avec les vallées et 0 aux autres) et if(x,0,1) pour les montagnes (attribuera 1 pour les arrêtes coïncidant avec les montagnes et 0 aux autres)
      • Avec Addition, on somme les deux listes, on a donc une liste de nombres en correspondance avec chaque arrête interne du maillage : 0 si ce n'est ni une vallée ni une montagne, -1 si c'est une vallée, +1 si c'est une montagne
      • Il n'y a plus qu'à faire la Multiplication avec la valeur de l'angle et l'insérer l'input RestAngle du Hinge
    • Maintenir les faces planes avec Planarize :
      • Avec Weavebird's Faces Polylines on extrait les polylignes des faces du maillage
      • Avec deux List Item on extrait les deux paires de faces formant les grands triangles qui doivent rester plans (dans mon fichier ce sont les 4 et 6 d'un côté et les 1 et 3 de l'autre)
      • Avec Discontinuity on extrait les points de ces faces et avec Cull Duplicates (input flatten), on retire les doublons, il ne reste donc que les quatre points de la facette à maintenir plane
      • Avec Explode Tree (BANG!) (inputs graft) on sépare les quatre points en quatre listes (de 1 point), enfin on les insère dans les inputs Point1Point2Point3 et Point4 en faisant bien attention de les replacer dans l'ordre de la facette

    Le reste du logigramme est identique à la version sans script. J'ai choisi de ne pas mettre de points d'ancrage.

    Ci-dessous le logigramme du pli de base la bombe à eau avec script et la vue du résultat final (cliquez pour voir en grand) :

     

    Ci-dessous la définition Grasshopper et le fichier Rhino.
    Merci de respecter le ou les auteur(s) et de bien vouloir me contacter pour toute utilisation.

      Base bombe à eau.gh

    Grasshopper - Séance 3 Base bombe à eau.3dm

    PARTIE 3 - GENERALISATION A UN MOTIF REPETE

    Nous pouvons maintenant aborder les structures plissées complexes réalisées par une répétition de motifs identiques.

    III-1 - Réalisation d'une voûte droite

    Pour réaliser une voûte droite, nous allons utiliser la même méthode que décrite précédemment mais en généralisant à une grande répétition du même motif.

    Voici le maillage réalisé sous Rhino pour la voûte (les vallées sont en vert et les montagnes en rouge) :

     

    Dans Grasshoopper, il suffit de reprendre le même logigramme que celui élaboré pour le pli de base de la bombe à eau (avec script) et d'y insérer ce maillage, les vallées et les montagnes dans les bonnes collections de géométries.

    Comme il n'y a pas de faces à maintenir planes, on peut supprimer toute la partie de la force Planarize.

    En revanche, il va falloir rajouteur deux forces pour simuler les conditions aux bords :

    • les deux bords doivent rester sur le plan OXY
    • chacun des deux bords doit rester bien droit
    • les deux bords doivent rester parrallèles entre eux

    La première condition se réalise avec la force PullToSurf qui oblige des points à rester sur une surface déterminée. La deuxième et la troisième condition peut se gérer avec la force Align qui oblige deux segments à s'aligner (être parallèles entre eux).

    Dans Grasshopper, voici les étapes pour modifier le pli de la bombe à eau afin d'obtenir la voûte plissée :

    • Force Pull to Surface :
      • Avec Weavebird's Vertices Component on extrait les points du maillage
      • Avec Decompose, on en extrait toutes les coordonnées X, Y et Z et via Sort List on réorganise la liste des points (input Values A) en fonction des X croissants (output X dans input Keys)
      • On inverse la liste avec Reverse List : la première liste de points permettra de travailler sur le premiers bord (points dont les X sont minimaux) et celle transformée par Reverse List sur l'autre bord (celui avec les X maximaux)
      • On commence par extraire la coordonnée X de chacun des deux bords en insérant ces deux listes de points dans l'input List de deux List Item (indice pris : 0)
      • On insère l'output X de Decompose dans deux Equality comparant la coordonnée X des points avec la valeur minimale et la valeur maximale (dans l'output B) obtenues grâce aux List Item
      • On Dispatch (copier deux fois le composant) les points obtenus avec Weavebird's Vertices Component selon le pattern (intput Pattern) obtenu dans les outputs = respectifs des deux Equality : on obtient ainsi deux listes de points correspondant respectivement aux points de chacun des bords de la voûte
      • Avec Cull Duplicates (copier deux fois le composant), on supprime les points en doublon
      • Enfin, on Dispatch (copier deux fois le composant) à nouveau les deux listes pour ne garder qu'un point sur deux
      • Les output A des deux Disptach sont insérées dans l'input Points d'une force PullToSurf
      • Pour l'input ConstraintSurface, qui correspond à la surface sur laquelle les points doivent rester, le plus simple est d'obtenir avec Weavebird's Naked boundary la polyligne de la périphérie du maillage initial (input Mesh) et de l'insérer directement dans l'input ConstraintSurface qui la transformera en surface automatiquement
      • L'input PullStrength est réglée à 1000
    • Force Align :
      • Pour Align, on utilise les outputs A des deux derniers Dispatch précédemment créés que l'on Decompose pour obtenir les coordonnées  X Y et Z des points des bords
      • Avec deux Sort List on trie ces points (input Values A) en fonction des Y croissants (output X dans input Keys)
      • Pour chacun de ces deux Sort List on crée un List Item et un Cull Index et l'on y insère les outputs A : les deux List Item contiennent le premier point de leur bord respectif et les Cull Index tous les autres points de ce bord
      • Dans une force Align, on insère le premier List Item en input Align1, le premier Cull Index dans l'input Align2 (en mode graft), le second List Item en input Align3 et le second Cull Index dans l'input Align4 (en mode graft) : cette technique permet de s'assurer à la fois que les bords restent parallèles entre eux mais aussi que dans un même bord tous les segments reliant le premier point du bord à tous les autres points restent bien alignés, ce qui permet d'obtenir un bord droit
      • L'input AlignStrength est réglée à 2000

    Ci-dessous le logigramme de la voûte plissée et la vue du résultat final (cliquez pour voir en grand) :

    Ci-dessous la définition Grasshopper et le fichier Rhino.
    Merci de respecter le ou les auteur(s) et de bien vouloir me contacter pour toute utilisation.

      Voute droite plissée.gh

    Grasshopper - Séance 3 Voute droite plissée.3dm

    III-2 - Réalisation d'une voûte plissée à géométrie libre

    La méthode est très facilement adaptable à une structure non droite et même avec des "originalités".

    Ci-dessous, un travail réalisé par Aglaë Dubois, Pia Lepetit, Pierre Jutteau, Oscar Chiu de Margerie et Jean-Baptiste Bolet, étudiants à l'Ecole d'Architecture de Paris la Villette. On voit une partie en voûte à bords non parallèles et une partie en forme de dôme. Plus bas ma réalisation sous Grasshopper. Il s'agit d'une simple adaptation de la voûte droite, avec le bon patron de base et quelques forces en plus (une nouvelle force intervient, il s'agit de PLaw qui permet de forcer deux point à se rejoindre, il s'agit d'une force d'attraction - répulsion).

    Je ne développe pas ici la méthode ni ne donne les fichiers car je ne suis pas l'auteur du projet de base.

       

    PARTIE 4 - RÉALISATION D'UNE COUVERTURE PLIABLE - DÉPLIABLE

    Dans cette partie de réalisation, je vais réaliser une structure plissée courbe afin de couvrir une surface d'environ 5m x 1m pour mon balcon : situé au 6ème étage, il n'est pas protégé par un autre balcon à l'étage supérieure et donc il est constamment agressé soit par le soleil soit par la pluie.

    La technique des structure plissées en architecture permet de donner de la raideur à une surface et donc d'atteindre des portées assez importantes avec très peu de matière. En effet, la plissure éloigne la matière de la fibre moyenne de la surface, augmentant ainsi le bras de levier des efforts interne. L'inertie dans le flexion variant de manière cubique avec "l'épaisseur" de la surface, cette technique permet donc de gagner très rapidement en rigidité.

    Ne pouvant modifier la façade de mon immeuble, il faut donc réaliser une structure démontable. Une structure plissée peut permettre cela, c'est par exemple de cas des voiles solaires des satellites. Très compacte pliés, il peuvent se déplier pour couvrir une grande surface. Le pli de ces voiles solaires est une surface développable pliable-dépliable.

    Le module de Miura-Ori permet par exemple de réaliser de telle surface. Néanmoins il s'agit d'une surface entièrement développable, c'est-à-dire que l'état déplié de la surface est parfaitement plan. Or, je viens de l'expliquer, ce qui est bon un voile solaire ne l'est pas en architecture (et pour la couverture de mon balcon) : un état déplié parfaitement plan n'a quasiment aucune rigidité. Il nous faudra donc, dans un second temps, modifier le module de Miura-Ori pour obtenir une une surface plissée non développable et pliable à plat. Dans l'état déplié, nous obtiendrons donc un plan « épais ».

    Enfin, il faudra également modifier ce module pour obtenir une surface à une courbure, de façon purement esthétiquement.

    J'ai appris la théorie de cette méthode dans un excellent papier dont je recommande très vivement la lecture (je ne développerais pas ici la théorie mathématique qui pourtant est très intéressante) : il s'agit de Conception d’une Enveloppe Plissée Pliable-Dépliable de D. Dureisseix, F. Gioia, R. Motro, B. Maurin. Une partie des illustrations utilisées dans mes explications est extraite de cet article.

    IV-1 - Réalisation d'une surface développable à partir du module de Moura-Ori

    Le module de Miura-Ori permet de transformer une surface plane en une surface pliable et dépliable. Il permet de la plier dans les deux directions et donc d'obtenir un résultat final extrêmement compact.

    Ci-dessous le module de Miura-Ori, le pattern de Miura-Ori et une vidéo du pliage-dépliage d'une surface plane selon cette méthode. Images en partie extraites l'article Wikipedia.

                  

    Afin de pourvoir paramétrer absolument toute la conception, et ainsi d'observer facilement les effets de chacune de nos modifications, l'ensemble du projet sera réalisé sous Grasshopper, sans utiliser Rhino, du module de Miura-Ori jusqu'à l'obtention de la géométrie de la couverture.

     

     


    Tags Tags : , , , , , , , , , , , , ,
  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :