修士論文 by Ryuyu ISHIHARA

建築の遺伝子 ― 建築形態の情報モデルに関する基礎的研究 ―

東京大学大学院工学系研究科建築学専攻隈研吾研究室 2013 年度修士論文 116064 石原隆裕

目次 0. 序

1-0. 生命科学と建築学における情報

1-1. 生物遺伝学から類推される建築遺伝学 1-2. 世代間での遺伝 2-0. 連動系の幾何学

9 14 15

2-1. 磯崎新の模型論

2-2. Greg Lynn: Animate Form

2-3. Bernard Cache: Objectile

2-4. 建築遺伝子

2-5. アルゴリズミック・デザインと遺伝子、進化

3-0. 実例を用いた検証

3-01. Zaha Hadid

3-02. Daniel Libeskind

3-03. 伊東豊雄、Cecil Balmond

3-04. Oscar Niemeyer

3-05.Alvaro Siza, Souto de Moura

3-06. Rem Koolhaas, Cecil Balmond

3-07. Olafur Eliasson, Kjetil Thorsen

3-08. Frank O Ghery

3-09. SANAA

3-10. Jean Nouvel

3-11. Peter Zumthor

3-12. Herzorg & de Meuron, Ai-weiwei

3-13. 藤本壮介

3-14. 遺伝子比較

3-15. パラメトリックスタディ

4. 考察

5. 結びにかえて

6. 補遺・建築 CAD 技術の展開

7. CODE

8. 文献目録

137

0. 序【主題】本論文は情報モデルによる建築学における《遺伝子》に関する研究である。1 【目的】本研究では -1. 生物の遺伝子を参照し、生物における遺伝子・生物情報学と対応する建築の《遺伝子》・建築情報学を定義付けること -2.また 1. の定義に基づいた建築情報学の基礎的な研究として、《遺伝子》を利用して同一環境において複数の建築物を分析・比較することを目的としている。【構成】第 1 編では《遺伝子》の定義付けを行っており、第 2 編で実例を用いて《遺伝子》を利用した分析を行っている。第 1 編 1 章は生命科学での情報について簡単に整理し、遺伝子の機能から建築の《遺伝子》のもつ性質や可能性を考察している。また、《遺伝子》に関する研究を行うにあたって遺伝情報を記述するメディアを正確に理解する必要性を示す。1 章での考察に基づいて 2 章では先行する論考から建築における遺伝情報を記述するメディアとしてパラメトリックな幾何学的システムが利用可能であることを示す。以上の章で建築の《遺伝子》の役割と記述方法を明らかとしたうえで、第 2 編では Serpentine Gallery のパビリオンを題材として建築の《遺伝子》の分析を実例に基づいて行い、そこから得られる結果を考察する。最後に本研究の成果を整理し今後の展望を述べる。【先行研究】「建築の遺伝子」という表現は多く見受けられるが、生物の遺伝学の手法を援用したものはほとんど存在せず、比喩表現として遺伝子をもちだしているに過ぎない。情報のシステムとして遺伝子に注目した言説としては田中浩也、松川昌平が設計手法と関連する文脈で生物の遺伝子を参照している2。また建築物の形態を数式として記述する研究としては麓他 (1996) の研究や Boschらのプロジェクト3 が存在している。

1 本論文では生物に関して一般に用いられている語と区別して、本研究の主題とする概念を《遺伝子》と表記する。 2 柄沢他 (2011)、54-110 頁、214-278 頁。 3 Hovestadt 2010, pp.108-117.

第1編 1 章生命科学と建築学における情報 2 章連動系の幾何学

1. 建築遺伝学

1-0. 生命科学と建築学における情報第一章ではまず生物における情報技術について簡単に整理することから始める。その後に、建築における情報技術について述べ、生物と建築を比較する。現在に至るまでに情報技術は２つの学問領域に限らず貢献してきているが、生命科学におけるクリアなパラダイムシフト、その結果として開かれた学術的可能性はモデルケースとして建築学に大きな示唆を与える。生命科学の分野で生物情報学と呼ばれる学術領域が研究されるようになってから日は浅い。例えば東京大学の生物情報科学科が設置されたのは 2007 年のことである 1。Ludger Hovestadt は生命科学における観察対象の変化を big zoomと呼んで、博物学すなわち生物種の分類から細胞生物学、分子生物学、生物情報学へと発展した経緯を指摘している 2。ここで注目しなければいけないことは、観察のレベルが詳細になったことが最終的に情報技術によって視座の転換になっていることである。いいかえれば、単なる学問の対象物や実験媒体の変化ではなく思考の方法が転換している点である。具体的には、細胞のレベルであれ分子のレベルであれ、物体として存在するモノをあつかって実体の挙動を観察する学問から生物のなかに流れる抽象的な情報をあつかう学問へという変化が生じている。遺伝子を例にとって見ると、DNAという高分子に関する研究が進んだことにより4 種の塩基の配列が遺伝情報を表現していることが明らかとなり、実物の塩基を離れ A,T,G,Cという文字の並びで遺伝情報を表記することが可能となった。その結果、実物としての生物に関する実験や観察に加えて、生物情報に対して情報技術を用いることで生命科学に有益な知見を得るアプローチも可能となり始めた 3。どの学問においても優れたモデルは優れた知見を与えるために必要なものであるが、とりわけ、生命科学は図形的モデルから一歩進んで情報として記述される抽象的なモデルを取り出すことに成功した点が注目に値する。生命科学は生物を電子的にモデル化するのみならず、生物情報そのものを研究することで生物情報学という新たな学問領域を開いたのである。また、見方を転じて高分子のモデル化が生物情報学の創始には不可欠であったことも注意せねばならない。なぜなら、情報を記述するメディアを取り扱えなければ情報を読み出すことができないからだ。さらに、個別の生物情報から生物の情報が構成するシステムを対象とするシステム生物学という学問が生まれている。生物をシステムとして捉えることで、それまでの生命科学で常識とされてきた学説に対して時限的な計算可能性から疑問が呈されということも起こっている。例えばダーウィン以来の自然淘汰の原理と遺伝子のランダム・ウォークでは現代の生物の多様性と地球の年齢との間に齟齬が生じる4。生命科学において情報という切り口の導入は表現や効率化以上の意味をすでに持っている。翻って、建築における情報の取り扱いを見てみる。情報という語は意味の変遷を経つつ日本の建築界では用いられてきている5。最も早い例として丹下健三と黒川紀章によって現実世界での情報が行き交うネットワーク化された都市・建築像が提示された。さらにその後、磯崎新、月尾嘉男らによる情報技術によって制御される実空間が設計され、坂村健のユビキタスの構想が建物にも応用された。20 世紀末から現在にかけては非現 1 東京大学理学部生物情報科学科 http://www.bi.s.u-tokyo.ac.jp/history.html. (accessed January 20, 2014). 2 Hovestadt(2010),pp.18-20. 3 こうした実体から情報への研究対象の転換に際して、興味深いことに建築分野の CAD 技術が高分子モデリングに活かされている。 Lenoir. 4 カウフマン (2008). 5 柳井 (2009).

実世界のコンピュータ・グラフィックスを空間ととらえるサイバーアーキテクトが存在するようになっている。建築学では生命科学とは異なり対象をモデル化するために物体として模型や図面を扱う技術が蓄積していたため、情報として建築を扱うと言うよりは、むしろ計算機にそれまでの技術を移植して効率化する方向に進歩してきた。Zaha Hadid6 や Gehry Technologies7 を筆頭に複雑な形状を操作する製図技術（3 次元 CAD）が活用され、エンジニアリングにおいても通風・日射などの環境シュミレーションや構造設計における構造解析が行われている。しかし、これらの計算機の利用は以前から存在していた原理を用いて高速化、大量化することで量質転化しているものであり、情報として建築を捉えることで新たな領域を拓くというものではない。例えば佐々木睦朗の Fluxstructure は物理原理的なところから大きく切り替わっているというよりも量的な変化によって全体の質が変化している 8。別の例を挙げれば、CFD によるシミュレーションとは電子化された風洞である。つまり、建築では生物学のように建築を情報としてとらえるような視座の転換は起こっていない。設計手法を見ても、Building Information Modeling(BIM) がある意味では建築の全てを情報化しようという試みだが、図面を中心とした設計図書の中に入っていた情報を電子化しているに過ぎない。ましてほとんどの設計の現場では紙に直接描いていた図面を計算機を利用して描いているに過ぎない。対照的に生物情報学は生物における物質的な現象（栄養・遺伝・ホルモン伝達など）を情報の流れとして捉えていることが細胞生物学・分子生物学と全く異なる。分子生物学から生物情報学への展開で重要な変化とは捉え方と視座の変化であり研究手段の問題ではない。このように建築と生物では情報の取り扱いが異なっている一方で、建築学と生命科学はこれまでも関係があった。例えばメタボリズム 9 やル・コルビュジエの都市計画 10 が存在する。しかし、これらはあくまで比喩であり、生物の与えるイメージを模倣しようという取り組みであったと考えられる。それに対して生物的イメージをモデルにするのではなく生命科学の学術的な研究手法と生物のもつ情報系の仕組みを建築と建築学に応用する可能性が存在している。もし生命科学において開拓したフロンティアと同様に情報技術が建築学において未知の領域を切り拓くことを期待するのであれば、生物の形態や仕組みを模倣するのみならず、生物情報学と同様に建築を情報としてとらえるためのモデル化が必要である。そのためには単純に設計図書を電子化するのではなく、情報の系として機能するように建築を捉え直さなくてはならない。そして、そのようなモデルがつくられて初めて、生命科学における生物情報学に相当する建築情報学の扉は開くことができる。11 生命科学の分野では遺伝子に関する研究から大量の情報をデータベース化して類縁性を求めるために生物情報学が誕生した。現在、建築情報学は確立した分野とは言いがたいが、いくつかの大学では建築学の一分野としてコンピュータ・グラフィクスや製図のソフトウェアを開発するにとどまらない研究が始まっている。建築情報学を単に計算機を援用するにとどまらない建築への新しいアプローチとするためには建築を情報としてとらえる遺伝子の考え方が重要な鍵となるであろう 12。 6 http://www.zaha-hadid.com/(accessed January 20, 2014). 7 http://www.gehrytechnologies.com/(accessed January 20, 2014). 8 佐々木 (2005)、70-87 頁。 9 菊竹 (2008)、220-222 頁。 10 人体に例えられたチャンディーガルが挙げられる。吉田 (1991)、41 頁。 11 豊田 (2013) がその必要性を述べている。 12 例えばドイツ・ミュンヘン工科大学には建築デザイン・モデリング講座内に建築情報学研究室が存在する。http://www.ar.tum.de/ en/institutes/institute-for-architectural-design-and-modelling/またスイス・連邦工科大学チューリッヒ校では計算機利用建築設計研究室が活発に活動している。http://www.caad.arch.ethz.ch/blog/これらの研究室の活動は建築を情報としてとらえるという分析的な手法よりは計算機を利用した造形や建設のアプローチという向きが強いが、先に述べた通りETH-Z の成果物をまとめた Hovestadt(2010) で生命科学における細胞生物学から分子生物学さらには生物情報学への展開が言及されている点は注目に値する。

1. 建築遺伝学

1-1. 生物遺伝学から類推される建築遺伝学前節では生命科学において観察対象が次第に小さくなり、最後に情報という物体として存在しないものを取り扱うようになったことを指摘した。また建築学において生命科学と同様に情報の流れをモデル化することが可能であれば建築情報学が研究可能であることを示唆した。ここでは仮に建築の《遺伝子》というものがメタファーではなくむしろアナロジカルに存在するとしたら《遺伝子》はどのようにはたらくのか、また建築遺伝学の意義はなんであるかを議論する 1。つまり、この節では生物に対しての遺伝学と同様に建築の遺伝学が存在するときの功罪について考える。まず、生命科学について、前節で触れた big zoom を遺伝学の発展についてもう一度見てみることにする。遺伝という現象は親が子に似ることから古代から認知されていたことは疑いようもない。しかし、科学的な検証が行われるまでは親世代の形質を絵の具を混ぜるように混ぜ合わせることで子世代の形質が決まると考えられていた。遺伝子の伝達する現象として遺伝の正確な理解はメンデルの遺伝の法則によって始めて可能になった 2。その後、まず染色体の存在が明らかとなり、さらに、その中に含まれるDNA( デオキシリボ核酸 ) が遺伝子の物質的実体 = 記録メディアであることが解明されていった。そして、遺伝子のほとんどは肉体とは関係ない最終的に DNA の立体構造が解析され遺伝子の解読が始まった。

形の要素

mRNA

Exon

捨てられる形 Intron

Code

発現調整、指示…

複製、変異、偽遺伝子、交配…

Gene GENOM ﬁg.1-1( 以下、図表は特記無き場合は筆者作成）

ここで、注意すべき点として DNA はすべてが遺伝情報をもつ遺伝子ではないこと F =には非遺伝子 Form(Gene, Environment), が指摘される(ﬁg.1-1)。DNA DNA が存在している。これらは遺伝子の

Gene = Codingてい + nonCoding, 組み換え修復など関連する機能を担っると考えられている。ヒトを含む真核生物では Coding = Exon + Intron,

遺伝子の中もエキソンと呼ばれる部分とイントロンと呼ばれる部分に分類することができるが、タンパク質のアミノ酸の配列情報を記載しているコード領域はエキソンにのみ含まれる。つまり実際につくられる物質的実体の情報に当たるものは DNA の中の一部のさらに一部分 Exon: 形の要素に関する情報だけに存在している 3。さらに、生物の保有している遺伝子は常にすべてが発現しているわ Itron: 作成の経過で消える形に関する情報

1ここでは analogyとmetaphor に対してそれぞれ < 類比 >と< 比喩 >という訳を当て、前者は別個の系（仮に AとB の 2 つとする）に対して同一の式や機構、算術が背後に存在し、A において成立している命題が B においても対応物に対して真であることと定義している。また後者は単に主観的に別個の事象 AとB に対して同一の印象を得られることから A に言及することで B を想起させることを言っている。 2 東京大学生命科学教科書編集委員会 (2013)、87 頁。 3 東京大学生命科学教科書編集委員会 (2013)、69-86 頁。

この図式は誤解。

より現実に近い図式。

ﬁg.1-2

けではない。調整的発現と言われる、環境に応じた発現の促進や抑制が行われている 4。つまり、生物の実体は遺伝子によって一意的に決定されているわけではなく、生物の遺伝情報と生物の肉体は一対一に対応しない (ﬁg.1-2)。このように、現代的な遺伝学の知識は遺伝という現象、遺伝子という情報、DNA という情報のメディアの存在を含んでいる。未だに DNA に記されている遺伝子と実体としての生物との関係は必ずしも理解しつくされているわけではないが、遺伝現象、遺伝子、 DNA のそれぞれのレベルで遺伝学的な知見は医療や農業などに応用が試みられている 5。さて、このような生物の遺伝・遺伝子・DNA に当たるものが建築に存在するであろうか。まず、建築も生物も実体をもって存在するものであるという点は共通している。実体とそれを作成する際に必要な情報という関係性が生物と遺伝子の間にはある。生物では実体は親によってつくられた卵が発生過程をへることによってこの世に誕生する6。このプロセスを説明する際に、しばしば遺伝情報を「生物の設計図」という言い方をするが、それは単なる比喩であることに注意しなくてはならない。例えば、クローンネコの事例を取り上げれば、遺伝子は同じであるが容姿や性格は異なる個体が存在する 7。また、一卵性双生児を思い浮かべれば、その二人が遺伝型に関しては完全に同一であるにもかかわらず、似ているだけで同一の容姿や性格ではない。先に述べた通り、生物の遺伝情報と生物の肉体は一対一に対応しない。もし、建築物と設計図の関係が生物とDNA の関係と同等であるならば、設計図は最終的に建設される建物の形態を指定していないことになる。生物におけるタンパク質の合成過程を見る際には、設計図はむしろ生物の DNA から遺伝子情報を読み取ったあとにタンパク質合成のために必要な情報を伝達するメッセンジャー RNA に相当するというのが妥当な類比である。このように、直截的に完成時の形態や素材あるいは建設プロセスを指示した図面や仕様書などの設計図書は、与件と呼応しながら建築の形を決めていくようなシステムである《遺伝子》ではない。建築の 4 東京大学生命科学教科書編集委員会 (2013)、219-229 頁。 5 ヒトゲノム＝人間のもつ DNA の塩基配列情報の総体は 2003 年に解読完了宣言が出されている。( 東京大学生命科学教科書編集委員会 (2013)、230 頁 ) ゲノムが把握されたことにより、生物の分類が形態の比較からゲノムの近縁性による分類に変わり、一見すると魚に似た形のクジラやイルカがカバの近縁種であるといったことが明らかになっている。( 東京大学生命科学教科書編集委員会 (2013)、231 頁。) 6 有性生殖のプロセスを発生に含めるのかは議論がある。単為生殖の事例は数多く存在し、単体の雌体から卵が発生過程に進んで別個の個体を生む場合も存在している。 7 こうした事例を紹介する記事はいくつかあるが一例を示しておく。 "Pet Lovers: Fancy a Cat Clone?" Wired . http://www.wired.com/medtech/health/news/2003/01/57322(accessed January 21, 2014).

1. 建築遺伝学

《遺伝子》とは設計図を生み出す機能をもち、エピジェネティック 8 に、つまり前もって決定してかかるのではなく与件と呼応しながら形態を決定していくためのシステムであるといえる (ﬁg.1-3)。与件を受け止めて図面や模型、透視図などを生み出すことができる情報のシステムこそ《遺伝子》である。すると、建築家が《遺伝子》であるという意見が出てきてしかるべきであろう。なぜならば建築家は設計図を生み出し、与件と呼応するからである。しかし、建築家は自らの設計した建物を弁護する文章を書いたり、建築物の保存のために政治的活動に走ったりする点で遺伝子とは異なる。また、建築家が生物の遺伝で言えば親に当たるという認識の仕方は遺伝子を設計図として見るのと同様の比喩によるものであり、類比は成立しない。親は子となる卵に同等の遺伝情報を与える存在であり、親自身の中にも遺伝情報が入っている。突然変異によって新たな種となることも考えられるが建築家の内部に存在するものと建築が保有する情報量を考えれば突然変異ではなく情報の切り出しである。こういった現象は生物ではありえない。しかし、見方を変えれば、建築家の思考を宿主として建築の《遺伝子》として存在しているものがあるということはできる。すると、その具体的なシステムを建築家の思考から外化することができればそれを《遺伝子》と呼ぶことができるだろう。そこで、そのようなシステムを関数として Form = Gene(Environment)

……①

と表現する。

ﬁg.1-3

与件との呼応を強調したが、ある範囲で形態を決定していることも重要な遺伝子のもつ性質である。収斂進化のような遺伝子と乖離した形態間の類似はあるものの、実 8 現代生命科学ではエピジェネティックという語を発現調整によって遺伝子変異を起こすことなく形質を大きく変化させる現象に限定して使う場合がここでは広義の後天的に形質を獲得していく状態を指している

体として存在する形を手がかりにして《遺伝子》の一部分が推定することは一定の妥当性をもつ。以上の議論を踏まえると、生物と同様に建築にも《遺伝子》があるとして生物に関する情報のシステムを対応させて考え、《遺伝子》には、形を定義する要素がありかつ与件から読み取られた情報と形態との間の関係性を記述するはずである。また、双子の例からわかるように遺伝子の発現調整は単に与件から自動的に決定するのではなく、一定の偶然性を有している。与件から読み取った情報に対して一意的ではない出力を返すことが遺伝子の忘れられやすいが極めて特徴的な性質である。まとめると、実体との関係性から《遺伝子》の要件として次の各項が挙げられる。 - 形を定義する情報を有している - 与件から読み取った情報を反映する - 与件に対して出力される形は複数の可能性をもつこれらの要件を満たし①式のように環境を引数として形を返す関数で表現された情報のシステムを建築における《遺伝子》と定義して研究を進める。関数の内部的な処理など具体的な情報のシステムとそれを記述する方法を検討することを 2 章で行う。ここではひとまず、そのような建築の《遺伝子》の存在を把握できたとして、どのような利点がありうるか考察を進める。

生物遺伝子工学血縁関係の判定

遺伝子医療

遺伝子組み換え品種開発

クローン作成

生物情報学

建築遺伝子工学作家性の定義

計画検討への利用

設計リソースとしての蓄積

優れた建築の参照

建築情報学

本研究では生命科学の遺伝学をモデルとしているので生物の遺伝子とその伝達の具体的なメカニズムが理解されることによってどのような利点があったかを分析することで類推できる(ﬁg.1-4)。生物の遺伝子工学の誕生によって開かれた可能性は多く存在す

ﬁg.1-4

1. 建築遺伝学

る。例えば、血縁関係の鑑定、遺伝子医療のための研究開発、遺伝子組み換え作物の開発、クローンの作成などの可能性が開かれてきた。では、建築において同様の可能性を具体的に書き並べてみる。建築の血縁関係の鑑定というものがあるとすれば、同一の建築家による作品の共通する特徴を指摘するアイデンティティと作家性の判定に使われうる。十分に大きな《遺伝子》データベースが存在すれば設計者不明とされていた建築物の設計者を見つけられるかもしれない 9。生物の遺伝子医療に相当するものとしては、計画段階の建築の《遺伝子》を解析し事前に問題点を把握して建築計画を改善することが可能になることが考えられる。また、既存建物の評価や問題の解決に対して対処療法的な修繕のみならず《遺伝子》レベルでの問題の把握で改修に何らかの知見を得られる可能性がある 10。また、《遺伝子》組み換え建築に関して言えば、ある基準に関して高い評価を得ている建築の形質を選んでそれを再現するような《遺伝子》を設計の中に取り込むことが可能になる。クローンの作成で言えば優れた建築作品を《遺伝子》レベルで複製して発生させることが可能となる 11。生物において問題となるような生命倫理が建築では存在しないため、より大きな可能性が期待できる。

9 このアプローチには疑問の余地がある。生物の遺伝子に関して言えば、相同性と類似性の区別が存在している。すなわち単に部分的な同一性を有するのか同一の祖先種が存在するかが判断されなければならない。別種の生物の収斂進化、例えば深海での視力の退化のような現象は相同性を持たない。( 東京大学生命科学教科書編集委員会 (2013)、293-294 頁 )。 10 これは人間の医療ですでに行われている取り組みである。筋強直性ジストロフィー症が DMPK 遺伝子の異常に基づくことが明らかとなり解決はしていないものの治療の戦略が示された。( 東京大学生命科学教科書編集委員会 (2013)、82 頁 )。 11 ここで注意しなくてはならないのは、仮に遺伝子を複製してもクローンは完全には同じ個体を発生させないという生物における事実である。ひとつにはエピジェネティクスの観点からクローン親とクローン娘は別の形になることがある。すなわちすべての形質がクローン元と同等に発現するわけではない。さらには建築に関して言えば親建築と同一の敷地に建てることは不可能であるから、与件の影響によって発生する建築は親とは確実に差異を持つと考えなくてはいけない。遺伝子とは自己同一性の重要な因子であるが、上記のような理由から本研究は完全なクローン、あるいは復元のための手法の開発を目的とはしていない。

1-2. 世代間での遺伝前節では建築の《遺伝子》に関して情報として存在している《遺伝子》と実体ある物体としての建築との関係性、すなわち発現機構に注目して《遺伝子》の性質を記述した。一方で、生物ではむしろ遺伝子は世代間で継承・交配される存在として認識される方が先であった。ここで、建築と生物の大きな違いとして生殖を行わないという点がある。すなわち、建築については明確な親子関係が存在しない。ある建築物に対して影響を与えた建築を親とすると親の存在が 2 つ（あるいは単為生殖と考えて 1 つ）に絞ることが難しい 1。それゆえに、建築の《遺伝子》に関して世代間の遺伝について議論することが難しくなっている。もし、世代間の遺伝が存在しないとすると、《遺伝子》によって発現する形質に対して評価を加える淘汰の原理が成立しなくなってしまう。また、親子関係が存在しないとなると《遺伝子》という呼び方がそもそも不適切である。ここでひとまず、個体内での情報の流れを遺伝子の発現とし、既に存在している個体から新しい個体への情報の伝達を世代間の遺伝として認識し、世代間遺伝に相当するような現象が建築同士で存在するかどうかを検討してみる。生物においては一般にオス・メスの親世代から遺伝情報を一世代の個体に保有されている量の半分ずつ受け継いで子世代の遺伝子が形成されると考えられている。ところが、水平伝播と呼ばれる親子ではない異種の生物間での遺伝情報の伝達も存在している 2。ウイルスなどによって遺伝情報が生物種の間で水平に広がるのである。建築の《遺伝子》ではこの水平伝播が生物種に比べて極めて高頻度に発生していると考えれば建築においても遺伝現象を理解することが可能である。つまり、建築はいかなる建築もなんらかのかたちで過去の建築の影響を受けて設計されるので親建築は存在するのであるが、水平伝播によって伝達した親以外からの遺伝情報が大量に子建築に含まれているために親の影響だけを見ることが難しくなっていると考えられる。この認識によって複数の建築の形質を継承した子建築が存在することを許容できる。また、生物の遺伝子同様に建築の《遺伝子》にも突然変異があると考えれば建築の親子関係、及び水平伝播によらない形質は突然変異によるものであるとみなすことができる。本論文では《遺伝子》の淘汰や変異など世代間の遺伝に関しては詳細に分析を行わないが、世代間での遺伝は存在している。今後、個体間での遺伝情報のやりとりに関して研究を進めるにあたっては、突然変異を親からの遺伝や水平伝播と識別することで建築様式の変遷や形態言語の流行において、なにが設計者の創意であり、なにが他者からの影響であるかを遺伝学の対象とすることが可能となると考えられる。

1 たとえば石井和紘の「同世代の橋」(1985) を 2 つの建築から遺伝子の半数を取り出して生み出すことは不可能であるとしてよいであろう。 2 東京大学生命科学教科書編集委員会 (2013)、234 頁。

2. 連動系の幾何学

2-0. 連動系の幾何学第 1 章で建築の《遺伝子》の存在を仮定し、《遺伝子》として満たすべき要件を次のように述べた。 - 形を定義する情報を有している - 与件から読み取った情報を反映する - 与件に対して出力される形は複数の可能性をもつまた、生物の遺伝学においてが高分子に関する研究が進み、DNA や RNA の分子レベルでの理解が進んだこと、つまり情報を記述するメディアに関する研究が生物情報学の創始に不可欠であったことを指摘した。では、建築学において建築の情報を保有するメディの研究とはどのようなものであろうか。これまで、建築を記述する方法としては図面と模型、 1 そして透視図が存在してきた。これらの建築の表現方法と与件を結びつける情報のシステムが記述できれば、それを建築の《遺伝子》を記述するメディアとして扱うことができる。第 2 章では、そのようなメデイアとして連動系の幾何学が利用できることを示す。この章ではまず磯崎新の模型論から実体と観念を結合するモデルとしてパラメトリックに操作される幾何学が存在することを指摘する。しかし、磯崎の論では具体的な幾何学の実像は不明である。そこで、1990 年代に建築論において生成 (generative)という語でパラメトリックな幾何学について語られてきた内容を Greg Lynn の論考から考察する。ここで Lynn を取り上げるのは animate formというキーワードを提示しコンピュータ・グラフィックスを中心とした計算機利用の設計において先駆的な存在であったためである。Lynn は具体的な形でパラメトリックに与件と建築を結びつけるような設計を行った人物として重要である。だが、先駆的ではあったが Lynn の議論には疑問の余地も多く、限界がある。そのため、より汎用性の高い理論体系に拡張するため Bernard Cache の建築論を参照する。Cache は Lynn の理論的バックボーンとなったフランス現代思想において幾何学的イメージに寄与しassociative geometryという、さらに遺伝子に近いテーマを掲げている。Cache の論を継承して、パラメトリックであることから一歩踏み込み、連動性をもつ《対象体》という概念を取り扱う。これらの考察から生物の遺伝子に相当する関数を建築において定義し生物の遺伝子と比較することで建築の《遺伝子》として定式化する。最後に、磯崎の手法論、情報として建築の設計を扱おうとした Christopher Alexander、および建築と与件を結ぶパラメータに関して論じた Patrik Schumacher の理論との比較を通じて、《遺伝子》のモデルに対してアルゴリズミック・デザイン、設計手法論の観点から考察を加える。

1 写真やレンダリングなどを含む。

2-1. 磯崎新の模型論磯崎新は『建築文化：特集＝情報空間』に寄せたエッセイ「模型的思考」 1 のなかで、何かを写したのではない自立した観念の内部から生まれた模型の存在について論じている。「自然そのものは、どのような手続きによって記述できるのだろうか。」 2という一文で始まるこの文章で、磯崎は模型の歴史的展開から模型的思考とメディアとの関係を明らかにしようと試みている。ここでの「模型」は建築物のミニチュアとしての模型ではなく、より広義に何かを写しとったモデルを指している。磯崎はまず「補助線」という観点で自然から模型をつくる「模型的思考の発生」3 を指摘する。つまり人間が自然を認知し、写し取るために測地線、等高線などの線を引くことで自然を記述することが模型的思考の始原である。次いで、「記号的図式」への転換が起こったと磯崎は言う。補助線があくまで自然物を測量する際に生まれるのに対して、宇宙観のように観測されていないにもかかわらず像を提示する必要のあるものに対して、「模型がそれ自体として形成されるようになってくる」4。ここでは自然物を写し取るものではなく「観念の内部に組み立てられた、不可測な事物の関係を表示するもの」 5 である。事例として、陰陽五行説、曼荼羅、カバラの宇宙像、そしてキリスト教の三位一体の図を列挙している。特に曼荼羅は線を持たず、仏の配列が宇宙観を示していることに磯崎は注目し、「まったく観念の内部に構築されていった独自の世界観を図像化した」6とする。すると、自然を写し取るものでなくなったために、模型が成立する始原はわからなくなり、模型は「みずからの展開法則を内側に生み出しながら、具体的現実に混入を開始する」 7 ようになる。一方で、プラトン以来の「非図像的模型」が同時に存在したと磯崎は考える。すなわち図像化されない論理模型である。プラトン自身は論理を体系づけても図像化はしなかったが、アルベルティの絵画および建築によって図像化が試みられた。その他、フイッチーノ 8 やピコ・デルラ・ミランドーラ 9 らの哲学者がネオ・プラトニズムと呼ばれ、プラトンを継承して論理模型を作ったことがルネサンスの創作の背景にあったとする。これらの論理模型の図像化はプラトン立体のシリーズとして認識されていたと磯崎は考え、このネオ・プラトニズムの原理が Richard Buckminster Fuller の思想にも受け継がれていると主張する。続けて、他の様々な模型的思考の存在を指摘しながら、この特集号の本題でもある情報空間との関係に急展開する。磯崎は情報空間における模型としてサイバネティクスを取り上げ、補助線としてメディアがあるとする。「測定器としてのメディア」と呼称するその存在は「いまだにあいまいであり、全部をつうじての解釈を可能にするパラメーターが発見できているわけではない」10と認めながらも、メディアが情報空間を測定するその実態をカタログ化したものとして膨大な図とキャプションを羅列している。磯崎の言う《模型》によって、本論文で取り扱っている建築の《遺伝子》も記述することが可能である。なぜなら、建築家の観念から建築物として実体化するにあたって、何らかの形で図像化されたダイアグラムが必要であり、かつ前章で論じたように周辺の環 1 磯崎 (1972)。 2 磯崎 (1972)、88 頁。 3 磯崎 (1972)、89 頁。 4 磯崎 (1972)、90 頁。 5 磯崎 (1972)、91 頁。 6 磯崎 (1972)、93 頁。 7 磯崎 (1972)、93 頁。 8 原文ママ、フィッチーノMarsilio Ficino を指すと思われる。 9 同じくGiovanni Pico della Mirandola のことであろう。 10 磯崎 (1972)、95 頁。

2. 連動系の幾何学

ﬁg.2-1

境から情報を読み取る性質、すなわち測定器としてのはたらきをあわせて成立するからである。さらにいえば模型的思考の始まりが「補助線」であったことから、実世界に対して何らかの数値を対応させること、すなわち環境のパラメータ化が模型的思考の背景に存在していると考えられる。つまり、ダイアグラム自身は自立した図像なのだが、ダイアグラムの図像に対して現実世界を表現するパラメータを対応させることによって実体としての意味が出現する。逆に、パラメータを対応させるまでは模型は意味を限定されない図像である。この独立した図像としての性質は《遺伝子》のもつ環境によらない形態の情報であると見ることができる。磯崎が模型的思想と呼ぶものを、前に掲載した環境 - 遺伝子 - 生物の関係を示す (ﬁg.1-2)と照らし合わせると、環境と《遺伝子》( 模型 ) をパラメータが結び、模型の中に図像が含まれていることがわかる(ﬁg.2-1)。遺伝子を関数として捉えると、 Form = Gene(Environment) ……① から Form = Gene(parameter(Environment),Geometry) ……② としてより詳細に定式化できる。この段階では Geometry が不明であるからこの関数の実体はわからない。次節以降で、さらに Geometry の項、環境からパラメータを取り出す parameter 関数の詳細を考察していく。

2-2. Greg Lynn: Animate Form Greg Lynn は 1964 年アメリカ・オハイオ州生まれの建築家・教育者・建築理論家である 1。パラメトリックな幾何学のシステムが建築論・建築設計論の議論で意識されるようになったひとつの契機は Any 会議での Greg Lynn の発表である。それ以前から建築の設計に用いられるような CAD ソフトウェアの発展は進んでいたが 2、意識的に animate form として設計へ取り込み、マニフェストを示したのは Lynn であった。Lynn はコンピュータソフトの開発会社の協力を得て、CG がまだ一般的ではなかった建築界で計算機を利用した設計を行った 3。単に透視図の描画を計算機を利用して行うのみならず、建築を設計する際に利用される新しい幾何学を提示し、それを animate form と呼ばれる概念で説明した。Lynn の言説を追う際にまず注目すべきものとして Any 会議での発表、特に Anybody(1996 年 ) の発表 "From Body to Blob"(「身体から流状体へ」) がある 4 が、これに加えて彼の書いた Architectural Design 誌 (1993 年 ) の Folding Architecture 特集号によせたエッセイ”Architectural Curvilinearity: The Folded, the Pliant and the Supple"5( 以下 "Curvilinearity") も重要である。特に "Curvilinearity" にはフランスの現代思想を始めとしてさまざまな理論的背景が示されておりこの点は次節で取り扱う Bernard Cache ともつながるものである。また論考 "Animate Form"6 では animate form の詳細な説明がなされている。この節ではこれらの言説を批判的に読むことで Lynn の議論を吟味し、パラメトリックな幾何学的システムの実態を明らかにする。まず Any 会議でのいくつかの発表に関してみていこう。最初の Anywise における「形態と領域」では建築に運動や時間の概念を取り込んだ設計がコンピュータによって可能になるとLynn は主張している。この考えの背景には「純粋で、静定的で、還元的で無時間的な古典主義モデルの形態や構造が、今日の都市やそれが支持している活動を描くのにもはやふさわしくない」 7という前提がある。Lynn はそのような設計のために D'Arcy Wentworth Thompson を引き合いに出し「自己同一性を通じて、より大きな環境的領域との絶えずフィードバックする」8 躍動的機械のダイアグラムを提示する。このダイアグラムを利用して生産される形態に関して「同一でも、プロトタイプ的でも、あるいは観念＝理想的でもなく、本質的に異なり、文脈的ななだらかな変化において統御され、遂行される機械状の集合体」 9と述べていることは注目に値する。また、この会議の段階ではパーティクルシミュレータを用いた住宅のプロジェクトを実例として示している。Lynn は翌年に講演 "From Body to Blob" を行っている。この講演で Any 会議では初めて Lynn の発言に blob が登場する。この回の ANY は Body をテーマとしていたが、プレゼンテーションのなかで Lynn は旧来の要素還元主義的なアプローチから生成的な考え方に世界観が変わるとともに身体は流状体と呼ばれるものに代わると主張し、自身の作品の紹介をして講演を終えている。このときLynn は「前決定的な同一性から生成的な同一性への転換」 10としてパラダイムの転換を指摘している。さらに、その理論的バックグラウンドとして 1 Greg Lynn Form. http://glform.com/bio-2/(accessed, January 20140106). 2 補遺：CAD 技術の展開を参照されたい。 3 Silicon Graphicなどとの協同関係がある(Lynn(1999) 奥付 )。AnywiseではArias Reserach and Wavefront Technologyからソフトウェアを寄贈されたことを明記している( 磯崎 (1999a)、78 頁 )。 4 Lynn の Any 会議での発表は Anywise「形態と領域」(1995), Anybody「身体から流状体へ」(1996), Anyhow「時の幾何学」(1997), Anytime「バイオ・タイム」(1998), Anymore「サーフェイスの効果」(1999), Anything「ニュー・ジェネリック」(2000) がある。「ニュー・ジェネリック」に関しては画像のみしか確認することができない。 5 Lynn (1993). 6 Lynn(1999). 7 磯崎 (1999a)、71 頁。 8 磯崎 (1999a)、74 頁。 9 磯崎 (1999a)、75 頁 10 磯崎 (1999b)、159 頁。

2. 連動系の幾何学

哲学の分野でのいくつかの論を挙げており、そこには Leibniz、Bergson、Alfred North Whitehead、Gill Deleuze が含まれている。また生成的であることと不定形であることの差異に関して注意を喚起しており、単に形態が定まらないのではなく、「進化する、可変的で多様な身体というものを追求したい。つまり、プロポーショナルには閉じているが、組織的には開かれており、外部の情報を折り畳み、それを内部で動的に押し広げることができるような身体である。」11としている。この主張をそのまま受け取れば blob は環境に対して応答し、かつ単に不定形なのではなく図形の要素が数的パラメータを用いて記述される関係性を保持しており、全体の表現型は変化する一方でシステムは同一である。すると blob は磯崎の模型的思考に基づいた《遺伝子》のモデルのひとつとして見ることができる。ところで、ここで紹介されているblob の実体はなんであろうか。blob はメタボール / メタクレイとも呼ばれるコンピュータ・グラフィックスのモデリング手法である 12 このモデリング手法は複数の原型となる立体が近接した際に単純な和集合の領域を与えるのではなく条件式を用いた判定によって滑らかにつなぐものである(ﬁg.7)。

ﬁg.2-2(Blin(1982),p.237).

このモデルは、最初に設定されるしきい値や変動する単体のメタボールの数などを保持しながらもメタボールの集合は各メタボールの位置というパラメータで変化する。ここで、この講演のタイトルには示されていないが Lynn が提示するのは流状体だけではなく骨組みを加えた 2 つのモデルであることに注目したい。Lynn はこの 2 つのうちで流状体 (blob) を特に重視している。これらのモデルは二段階で決定されていくとされ次のように述べられている。

【第一】コンポーネントのレヴェルであり、ここでは内的な変形や変化の可能性に関する限界が定められ、同時に外的な影響や他の原始的なコンポーネントも決められる。【第二】関係と連結のレヴェルである。（中略）デザインはまずはじめに内的な強制と外的な影響というパラメータのレヴェルにおいて現われる。 13 このように設定した幾何学と与件がパラメータで結び付けられることによって、建築家が考えた建築の同一性を敷地に建つ建物に付与するのではなく、与件から建築が生成するとLynn は考えている。しかし、なぜ骨組みと流状体なのかは判然としない。この講演で Lynn が示した外部の情報を取り込むモデルは建築の設計における《遺伝子》のモデルともなるものだと考えられるが、その図像として提示されるものが流状体と骨組みでなくてはならないという主張には疑問の余地が残る。また、これらだけを《遺伝子》のモデルとし 11 磯崎 (1999b)、160-161 頁。 12 Blin(1982). 13 磯崎 (1999b)、163-164 頁。

てしまうと過去の建築物が説明不可能となってしまう。端的に言って、Lynn の議論に対してまず思い浮かぶ疑問点は「環境と呼応するシステムはなぜ blob でなければいけないのか」というところにある。続く1997 年の発表「時の幾何学」ではこの疑問に対する答えが少しだけ示される。Lynn はこの講演で「建築家が静的でない動的空間において設計し思考するするために、動きと時間に関する一般的な知識を増やすこと」 14 を示唆している。また、その目的として、船体を例に出して流れや力を意識しつつもそれ自体が文字通りに動くわけではない形態の設計を行うことを挙げている。そして、そのためにはベクトルとスプライン関数を用いて記述される幾何学を用いるべきであると主張している。そのような数学的記法を用いる動画技術に関して「この技術が建築で何をしたがっているかを問うほうがいいかもしれない」15とも述べていることから Lynn の思想の背景がわかる。blobもまたベクトルによって記述され、最終的な立体形状はあるしきい値を表現する曲面で描かれることから、これらの「時の幾何学」で主張されている内容は blobも含意していると見て良いだろう。つまり、blob を選択しているというよりもblob ありきで、blob を用いて何が可能かという発想で Lynn が思考していることがうかがえる。1998 年の「バイオタイム」は「時の幾何学」での議論を継承し「遺伝学の分野で定義される総称的形態」16 を新しい一般性として示そうとしている。この際に「内部で圧迫されていた組織が、さまざまな影響がひしめく場のコンテクストのなかで、複雑にひも解かれる」 17 成長の時間が鍵となるとLynn はいう。まさに本研究が遺伝子の発現機構に注目している視点と同一である。Lynn は再びベクトルとスプラインを取り出し、これらの幾何学を用いることで「建築は内面から複雑性を発生させ、かつ周辺コンテクストから複雑性を取り込んでいくプロセス」18 を通して設計されるようになるという。この表現からは生命的イメージに付随する周辺からの情報の読み取りを Lynn が意識している様子がよく分かる。残る二つの発表「サーフェスの効果」と「ニュー・ジェネリック」は画像や実例の提示であり理論的構築性に乏しく、幾何学に関する議論では無視して良い 19。さて、Lynn の幾何学的システムと生物の遺伝子の情報システムとしての類似性は確認できるが、なぜ blob を Lynn が選択しているのかは吟味されなくてはいけない。そこで blob を Lynn が選択している背景を精査していく。blob を利用することで環境と形態を結びつけることが可能であるという十分性の議論は論考 "Animate Form" に詳しい。この文章は "From Body to Blob"と近い内容であるが講演ではなく論文であるためにより詳細に論理が展開されている。このなかで Lynn は周辺環境から受ける力のベクトルを溜め込むようなトポロジカルなサーフェスとして、"blob, skelton, warps, force, particle"20 を挙げている。この際、blob は球体から始まり、近傍のメタオブジェクトと相互作用することでより多くの情報を格納できるとLynn は考えている。すなわち、球体が中心と半径という2 種類のパラメータで決定されるのに対して、blob は中心・表面積・近傍の中心・影響のベクトル場の 4 種類のパラメータによって記述される。全体の面が部分の相互作用によって定義されること、また関係性が形態を決める図形であることがメタボールを採用した理由であると見ていいだろう。また、論考全体を通して blob は実際に動かないとしても運動を内包しているように見えるために表徴としての意味も持たせようとしている様子がうかがえ 14 磯崎 (2000)、156 頁。 15 磯崎 (2000)、163 頁。 16 磯崎 (2001)、266 頁。 17 磯崎 (2001)、267 頁。 18 磯崎 (2001)、269 頁。 19 ただしAnymore では Lynnと次節に取り上げるBernard Cache が同じセッションに参加していたことは注目に値する。 20 Lynn(1999), p.30.

2. 連動系の幾何学

る。一方で、blob が環境との関係性を建築化する際に必要であるというような論証は管見の限り見つけられない。なぜ他の図形を選ばないのか。 blob を Lynn が選択した始まりを探るために時間的に見て、最も早い段階で書かれた”Curvilineality”にさかのぼってみる。この時点では外的な要因に対して呼応することのみがテーマとされていて、そのための幾何学の議論は抽象的な言葉にとどまり具体的な描画手法を指定していない。この論文では Gilles Deleuze の著作や René Thom、料理の理論そして地質学を含むさまざまな題材を取り扱っているが、特に重要なのは『千のプラトー』21 や『襞――ライプニッツとバロック』22 を取り上げて言及されているDeleuze の思想であると考えられる 23。Lynn はこの論文で脱構築主義と歴史主義ポストモダンを共に批判し foldingというキータームを提示してオルタナティヴを示そうと試みている。folding は Deleuze の《襞》を明示的に意識しており、folding による生成は Deleuze に由来していると言えるが、Lynn はそれに対して幾何学的なイメージをこの時点では対応させずにいた。"Curvilinearity" からAnimate Form への変化を考察すると、Deleuze 的な生成変化という概念と併せて彼が興味を持っていたコンピュータ・グラフィックスの技術を、後に結びつけて animate form = blobとして理論化したと考えられる 24。事実、 "Animate Form" でも"From Body to Blob" でもアニメーションや CAD のソフトウエアにおける幾何学の取り扱いについて繰り返し述べられており25 論理展開において幾何学的なシステムが持たなくてはいけない必然性から blob を選択しているのではない。 Lynn が当時手にすることができた計算機を利用した幾何学においてパラメトリックに応答する幾何学を作りやすかったのが blob であるというのが選択の大きな要因を占めている。つまり、Lynn にとって blob を選択することは必要条件ではなく単なる偶然と限界であった。以上の考察を踏まえ、本論文では今後、Lynn の議論を継承するにあたって、 blob に依拠する議論とそれ以外の生成系の議論、すなわち与件とパラメータを介して建築をつなぐという考え方を分けて取り扱う。どのような図形によってシステムを構築するのかというコンポーネントに関する議論よりはむしろ、パラメータの決定に関して Any 会議では議論になった 26。パラメータを使って変形していく曲面は与えるパラメータを選択する操作者がいなければ決定できない。Lynn の著書 Animate Form でも変形していくblob が複数の状態で提示されているが、そのうちのひとつを最終的な提案として提示する行為が必要であり、結局それはパラメータというインターフェイスを利用して設計者が形態を決定しているのである。すなわち与件から「生成する」といいながらも建築家が設定した blobという初期形態と最終的なパラメータの固定こそが形態を決定する要因であり、自走する系によって建築が生成するというよりも、数値を介して建築家が造形していることが議論された 27。しかし、このことからパラメトリッ 21 ドゥルーズ (2010). 22 ドゥルーズ (1998). 23 "Curvilinerity" での言及とLynn が建築と同時に哲学の学士号を取得している背景を踏まえている 24 補遺・CAD 技術の展開を見れば分かる通り、2014 年現在一般的となっているMaya や 3dsMax の普及よりも前に Lynn が CG 技術を利用していることから思い入れの深さが伺える。 25 "Animate Form" p.20 では 'There are fundamental properties of organization in a computer that are very diﬀerent from the characteristics of inert mediums such as paper and pencils'というように計算機における幾何学がどのように扱われるかを述べた部分が複数存在する。 26 磯崎は「どこかでストップをかけて、フリーズした状態で初めて実際の建築物に転換できるのであって、それがずっと動いていたら、いつまで経っても建築物にならない。それをどうするんだ？という質問をグレッグ・リンにした」( 東 (2009)、60 頁 )と述べているが出版されている各々の議事録では具体的にどの会話を指すのかはっきりとしない。サスキア・サッセンの発言「膨大なオプションと、あなたが導入なさった変数の向こうには、何が存在するのでしょうか。」( 磯崎 (1999a)、84 頁 ) など他の発言者からこれに類似する質問が投げかけられている。 27 Eisenman の質問「フランク・ゲーリーと、( 中略 ) 違いはあるのでしょうか？」などがある( 磯崎 (1999b)、204 頁 )。

ﬁg.2-3

クな計算機を利用した造形とLynn 以前の造形とに差異がないというわけではない。生成という語が与件から建築が自動生成することで一意に決定するかのような印象を与えてしまうが、Lynn の議論はむしろ前決定的な同一性を否定しているので複数の可能性を生み出すことが必然でもある。パラメータを利用することで、建築物そのものだけでなく造形を操作するプロセス部分が意識され、建築の設計における情報の流れをモデル化するアプローチに近づいた。周辺環境からパラメータを取り出す、パラメータ決定のアルゴリズムが未だ建築家の内部にブラックボックス化されてはいるものの、Lynn は計算機を介在させたことによって建築家の思考の少なくとも一部をパラメータという情報としてとらえる状況を生み出した。Lynn が示したパラメトリックな幾何学の扱いがもつ価値は自動生成を行う可能性にあるのではなく、建築家による与件の読み取りや整理と造形の関係性を暗黙裡のものから幾何学のシステムとそれに対して入力されるパラメータの決定として明示したことにある。animate form のもつパラメータを介して周辺環境のもつ情報を取り込むという仕組みを、関数として表現するダイアグラムによって表すと(ﬁg.2-3) のようになる。 Lynn の議論は前節で示した Form = Gene(parameter(Environment),geometry) ……② を <Animate> Form = blob(parameter(Environment) ) ……③ としてとらえていると見ることができる 28。ここで、パラメータを反映させる図形のシステムとして Lynn は blob を選択していたが、その選択には必然性がないことはすでに述べた。では、どのような幾何学でも良いのだろうか。blob に限定しないパラメトリックな幾何学のシステムによって《遺伝子》のシステムを記述するための条件を明らかにする必要がある。次節では Lynn に生成という概念をもたらした Deleuze の思想、そして Deleuze の思想に幾何学的モデルを与えていた Bernard Cache のちからを借りて Lynn の理論を拡張し、《遺伝子》を描く幾何学に必要な性質を明らかにしていく。

28 ここで <Animate> は Form の変数型宣言のようなものと考えている。

2. 連動系の幾何学

2-3. Bernard Cache: Objectile この節では設計事務所兼研究所であるObjectile を主宰する建築家の一人であるCache の建築論を取り扱う。Cache は 1958 年 5 月 26 日、フランス、サン = カンタン生まれの家具デザイナー、建築家、そして幾何学と計算機利用を主に扱う建築理論家である。日本での知名度が高いとは言いがたいが、今村創平が『10+1 web site』で取り上げている 1 他、森美術館の「アーキラボ」展で作品が紹介されている 2。 Cache は生成系の建築論のまさしく源泉にいた存在であると同時に、現代建築における計算機を利用した設計に関する理論と実践における重要人物である 3。 Lynn をはじめとする生成系建築の言説で言及されるDeleuze の著書は『千のプラトー』などいくつかあるが、その中でも形態や空間と直結する著作のひとつが『襞 ―ライプニッツとバロック』である。この本の冒頭で図版を引用して議論されている objectile( 対象体 )という概念は Cache が Deleuze( あるいは Bergson) の哲学を造形に応用しようとした試みの中で生まれたものである4。実際には DeleuzeとCache は直接の面識がある師弟関係にあるので 5 この二人の思想は相互作用的に発展している。たとえば、Deleuze の哲学と触れる中で Cache が提示した幾何学的な概念に Deleuze が objectileという名前を与えている。前章で見たように Lynn は哲学的な襞の概念を体現するモデルとして blob を提示しているわけだが、むしろ襞は対象体という幾何学的なイメー 6 ジが並行して成立していたのである。しかし、襞の建築的な応用として CacheよりはむしろLynn が重視される傾向が見受けられる7。その理由として出版物として理論が広まるタイミングがあったと考えられる。関連論考の出版を時系列順に並べると次のようになる。 1983 年 1988 年

Terre Meuble（Cache）私家版 Le Pli（Deleuze）

1993 年 1995 年 1996 年

Architectural Curvilinearity（Lynn） Earth Moves, Anywise 会議 Anybody 会議

1997 年 1999 年

Terre Meuble フランス語版出版 Animate Form

ここからわかるように、『襞』のなかで後日出版されるものとして引用されているCache の Terre meuble は実際には 1997 年に至るまでフランス語では出版されず、先に英語翻訳版の Earth moves がアメリカで出版される。8 この間に、Deleuze の『襞』のみならず AD 誌での "Folding architecture" 特集号が出版されてしまう。結果として一般に受容される順序としては Deleuze、Lynn、Cache の順で発言しているような状況となった。また、Earth moves が出版されるに際しても、すでに広く知られるようになっていた Lynn 1 今村「新しい形を「支える」ための理論」『10+1Web site』http://10plus1.jp/monthly/2003/06/10163514.php( 最終アクセス 2014/01/25)。 2 森美術館 (2005)、265、302 頁。 3 Cache(2011) に寄せた Mario Carpo による巻頭言では 20 世紀終わりに現れ始めたディジタル建築の先駆者において、"Bernard Cache was one of the ﬁrst among them - both chronologically and in order of importance."(5 頁 )というまでに重要人物とされている。 4 Cache(2011), p.20. 5 Beaucé(2007), 奥付。 6 Deleuze は『フーコー』でも襞という概念に触れている。Cache が単独で生み出したと言うよりこれも相互作用とみるのが妥当であり、並行して成立したという表現をここではとっている 7 たとえばヴィゾヴィティ(2004 年 06 月 ) などでの言及の順序。 8 この様子は Mario Carpo によるProjectile のイントロダクションにも明記されている。

を意識した形で編集者からの前書きが寄せられるなど、後追いした形になってしまっていた。しかし上の年譜で示した通り、むしろ Cacheこそが生成系建築の始原である。9 この節で Cache を取り上げたのは生成系の建築論の源泉に彼がいるからというだけではない。Cache が重要なのは彼の建築論において鍵となる概念として nonstandard( 非標準 )、associative（連動性）、そして objectile( 対象体 ) があり、これらは Lynn の議論から拡張して《遺伝子》を考える上で必要となるからである。それぞれの概念を分析していく。これら 3 つの概念のなかで理解が容易いのは非標準という概念である。標準化された工業製品に対して、非標準建築は同じ型で大量生産されることはない。しかし Cache は 2000 年代に活発に利用されるようになってきたソフトウェアが可能にしているような曲面を使った「高価な彫刻」10 を創ることには批判的である。Cache が目指している非標準建築はシリーズとなっていながらも型の再生産ではない建築である。11 同じ型の建物が大量複製されるのでもなく、複雑で固有な形態をもった建物を無限に生み出していくのでもない建築の生産を Cache は追求している。では、その非標準建築はどのようにして実現されるのか。標準というものが合同によって同じ型にまとめられるという基準を持っているとしたら、非標準なシリーズは、相似、射影幾何学、位相幾何学を追加していくことでその枠組を拡張して達成されるとCache は考えている。幾何学

変形

幾何学的不変量

数値的不変量

合同

回転

距離

a1 = a2

相似

拡大

角度

a1/b1 = a2/b2

射影

投影

交差

(a1/b1)/(c1/d1) = (a2/b2)/(c2/d2)

位相

歪曲

連続性

Euler number: V+F-Eなど

ﬁg.2-4

これらの幾何学を利用することで導入されるのが連動性である。連動性という語が指しているのは単一のレベルではない。図形のすべての部分相互の連動性、アイディアの構想から生産の現場までの連動性である。この連動性が端的に表れるような例を挙げるとするならば、連動性が与えられたモデルでは建物を構成する要素のひとつ（例えばジョイント）を交換しようとしたときに、すべての箇所で書き換えをしていくのではなく、関係性を記述しておくことで、ジョイントの「オリジナルな親」 12となっているデータを上書きするだけで一度に書き換えを連動させる。連動性を与えるためには、図形の各部分の相対的な関係 9 更に、日本では日本語訳が存在するCache のテキストの内、もっとも建築界に広く知られたであろうものが「柔らかい大地」であり、その内容は必ずしも平明ではなく、哲学的な言説を振り回しているかのような誤解を生んでいる印象さえある。一方で Cache は AA School や Belrage Institute 他の欧州の主要な建築教育の場で教鞭をとり、作品は Frac にも収蔵されており、忘れ去られた存在というわけでもない。 10 拙訳、Cache(2011), p. 60. 11 Mario Carpo はマス・カスタマイゼーションの一つの形として non-standard production を捉えている(Cache(2011),introduction)。 12 拙訳、Cache(2011), p. 69.

2. 連動系の幾何学

を把握する必要があり、定義する点、それによって二次的に決まる点…という参照の継承関係が明確にされなければならない。この要件は「我々に合理的な方法で建築のプロジェクトを一貫して考えることとプロジェクトの前提を明瞭にすることを義務付けるフィルタを形成する」13というのが Cache の最初に掲げる連動性のメリットである。しかし、 Cache の連動性という概念は Vitruvius の建築書における機械や Dürer の透視図法に影響を受けたもので、14 着想は古典的でさえあるが、もし現在一般的な製図技術を用いてこれを設計し生産するとしたら問題がある。標準化された場合と比較して多大なデータ量になり、技術的・金銭的なコストが膨大なものとなってしまうという問題である。そこで計算機を導入することで Cache は生産性の観点から言っても標準化された建築生産に対抗可能な非標準化された建築生産を提案する。 Cache が提示している非標準建築のための CAD-CAM の連動システムの基礎的な要素は 4 つある。 - 関係性の雛型にコンポーネント挿入をする - 常に数値は暫定的であり最後まで連動性を持ち続ける - 建設に必要な全ての図書を出力する(BIM) - 金銭的な情報をひもづけるこの要件は Lynn の animate form にも共通する部分があるが、Cache に特徴的なのは blob に限定せずに構成システムとは別に交換可能なコンポーネントを想定している点である。この仕組であれば Lynnよりも広汎な形態言語に対して理論を応用しうる。 Objectile 事務所はこうした要素を持つ設計・生産の連動性のあるシステムをフランスの CAD 開発会社 TOPCADと連携して製作まで実験的に取り組んでいる。15 一方で、事務所の名前ともなっているobjectile( 対象体 )という概念は捉えにくい。対象体は Deleuze、Cache によって次のように定義されている。

対象はもはや本質的な形態によって定義されるのではなく、パラメーターに枠づけされた曲線族を変化させるものとして純粋な機能性に帰着し、可能な変化の系列と不可分、あるいはこの対象自身が描きだす、可変的な湾曲をもつ平面と不可分である。この新しい対象を対象体（オブジェクティル）と呼ぶことにしよう。 16 By this, I mean objects that are repeatable variations on a theme, such as a family of curves declining the same mathematical model 17 計算のパラメータを操作することでひとつのシリーズの中の各々のオブジェクトに対して異なる形態が生産可能になる。こうして個性的なオブジェクトが工業化生産され 13 拙訳、Cache(2011), p. 69. 14 "Vitruvius Machinator Terminator" Cache(2011), pp.119-139. 講義では Vitruvius に着想を得た動的なモデルが示されている。 Cache, KTH での講義 http://www.youtube.com/watch?v=VxzdW4H4aww(accessed, January 21, 2014). 15 「アーキラボ」展で紹介されたように彼らの取り組みは哲学的であるのみならず実践的である。森美術館 (2005)。 16 ドゥルーズ (1998)、34 頁。 17 Cache(2011), p.20.

るようになる。曲面によって生み出されるものを「サブジェクティル」、立体によって生み出されるものを「オブジェクティル」呼ぶことにしよう。 18 これらの記述から総合的に考えて、対象体は連動性を導入された動的な図形によって表象される非標準な生産を可能にする連動のシステムであると考えて良い。動的存在であるから、あるひとつの状態で図形を紙に印刷しても対象体を表現することはできない。対象体は無数の可能な形をもった図形のシステムであり、Deleuze のテキストが示しているようにモノとしての対象 (object) に結び付けられた操作すべき機能性を持つものである。 Lynn の animate form が動的な形そのものであり、動きを静止した時にも表現しうるような流状体であることを指定されているのに対して、対象体は連動性をもつ形を生み出す仕組みであり、構成要素そのものには指定はない。事実、設計事務所 Objectile の作品を展示したドイツ・ハンブルクにあった iCP19 での展示会に併せて出されたコンセプトブックに掲載されている写真は合板の組み合わせられた家具もミリングマシンを使ったと見える曲面も存在している。

Environment

OBJECTILE component

associative

component

Non-Standard Form

ﬁg.2-5

Cache は生成系の建築理論の始原であるが、以上に見た通り彼の提唱している「対象体を構築する非標準的な建築の設計」は生成的というよりも連動的である。対象体の持つ連動性や、非標準という概念を導入して animate form で得られたダイアグラムを更新すると(ﬁg.2-5) のようになる。 Lynn の議論を関数として表した <Animate> Form = blob(parameter(Environment) ) ……③ 18 拙訳、Cache(1995), p.88. 19 institute for Cultural Policy 文化政策研究所、この名前はある種のパロディであり、独立系アートギャラリーのようなものであった。現在の活動状況や存続は不明。

2. 連動系の幾何学

では静的な blob 関数しかなかったものが、関数そのものが動的に変化しうる形で次のように書き換えられる。 <Non-Standard> Form = <Associative> Objectile(Component, parameter(Environment))20

……④ Cache はこの対象体を設計の手段として提案しているわけであるが、ある形態と環境の組に対して、遡行的に実体を与えるような対象体を推定することを考えるとどうなるであろうか。つまり、形態を、与件と結びつける要素と形態の図像的な要素とに分けてそれをシステムとしてとらえるとどうなるであろうか。21 必ずしも建築物は連動性や非標準性を意識して対象体から設計されているわけではないが、その場合でも関数として定義するのであれば、環境からの引数に対して定数を形として返す関数として捉えることで連動性の弱さや非連動性さえも定式化できる。このような非連動な場合も含め、遡行的に推定される拡張された対象体と、生物の遺伝子を比較することで、拡張された対象体、すなわちパラメトリックに変形可能な幾何学のシステムが建築の《遺伝子》を表現したモデルと考えられることを次節で確認する。

20 ただしここでもNon-Standard, Associative は型を示す。 21 2-5.「アルゴリズミック・デザインの理論と遺伝子、進化」で詳しく考察するが、菊竹清訓の「か・かた・かたち」の理論における認識と実践の関係性から設計手法の＜かた＞と＜かたち＞の関係性は認識における＜かたち＞と＜かた＞の関係性を転じたものであると考える。

2-4. 建築遺伝子前節までに磯崎、Lynn、Cache の議論を取り込んだパラメトリックな幾何学のシステムをダイアグラムと関数の式で提示した。Lynn においては animate formとして限定された幾何学的要素でシステムが構築されていたが、Cache の言説を参照すると associative geometryとしてパラメトリックに変形する計算幾何のシステム一般を取り扱うことができる。こうした生成系のデザインではパラメータが変化することによって環境と呼応して建築が生成するというモデルが漠然としてあった。この研究ではそれらを、 Lynn: <Animate> Form = blob(parameter(Environment) ) ……③ Cache:

として定式化した。さらに、非連動な場合も相関性ゼロの関数として捉えれば遡行的に形態と環境からObjectile 関数を推定しうるということを続けて述べた。Objectile 関数はさきに挙げた《遺伝子》の要件 - 形を定義する情報を有している - 与件から読み取った情報を反映する - 与件に対して出力される形は複数の可能性をもつをすべて満たすことができる。ゆえに、これを《遺伝子》の表現として用いることができる。ところで、遺伝子をもった生命体がまず存在しなければ環境のなかで生物が生成しないように、建築も与件だけから自動生成するわけではない。生成系のシステムにはまず、与件とは連動していない状態でパラメトリックに変化可能な性質が与えられ、 <Genotype> Form = Objectile(Component)

……⑤

という状態が存在する。そこから、どのような方式で与件と関連付けるかを決定して環境と連動する性質を獲得する。 <Phenotype> Form = Objectile(Component, parameter)1 ……⑥ このような形態と環境の関連付けを生成ではなく連動と表現する。その理由が 2 つある。まず、形態には環境要因とは独立な Component( 形態の要素 ) の項が存在していることから、あたかも自動的に形態が決定するかのような印象をあたえる生成の語が不適切であると考えられること。そして、形態と環境がこのように関連付けられた場合、何らかの評価に対して parameter 関数のみの書き換えを行うと、Objectile 関数、Component 変 1 この式では固有の parameter を代入しているので表現型が現われる。parameter が Environment の関数として変化するとNonStandard な群を出力する。

2. 連動系の幾何学

数をそのままにしていても連動して形態を操作できるというフィードバック可能性が存在しているためである。環境をパラメータに変換する作業は実環境を環世界としてとらえる行為である 2 から実環境が変化しない状態でもパラメータは変化しうる。つまりForm は Objectile 関数から一度出力されて終わるのではなく、Cache が指摘しているように「まさに最後のその瞬間まで」3 連動しているという重要な性質がある。このフィードバック可能性を含んだ FormとEnvironment の関数をダイアグラムに表すと(ﬁg.2-6) のようになる。ここでさらに、形態と環境の連動性を定式化する関数と比較するために生物の遺伝子を同様の関数で表現することを考えると、 Form = Gene(Coding,nonCoding(Environment))

……⑦

と書くことができる。これもダイアグラムにすると(ﬁg.2-7) のようになる。

ここからわかるように生物ではパラメ―タ取得の関数にフィードバックはかけられていないが発現調整は環境の変化に応じて起こるので、パラメータを取得するparameter 関数に評価と関数の更新が含まれていると見ることもできる。ただし生物の発現調整は量的なものであることには注意が必要である。質的な変化に関しては生物の場合は進化のプロセスで突然変異を起こすことで世代レベルで見て遺伝子が変化している。また建築の Form とEnvironment の関数において Component および parameter 関数を書き換える行為は設計案の変化であると考えられる。部分的な違いはあるものの、パラメトリックに図形を変化させる関数と遺伝子を表現した関数がよく似た形で書き表せることが確認できる。以後このように関数の形で示されたパラメトリックな幾何学的システムを利用して《遺伝子》を記述し建築論に利用する。

2 この認識に関する詳細な議論は柄沢他 (2011)、216-217 頁を参照されたい。 3 Cache(2011) , p.70.

Start

F=null

parameterとEnvironmentの関係を定義

Componentとパラメータの関係を定義

p = parameter (Environ)

f = Component(p)

delete(f )

f∈parts

yes F=F+f

evaluate(F)=True

yes End ﬁg. 2-6

Start

F=null

Environmentによる発現調整をGenomから読みとり

p = parameter (Environ)

発現調整

Coding領域をGenomから取得

f = Coding(p)

delete(f )

翻訳

f∈Exon由来

yes F=F+f

End ﬁg. 2-7

2. 連動系の幾何学

2-5. アルゴリズミック・デザインと遺伝子、進化さきに取り上げた磯崎の「模型的思考」の初出は『建築文化 : 特集＝情報空間』 1 であるが、のちにこのテキストが『手法が』に再録されている事実は注目に値する。磯崎は明示的に書いてはいないものの、手法と模型がセットになって機能すると考えていた様子がうかがえる。磯崎の《手法》という表現は時期によって意味に幅がある。2 しかし、手法は「簡明な手続き上の技法、あるいは作図の方式に還元されていることが望ましい」 3という表現からわかるようにアルゴリズムを内包する概念として用いている様子が伺える4。なぜ磯崎は手法論とあわせて模型論を書いたのか。その理由は Christopher Alexander の著書『形の合成に関するノート』5 で述べられているダイアグラムの分類から考えることができる。Alexander はこの論文において集合論を用いて機能に適合する形態を合成する手法を考案した。彼はこのとき、デザインを問題解決として捉え、要求に対して答えを求めることで形態を導き出すことができるとしていた。デザインを問題解決としてとらえること自体に対して議論の余地はあるが、合成のプロセスにおいてダイアグラムに関して記述されている内容は示唆に富んでいる。次の引用でわかるように、Alexander はデザインの成立が部分を結合することによって可能であると考えている。

実現は、小さなダイアグラムをプログラムの指示に従って結合し、徐々に複雑なダイアグラムを得ることによって達成される。そうするためには、プログラムの中の要求の集合を、それと対応するダイアグラムに合わせることを習得せねばならない。 6 個々の問題を合成することで全体が成立するという考え方には批判が向けられる。部分の相互の干渉を配慮してまとめたとして、差し障りが無いものはできるが、それが優れているという保証が何もないためである。これだけではデザインの手法論とは呼べず、問題解決型の発想による限界が見える。しかしながら、要求とダイアグラムを対応させるという考え方はパラメトリックな幾何学のシステムを前提に考えると有意な指摘である。Alexander はダイアグラムを分類して「形のダイアグラム」「要求のダイアグラム」とそれらの積集合である「建設的ダイアグラム」を説明することで示している。

要求だけ、形だけを表しているダイアグラムは、要求を形に変えていくときに効力がなく、形の追求にとっては何らかの建設的な役割を果たさない。ダイアグラムの中にこれら二つが含まれているときに限り、すなわち、それが同時に要求のダイアグラムであり形のダイアグラムであるときに限り、そのようなダイアグラムを建設的 (constructive)と呼ぶ。 7 ここで記述されていることをパラメトリックな幾何学のシステムで考えてみる。パラメータは媒介となる変数であるが、何を媒介しているのかと言えば与件と形態である。与件を何らか 1 磯崎 (1979)。 2 自身で「これまでの建築に関わる私自身の仕事の核心に < 手法 ([ ふりがな ] マニエラ )>という概念をおこうとしてきたのだが、このコトバは、用いるたびにその意味が曖昧になり、論議が拡散しがちである。」と述べている磯崎 (1979)、44 頁。 3 「政治的言語とマニエラ」磯崎 (1979)、45 頁。 4 磯崎はのちに振り返って、「コンピュータ・アルゴリズムと芸術、文化のなかにおけるフォルマリズム、これら相互の関連を考えた記憶はあるけれど、自分なりに明快に説明する理論に到達したとは思っていません」( メディア・デザイン研究所 (2007)、76 頁 )と言っているが同時に「自我を囲いこんで、外に存在するアルゴリズムを取り出して方法論化したいと思っていたのは確かですね。」( 同書、75 頁 )とも述べていることも証左となる。 5 アレグザンダー (1978)。 6 アレグザンダー (1978)、72 頁。 7 アレグザンダー (1978)、75 頁。

の数値として表現することができればそれは要求のダイアグラムであり、それをパラメータとしてパラメトリックな図形に代入することで、形のダイアグラムに過ぎなかった図形が建設的なダイアグラムに変わるといえる。

建設的なダイアグラムは、コンテクストを描写することができ、そして形を描写することもできる。それは、コンテクストを探る方法と、形を追求する方法を我々に提供する。 8 この記述を踏まえると、連動性をもったパラメトリックな幾何学のシステムはコンテクストをパラメータとして取り込みながら形態を操作することを可能にしており、まさに建設的ダイアグラムである。磯崎が模型的思考を手法論と抱き合わせにして『手法が』のなかに収録したのは、手法を建築の形態としてまとめるためには建設的ダイアグラムが不可欠だからである。もし手法だけが存在したとしたら、抽象的手続きだけが定義され形態を得ることができない。模型的思考を併せて初めて手法は建築と結びつくのである。このようにパラメータと建設的ダイアグラムを通じて環境と形態を結びつける設計手法を Parametricismとして Patrik Schumacher は定義づけ、それが新しい Style( 様式 ) であると主張している。9Schumacher は Parametricism を Style( 様式 ) であるというが、ここで言う様式とは "whole new research traditions that are directed by a new fundamental theoretical framework"10 である。パラメトリックな幾何学のシステムによって建築は場の持っているさまざまな力やポテンシャルを探り出し表現することが可能となる。その結果としてひとつのシステムから生み出される形態は Cache のいう非標準な造形であり、固有性をもちながらもシリーズとして存在することが可能となる。Schumacher は Parametricism の肯定的規範と否定的規範として次の条件が有効ではないかと提案している。否定的規範 - 硬い図形 ( プラトン立体など ) を避ける - 単純な繰り返しを避ける - 無関係な要素をつぎはぎにしない

8 アレグザンダー (1978)、78 頁。 9 Schumacher(2009), p.16. 10 Schumacher(2009), p.23.

肯定的規範 - 柔らかな形態を用いる - 全てのシステムが分化する - 全てのシステムが関係する

2. 連動系の幾何学

これらの規範はParametricismという様式を確立するためのドグマでありタブーである11。つまり、過去にさかのぼってまで全ての建築物を議論するための土台ではない。しかし、この設定を Cache の対象体、連動性、非標準という概念と照らしあわせて考えると、3 つの条件のうち第 1 項目だけが Cacheとの差異になっているということがわかる。Cache の用語で Schumacher の規範を表現すれば、肯定も否定も次の内容を述べていると言える。

- 対象体の要素となる図形を指定する - システムは非標準生産に供与する - システムは連動する Cacheとの差異は、Schumacher の意図による。形態の探索にあたって、この規範に則ることでより明確にデザインの手法を形態に表現することをねらっていて、彼は広範な建築の議論の土台を与えることではなくアヴァンギャルドのマニフェストを提示することを志向している。遺伝子という観点で見れば、このマニフェストは、多様な可能性を持ちうる遺伝子を制限するものである。換言すると種が定まらない遺伝子に Component 定数として固有の値を与えることで種を決定しており、対象体の要素が同一性と関連していることを示唆している。いま、広義の対象体を設計とは逆の順番で形態から取り出すことによって《遺伝子》を分析するならば、Schumacher は Parametricismとして《遺伝子》の Component 変数を blob や particle などの一群から取った対象体を用いて設計することを指しているといえる。Schumacher のこのマニフェストはパラメトリックな幾何学システムを利用する上で、建築の記号的側面にその手法を表出させることには有効である。しかし、遺伝子と実体の形態の関係性は菊竹清訓の代謝建築論でいう< かた >と＜かたち＞の関係にあたり「＜か・かた・かたち＞は、環になっていって、しだいに、ラセン状に循環していくことで＜かたち＞の創造性は強化されてゆく」12という＜かたち＞の発展プロセスを踏まえると、より良い＜かたち＞を求めるためにはある時点で対象体の要素を書き換える可能性を担保しておくべきである。言い換えるならば、ある世代での＜かた＞を提示しているSchumacher の議論は《遺伝子》の進化を配慮していない。13 遺伝子を意識したアルゴリズミック・デザインを展開していく可能性が開くためには、進化のプロセス、す 11 註記 :Schumacher 自身の表現は一定ではない。ここではいくつかの原典から共通する要素を勘案して翻訳している。以下に複数の表現を列記する。

Negative heuristics:avoid familiar typologies, avoid platonic/hermetic objects, avoid clear-cut zones/territories, avoid repetition, avoid straight lines, avoid right angles, avoid corners, …, and most importantly: do not add or subtract without elaborate interarticulations. Positive heuristics: interarticulate, hyberdize, morph, deterritorialize, deform, iterate, use splines, nurbs, generative components, script rather than model, (Schumacher(2008).) あるいは

Negative principles(taboos): -no rigid forms -no simple repetition -no collage of isolated, unrelated elements

Positive principles(dogmas): -all forms soft(intelligent: deformation=information) -all systems diﬀerentiated -all systems correlated

(Schumacher(2010).)

あるいは -Negative heuristics(taboos):avoid rigid geometric primitives such as squares, triangles and circles; avoid simple repetition of elements, avoid juxtaposition of unrelated elements or systems. -Positive heuristics(dogmas): consider all forms to be parametrically malleable; diﬀerentiate gradually(at varying rates), inﬂect and correlate systematically.

(Schumacher(2009), p.16.) 12 菊竹 (2008)、42 頁。 13 松川 ( 柄沢 (2011)、265 頁 ) はアルゴリズミック・デザインのプロセスを生成と淘汰の繰り返しとし、フィードバックを組み込み＜かた＞を更新する枠組みまでも含む手法論が存在しうるとしている。Schumacher の Parametricism は松川のいう＜かち＞を＜かたち＞として明示化しようとする＜かた＞であり、このかたによって生産される建築に淘汰圧をかけることで Parametricismという＜かた＞もまた更新される可能性を持っている。

なわちパラメータの調整のレベルでは生じ得ない変化を生むために、対象体のシステムや要素のレベルで遺伝子を書き換えるアルゴリズムを包摂することが必要である。このようなアルゴリズムが実装されれば、いわゆる遺伝的アルゴリズムとは異なり、個体のマーカーとしてだけではなく生物の遺伝子同様にその建築のあり方を定義づける情報を《遺伝子》として取り扱う設計アルゴリズムとして機能する。本研究ではこのようなアルゴリズミック・デザインの設計手法の開発までは取り扱っていないが、今後の可能性を示しておく。

第2編 3 章実例を用いた検証 4 章考察

3. 実例を用いた検証

3-0. 実例を用いた検証第 3 章では Serpetine Gallery のパビリオン ( 以下 Serpentine) を実例として建築物の《遺伝子》を解析し、具体的に《遺伝子》を取り扱うことでなにがわかるのかを示す。まず、なぜ Sserpetine なのか。一連のパビリオンは 2000 年に Zaha Hadid がギャラリーの 30 周年を記念するディナーのために会場を設計したことから始まった企画である。毎年、設計者としてイギリスに竣工作品のない建築家が選ばれカフェとレクチャースペースとなるパビリオンを設計する。敷地は厳密に同じ場所ではないが概ね Serpentine Gallery の前庭の範囲である (ﬁg.3-1)。

1:100

ﬁg.3-1

2000 年から 2013 年までに 13 のパビリオンが同じ敷地、同じ要求機能で建設されたことになる1。《遺伝子》が与件 ( から得られる環世界 )と形態を結ぶものだとするならば、同一の環境に建つ建築物を比較することで各個体の《遺伝子》の固有性を明らかにすることができる。すなわち Form = Gene(Component, perameter(Environment))

……⑧

においてparamete(Environment)を定数とおいてGene 関数を比較することができる。本研究では入手できる資料の限界からパビリオンの遺伝子のうち形態に関係する部分のみを対象とした。そのため色彩や素材などに関係する部分に関する研究は後の課題としたい。 1 MVRDV によって設計された 2004 年のパビリオンは建設されていない。

分析の手法としては Serpentine の図面、写真を資料 2 からわかるパビリオンの形態をもとに、パラメータで変化する associative geometry としてプログラミング言語 3 で記述し全事例を比較する。この際、形態を計算機で復元するだけでは意味がなく、パラメータにもとづいて形態を変化させるシステムを構築することを目的としている。そのため図形のもつ拘束条件や継承関係を見つけうる限りすべて反映し、最小限の入力で操作可能となるようにした。また、形態に関連する数値を、与件と関係なく決定可能な定数と与件と連動して変化させうるパラメータに識別した。与件と連動するパラメータが環世界を表現するパラメーターであり、与件と無関係な数値はコンポーネントに含まれる。これら描画プログラム全体が建築の遺伝子の形態に関する部分のモデルとなる。13 の事例それぞれに対して遺伝子を書き出した。その後、プログラムの行数、データの情報量を比較した。その上で敷地に存在する道と樹木が変化したと仮定して、これらと対応していると想定される環世界のパラメータを変化させて、パラメータの変動に対する応答性能を比較した。また以下では次の略称を用いる：2000 年に建設されたパビリオンを＜ Zaha ＞、同様にして 2001 年は＜ Libeskind ＞、 2002 年は＜伊東＞、 2003 年は＜ Niemeyer ＞、 2005 年は＜ Siza ＞、2006 年は＜ Koolhaas ＞、2007 年は＜ Eliasson ＞、2008 年は＜ Gehry ＞、2009 年は＜ SANAA ＞、2010 年は＜ Nouvel ＞、2011 年は＜ Zumthor ＞、2012 年は＜ HdM ＞、2013 年は＜藤本＞と表記する。次に全パビリオンの写真とプログラムによって出力された画像を掲載しておく。

ﬁg.3-2 ＜ Zaha ＞ ( 画像は Serpentine Gallery の webによる。以下＜藤本＞まで同様。 http://www.serpentinegalleries.org/sites/default/ﬁles/ images/1.I.jpg

2 Jodidio(2011). 吉田 (2006). 吉田 (2012)、吉田 (2013) など。 3 Processing. http://processing.org/(accessed 20140124).

3. 実例を用いた検証

ﬁg.3-3 ＜ Libeskind ＞

http://www.serpentinegalleries.org/sites/default/ﬁles/styles/ half_width/public/images/1.II_.04.SD__0.jpg?itok=C3GjIbYI

ﬁg.3-4 ＜伊東＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ images/3.III_.A.SD_.jpg

ﬁg.3-5 ＜ Niemeyer ＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ images/11.IV_.22.SD_.jpg

ﬁg.3-6 ＜ Siza ＞

http://www.serpentinegalleries.org/exhibitions-events/ serpentine-gallery-pavilion-2005-alvaro-siza-and-eduardosouto-de-moura-cecil-balmond-0

ﬁg.3-7 ＜ Koolhaas ＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ images/9.VII_.E.JO__1.jpg

ﬁg.3-8 ＜ Eliasson ＞

http://www.serpentinegalleries.org/exhibitions-events/ serpentine-gallery-pavilion-2007-olafur-eliasson-and-kjetilthorsen

3. 実例を用いた検証

ﬁg.3-9 ＜ Gehry ＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ images/8.IX_.JO_.jpg

ﬁg.3-10 ＜ SANAA ＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ images/9.X.NG_.V.jpg

ﬁg.3-11 ＜ Nouvel ＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ i m a g e s / 1.% 2 0 A% 2 0 M A I N % 2 0 i m a g e % 2 01.% 2 0 A% 2 0 MAIN%201.XI_.PR_.jpg

ﬁg.3-12 ＜ Zumthor ＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ images/1.%20A%20MAIN%20image%20Copy%20of%20_ MG_7808SerpentineZumthormed-res.jpg

ﬁg.3-13 ＜ HdM ＞

h t t p : // w w w. s e r p e n t i n e g a l l e r i e s . o r g /s i t e s /d e f a u l t / f i l e s / im a g e s /1.%20A%20 M a i n%20 im a g e %20 H d M%20 Serpentine%207144%20Press%20Page.jpg

ﬁg.3-14 ＜藤本＞

ht tp://w w w.serpentinegalleries.org/sites/default /files/ imag es /A%20 Main%20 ima g e %20 s er p entin e _gall er y_ pavilion_sou_fujimoto_2013_2.jpg

3. 実例を用いた検証

3-01. Zaha Hadid まず形態の要素を分析すると、 - 屋根面は三角形分割で構成 - 斜めの柱 - 床面は基本としてフラットだがギャラリー側に段差があるここで、各要素の関係を見てみると、立面図から屋根の屈折点と柱と屋根の接合点が一致していることがわかる。また床面と屋根面の水平面への投影は同じ平行四辺形となっている。したがって、屋根面の形態を定義してからそれに従属して柱と床の形態を定義することができる。三角形分割を作成するにあたりいくつかの方法が存在する。３D モデリングの技法として簡易なものとしては先に合同な三角形を並べて原形となる立体 ( 以下メッシュと呼ぶ ) を作り、その頂点を移動することで歪んだ形を作るという方法がある。しかし、屋根伏図をみるとイレギュラーな箇所がある。この点の存在から、メッシュを歪ませて造形することでは同様の図形を再現できない。比較的近いメッシュから屋根伏図に併せて変形するといくつかの辺が再現できないことがわかる (ﬁg.Z-1)。

ﬁg.Z-1

そこで頂点から決定する方法としてドロネー分割を考える。ドロネー分割であれば外周の壁上の頂点の数が対辺で等数である必要がなく、先に述べた図中のイレギュラーな点も存在できる。まず変形するための図形

Form = Gene(Component, parameter) の状態を作る。水平投影に関しては平行四辺形の平面であるから、ひとつの頂点と二つのベクトル ( 新しい基底、図中の OA と OC) を決めると残りの頂点が定義できる。各辺上の点の数、平行四辺形内部の点の数を決める。また、柱の足の数を決め、頂点の中から柱の頭となるものをえらぶ (ﬁg.Z-2)。次に環世界を表現するパラメータを屋根面の点、柱の足の数だけ与える。 Form = Gene(Component, parameter(Environment)) この際、点が辺上にある場合や平行四辺形の頂点にあたる場合には自由度が減る。全ての点に鉛直方向の自由度 Z が存在するが水平面内の移動に関しては拘束がかかる。図中では①、②、③のように自由度を示した。こうして柱と屋根の位置が決まる。さらに、それぞれの厚み、太さをあたえると屋根と柱の形態が決定する。床の階段部分は踏面幅、蹴上高さ、各段の長さ ( 踏面が台形なので長い方と短い方の二つ ) を与えると定義できる。

2 2

ﬁg.Z-2

3. 実例を用いた検証

3-02. Daniel Libeskind この造形の最大の特徴は展開可能性である。しかし、パビリオンとして機能するために足元の部分に一定の空間が必要であり、展開図を先行させてしまうと立体として成立はしても内部空間が確保できるとは限らない。各折り曲げ線が山折りか谷折りかもルールが存在しない。そこで、ひとまず一辺が地面に接しているような、ある構面から作成し、次に地上に接する構面までを作成し（以下、このようにして作成される 2 枚の壁と屋根の 1 組をターンと呼ぶことにする）、それをつなげることで全体をつくるという順番で考える。これによって平面形状を向かい合う壁の着地線で制御することができる。また折り曲げ線のうち地上に存在するものはすべて同一平面に存在するという制約を与えることができる。1 つずつのターンに対して壁２、屋根１の組み合わせが基本となっている（エントランスのみ例外）。各ターンごとに p5

p6 v3 p7

v1 v2

ﬁg.L-1

-1. 地上に存在する折り曲げ線分を２本規定 ( 点 p0,p1,p2,p3) -2. 各々の線分を含むような平面を１つずつ作成する（点 p4,p5 によって決まる） -3. p0 から p4 へのベクトル v1, ｐ 0 から p3 へのベクトル v2,p4 から p5 へのベクトル v3 を求める -4. p0 から p7 へのベクトルを v1, v2 の線形結合で定義する（p0,p3,p4,p7 が同一平面） -5. ｐ４から p7 へのベクトルを v4 として p6 を v3, v4 の線形結合で定義するという手順で作図する (ﬁg.L-1)。この際、p1,p2,p5 とｐ 6 が同一平面に載るために線形結合の係数 (s,t) は直線的な関係にある。すなわち、s あるいは t の片方だけを与えれば良い。このようにして作成されるターンをつなぎ、屋根と壁ができる。さらにターンの足の中から端点となる頂点を選択して結ぶことで床面を作図する。ターンの個数は与件と関係なく決められる。環世界のパラメータは足の位置、壁と屋根の傾き（面の法線）、屋根面の高さ、共有直線上で点を定義するパラメータとして機能する。

3-03. 伊東豊雄、Cecil Balmond セシル・バルモンド自身による作図手順の説明をまず引用しておく。

アルゴリズムの提案：正方形の隣接する 2 辺の中点から1/3 点へ。その 1/2 から1/3 のルールが、もととなる正方形の中に互いに接合しない 4 本の線を描きだす。( それぞれの 1/3 点の代わりに中点を結ぶと1/2 から1/2 への線は、正方形の囲い込みの中で完全に元の場所へと跳ね返ってくるビリヤードのボールのように、その起点に戻って閉じる)。」1/2 から1/3 のルールは、オリジナルの正方形の外へ出て、リズムが続いていくものとなる。このサイクルを 6 回繰り返すと、基本的な構造体が得られる。その後、これらの線のすべてが延長されると、結果として多くの交点をもったパターンがつくり出される。そのいくつかは荷重伝達の主要要素となり、またあるものは 2 次的なブレーシングとなり、そして残りはボックスのタイポロジーの表層をランダムに横断するバインディング・モティーフとなる。1 しかし、この記述に従って作図すると、実際のパビリオンの図面とは異なるパターンが作成される (ﬁg.I-1)。実物と同じパターンを与えるためには、中心に近い2 つの正方形は 1/2 から1/3 ではなく逆順に 1/3 から1/2 のルールで作図されなければならない (ﬁg. I-2)。また、壁に関してみれば作成されるパターンに追加された線が存在する。これを立体に組み立て階段を追加する。環世界と分けられる数値として正方形の作成回数、「1/2 → 1/3」から「1/3 → 1/2」へのルールの転換が起きる回の設定がある。また1/2と1/3 は1/nと1/mとしてパラメーター化することもできる。環世界のパラメータは追加される線を決める端点の組を決めるパラメータ、全体と階段部分寸法がある。

ﬁg.I-1 1 吉田 (2006)、51 頁。

ﬁg.I-2

3. 実例を用いた検証

3-04. Oscar Niemeyer 図形的要素を下から数え上げる。基壇となる半地下室その上に載る床面床面の左右の端から斜めに立ち上がる壁一方の壁の円形の開口床面の端に立つ屋根面までの垂直な壁床面端の手すりの高さの腰壁壁の上端同士を結びつける懸垂曲線の屋根地下屋根までの柱スロープ階段がある。取り合い位置で各々の要素が接続するように位置関係の拘束が存在する。環世界と結びつくパラメーターは階段とスロープの取り付き位置左右の壁の各々の傾き懸垂曲線の形状を決める定数（質量と弾性の比）手すりの高さ床面の高さ床面・壁・屋根の厚み階段の通路幅・蹴上・踏面のプロポーションスロープの折り返し角度・長さがある。

ﬁg.N-1(Jodidio(2011),p.IV.31).

3-05.Alvaro Siza, Souto de Moura 屋根面とそれに取り付く脚という構成になっている。屋根面の格子は -1. 水平面で見ても鉛直面で見ても独立な 4 つの円弧で囲われた領域をつくる -2. カルテジアン・グリッドをモーフィングする -3. 鉛直方向になめらかなムクリを与えるという手順で作成している。これに対して脚は 2 種類が存在し 1 それを屋根面の格子を延長するように面の向きを揃えて配列している。ただし 4 隅に関しては放射状になる。未知の位置に合わせて柱を取り除いた箇所が存在し、それがエントランスとなる。環世界のパラメーターは領域の 4 周を切り取る曲線を決める円弧の半径が水平方向と鉛直方向に 1 つずつ存在する。歪みを操作するパラメーターは評価しづらい。ここではひとまず議論を進めるために 2 変数のガウス関数を用いて変形させ、パラメータは 5 つとしている 2。屋根面の基準高さを与え、柱の形状は高さが屋根面の格子から決まり、折れ曲がりが一箇所あり見付幅、見込み幅、折れ曲がり形状を定義するパラメータが 3 つ (ﬁg.S-1)。 w2

w1 O d

a*h

h ﬁg.S-1

ﬁg.S-2

1 Arup はこれを type A, type B と呼んでいた。Jodidio(2011), p.VI 28. 2 Nurbs サーフェスを用いて外形をモデリングしていると仮定すると uv のポイント数だけパラメータが必要となる。これの問題はのちの全パビリオンを通じた分析で触れる

3. 実例を用いた検証

3-06. Rem Koolhaas, Cecil Balmond 下から階段と踊り場からなるフロアプラットフォーム、二重の円筒を近似した二つの 40 角形 ( 中心角 9 度の扇型を三角形で近似したものと考えられる)、風船という構成になっている。40 角形には数カ所の開口部が存在して入り口やカウンターとして機能している。風船の下には織り上げの天井があり、正方形平面の筒が風船にめり込むようになっている。風船の形状は純粋な球形ではなく歪みがあり、正方形と滑らかに接続する。風船はヘリウムが上部に入っていて浮力とアンカーするロープで位置が決まっており、状況に応じて上下させることができる。また近傍の樹木に合わせて凹みをつけている 1。環世界のパラメータとしては、風船の半径、風船の高さ、風船の歪みの位置、階段の蹴上・踏面・通路幅の寸法、踊り場の長さ、40 角形の高さ、各開口の寸法、織り上げ天井の懐高さが存在する。

ﬁg.K-1(Jodidio(2011), p.VII-30).

1 ＜ Siza ＞同様この変形も近似式で行っている。

3-07. Olafur Eliasson, Kjetil Thorsen 二つの斜円錐台を組み合わせて基本形状としている。円錐台の側面を螺旋状に切り取り、その切断面をつなぐ壁が追加されている。斜円錐の側面に沿ってスロープが巻き付いており、一定の天井高さを保って螺旋状に内部に突き出たバルコニーまで連続している。下から上っていく螺旋が円錐台の側面に触れ始める位置を円筒座標のθ =0 とすると、θ = πとθ＝ 3 πの位置が水平投影面でみて同一の位置になることから、上下の円錐台に (ﬁg.O-1) のような拘束がかかっている。またスロープの手すりの上下を結ぶようにねじれたスクリーンが取り付けられている。円錐台の割付とスクリーンの枚数は連動しているのでパネリングに関する数値を円周方向でひとつ決めるとスロープを含めセグメントの数が決定する。環世界のパラメータは円錐台の寸法 ( 図示した拘束関係から下の斜円錐は上の斜円錐のパラメータを継承する)、スロープの勾配を決める一周で上る高さ ( この数値で円錐の高さ方向の割付の寸法も決まる)、上の円錐の天窓を決める切断平面の位置と向きのパラメータがある。

ﬁg.E-1(Jodidio(2011), p.VIII.28. から作成 ).

3. 実例を用いた検証

3-08. Frank O Ghery 4 本の柱と 2 本の梁、2 本の桁からなる架構が通路を覆うように組まれている。柱の断面はすべて同じで、高さは二種類あり、柱の幅と同じだけ芯をずらして立っている。すなわち東南側の立面的に見て柱同士が接するようになっている (ﬁg.G-1)。通路は地面よりも高い位置にあり、階段が接続している。通路の両側に広がるような段状の座席、座席の最上段に立つ手すり、それに取り付いたステージ、鉄砲階段がある。架構からは長手の両側に 3 枚ずつ、短手の両側に 1 枚ずつ、架構の内側に 1 枚のパネルが吊り下げられている。環世界の主要なパラメータは - 柱の断面寸法 - 梁間・桁行き方向のスパン - 座席の段差 - 手すり高さ - 階段の蹴上・踏面寸法 - 各パネルの大きさと向きを決めるパラメータ - ステージに接続する階段の向きである。

ﬁg.G-1(Jodidio(2011),p.IX.27)

3-09. SANAA 三次元的に広がったなめらかな曲面と柱でできている。曲面を作成するに当たり今回はベジェ曲線を用いた。検討を進める際にベジェ曲線で再現不能であれば B スプライン曲線、さらには NURBs(Non-Uniform Rationa B-spline) を導入することを検討していたが、(ﬁg.Sa-1) の通りベジェ曲線で十分である。1 ベジェ曲線には次数が存在するが低次から順に増やしていくと図に示すように屋根面に関しては 3 次のベジェで十分である。2 コントロールポイント数に関してはまず、ベジェ曲線におけるコントロールポイントと接線の関係から外に凸な部分と内側に凸な部分の数に合わせて最低限の個数が決まる。言い方を変えれば曲率円の中心と曲線の囲う領域の包含関係が切り替わる点でベジェ曲線のコントロールポイントを結ぶ多角形と曲線が交わることからベジェ曲線のコントロールポイントの最低限の数が決められる。次に、トレースするべき曲線との差異を減らすためにコントロールポイントを追加していく。図に示すように凹凸のひとつの山（あるいは谷）について２つずつのコントロールポイントが必要十分である。次にコントロールポイントの Z 座標に変化を加え目的とする曲面を得る。柱に関しては概ね均一に分布しているが分布の傾向に明快な規則性はない。ただし、通路の位置とレクチャースペースの位置には柱は立っていない。 41 環世界のパラメータはベジェのコントロールポイント、柱の位置である。 0

11 12 13 40

10 9

38 3 34

4 28

33 36

22 19 25 35

ﬁg.Sa-1

1 Farin(1991) が曲線の描画手法に関して詳しい。計算幾何の手法の評価において「ベジェ曲線は B- スプライン曲線の特別な場合」 (p.285) であり、「どんなスプラインでも B- スプライン曲線として書くことができる」( 同じくp.285) ことからこのような手順で評価を試みている。またエルミート補間などの他の曲線定義に用いられる手法に関しても同書を参照されたい。 2 一方で床仕上げに関しては 5 次のベジェ曲線と 3 次のベジェ曲線に有意な差が見られた。

3. 実例を用いた検証

3-10. Jean Nouvel 大きく分けてスクリーン、キャノピー、キューブと名付けられた 3 つの構成要素からなっている (ﬁg.N-1)。スクリーンは傾斜と厚みにテーパーが掛かった壁面である。キャノピー側に倒れるように転んでいる。キャノピーは切妻の屋根を基本形状として折れ曲がりが加わっている。一番高いところから見て東南側に 2 段、北西側に 4 段でできていて、北西側に一番外側の端部は地面に接続している。キューブは立方体を基本形状としている。最下部に 2 枚の回転扉が付けられている。東南―北西方向のガラス面が開閉できるようになっており、内側にはカーテンが垂れている。環世界のパラメーターはスクリーンの厚み、転び、テーパーの比率、キャノピーの高さ、幅 ( これは 2 本の樹木に制限されていることがわかる)、キューブの寸法、回転扉の高さがある。平面的に見て、キャノピーの頂部を通る芯線にキューブとスクリーンの中心線が合わせられている。スクリーンとキャノピーの間の隙間は道路側からのアプローチとなっている。

ﬁg.No-1(Jean Nouvel Ateliers. http://www.jeannouvel.com/english/preloader.html.accessed, January 20, 2014)

3-11. Peter Zumthor 平面形状でみると中庭とそれを取り囲む回廊によって構成されている。屋根面は内側に向かって漏斗状に傾斜している。軒裏は水平に天井が張られているが回廊部分はあらわしで斜めの天井である。開口は外周の長手両側に 3 ヶ所ずつの 6 ヶ所と内周の長手両側 2ヶ所ずつの 4 ヶ所で合計 10 ヶ所存在する。環世界のパラメータとしては建物の長さ・幅・高さ、開口部の位置・幅・高さ、屋根面の傾斜などが挙げられる。また、これらの各種寸法に加えて建物の振り角がある。この角度は樹木の配置と庭園の芝生部分の形に制限されている。

ﬁg.Zu-1( 吉田 (2013)、 66 頁。)

3. 実例を用いた検証

3-12. Herzorg & de Meuron, Ai-weiwei 円形の領域内で過去のパビリオンの基礎と屋根伏図を重ねあわせて制作された図像に対して高さ情報を与えてすり鉢状の床面を作っている。その上に中心をずらした円形を屋根面として重ね、円の端を中心角 60 度の弦で切り取っている。屋根面を支える柱は 12 本存在している。これらの柱はそれぞれ過去のパビリオンと関連付けられている。環世界と関連付けるパラメータは床の段差の高さ、屋根面の高さなどの鉛直方向の寸法と、「遺跡」を掘り起こす円形の大きさを決める半径である。

ﬁg.H-1

3-13. 藤本壮介積み上げられた立方体のボリュームを 12 辺の角材で置換することでできる立体である。部分的に立方体を分割する長さが 1/2 の立方体に置き換えられている。角材は上部では角のようにつきだしている部分がある。加えて、座席や屋根となるように部分的に面が張られている。グリッドの 1 マスの大きさを決めるひとつの寸法と、グリッド内の実体化されるマス・面を張る位置を指定する座標の組が環世界から与えられる。

ﬁg.F-1( 吉田 (2013)、106 頁。)

3. 実例を用いた検証

3-14. 遺伝子比較 3-01. から 3-13 で作成した遺伝子モデルを記述するデータ量に関して定量的な諸元を示す。空行などの部分も含めて (table.3-15) の通り。

data総量(kB) ＜Zaha＞＜Libeskind＞

12.8 6.74

行数

入力変数

477

233

126

＜伊東＞

19.5

497

＜Niemeyer＞

14.3

516

＜Siza＞

15.8

532

350

＜Koolhaas＞

8.89

＜Eliasson＞

16.1

547

＜Gehry＞

30.6

974

141

376

＜SANAA＞

9.63

＜Nouvel＞

10.8

414

＜Zumthor＞

11.9

353

＜HdM＞

68.5

2080

4794

＜藤本＞

75.3

2870

8067 table.3-15

各パビリオンの相対的な順位は各項目に関して table.3-16 の通り。

data総量(kB)

行数

入力変数

＜藤本＞

＜HdM＞

＜Gehry＞

＜伊東＞

＜Eliasson＞

＜Libeskind＞

＜Eliasson＞

＜Siza＞

＜Zaha＞

＜Siza＞

＜Niemeyer＞

＜Siza＞

＜Niemeyer＞

＜伊東＞

＜SANAA＞

＜Zaha＞

＜伊東＞

＜Zumthor＞

＜Nouvel＞

＜Niemeyer＞

＜Nouvel＞

＜SANAA＞

＜Koolhaas＞

＜SANAA＞

＜Zumthor＞

＜Nouvel＞

＜Koolhaas＞

＜Eliasson＞

＜Libeskind＞

＜Zumthor＞ table.3-16

3. 実例を用いた検証

3-15. パラメトリックスタディこの節では前節までに示した 13 のパビリオンに対して、敷地図 (ﬁg.3-17) にある道と樹木の位置や有無を (ﬁg.3-18, 19, 20, 21) のように変化させると想定して、 objectile による non-standard な形態の生産を行い、《遺伝子》の応答を考察する。ここで道と樹木と称しているオブジェクトと領域は敷地図中の Tree A, B, C と Path である。3-01. から 3-13.で作成したモデルは環世界のパラメータを介して周辺環境と関連付けがされているが、どのパラメータが周辺環境のどの要素と結び付けられているかについては検討しなかった。しかし、いくつかのパラメータは蓋然性をもって説明可能である。以下に各パビリオンについて、樹木、道とパラメータの関係性を列挙していく。＜Zaha＞は樹木との位置で外周の平行四辺形の辺OAの長さと角度が決まっている。また、道の位置が辺 BC の位置を決めている。＜ Libeskind ＞は樹木について衝突しないという自明な制限以外に関連付けは見受けられない。一方で、ターンのひとつが道をまたぐようになっている。＜伊東＞は建築の形態と周辺環境の関連付けはないが、配置に関して方位、既存建物、道のすべてに対して整列されていないことから樹木 A, C を結んだ線が建物のボリュームを振る角度を決定していると考えられる。樹木 A に近接しているため A の位置を変数とすると変形が起こるとも考えられるが、その他の大きさに関する制限が無いために平行移動を行う可能性もある。＜ Niemeyer ＞は樹木、道ともに衝突しないという以外に制限はない。＜ Siza ＞は樹木 A に接する位置に建物の一辺が置かれている。また、道の位置にしたがって柱の座標（あるいはインスタンス化する柱の指定を行うパラメータ）のうち道の領域に内包されるものが排除される。＜ Koolhaas ＞は樹木 A の位置で風船の凹みの位置を決定している。また、道の縁に合わせて階段の始点がある。＜ Eliasson ＞は樹木 A,C を中心とした同心円に接するように全体の大きさを決めている。道に関してはアプローチが接続しているが角度や長さを関連付けてはいない。＜ Gehry ＞は樹木、道ともに衝突しないという以外に制限はない。＜ SANAA ＞は樹木に関しては樹木から離れた位置にある部分の屋根面が低い。また道のある位置にしたがって柱の座標のうち道の領域に内包されるものが排除される。道の上で谷になっている。＜ Nouvel ＞は樹木の位置で最大寸法が制限されている。道の縁にはアプローチが接している。＜ Zumthor ＞は建築の形態と周辺環境の関連付けはないが、配置に関して方位、既存建物、道のすべてに対して整列されていないことから樹木 A, C を中心とした同心円が建物の外周と接するように建物が振られている。＜ HdM ＞は樹木 A,C を中心とした同心円に接するように発掘の円を決めてい

る。道に関しては衝突しないという自明な制限のみである。＜藤本＞は樹木、道ともに衝突しないという以外に制限はない。以上の内容を踏まえると樹木の中では A が考慮されているケースが多く、B, C に関しては自明な拘束 ( 衝突の回避 ) しか見られない。そこで樹木 A と Path がそれぞれ (ﬁg.3-2,3,4,5) のような環境であったと仮定して、実際にパラメータを変更して画像として以下に示す。＜伊東＞と＜ Zumthor ＞は回転運動でありパビリオン自体が変形しないため、ここでは扱わない。

Tree B

Tree A

Path Tree C

1:100

ﬁg.3-17( 実態を再現した環境 )

3. 実例を用いた検証

1:100

ﬁg.3-18( 樹木を西側に移動 )

1:100

ﬁg.3-20( 道を西側に移動 )

1:100

ﬁg.3-19( 樹木を南側に移動 )

1:100

ﬁg.3-21( 道を東側に移動 )

3. 実例を用いた検証

zaha_0( 実態を再現した環境 )

zaha_1( 樹木を西側に移動 )

zaha_2( 樹木を南側に移動 )

zaha_3( 道を西側に移動 )

zaha_4( 樹木を東側に移動 )

libeskind_0( 実態を再現した環境 )

libeskind_3( 道を西側に移動 )

libeskind_4( 道を東側に移動 )

3. 実例を用いた検証

siza_0( 実態を再現した環境 )

siza_1( 樹木を西側に移動 )

siza_2( 樹木を南側に移動 )

siza_3( 道を西側に移動 )

siza_4( 道を東側に移動 )

koolhaas_0( 実態を再現した環境 )

koolhaas_1( 樹木を西側に移動 )

koolhaas_2( 樹木を南側に移動 )

koolhaas_3( 道を西側に移動 )

koolhaas_4( 道を東側に移動 )

3. 実例を用いた検証

sanaa_0( 実態を再現した環境 )

sanaa_1( 樹木を西側に移動 )

sanaa_2( 樹木を南側に移動 )

sanaa_3( 道を西側に移動 )

sanaa_4( 道を東側に移動 )

nouvel_0( 実態を再現した環境 )

nouvel_1( 樹木を西側に移動 )

nouvel_3( 道を西側に移動 )

nouvel_2( 樹木を南側に移動 )

3. 実例を用いた検証

hdm_0( 実態を再現した環境 )

hdm_1( 樹木を西側に移動 )

hdm_3( 道を西側に移動 )

hdm_2( 樹木を南側に移動 )

以上の各例に関して、プロポーションの変化以外に図形としての破綻など特筆すべき事象が生じている場合を取り上げてみる。＜ Libeskind ＞では、道を変化させた libeskind_3 が道をまたぐターンを移動しただけでは別のターンに衝突してしまうことがわかる。＜ Siza ＞では樹木を移動した siza_2 は周を定義する円弧が干渉している。＜ Koolhaas ＞では koolhaas_3 では階段の踊り場が建物中にめりこんでいる。＜ HdM ＞では樹木を移動した hdm_1 で屋根面から柱が出てしまっている。これらの結果から、道、樹木とパラメータとの明示的な関連付けの有無、パラメータを変化させた際の図形として成立するか否かでパビリオンを分類すると (ﬁg.3-22) のようになる。

PAVILIONS 関連付けあり破綻あり

破綻なしプロポーション

＜Libeskind＞

＜Zaha＞

＜Siza＞

＜Eliasson＞

＜Koolhaas＞＜HdM＞

＜Nouvel＞＜Gehry＞非プロポーション

＜SANAA＞＜藤本＞

関連付けなし

＜伊東＞＜Niemeyer＞＜Zumthor＞ ﬁg.3-22

破綻のないものの中でみると、形態の変化がプロポーションの変化であるものと、プロポーション以外の変化が生じているものとがある。

4. Serpetine の遺伝子的観点からの考察

4. 考察 3 章で得られた結果に基づき、遺伝子から見た Serpentine の遺伝子的観点からの考察を行う。前節の分類を解釈すると関連付けのないパビリオンは意図した固有の形態を提示しているのに対して、関連付けのあるものは与件に応答するようなシステムの提案を含んでいるといえる。パラメータの変化によって破綻を生じるものは、固有の条件に対しての応答であり、形態の中に汎用的なシステムは内包していない。同等の環境に対して設計されているにもかかわらず data 総量に大きな開きがあることがまず注目される。すなわち、生物種と同様に遺伝子の情報量には差がある。同時に、生物種において生物のもつ知性や形態の複雑性と遺伝子の情報量が必ずしも一致しないことは留意されるべであろう。つまり、記述する情報の量が計画の優劣を決定するという結論ではない。data 総量と行数は概ね対応する一方で、data 総量に対して入力変数の数は単純に対応せず、上位の 3 パビリオンを除けば入れ替わりが激しい。入力変数が多いということは環境と応答しうるインターフェースが多いということである。しかし、与件との関連付けなしと考えられる＜伊東＞、＜ Niemeyer ＞、＜ Zumthor ＞の他に＜ Koolhaas ＞、＜ Nouvel ＞、＜ Eliasson ＞も入力変数が少ないグループに入っている。＜ Nouvel ＞と＜ Eliasson ＞は関連付けありのグループで、プロポーションの変形を生じるものである。この事実が示唆していることは、与件との関連付けのないグループが建築家の意図した形態を提示している一方でプロポーションの変化は意図された理想型を実環境に適応させるために非等倍率の拡大縮小を許した変形であることである。ここで、＜ Koolhaas ＞が破綻ありの中に入ってしまっている問題が浮上するが、議論を進めるためにひとまず生物の場合に対応させて考えてみる。大きな環境の変動に対して生存不可能な生物種であると評価されている破綻ありのグループであるが、絶滅するというシナリオ以外に、遺伝子に何らかの突然変異が生じて別の種に進化することで種を保存する可能性が出てくる。これを Serpetine に援用すれば図形的な破綻の有無という評価に対して遺伝子を変化させることで建築を進化させ、破綻のないパビリオンに変える可能性が存在している。＜ Koolhaas ＞は階段のめり込みが生じないようにある一定の長さよりも踊り場が小さくなった場合に、階段の位置を変化させるのではなくプロポーションを変化させていくように遺伝子を書き換えれば容易に破綻を解決することができる。すると＜ Koolhaas ＞もまた破綻なしかつプロポーションのグループに入っていることになる。概ね、入力変数に関して上位のものが環境と応答しやすく、下位の者は応答しないかプロポーションのみを変化させているものであると見ることができる。もっとも、＜ Gehry ＞や＜ Zaha ＞が＜ SANAA ＞よりも上位に来ているため、絶対的な法則性ではない。例外が生じる主な理由は、入力変数が多くとも、環世界とは独立に変数を設定している限り与件との応答は生じないからであると考えられる。まとめると、＜与件との関連付けなし＞、＜与件とはプロポーションのみを関連付ける＞、＜プロポーションに限定しない与件との関連付けがある＞という3 分類が存在し、それは遺伝子のパラメータの量に概ね従属して決定される。またプログラムによっ

て形態を記述することでこの事実を明示的に表現することができた。

PAVILIONS 関連付けあり

非プロポーション

＜Libeskind＞＜Siza＞＜SANAA＞＜藤本＞

プロポーション

＜Zaha＞

＜Nouvel＞

＜Koolhaas＞＜Eliasson＞＜Gehry＞＜HdM＞関連付けなし

＜伊東＞＜Niemeyer＞＜Zumthor＞ ﬁg.4-1

5. 結びにかえて

5. 結びにかえてコンピュータは犬以下の代物だ。さして賢くもない 1。しかし、きちんとしつけた上で適切に指示をすれば人間の役に立てることもできる。同時に、使う側の人間がしつけることもなく、適切な飼い方をしなければただの穀潰しであり、下手をすれば噛みついてくる危険さえある。そこで、我々は計算機をどう飼い慣らすか考えなくてはいけない。 MIT にアメリカ空軍が Computer-Aided Design(CAD) の研究を委託してから既に半世紀以上が過ぎている 2 にもかかわらず、建築学に関しては計算機を援用した設計に関する議論さえ厭う傾向が見受けられることにいささかの怒りを感じながら私はこの論文を書いていた。 Computer-Aided Drafting(CAD) はかなりの水準で普及している。2013 年現在、日本では売上上位の設計事務所も大手ゼネコンも作図に CAD を使わないところはないだろう。しかし、複雑な形態が操作できるようになったり、反復処理や複製が容易になったという以上に設計のあり方を変えるような取り組み、あるいは理論が提示されただろうか？せいぜい Grasshopper のようなアルゴリズムエディタによってプロセスを記述するモデリングがみられる程度の変化しか生み出していない。未だに計算機利用の建築設計に取り組んでいるというと「CG を描いているの？」というような反応が返ってくる。建築業界の大半は計算機に関して無知だ。無知なうえに否定的だ。知りもしないものを否定するのは愚の骨頂としか思えないが、厳然としてそういう大勢の中で建築の設計が行われていることを肌身で感じるシーンは少なくない。そうした現状の中で、本研究での取り組みがどのような意味を持つだろうか？この研究では生物の遺伝子を参考に建築の遺伝子を定義付け、実際に同一の環境に建設されたパビリオン群に対して遺伝子の分析を行った。これによって既往の建築の分類とは異なる指標で建築を評価しその性質を記述することができた。これは情報という切り口で、建築を捉えることが可能であるという事実にほかならない。このアプローチは建築がうねうねと曲線になること、あるいは形態的に複雑化することを推奨してはいない。また、何らかの形態的言語、様式の存在を否定するという狭量なマニフェストでもない。なんら形態的イデオロギーを含まない。あくまで、建築への視座として建築情報学という分野が存在していることを示しているのである。今後、建築情報学が確立した分野となる。その先駆的研究成果として本論文が存在している。

1 Greg Lynn の発言をふまえている。「コンピュータはデザイナーと同等に賢いわけではありません。その賢さと便利さは、事務所で飼ってる犬くらいのものです。」( 磯崎 (1999a)、83 頁 )。 2 補遺・CAD 技術の展開を参照。

5. 結びにかえて

本論文で示した内容に関してありうべき批判や疑問を幾つか取り上げて、今後の展望やこの研究の位置づけをもう少し明らかにしておく。 Q.1「構造や設備、材料といった要素を扱っていない時点で不完全であり、そんなものは遺伝子とは呼べない。この研究は無意味なのではないか？」 A.1「まず遺伝子という語を明確にすることで不毛なすれ違いを避けましょう。おそらくこの質問では遺伝子と言う言葉でひとつの個体が持つ遺伝情報の総体、すなわちゲノムのことを指していると推察されます。しかし、本研究ではゲノムの一部である形態に関連する遺伝子を取り出して研究を行っています。今後、形態以外の要素を全て情報として捉え、モデル化することによってこの研究は発展し建築のゲノムと呼べるものが取り扱われることになります。」 Q.2「Revit や Digital Project のような BIM ソフトで建築をモデリングしたデータは遺伝子とは呼べないのか？」 A.2「遺伝子には環境との応答性や連動性がありますが、BIM では明確に意識されていません。Q.1とも関連しますがゲノムを扱う際には BIM に連動性を付与した BIMObjectile のようなものを拡張概念として作ることになると思います。」 Q.3「形態のモデリング手法には多くの選択肢が存在するが、この研究で記述された以外の描画手法で同等の情報システムを記述した場合それを《遺伝子》ということはできないのか？」 A.3「生物の遺伝子に関してもそうですが、遺伝子とは情報であり、それはアルファベットや数字、あるいはリボ核酸で記述され、その表現は多様です。この研究では情報のシステムを記述するひとつの方法を示しており、《遺伝子》の表現のうちのひとつを描いているので、ほかの方法で記述する術もあります。遺伝子間の比較を行うためには一定の規約が必要となるでしょう。この研究の途中で processing ではなくrhino. Python に切り替えようとしたときがあったのですが、同じ言語でなければ比較できなくなるために processing で一貫しました。」 Q.4「研究の内容が形態の生成原理に限られている。これに対してインスタンスをどう評価するかという評価プロセスを内包しないと設計手法論に応用できないのではないか？」 A.5「現時点では本研究の成果を利用して設計をすぐに出来るわけではありません。しかし、本研究で定義付け作成した遺伝子に対して、評価プロセスと進化プロセスを追加することでアルゴリズミック・デザインに応用可能であると考えています。いわゆる遺

伝的アルゴリズムは形態に対して付与するマーカーを遺伝子と呼称している点、進化の際に淘汰のアルゴリズムと突然変異のみで自己組織化などいくつかの生物の特質をモデル化できていない点で生命科学の遺伝現象とは大きく異なり、擬似遺伝的アルゴリズムとでも言うべきものです ( それ自体にはなんの問題もないのですが )。一方、本研究で定義した遺伝子を利用することで真遺伝的アルゴリズムを考案することができると考えています。」

補遺・建築 CAD 技術の展開

6. 補遺・建築 CAD 技術の展開かつて Computer はマウスではなくライトペンと呼ばれる長さ 5-1/2”(139.7mm)、直径 3/8”(9.53mm) の道具で操作されていた。この道具は 1957 年に Ben Gurley によって発明され 1959 年にエレクトロニクス学会に発表されている (Hurst,p.45)。こうした道具が作られるようになって計算機は数値を返すのみならず、リアルタイムにオペレータと対話できるようになり始めた。CAD に関しては 1959 年に Computer-Aided Design に関する研究がアメリカ空軍の援助の下でマサチューセッツ工科大学 (M.I.T.) で研究が行われたことが始まりであると考えられる ( Yares(2013))。Douglas Ross、Steven Coons と Robert Mann によって各々この研究の理論的報告書が出された 1960 年とほぼ同時期の 1963 年に、同じくM.I.T.で Ivan Edward Sutherland によって sketchpad と呼ばれる GUI が開発された。これによってリアルタイムで計算機に対して人間が画像を介した入出力を行う可能性が開かれた。その後、立て続けに Timothy E. Johnson によって 3 次元の立体に拡張された sketchpad III が開発され、Lawrence G. Roberts によって隠線処理の技術がもたらされた。注意すべきことは Sutherland は CAD 研究のプロジェクトのメンバーではなく、sketchpad は GUI であって CAD として作られたのではないことである。Ross らの当初の CAD 構想は Drafting ではなくComputer-Aided Design であり、それは数値制御による工業生産を含んだ概念であった (Hurst,p.66)。Computer-Aided Drafting の意味では、1961 年に ITEK において Electronic Drafting Machine(EDM) として初の CAD ソフトが作られた。1964 年に EDM は Control Data 社に売却され CDC Digigraphics system へと発展した。その他の各々のソフトウェアの発表などは年表にまとめてある。アメリカでは Lockheed などの航空機産業がその後もインハウスで CAD ソフトを育て来たが、結果として社外秘となった曲面制御の技術などが共有されないといった事態となったことは注目に値する事実であろう (Farin(1991), 1 頁 )。このため、フランスの Renault や Citroën はアメリカとは独立に自動車の設計のために CAD を発展させることとなる。しかし、米仏間に全く技術的交流がなかったわけではなく、例えば 1975 年に Avions Marcel Dassault (AMD、現在の Dassault Systemes) が CADAM (Computer-Augmented Drafting and Manufacturing) のソフトウェア・ライセンスを Lockheed から購入した。その後 Dassault が独自に三次元拡張を施したものが後の CATIA である。さらにアメリカの Gehry Technologies が BIM 機能を追加し Digital Project が制作されている。

- 1958 - California Computer Products, Inc. (CalComp) が合併によって設立 - 1959 - Bezier 曲線の定式化 - 1960 - McAuto(McDonnell Douglas Automation Company) が設立される MIT の CAD プロジェクトが一定の成果をまとめる - 1963 - SketchPad が MIT で Ivan Sutherland によって開発される - 1964 - Ferguson "Multivariable Curve Interpolation." が公表される - 1968 - UNISURF がルノーで開発を開始 - 1972 - ADAM (Automated Drafting and Machining) が発表される - 1974 - SIGRAPH 会議が始まる。Gordon and Riesenfeld"Bernstein-Bézier." - 1975 - UNISURF がルノーで使用開始、Dassault が CADAM を導入 - 1979 - Stroustrup がプログラミング言語 C with Classes( 後の C++) の開発を開始 - 1981 - Catia V1,Romulus,Uni-Solid が発売 - 1982 - Blinn による blob 描画技術の公開、Autodesk 設立・AutoCAD R1 の発売 - 1983 - Alias Research の設立 - 1984 - Wavefront Technologies 設立、MicroStation 発売、 Rader CH = ArchiCAD1.0、発売 - 1985 - C++ の商用リリース - 1987 - ArchiCAD バーチャルビルディング (BIM) を発表、 TopCAD( 後の TopSolid) が発売 - 1990 - PowerAnimator( 後の Maya)、3D Studio DOS( 後の 3dsMax) が発表される - 1992 - McNeel 社と Applied Geometry(AG) が AGLib(NURBs のライブラリ ) を AutoCAD に統合する構想が立ち上がる - 1992 - AutoCAD 上のプラグインとしての Rhino のプロトタイプが出される - 1992 - McNeel と AG が AccuModel という名称で開発に合意 - 1992 - McNeel 社にインターンとして Michael Gibson が参加。彼がメッシュモデラー Sculptura をもたらす - 1993 - Sculptura 発売 - 1994 - Alias Research が AG を買収 - 1994 - Private showing of Rhino at SIGGRAPH - 1995 - Alias が Silicon Graphics を買収、Blender が発売 - 1997 - AccuModel for AutoCAD の開発が終了 - 1998 - Maya が発売 - 1998 - Rhino version 1.0 公開 - 1999 - Inventor が公開 - 2001 - Processing が公開 - 2005 - Maya が Autodesk に買収される - 2008 - Grasshopper 公開

source code

7. CODE /* Ryuyu Ishihara Computational Solution for Architectural Design zaha hadid //______________________________________________*/ import processing.dxf.*; boolean record; import org.processing.wiki.triangulate.*; import import import import import import import import import import import

toxi.math.conversion.*; toxi.geom.*; toxi.math.*; toxi.geom.mesh2d.*; toxi.util.datatypes.*; toxi.util.events.*; toxi.geom.mesh.subdiv.*; toxi.geom.mesh.*; toxi.math.waves.*; toxi.util.*; toxi.math.noise.*;

} //___________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ stroke(360); fill(0, 0, 300, 300); building.render();

}

//record end______________ if (record) { endRaw(); record = false; }

import toxi.processing.*;

//cam key_____________________________________________

import import import import

void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order // ortho(0, 2*environVecs.get(2).x, 0, 2*environVecs. get(2).y, 0, 2*environVecs.get(2).z); }

peasy.test.*; peasy.org.apache.commons.math.*; peasy.*; peasy.org.apache.commons.math.geometry.*;

//global variable PeasyCam cam; ToxiclibsSupport gfx; Plane gl; int columnNumS = 7; int columnNumN = 7; ArrayList<Integer> exon =new ArrayList(); Structure building; //_______________________________________________ void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(500, 500, 0), new Vec3D(0, 0, 1));//ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__ exon.add(1);//Number of point on Edge OA exon.add(4);//on Edge AB exon.add(1);//on Edge BC exon.add(3);//on Edge CO exon.add(4);//inside parallelogram exon.add(5);//column feet AB exon.add(5);//column feet CO String environData[] = loadStrings("environ.txt"); //column num vector int[] cNT = { 0, 1, 1, 2, 3, 3, 4 }; int[] cNB = { 0, 0, 1, 1, 2, 3, 4 }; int[] cST = { 1, 2, 2, 3, 3, 4, 5 }; int[] cSB = { 0, 0, 1, 2, 3, 3, 4 }; building = new Structure(environData, exon, cST, cSB, cNT, cNB); //(String[] _environData, ArrayList<Integer> _exon, int[] cST,int[] cSB,int[] cNT, int[] cNB)

void sideView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, PI, PI); // pitch, rotations are applied in that order } void axon() { cam.setRotations(-QUARTER_PI, 0, 0); cam.lookAt(0, 0, 0, 10000); }

yaw,

yaw, roll

void setPerpetiveView() { perspective(PI/3.0, (float)width/height, 1, 100000); } void setOrthoView() { ortho(0, building.environVecs.get(2).x, 0, building. environVecs.get(2).y, -100, 200*building.environVecs. get(2).z); } void keyPressed() { if (key == 't' || key == 'T') { topView(); } if (key == 'L' || key == 'l') { sideView(); } if (key == 'f' || key == 'F') { frontView(); } if (key == 'p' || key == 'P') { setPerpetiveView(); } if (key == 'o' || key == 'O') { setOrthoView(); } if (key == 'd' || key =='D') { record = true; } if (key == 'p'||key =='P') { saveFrame("line-######.jpg"); }

} // that is all cam key________________________________

class Structure { int numPt = 4;//number of point,first four vertexes of parallelogram int numRoofPt = 0; int numColumnPt = 0; ArrayList<PVector> pts = new ArrayList(); ArrayList<PVector> ptTris = new ArrayList(); ArrayList<PVector> ptTrisUp = new ArrayList(); ArrayList<PVector> vert1 = new ArrayList(); ArrayList<PVector> vert2 = new ArrayList(); ArrayList<PVector> vert3 = new ArrayList(); String[] environdata; ArrayList<Vec3D> environVecs = new ArrayList(); ArrayList<ArrayList<Vec3D>> defPoints = new ArrayList(); ArrayList<Integer> exon = new ArrayList(); int[] int[] int[] int[]

columnVectorSouthT;//index column head columnVectorSouthB;//index column foot columnVectorNorthT; columnVectorNorthB;

Structure(String[] _environData, ArrayList<Integer> _exon, int[] cST, int[] cSB, int[] cNT, int[] cNB) { environdata = _environData; exon = _exon; columnVectorNorthB = cNB; columnVectorNorthT = cNT; columnVectorSouthB = cSB; columnVectorSouthT = cST; /* for (int i=0;i<columnNumS;i++) { columnVectorSouthT[i] = int(random(exon.get(1))); columnVectorSouthB[i] = int(random(exon.get(5))); } columnVectorSouthT = sort(columnVectorSouthT); columnVectorSouthB = sort(columnVectorSouthB); for (int i=0;i<columnNumN;i++) { columnVectorNorthT[i] = int(random(exon.get(3))); columnVectorNorthB[i] = int(random(exon.get(6))); } columnVectorNorthT = sort(columnVectorNorthT); columnVectorNorthB = sort(columnVectorNorthB);*/ for (int i=0;i<exon.size();i++) { numPt = numPt + exon.get(i);//add number of points // println(numPt); } numColumnPt = exon.get(5)+exon.get(6); numRoofPt = numPt-numColumnPt; for (int i=0; i<numPt ;i++) { String data[] = split(environdata[i], ","); environVecs.add(new Vec3D(float(data[0]), float(data[1]), float(data[2]))); } // println(environVecs); baseCon(environVecs, environVecs.get(1), environVecs.get(3)); // println(environVecs); defPoints = sortPt(environVecs); // println(environVecs); ArrayList<Vec3D> roofPts = new ArrayList(); for (int i=0;i<numRoofPt;i++) { roofPts.add(environVecs.get(i)); } triangulation(roofPts); // // //

environVecs.get(1).y, environVecs.get(1).z); } if (columnVectorSouthT[i]>0&columnVectorSouthT[i ]<=exon.get(1)) { line(defPoints.get(5). get(columnVectorSouthB[i]).x, defPoints.get(5). get(columnVectorSouthB[i]).y, 0, defPoints.get(1). get(columnVectorSouthT[i]-1).x, defPoints.get(1). get(columnVectorSouthT[i]-1).y, defPoints.get(1). get(columnVectorSouthT[i]-1).z); } if (columnVectorSouthT[i]>exon.get(1)) { line(defPoints.get(5). get(columnVectorSouthB[i]).x, defPoints.get(5). get(columnVectorSouthB[i]).y, 0, environVecs.get(2).x, environVecs.get(2).y, environVecs.get(2).z); } } for (int i=0;i<columnNumN;i++) { println(columnVectorNorthT[i]); if (columnVectorNorthT[i]>3) { println("aaa"); line(defPoints.get(6). get(columnVectorNorthB[i]).x, defPoints.get(6). get(columnVectorNorthB[i]).y, 0, environVecs.get(3).x, environVecs.get(3).y, environVecs.get(3).z); } if (columnVectorNorthT[i]==0) { line(defPoints.get(6). get(columnVectorNorthB[i]).x, defPoints.get(6). get(columnVectorNorthB[i]).y, 0, environVecs.get(0).x, environVecs.get(0).y, environVecs.get(0).z); } if (columnVectorNorthT[i]>0&columnVectorNorthT[i ]<=exon.get(3)) { line(defPoints.get(6). get(columnVectorNorthB[i]).x, defPoints.get(6). get(columnVectorNorthB[i]).y, 0, defPoints.get(3). get(columnVectorNorthT[i]-1).x, defPoints.get(3). get(columnVectorNorthT[i]-1).y, defPoints.get(3). get(columnVectorNorthT[i]-1).z); } } } void triangulation(ArrayList<Vec3D> originals) { ArrayList triangles = new ArrayList(); for (Vec3D vec:originals) { pts.add(new PVector(vec.x, vec.y, 0)); } triangles = Triangulate.triangulate(pts);

for (Vec3D v:environVecs) { println(v); }

} void render() { renderTri(ptTrisUp, vert1, vert2, vert3); for (int i=0;i<numColumnPt;i++) { pushMatrix(); translate(environVecs.get(numRoofPt+i).x, environVecs.get(numRoofPt+i).y, 0); sphere(RADIUS); popMatrix(); } for (int i=0;i<columnNumS;i++) { if (columnVectorSouthT[i]==0) { line(defPoints.get(5). get(columnVectorSouthB[i]).x, defPoints.get(5). get(columnVectorSouthB[i]).y, 0, environVecs.get(1).x,

}

//rearrangement of points for (int i = 0; i < triangles.size(); i++) { Triangle t = (Triangle)triangles.get(i); ptTris.add(t.p1); ptTris.add(t.p2); ptTris.add(t.p3); } for (PVector p:ptTris) { PVector newp = new PVector(); newp.set(addedZ(p, originals)); ptTrisUp.add(newp); } for (int i = 0;i<triangles.size()-2/3 ;i++) { vert1.add(ptTrisUp.get(3*i)); vert2.add(ptTrisUp.get(3*i+1)); vert3.add(ptTrisUp.get(3*i+2)); } pts.clear();

source code

public void renderTri(ArrayList<PVector> vectors, ArrayList<PVector> vert1, ArrayList<PVector> vert2, ArrayList<PVector> vert3) { beginShape(TRIANGLES); for (int i = 0;i<(vectors.size())/3 ;i++) { PVector p1, p2, p3; p1=new PVector(); p1.set(vert1.get(i)); p2=new PVector(); p2.set(vert2.get(i)); p3=new PVector(); p3.set(vert3.get(i)); vertex(p1.x, p1.y, p1.z); vertex(p2.x, p2.y, p2.z); vertex(p3.x, p3.y, p3.z); } endShape(); }

}

//base vector convert void baseCon(ArrayList<Vec3D> givens, Vec3D newV1, Vec3D newV2) { Vec3D operateX, operateY; operateX = new Vec3D(); operateY = new Vec3D(); operateX.set(newV1.x, newV2.x, 0); operateY.set(newV1.y, newV2.y, 0); for (Vec3D given :givens) { if (givens.indexOf(given) != 0 && givens. indexOf(given) != 1 && givens.indexOf(given) != 3) { Vec3D newV = new Vec3D(given.dot(operateX), given.dot(operateY), given.z); givens.set(givens.indexOf(given), newV); } } } PVector addedZ(PVector pt, ArrayList<Vec3D> vs) { ArrayList<Vec3D> flatVs = new ArrayList(); PVector newp= new PVector();

}

for (Vec3D vec:vs) { Vec3D tmpv = new Vec3D(vec.x, vec.y, 0); flatVs.add(tmpv); } int id = flatVs.indexOf(new Vec3D(pt.x, pt.y, pt.z)); float newZ = vs.get(id).z; //println(vs.get(id)); newp.set(pt.x, pt.y, newZ); return newp;

//Vec3D PVector converter PVector t2p(Vec3D tV) { PVector pV = new PVector(); pV.set(tV.x, tV.y, tV.z); return pV; } ArrayList<ArrayList<Vec3D>> sortPt(ArrayList<Vec3D> vectors) { ArrayList<ArrayList<Vec3D>> ptList = new ArrayList();//temporary list to sort points int count = 0; float X1; float Y1; float Y2; float m; ArrayList<Vec3D> newEnVec = new ArrayList<Vec3D>(); X1 = vectors.get(2).x; Y1 = vectors.get(2).y; Y2 = vectors.get(1).y; m = (Y1-Y2)/X1; for (int j = 0; j<exon.size();j++) { ptList.add(new ArrayList()); for (int i= 0; i<exon.get(j) ;i++ ) { ptList.get(j).add(vectors.get(i+count+4)); } ptList.set(j,sortByX(ptList.get(j))); count = count + exon.get(j);

}

//points on OA should have Xcomponent of 0 for (Vec3D vec:ptList.get(0)) { vec.setComponent(X, 0); } //points on AB should have Y = m*X+C for (Vec3D vec:ptList.get(1)) { vec.setComponent(Y, m*vec.x+Y2); } for (Vec3D vec:ptList.get(5)) { vec.setComponent(Y, m*vec.x+Y2); } //points on BC should have Xcomponent of X1 for (Vec3D vec:ptList.get(2)) { vec.setComponent(X, X1); } //points on CO should have Xcomponent of 0 for (Vec3D vec:ptList.get(3)) { vec.setComponent(Y, m*vec.x); } for (Vec3D vec:ptList.get(6)) { vec.setComponent(Y, m*vec.x); } //replace all vectors for (int i=0;i<4;i++) { newEnVec.add(vectors.get(i)); } for (int i=0;i<exon.size();i++) { for (Vec3D vec:ptList.get(i)) { newEnVec.add(vec); } } vectors.clear(); vectors.addAll(newEnVec); return ptList;

//sort points by their X coordinates ArrayList sortByX(ArrayList<Vec3D> originals) { ArrayList<Vec3D> obtain= new ArrayList<Vec3D>(); // println(originals); float[] originalX=new float[originals.size()]; for (int i=0;i<originals.size();i++) { originalX[i] = originals.get(i).x; } ArrayList<Float> originalXList = new ArrayList(); for (float x:originalX) { originalXList.add(x); } // println(originalXList); float[] sortedX = sort(originalX); // println(sortedX); for (int i=0;i<originals.size();i++) { int id = originalXList.indexOf(sortedX[i]); obtain.add(originals.get(id)); } }

return obtain;

/* Ryuyu Ishihara Computational Solution for Architectural Design Libeskind2.0 //_________________________________________________*/ import processing.dxf.*; boolean record; import traer.physics.*; import import import import import import import import import import import import

import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport gfx; Plane gl; int numberOfTurn=6; Vec3D[] environ; Turn[] turn = new Turn[numberOfTurn]; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1));// ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__ String lines[] = loadStrings("environ.txt"); for (int j=0; j<numberOfTurn;j++) { environ = new Vec3D[8]; for (int i=0+j*8; i<8+j*8; i++) { String data[] = split(lines[i], ","); //println(data); environ[i-j*8]=new Vec3D(float(data[0]), float(data[1]), float(data[2])); } turn[j] = new Turn(environ); } // println(turn); } //____________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl,20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__

}

stroke(0, 0, 300); fill(200, 200, 200); for (int j=0;j<numberOfTurn;j++) { turn[j].render(); println(turn[j] ); } //record end______________ if (record) { endRaw(); record = false; }

//cam key____________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order } void leftView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, rotations are applied in } void backView() { cam.setRotations(PI/2, rotations are applied in }

PI, PI); // pitch, that order 0, PI); // pitch, that order

yaw,

yaw, roll

void setPerpetiveView() { perspective(PI/3.0, (float)width/height, 1, 100000); } void setOrthoView() { ortho(0, width*2, 0, height*2, -100, 10000); } void keyPressed() { if (key == 't' || key == 'T') { topView(); } if (key == 'R' || key == 'r') { rightView(); } if (key == 'L' || key == 'l') { leftView(); } if (key == 'B' || key == 'b') { backView(); } if (key == 'f' || key == 'F') { frontView(); } if (key == 'p' || key == 'P') { setPerpetiveView(); } if (key == 'o' || key == 'O') { setOrthoView(); } if (key == 'd' || key =='D') { record = true; } if (key == 'p'||key =='P') { saveFrame("line-######.jpg"); }

} // that is all cam key______________________________

source code

class Turn { Vec3D[] environment = new Vec3D[8]; Vec3D[] vertPoints = new Vec3D[8]; Turn(Vec3D[] _e) { environment = _e; for (int i=0;i<6;i++) { vertPoints[i] =_e[i]; } //calculation for developable surface float s1, t1, s2, t2; s1 = _e[6].x; t1 = _e[6].y; s2 = _e[7].x; t2 = _e[7].y; Vec3D v1, v2, v3, v4; v1 = new Vec3D(vertPoints[4].sub(vertPoints[0])); v2 = new Vec3D(vertPoints[3].sub(vertPoints[0])); v3 = new Vec3D(vertPoints[5].sub(vertPoints[4])); vertPoints[7] = new Vec3D(vertPoints[0]. x+s2*v1.x+t2*v2.x, vertPoints[0].y+s2*v1.y+t2*v2.y, vertPoints[0].z+s2*v1.z+t2*v2.z); v4 = new Vec3D(vertPoints[7].sub(vertPoints[4])); vertPoints[6] = new Vec3D(vertPoints[4]. x+s1*v3.x+t1*v4.x, vertPoints[4].y+s1*v3.y+t1*v4.y, vertPoints[4].z+s1*v3.z+t1*v4.z); } void render() { /* for(Vec3D p:vertPoints){ pushMatrix(); translate(p.x,p.y,p.z); sphere(10); popMatrix();} pushMatrix(); translate(vertPoints[0].x,vertPoints[0]. y,vertPoints[0].z); sphere(RADIUS); popMatrix();*/ beginShape(); vertex(vertPoints[0].x, vertPoints[0].y, vertPoints[0].z); vertex(vertPoints[3].x, vertPoints[3].y, vertPoints[3].z); vertex(vertPoints[7].x, vertPoints[7].y, vertPoints[7].z); vertex(vertPoints[4].x, vertPoints[4].y, vertPoints[4].z); endShape(CLOSE); beginShape(); vertex(vertPoints[5].x, vertPoints[5].y, vertPoints[5].z); vertex(vertPoints[6].x, vertPoints[6].y, vertPoints[6].z); vertex(vertPoints[7].x, vertPoints[7].y, vertPoints[7].z); vertex(vertPoints[4].x, vertPoints[4].y, vertPoints[4].z); endShape(CLOSE); beginShape(); vertex(vertPoints[1].x, vertPoints[1].y, vertPoints[1].z); vertex(vertPoints[2].x, vertPoints[2].y, vertPoints[2].z); vertex(vertPoints[6].x, vertPoints[6].y, vertPoints[6].z); vertex(vertPoints[5].x, vertPoints[5].y, vertPoints[5].z); endShape(CLOSE); } }

/* Ryuyu Ishihara Computational Solution for Architectural Design ITO TOYO //________________________________________________*/ import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport gfx; Plane gl; float a = 800; float wallLn = .3;//define devision position between roof wall Vec3D[][] p; Plane[] cps = new Plane[4]; Generation[] gs; int gene=7; int reverseNum=2;//generation id for 1/2-1/3 exchange ArrayList<Vec3D> ePts1 = new ArrayList<Vec3D>(); ArrayList<Vec3D[]> addLine = new ArrayList<Vec3D[]>(); void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1));// ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__ p = new Vec3D[gene+1][]; p[0] = new Vec3D[4]; p[0][0] = new Vec3D(); p[0][1] = new Vec3D(a, 0, 0); p[0][2] = new Vec3D(a, a, 0); p[0][3] = new Vec3D(0, a, 0); cps[0] = new Plane(new Vec3D(), new Vec3D(0, -1, 0)); cps[1] = new Plane(new Vec3D(a, 0, 0), new Vec3D(1, 0, 0)); cps[2] = new Plane(new Vec3D(a, a, 0), new Vec3D(0, 1, 0)); cps[3] = new Plane(new Vec3D(0, a, 0), new Vec3D(-1, 0, 0)); // cps[4] = new Plane(new Vec3D(), new Vec3D(0, 1, 0)); // cps[5] = new Plane(new Vec3D(p[0][1]), new Vec3D(-1, 0, 0)); // cps[6] = new Plane(new Vec3D(p[0][2]), new Vec3D(0, -1, 0)); // cps[7] = new Plane(new Vec3D(p[0][3]), new Vec3D(1, 0, 0)); gs = new Generation[gene]; for (int i=0; i<(gene+1)-reverseNum ;i++) { Generation g = new Generation(p[i], false); gs[i] = g; p[i+1]=new Vec3D[4]; p[i+1] = g.getOffspring(); } // println(p); for (int i =(gene+1)-reverseNum-1 ;i<gene;i++) { Generation g = new Generation(p[i], true); gs[i] = g; // println(gs); p[i+1] = new Vec3D[4]; p[i+1] = g.getOffspring();

} //irregular lines Vec3D[] lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(-wallLn*a*.5, wallLn*a, 0); lnPts[1] = new Vec3D(-wallLn*a, (1-wallLn*.4)*a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(-wallLn*a*.8, a, 0); lnPts[1] = new Vec3D(-wallLn*a, (1-wallLn*.6)*a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(-wallLn*a*.2, wallLn*a, 0); lnPts[1] = new Vec3D(-wallLn*a, (wallLn*.7+.3)*a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(0, (1+wallLn*.6)*a, 0); lnPts[1] = new Vec3D(.9*(1-wallLn)*a, a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(0.2*(1-wallLn)*a, a, 0); lnPts[1] = new Vec3D(0.1*(1-wallLn)*a, (1+wallLn)*a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(0.5*(1-wallLn)*a, a, 0); lnPts[1] = new Vec3D(0.3*(1-wallLn)*a, (1+wallLn)*a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D(0.55*(1-wallLn)*a, a, 0); lnPts[1] = new Vec3D(0.6*(1-wallLn)*a, (1+wallLn)*a, 0); addLine.add(lnPts); lnPts = new Vec3D[2]; lnPts[0] = new Vec3D((1-wallLn)*a, (1+wallLn*.2)*a, 0); lnPts[1] = new Vec3D(.5*(1-wallLn)*a, (1+wallLn)*a, 0); addLine.add(lnPts); } //____________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 10000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ pushMatrix(); translate(0, 0, 300); //wall Line stroke(360); line(-wallLn*a, wallLn*a, 0, a, wallLn*a, 0); line((1-wallLn)*a, -0, 0, (1-wallLn)*a, (1+wallLn)*a, 0); line(-wallLn*a, wallLn*a, 0, -wallLn*a, a, 0); line(0, (1+wallLn)*a, 0, (1-wallLn)*a, (1+wallLn)*a, 0); line(0, a, 0, 0, (1+wallLn)*a, 0); line(-wallLn*a, a, 0, 0, a, 0); for (int k=0;k<gene;k++) { for (int i=0;i<4;i++) { stroke(360*k/gene, 360, 360); line(gs[k].ends[i].x, gs[k].ends[i].y, gs[k]. ends[i].z, gs[k].starts[i].x, gs[k].starts[i].y, gs[k].starts[i].z); stroke(0, 360, 360); pushMatrix(); translate(gs[k].getEnds()[i].x, gs[k].getEnds() [i].y, gs[k].getEnds()[i].z); sphere(2); popMatrix(); stroke(200, 360, 360); pushMatrix(); translate(gs[k].getStarts()[i].x, gs[k]. getStarts()[i].y, gs[k].getStarts()[i].z); sphere(2); popMatrix();

} } for (int i=0;i<3;i++) { line(p[0][i].x, p[0][i].y, p[0][i+1].x, p[0][i+1]. y); } line(p[0][0].x, p[0][0].y, p[0][3].x, p[0][3].y); stroke(0, 0, 0); for (Vec3D[] pts:addLine) { line(pts[0].x, pts[0].y, pts[1].x, pts[1].y); }

}

popMatrix(); //record end______________ if (record) { endRaw(); record = false; }

//cam key_____________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order } void leftView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, rotations are applied in } void backView() { cam.setRotations(PI/2, rotations are applied in }

PI, PI); // pitch, that order 0, PI); // pitch, that order

yaw,

yaw, roll

} // that is all cam key_______________________________

source code

public class Generation { Vec3D[] p; Vec3D[] q = new Vec3D[4]; Vec3D[] m = new Vec3D[4]; Ray3D[] l; Ray3D[] lMinus; Plane[] cplane; Vec3D[] offs; Vec3D[] ends; Vec3D[] starts; Generation(Vec3D[] _p, boolean reverse) { for (int i=0;i<3;i++) { q[i]=new Vec3D(2*_p[i].x/3+_p[i+1].x/3, 2*_p[i]. y/3+_p[i+1].y/3, 2*_p[i].z/3+_p[i+1].z/3); } q[3]=new Vec3D(2*_p[3].x/3+_p[0].x/3, 2*_p[3]. y/3+_p[0].y/3, 2*_p[3].z/3+_p[0].z/3); for (int i=0;i<3;i++) { m[i]=new Vec3D(_p[i].x/2+_p[i+1].x/2, _p[i]. y/2+_p[i+1].y/2, _p[i].z/2+_p[i+1].z/2); } m[3]=new Vec3D(_p[3].x/2+_p[0].x/2, _p[3].y/2+_ p[0].y/2, _p[3].z/2+_p[0].z/2); //till Generation[gene-2] l= new Ray3D[4]; for (int i=0;i<3;i++) { l[i] = new Ray3D(m[i], new Vec3D(q[i+1].x-m[i].x, q[i+1].y-m[i].y, 0)); } l[3] = new Ray3D(m[3], new Vec3D(q[0].x-m[3].x, q[0].y-m[3].y, 0)); lMinus = new Ray3D[4]; for (int i=0;i<3;i++) { lMinus[i] = new Ray3D(m[i], new Vec3D(-q[i+1]. x+m[i].x, -q[i+1].y+m[i].y, 0)); } lMinus[3] = new Ray3D(m[3], new Vec3D(-q[0]. x+m[3].x, -q[0].y+m[3].y, 0)); //Generation [gene-1] if (reverse) { l= new Ray3D[4]; for (int i=0;i<3;i++) { l[i] = new Ray3D(q[i], new Vec3D(m[i+1]. x-q[i].x, m[i+1].y-q[i].y, 0)); } l[3] = new Ray3D(q[3], new Vec3D(m[0].x-q[3].x, m[0].y-q[3].y, 0)); lMinus = new Ray3D[4]; for (int i=0;i<3;i++) { lMinus[i] = new Ray3D(q[i], new Vec3D(-m[i+1]. x+q[i].x, -m[i+1].y+q[i].y, 0)); } lMinus[3] = new Ray3D(q[3], new Vec3D(-m[0]. x+q[3].x, -m[0].y+q[3].y, 0)); } cplane = new Plane[4]; for (int i =0; i<4;i++) { cplane[i] = new Plane(m[i], l[i].getDirection(). getRotatedZ(-HALF_PI)); } if (reverse) { for (int i =0; i<4;i++) { cplane[i] = new Plane(q[i], l[i]. getDirection().getRotatedZ(-HALF_PI)); } } offs = new Vec3D[4]; offs[0] = new Vec3D(cplane[0]. getIntersectionWithRay(l[3])); for (int i=1;i<4;i++) { offs[i] = new Vec3D(cplane[i].getIntersectionWit hRay(l[i-1])); } //line extension ends = new Vec3D[4]; //ends0 if ((cps[0].getIntersectionWithRay(l[3])!=null)&&

(cps[0].getIntersectionWithRay(l[3]).x()>0)&&(cps[0]. getIntersectionWithRay(l[3]).x()<a)) { ends[0] = new Vec3D(cps[0]. getIntersectionWithRay(l[3])); } if ((cps[1].getIntersectionWithRay(l[3])!=null)&& (cps[1].getIntersectionWithRay(l[3]).y()>0)&&(cps[1]. getIntersectionWithRay(l[3]).y()<a)) { ends[0] = new Vec3D(cps[1]. getIntersectionWithRay(l[3])); } if ((cps[2].getIntersectionWithRay(l[3])!=null)) { if ((cps[2].getIntersectionWithRay(l[3]). x()>0)&&(cps[2].getIntersectionWithRay(l[3]).x()<(1wallLn)*a)) { Plane cp = new Plane(new Vec3D(a, (1+wallLn)*a, 0), new Vec3D(0, 1, 0)); ends[0] = new Vec3D(cp. getIntersectionWithRay(l[3])); null) {

if ( cps[3].getIntersectionWithRay(l[3]) !=

if ((cps[3].getIntersectionWithRay(l[3]). y()>a)&&(cps[3].getIntersectionWithRay(l[3]). y()<(1+wallLn)*a)) { ends[0] = new Vec3D(cps[3]. getIntersectionWithRay(l[3])); } } Plane cpl = new Plane(new Vec3D((1-wallLn)*a, a, 0), new Vec3D(0, 1, 0)); if (cpl.getIntersectionWithRay(l[3]) != null) { if ((cpl.getIntersectionWithRay(l[3]). y()>a)&&(cpl.getIntersectionWithRay(l[3]). y()>(1+wallLn)*a)) { ends[0] = new Vec3D(cpl. getIntersectionWithRay(l[3])); } } } if ((cps[2].getIntersectionWithRay(l[3]).x()>(1wallLn)*a)&&(cps[2].getIntersectionWithRay(l[3]). x()<a)) { ends[0] = new Vec3D(cps[2]. getIntersectionWithRay(l[3])); } } if ((cps[3].getIntersectionWithRay(l[3])!=null)) { if ((cps[3].getIntersectionWithRay(l[3]). y()>0)&&(cps[3].getIntersectionWithRay(l[3]). y()<wallLn*a)) { ends[0] = new Vec3D(cps[3]. getIntersectionWithRay(l[3])); } if ((cps[3].getIntersectionWithRay(l[3]). y()>wallLn*a)&&(cps[3].getIntersectionWithRay(l[3]). y()<a)) { Plane cp = new Plane(new Vec3D(-wallLn*a, 0, 0), new Vec3D(-1, 0, 0)); ends[0] = new Vec3D(cp. getIntersectionWithRay(l[3])); Plane cpl = new Plane(new Vec3D(0, wallLn*a, 0), new Vec3D(0, -1, 0)); if (cpl.getIntersectionWithRay(l[3]) != null) { if ((cpl.getIntersectionWithRay(l[3]).x()>wallLn*a)&&(cpl.getIntersectionWithRay(l[3]).x()<0)) { ends[0] = new Vec3D(cpl. getIntersectionWithRay(l[3])); } } if (cps[2].getIntersectionWithRay(l[3])!=null) { if ((cps[2].getIntersectionWithRay(l[3]). x()>-wallLn*a)&&(cps[2].getIntersectionWithRay(l[3]). x()<0)) { ends[0]=new Vec3D(cps[2]. getIntersectionWithRay(l[3])); } } } } for (int i=1;i<4;i++) { if ((cps[0].getIntersectionWithRay(l[i1])!=null)&&(cps[0].getIntersectionWithRay(l[i-1]).

x()>0)&&(cps[0].getIntersectionWithRay(l[i-1]).x()<a)) { ends[i] = new Vec3D(cps[0].getIntersectionWith Ray(l[i-1])); } if ((cps[1].getIntersectionWithRay(l[i1])!=null)&&(cps[1].getIntersectionWithRay(l[i-1]). y()>0)&&(cps[1].getIntersectionWithRay(l[i-1]).y()<a)) { ends[i] = new Vec3D(cps[1].getIntersectionWith Ray(l[i-1])); } if ((cps[2].getIntersectionWithRay(l[i1])!=null)) { if ((cps[2].getIntersectionWithRay(l[i-1]). x()>0)&&(cps[2].getIntersectionWithRay(l[i-1]).x()<(1wallLn)*a)) { Plane cp = new Plane(new Vec3D(a, (1+wallLn)*a, 0), new Vec3D(0, 1, 0)); ends[i] = new Vec3D(cp.getIntersectionWithRa y(l[i-1])); if (cps[3].getIntersectionWithRay(l[i1])!=null) { if ((cps[3].getIntersectionWithRay(l[i-1]). y()>a)&&(cps[3].getIntersectionWithRay(l[i-1]). y()<(1+wallLn)*a)) { ends[i] =new Vec3D(cps[3].getIntersectio nWithRay(l[i-1])); } } Plane cpl = new Plane(new Vec3D((1-wallLn)*a, a, 0), new Vec3D(0, 1, 0)); if (cpl.getIntersectionWithRay(l[i-1])!=null) { if ((cpl.getIntersectionWithRay(l[i-1]). y()>a)&&(cpl.getIntersectionWithRay(l[i-1]). y()<(1+wallLn)*a)) { ends[i-1] = new Vec3D(cpl.getIntersectio nWithRay(l[i-1])); } } } if ((cps[2].getIntersectionWithRay(l[i-1]). x()>(1-wallLn)*a)&&(cps[2]. getIntersectionWithRay(l[i-1]).x()<a)) { ends[i] = new Vec3D(cps[2].getIntersectionWi thRay(l[i-1])); } } if ((cps[3].getIntersectionWithRay(l[i1])!=null)) { if ((cps[3].getIntersectionWithRay(l[i-1]). y()>0)&&(cps[3].getIntersectionWithRay(l[i-1]). y()<(wallLn)*a)) { ends[i] = new Vec3D(cps[3].getIntersectionWi thRay(l[i-1])); } if ((cps[3].getIntersectionWithRay(l[i-1]). y()>(wallLn)*a)&&(cps[3]. getIntersectionWithRay(l[i-1]).y()<a)) { Plane cp = new Plane(new Vec3D(-wallLn*a, a, 0), new Vec3D(-1, 0, 0)); ends[i] = new Vec3D(cp.getIntersectionWithRa y(l[i-1])); Plane cpl = new Plane(new Vec3D(0, wallLn*a, 0), new Vec3D(0, -1, 0)); if (cpl.getIntersectionWithRay(l[i-1]) !=null) { if ((cpl.getIntersectionWithRay(l[i-1]). x()>-wallLn*a)&&(cpl.getIntersectionWithRay(l[i-1]). x()<0)) { ends[i] = new Vec3D(cpl.getIntersectionW ithRay(l[i-1])); } } if (cps[2].getIntersectionWithRay(l[i-1]) != null) { if ((cps[2]. getIntersectionWithRay(l[i-1]).x()>wallLn*a)&&(cps[2].getIntersectionWithRay(l[i-1]). x()<0)) { ends[i] = new Vec3D(cps[2].getIntersecti onWithRay(l[i-1]));

}

} //starts___________________________________ starts = new Vec3D[4]; //starts0 if ((cps[0].getIntersectionWithRay(lMinus[3])! =null)&&(cps[0].getIntersectionWithRay(lMinus[3]). x()>0)&&(cps[0].getIntersectionWithRay(lMinus[3]). x()<a)) { starts[0] = new Vec3D(cps[0].getIntersectionWith Ray(lMinus[3])); } if ((cps[1].getIntersectionWithRay(lMinus[3])! =null)&&(cps[1].getIntersectionWithRay(lMinus[3]). y()>0)&&(cps[1].getIntersectionWithRay(lMinus[3]). y()<a)) { starts[0] = new Vec3D(cps[1].getIntersectionWith Ray(lMinus[3])); } if ((cps[2].getIntersectionWithRay(lMinus[3])!=nu ll)) { if ((cps[2].getIntersectionWithRay(lMinus[3]). x()>0)&&(cps[2].getIntersectionWithRay(lMinus[3]). x()<(1-wallLn)*a)) { Plane cp = new Plane(new Vec3D(a, (1+wallLn)*a, 0), new Vec3D(0, 1, 0)); starts[0] = new Vec3D(cp.getIntersectionWithRa y(lMinus[3])); if (cps[3].getIntersectionWithRay(lMinus[3])!= null) { if ((cps[3].getIntersectionWithRay(lMin us[3]).y()>a)&&(cps[3].getIntersectionWithRay(lMin us[3]).y()>(1+wallLn)*a)) { starts[0] =new Vec3D(cps[3].getIntersectio nWithRay(lMinus[3])); } } Plane cpl = new Plane(new Vec3D((1-wallLn)*a, a, 0), new Vec3D(0, 1, 0)); if (cpl.getIntersectionWithRay(lMinus[3])!=nu ll) { if ((cpl.getIntersectionWithRay(lMinus[3]). y()>a)&&(cpl.getIntersectionWithRay(lMinus[3]). y()>(1+wallLn)*a)) { starts[0] = new Vec3D(cpl.getIntersectionW ithRay(lMinus[3])); } } } if ((cps[2].getIntersectionWithRay(lMinus[3]). x()>(1-wallLn)*a)&&(cps[2].getIntersectionWithRay(lMin us[3]).x()<a)) { starts[0] = new Vec3D(cps[2].getIntersectionWi thRay(lMinus[3])); } } if ((cps[3].getIntersectionWithRay(lMinus[3])!=nu ll)) {// if ((cps[3].getIntersectionWithRay(lMinus[3]). y()>0)&&(cps[3].getIntersectionWithRay(lMinus[3]). y()<wallLn*a)) { starts[0] = new Vec3D(cps[3].getIntersectionWi thRay(lMinus[3])); } if ((cps[3].getIntersectionWithRay(lMinus[3]). y()>wallLn*a)&&(cps[3].getIntersectionWithRay(lMin us[3]).y()<a)) { Plane cp = new Plane(new Vec3D(-wallLn*a, a, 0), new Vec3D(-1, 0, 0)); starts[0] = new Vec3D(cp.getIntersectionWithRa y(lMinus[3])); } } for (int i=1;i<4;i++) { if ((cps[0].getIntersectionWithRay(lMinus[i1])!=null)&&(cps[0].getIntersectionWithRay(lMinus [i-1]).x()>0)&&(cps[0].getIntersectionWithRay(lMinus [i-1]).x()<a)) {

source code

starts[i] = new Vec3D(cps[0].getIntersectionWi thRay(lMinus[i-1])); } if ((cps[1].getIntersectionWithRay(lMinus[i1])!=null)&&(cps[1].getIntersectionWithRay(lMinus [i-1]).y()>0)&&(cps[1].getIntersectionWithRay(lMinus [i-1]).y()<a)) { starts[i] = new Vec3D(cps[1].getIntersectionWi thRay(lMinus[i-1])); } if ((cps[2].getIntersectionWithRay(lMinus[i1])!=null)) {// if ((cps[2].getIntersectionWithRay(lMinus [i-1]).x()>0)&&(cps[2].getIntersectionWithRay(lMinus [i-1]).x()<(1-wallLn)*a)) { Plane cp = new Plane(new Vec3D(a, (1+wallLn)*a, 0), new Vec3D(0, 1, 0)); starts[i] = new Vec3D(cp.getIntersectionWith Ray(lMinus[i-1])); if (cps[3].getIntersectionWithRay(lMinus[i1])!=null) { if ((cps[3].getIntersectionWithRay(lMinus [i-1]).y()>a)&&(cps[3].getIntersectionWithRay(lMinus [i-1]).y()<(1+wallLn)*a)) { starts[i] = new Vec3D(cps[3].getIntersec tionWithRay(lMinus[i-1])); } } Plane cpl = new Plane(new Vec3D((1-wallLn)*a, a, 0), new Vec3D(1, 0, 0)); if (cpl.getIntersectionWithRay(lMinus[i-1]) !=null) { if ((cpl.getIntersectionWithRay(lMinus [i-1]).y()>a)&&(cpl.getIntersectionWithRay(lMinus [i-1]).y()<(1+wallLn)*a)) {//) starts[i] = new Vec3D(cpl.getIntersectio nWithRay(lMinus[i-1])); } } } if ((cps[2].getIntersectionWithRay(lMinus [i-1]).x()>(1-wallLn)*a)&&(cps[2].getIntersectionWithR ay(lMinus[i-1]).x()<a)) { starts[i] = new Vec3D(cps[2].getIntersection WithRay(lMinus[i-1])); } } if ((cps[3].getIntersectionWithRay(lMinus[i1])!=null)) {// if ((cps[3].getIntersectionWithRay(lMinus [i-1]).y()>0)&&(cps[3].getIntersectionWithRay(lMinus [i-1]).y()<wallLn*a)) { starts[i] = new Vec3D(cps[3].getIntersection WithRay(lMinus[i-1])); } if ((cps[3].getIntersectionWithRay(lMinus [i-1]).y()>wallLn*a)&&(cps[3].getIntersectionWithRay(l Minus[i-1]).y()<a)) { Plane cp = new Plane(new Vec3D(-wallLn*a, a, 0), new Vec3D(-1, 0, 0)); starts[i] = new Vec3D(cp.getIntersectionWith Ray(lMinus[i-1])); Plane cpl = new Plane(new Vec3D(0, wallLn*a, 0), new Vec3D(0, -1, 0)); if (cpl.getIntersectionWithRay(lMinus[i-1]) !=null) { if ((cpl.getIntersectionWithRay(lMinus [i-1]).x()>-wallLn*a)&&(cpl.getIntersectionWithRay(lMi nus[i-1]).x()<0)) { starts[i] = new Vec3D(cpl.getIntersectio nWithRay(lMinus[i-1])); } } if (cps[2].getIntersectionWithRay(lMinus [i-1]) != null) { if ((cps[2].getIntersectionWithRay(lMinus [i-1]).x()>-wallLn*a)&&(cps[2].getIntersectionWithRay( lMinus[i-1]).x()<0)) { starts[i] = new Vec3D(cps[2].getIntersec tionWithRay(lMinus[i-1])); } } }

}

} Vec3D[] getOffspring() { return this.offs; } Vec3D[] getEnds() { return this.ends; } Vec3D[] getStarts() { return this.starts; } Ray3D[] getRay() { return this.l; }

/* Ryuyu Ishihara Computational Solution for Architectural Design

stairL=250.0; landingL =200.0; dansu=20; rampW = 150.0; chiri=30.0; rampL1 = 1050.0; rampL2 = 2000.0; rampTheta = HALF_PI/9; redWallPos = 0.3; railingH = 110; cat = -0.13;

Oscar Niemeyer //_________________________________________________*/ import traer.physics.*; import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import import import import

peasy.test.*; peasy.org.apache.commons.math.*; peasy.*; peasy.org.apache.commons.math.geometry.*;

ArrayList<Vec3D> points; PeasyCam cam; ToxiclibsSupport gfx; Plane gl; float SPRING_STRENGTH = 0.2; float SPRING_DAMPING = 0.1; float h1, h2, xp1, xp2; Vec3D floorDim; float floorAlt; Vec3D baseDim; float baseAlt; float baseShift; float thickness; float stairW; float stairL; float landingL; int dansu; float rampW; float chiri; float rampL1, rampL2; float rampTheta; float redWallPos; float railingH; float cat; Structure struct; //____________________________________________________ void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //__ gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1)); h1 = 400.0; h2 = 650.0; xp1 = .32; xp2 = .68; floorDim = new Vec3D(2500.0, 1000.0, 70.0);//floor X-width Y-depth Z-height floorAlt = 200.0;//floor upper face height baseDim = new Vec3D(900.0, 700.0, 300.0-.1);//z-.1 for artifact adjustment baseAlt = 50.0; baseShift = 50.0; thickness = 40.0; stairW = 200.0;

}

struct = new Structure( floorDim, floorAlt, baseDim, baseAlt, baseShift, xp1*floorDim.x, xp2*floorDim.x, h1, h2, thickness, stairW, stairL, landingL, dansu, rampW, chiri, rampL1, rampL2, rampTheta, redWallPos, railingH);

//____________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 10000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ struct.render(); //record end______________ if (record) { endRaw(); record = false; } } //cam key____________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order }

yaw,

void leftView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, PI, PI); // pitch, rotations are applied in that order }

yaw,

yaw, roll

void setPerpetiveView() { perspective(PI/3.0, (float)width/height, 1, 100000); } void setOrthoView() { ortho(0, width*2, 0, height*2, -100, 1000); } void keyPressed()

source code

{

if (key == 't' || key == 'T') { topView(); } if (key == 'R' || key == 'r') { rightView(); } if (key == 'L' || key == 'l') { leftView(); } if (key == 'f' || key == 'F') { frontView(); } if (key == 'p' || key == 'P') { setPerpetiveView(); } if (key == 'o' || key == 'O') { setOrthoView(); } if (key == 'd' || key =='D') { record = true; } if (key == 'p'||key =='P') { saveFrame("line-######.jpg"); }

} // that is all cam key______________________________

public class Membrane { //member ParticleSystem physics; float x1; float x2; float floorAlt; Particle[][] particles; int gridSize = 10; float cat; //constructor__________________________________ Membrane(float _x1, float _x2, float _h1, float _h2, Vec3D _floorDim, float _floorAlt, float cat) { this.x1= _x1; this.x2= _x2; this.floorAlt= _floorAlt; physics = new ParticleSystem(0, 0, cat, 0.2); particles = new Particle[gridSize][gridSize]; float gridStepX = (_x2-_x1) / (gridSize-1); float gridStepY = (float) (floorDim.y / (gridSize-1)); for (int i = 0; i < gridSize; i++) { for (int j = 0; j < gridSize; j++) { particles[i][j] = physics.makeParticle(0.2, j * gridStepX + _x1, i * gridStepY, _floorAlt+_ h1+j*gridStepX*( (_h2-_h1) / (_x2-_x1) ) ); if (j > 0) { physics.makeSpring(particles[i][j - 1], particles[i][j], SPRING_STRENGTH, SPRING_DAMPING, gridStepX); } } } for (int j = 0; j < gridSize; j++) { for (int i = 1; i < gridSize; i++) { physics.makeSpring(particles[i - 1][j], particles[i][j], SPRING_STRENGTH, SPRING_DAMPING, gridStepY); } } for (int j = 0;j<gridSize;j++) { particles[j][0].makeFixed(); particles[j][gridSize-1].makeFixed(); } } void render() { physics.tick(); // stroke(320, 0, 360); fill(0, 0, 360, 300); noStroke(); for (int i = 0; i < gridSize-1; i++) { beginShape(QUAD_STRIP); curveVertex(particles[0][i].position().x(), particles[0][i].position().y(), particles[0][i]. position().z()); curveVertex(particles[0][i+1].position().x(), particles[0][i+1].position().y(), particles[0][i+1]. position().z()); for (int j = 0; j < gridSize; j++) { curveVertex(particles[j][i].position().x(), particles[j][i].position().y(), particles[j][i]. position().z()); curveVertex(particles[j][i+1].position().x(), particles[j][i+1].position().y(), particles[j][i+1]. position().z()); } curveVertex(particles[gridSize - 1][i]. position().x(), particles[gridSize - 1][i].position(). y(), particles[gridSize-1][i].position().z()); curveVertex(particles[gridSize - 1][i+1]. position().x(), particles[gridSize - 1][i+1]. position().y(), particles[gridSize-1][i+1].position(). z()); endShape(); } //wallred fill(0, 360, 360); noStroke(); beginShape(); vertex(x1, 0, floorAlt);

vertex(particles[0][0].position().x(), particles[0][0].position().y(), particles[0][0]. position().z()); for (int i=0;i<gridSize;i++) { vertex(particles[0][i].position().x(), particles[0][i].position().y(), particles[0][i]. position().z()); } vertex(particles[0][gridSize-1].position().x(), particles[0][gridSize-1].position().y(), particles[0] [gridSize-1].position().z()); vertex(x2, 0, floorAlt); endShape(CLOSE); noFill(); } }

public class Structure { Vec3D floorDim= new Vec3D(); float floorAlt; Vec3D baseDim; float baseAlt; float baseShift; Vec3D[] floorPts = new Vec3D[4]; Vec3D[] roofPts = new Vec3D[4]; float h1; float h2; float x1; float x2; float w; float h; float l; float d; float stairWidth; float stairLength; float landingLength; int numStep; float rampWidth; float chiri; float rampL1; float rampL2; float rampTheta; float redWallPos; float railingH; Vec3D corner; Membrane roof; ZAxisCylinder mado; Vec3D madoPos; float wallAngle; float madoSize; float madoHfactor;

Structure( Vec3D _floorDim, float _floorAlt, Vec3D _baseDim, float _baseAlt, float _baseShift, float _x1, float _x2, float _h1, float _h2, float _thickness, float _stairWidth, float _stairLength, float _landingLength, int _numStep, float _rampWidth, float _chiri, float _rampL1, float _rampL2, float _rampTheta, float _redWallPos, float _railingH ) { w = _floorDim.x; h = _floorDim.y; l = _floorDim.z; this.floorDim = _floorDim; this.floorAlt = _floorAlt; this.baseDim = _baseDim; this.baseAlt = _baseAlt; this.baseShift = _baseShift; this.floorPts[0] = new Vec3D(0, 0, floorAlt); this.floorPts[1] = new Vec3D(0, h, floorAlt); this.floorPts[2] = new Vec3D(w, h, floorAlt); this.floorPts[3] = new Vec3D(w, 0, floorAlt); this.roofPts[0] = new Vec3D(_x1, 0, floorAlt h1); this.roofPts[1] = new Vec3D(_x1, h, floorAlt h1); this.roofPts[2] = new Vec3D(_x2, h, floorAlt h2); this.roofPts[3] = new Vec3D(_x2, 0, floorAlt h2); this.x1 = _x1; this.x2 = _x2; this.h1 = _h1;

+ _ + _ + _ + _

source code

this.h2 = _h2; this.d = _thickness; this.stairWidth = _stairWidth; this.stairLength =_stairLength; this.landingLength = _landingLength; this.numStep = _numStep; this.rampWidth=_rampWidth; this.chiri = _chiri; this.rampL1 = _rampL1; this.rampL2 = _rampL2; this.rampTheta = _rampTheta; this.corner = new Vec3D(x1+rampL1, h+chiri+rampWidth, floorAlt*(rampL2/(rampL1+rampL2))); this.redWallPos = _redWallPos; this.railingH = _railingH; roof = new Membrane(x1, x2, h1, h2, floorDim, floorAlt, cat); madoPos = new Vec3D((floorPts[2].x()+floorPts[3]. x())/2, (floorPts[2].y()+floorPts[3].y())/2, (floorPts[2].z()+floorPts[3].z())/2 ); Vec3D tmp = new Vec3D(roofPts[2].x()-floorPts[2]. x(), roofPts[2].y()-floorPts[2].y(), roofPts[2].z()floorPts[2].z()); madoHfactor = .3; madoPos.addSelf(madoHfactor*tmp.x(), madoHfactor*tmp.y(), madoHfactor*tmp.z()); madoSize = 200; mado = new ZAxisCylinder(new Vec3D(), madoSize, 1);

}

Vec3D hori = new Vec3D(-1, 0, 0); wallAngle = tmp.angleBetween(hori, true);

void render() { stroke(0, 0, 200); fill(0, 0, 360, 350); //floor Vec3D centerPt = new Vec3D(w/2, h/2, floorAlt-l/2); AABB floor = new AABB(centerPt, floorDim.scale(.5)); gfx.box(floor); //base centerPt.clear(); centerPt = new Vec3D(w/2, baseShift+baseDim.y/2, baseAlt); AABB base = new AABB(centerPt, baseDim.scale(.5). add(d/2, d/2, 0)); gfx.box(base); //column1 centerPt.clear(); centerPt = new Vec3D(x1, 4*h/5, floorAlt+h1/2); AABB column1 = new AABB(centerPt, new Vec3D(d/2, d/2, h1/2)); gfx.box(column1); //column1 centerPt.clear(); centerPt = new Vec3D(x2, 4*h/5, floorAlt+h2/2-20); AABB column2 = new AABB(centerPt, new Vec3D(d/2, d/2, h2/2)); gfx.box(column2); //stair ArrayList<Vec3D> sPts1 = new ArrayList(); ArrayList<Vec3D> sPts2 = new ArrayList(); for (int i =0;i<=numStep;i++) { sPts1.add(new Vec3D(x1-stairWidth, -landingLength-i*2*stairLength/numStep, floorAlti*2*floorAlt/numStep)); sPts1.add(new Vec3D(x1-stairWidth, -landingLength-(i+1)*2*stairLength/numStep, floorAlti*2*floorAlt/numStep)); sPts2.add(new Vec3D(x1, -landingLengthi*2*stairLength/numStep, floorAlt-i*2*floorAlt/ numStep)); sPts2.add(new Vec3D(x1, -landingLength(i+1)*2*stairLength/numStep, floorAlt-i*2*floorAlt/ numStep)); } beginShape(QUAD_STRIP);

Vec3D stairStrt = new Vec3D(x1-stairWidth, 0, floorAlt); Vec3D stairStrt2 = new Vec3D(x1, 0, floorAlt); vertex(stairStrt.x, stairStrt.y, stairStrt.z); vertex(stairStrt2.x, stairStrt2.y, stairStrt2.z); for (int i=0;i<=numStep;i++) { vertex(sPts1.get(i).x, sPts1.get(i).y, sPts1. get(i).z); vertex(sPts2.get(i).x, sPts2.get(i).y, sPts2. get(i).z); } endShape(CLOSE); //ramp beginShape(QUAD_STRIP); vertex(x1-stairWidth, h, floorAlt); vertex(x1-stairWidth, h+rampWidth+chiri, floorAlt); vertex(x1, h, floorAlt); vertex(x1, h+rampWidth+chiri, floorAlt); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(x1, h+chiri, floorAlt); vertex(x1, h+chiri+rampWidth, floorAlt); vertex(x1+rampL1, h+chiri, floorAlt*(rampL2/ (rampL1+rampL2)) ); vertex(x1+rampL1, h+chiri+rampWidth, floorAlt*(rampL2/(rampL1+rampL2)) ); endShape(CLOSE); beginShape(TRIANGLE_STRIP); vertex(x1+rampL1, h+chiri, floorAlt*(rampL2/ (rampL1+rampL2))); vertex(x1+rampL1+rampWidth*(cos(rampTheta)-tan( rampTheta)+sin(rampTheta)*tan(rampTheta)), h+chiri, floorAlt*(rampL2/(rampL1+rampL2)) ); vertex(x1+rampL1, h+chiri+rampWidth, floorAlt*(rampL2/(rampL1+rampL2)) ); vertex(x1+rampL1+rampWidth*(cos(rampTheta)+sin (rampTheta)), h+chiri+rampWidth*(1+cos(rampTheta)sin(rampTheta)), floorAlt*(rampL2/(rampL1+rampL2)) ); vertex(x1+rampL1+rampWidth*sin(rampTheta), h+ch iri+rampWidth*(1+cos(rampTheta)), floorAlt*(rampL2/ (rampL1+rampL2))); endShape(); beginShape(); vertex(x1+rampL1, h+chiri+rampWidth, floorAlt*(rampL2/(rampL1+rampL2))); vertex(x1+rampL1+rampWidth*sin(rampTheta), h+ch iri+rampWidth*(1+cos(rampTheta)), floorAlt*(rampL2/ (rampL1+rampL2))); vertex(x1+rampL1+rampWidth*sin(rampTheta)rampL2*cos(rampTheta), h+chiri+rampWidth*(1+cos(rampTh eta))+rampL2*sin(rampTheta), 0); vertex(x1+rampL1-rampL2*cos(rampTheta), h+chiri+ra mpWidth+rampL2*sin(rampTheta), 0); endShape(CLOSE); //wall 1 beginShape(); vertex(floorPts[0].x, vertex(floorPts[1].x, vertex(roofPts[1].x, vertex(roofPts[0].x, endShape(CLOSE);

floorPts[0].y, floorPts[1].y, roofPts[1].y, roofPts[0].y,

floorPts[0].z); floorPts[1].z); roofPts[1].z); roofPts[0].z);

//wall2 beginShape(); vertex(floorPts[3].x, floorPts[3].y, floorPts[3].z); vertex(floorPts[2].x, floorPts[2].y, floorPts[2].z); vertex(roofPts[2].x, roofPts[2].y, roofPts[2].z); vertex(roofPts[3].x, roofPts[3].y, roofPts[3].z); endShape(CLOSE); //window noStroke(); fill(200, 260, 300, 100); pushMatrix(); translate(madoPos.x, madoPos.y, madoPos.z); rotateY(wallAngle); gfx.cylinder(mado); popMatrix(); //wall3 redwall beginShape();

vertex(0, redWallPos*h, floorAlt); vertex(x1-stairWidth, redWallPos*h, (x1stairWidth)*h1/x1+floorAlt); vertex(x1-stairWidth, redWallPos*h, floorPts[0].z); endShape(CLOSE); //wall4 beginShape(); vertex(w, 0, floorAlt); vertex(w-(w-x2)*railingH/h2, 0, floorAlt+railingH); vertex(x2, 0, floorAlt+railingH); vertex(x2, 0, floorAlt); endShape(); //wall5 beginShape(); vertex(x1-stairWidth, 0, floorAlt+railingH); vertex(x1-stairWidth, 0, floorAlt); vertex(0, 0, floorAlt); vertex(x1*railingH/h1, 0, floorAlt+railingH); endShape(CLOSE); //wall6

}

//membraneroof roof.render();

Vec3D[] getRoofPts() { return roofPts; } float getH1() { return h1; } float getH2() { return h2; }

/* Ryuyu Ishihara //<>// Computational Solution for Architectural Design unit cm/pix alvaro siza e souto de moura //_______________________________________________*/ import traer.physics.*; import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import import import import

peasy.test.*; peasy.org.apache.commons.math.*; peasy.*; peasy.org.apache.commons.math.geometry.*;

PeasyCam cam; ToxiclibsSupport gfx; Plane gl; Roof roof; float H; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx = new ToxiclibsSupport(this); //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //__

}

gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1)); //DONOTTOUCH above this line in setup(){}____ roof = new Roof( 22, // number 18, // number .5, //cell size new PVector(0, 0, 0), new PVector(223, 2100, 0), new PVector(2513, 1940, 0), new PVector(2261, 630, 0), 3000, 9450, 1200, 3060, 18570, 22680, 2024, 13560, 1.2, //;gaussian parameter 2500, //;gaussian parameter 650, //gaussian parameter 1200, //;gaussian parameter 200, //;gaussian parameter 16, 17 );

//_____________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 10000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ roof.render(); //record end______________

source code

}

if (record) { endRaw(); record = false; }

//cam key_________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order }

yaw,

yaw, roll

void setPerpetiveView() { perspective(PI/3.0, (float)width/height, 1, 100000); } void setOrthoView() { ortho(0, width*2, 0, height*2, -100, 1000); } void keyPressed() { if (key == 't' || key == 'T') { topView(); } if (key == 'R' || key == 'r') { rightView(); } if (key == 'L' || key == 'l') { leftView(); } if (key == 'f' || key == 'F') { frontView(); } if (key == 'p' || key == 'P') { setPerpetiveView(); } if (key == 'o' || key == 'O') { setOrthoView(); } if (key == 'd' || key =='D') { record = true; } if (key == 'p'||key =='P') { saveFrame("line-######.jpg"); }

} // that is all cam key________________________________

class Leg { Vec2D[] v=new Vec2D[5]; float h; float ratio; float w1, w2; float d; Line2D l0, l1, ln1, ln2; Vec2D p1, p2; Leg(float _h,float _w1,float _w2) { h = _h; w1 = _w1; w2 = _w2; d=30; ratio=0.30; v[0] = new Vec2D(-w1, ratio*h); // println(v[0] ); v[1] = new Vec2D(-w1-w2, h); p1 =new Vec2D(v[0]); println(p1); p1 = p1.rotate(HALF_PI); println(p1);// println(v[0]); p1 = p1.getNormalizedTo(d); println(p1 ); Vec2D tmp0 = new Vec2D(v[0]); tmp0 = new Vec2D(p1.sub(tmp0. getNormalizedTo(1000000) )); println(p1); Vec2D tmp1 = new Vec2D(v[0]); tmp1 = new Vec2D(p1.add(tmp1. getNormalizedTo(1000000))); println(p1); ln1= new Line2D(tmp0, tmp1); p2 = new Vec2D(v[1].sub(v[0])); p2 = p2.rotate(HALF_PI); p2 = p2.getNormalizedTo(d); p2 =p2.add(v[0]); Vec2D dir = new Vec2D(v[1].sub(v[0])); dir = dir.getNormalizedTo(1000000); Vec2D tmp2 = new Vec2D(p2.sub(dir)); Vec2D tmp3 = new Vec2D(p2.add(dir)); ln2 = new Line2D(tmp2, tmp3); l0= new Line2D(v[0], v[1]); println(p1); v[3] = ln1.intersectLine(ln2).getPos(); println(v[3]); Line2D xjiku = new Line2D(new Vec2D(-10000, 0), new Vec2D(10000, 0)); Line2D glLn =new Line2D(new Vec2D(-10000, h), new Vec2D(100000, h)); v[2] = ln2.intersectLine(glLn).getPos(); v[4] = ln1.intersectLine(xjiku).getPos(); } void render() { pushMatrix(); translate(-v[4].x,0); beginShape(); vertex(0, 0, 0); for (Vec2D vec:v) { vertex(vec.x, 0, -vec.y); } endShape(CLOSE ); popMatrix(); } }

class Roof { ParticleSystem physics; Particle[][] particles; PVector[][] pts; int gridSizeX; int gridSizeY; float cell; float SPRING_STRENGTH = 0.1; float SPRING_DAMPING = 0.1; float annoteR=2; PVector[][] positions; PVector p1, p2, p3, p4; //PVector c1, c2, c3, c4; float r1, r2, r3, r4; float R1, R2, R3, R4; float ga, gbx, gcx, gby, gcy; Leg legs0[];// =new Leg[gridSizeY]; Leg legs1[];//= new Leg[gridSizeX]; Leg legs2[];// =new Leg[gridSizeY]; Leg legs3[];//= new Leg[gridSizeX]; float[] angles0; float[] angles1; float[] angles2; float[] angles3; int roadStart; int roadEnd; Roof( int _gridSizeX, int _gridSizeY, float _cell, PVector _p1, PVector _p2, PVector _p3, PVector _p4, float _r1, float _r2, float _r3, float _r4, float _R1, float _R2, float _R3, float _R4, float _ga, float _gbx, float _gcx, float _gby, float _gcy, int _roadStart, int _roadEnd ) { gridSizeX =_gridSizeX;//22; gridSizeY =_gridSizeY;//18; cell = _cell;//.5; p1 = _p1;//new PVector(0, 0, 0); p2 = _p2;//new PVector(0, 2100, 0); p3 = _p3;//new PVector(3500, 1940, 0); p4 = _p4;//new PVector(3060, 630, 0); r1 = _r1;//3000; r2 = _r2;//9450; r3 = _r3;//1200; r4 = _r4;//3060; R1 = _R1;//18570; R2 = _R2;//22680; R3 = _R3;//2024; R4 = _R4;//13560; ga = _ga;//1.2;gaussian parameter gbx = _gbx;//2500;gaussian parameter gcx = _gcx;//650;gaussian parameter gby = _gby;//1200;gaussian parameter gcy = _gcy;//200;gaussian parameter H = 200; roadStart = _roadStart; roadEnd = _roadEnd; pts = new PVector[gridSizeX][gridSizeY]; positions = new PVector[gridSizeX][gridSizeY]; physics = new ParticleSystem(0, 0, 0.5, 0.01); particles = new Particle[gridSizeX][gridSizeY]; for (int i =0;i<gridSizeX;i++) { for (int j =0 ;j<gridSizeY;j++) { particles[i][j] = physics.makeParticle(0.22, 0, 0, 0);

} } //X direction spring for (int i =0;i<gridSizeX-1;i++) { for (int j =0 ;j<gridSizeY;j++) { physics.makeSpring(particles[i][j], particles[i+1][j], SPRING_STRENGTH, SPRING_DAMPING, (1+(abs(gridSizeX/2-i)/gridSizeX))*cell); } } //Y direction spring for (int i =0;i<gridSizeX;i++) { for (int j =0 ;j<gridSizeY-1;j++) { physics.makeSpring(particles[i][j], particles[i][j+1], SPRING_STRENGTH, SPRING_DAMPING, (1+(abs(gridSizeY/2-i)/gridSizeY))*cell);// } } ptsCal(); for (int i = 0;i<gridSizeX;i++) { particles[i][0].position().set(pts[gridSizeX1-i][0].x, pts[gridSizeX-1-i][0].y, pts[gridSizeX-1-i] [0].z); } for (int i = 0;i<gridSizeX;i++) { particles[i][gridSizeY-1].position().set(pts[i] [gridSizeY-1].x, pts[i][gridSizeY-1].y, pts[i] [gridSizeY-1].z); } for (int j = 0;j<gridSizeY;j++) { particles[0][j].position().set(pts[0][j].x, pts[0][j].y, pts[0][j].z); } for (int j = 0;j<gridSizeY;j++) { particles[gridSizeX-1][j].position(). set(pts[gridSizeX-1][j].x, pts[gridSizeX-1][j].y, pts[gridSizeX-1][j].z); } for (int i = 0;i<gridSizeX;i++) { particles[i][0].makeFixed(); particles[i][gridSizeY-1].makeFixed(); } for (int j=0;j<gridSizeY;j++) { particles[0][j].makeFixed(); particles[gridSizeX-1][j].makeFixed(); } legs0 =new Leg[gridSizeY]; angles0 = new float[gridSizeY]; legs1= new Leg[gridSizeX]; angles1 = new float[gridSizeX]; legs2 =new Leg[gridSizeY]; angles2 = new float[gridSizeY]; legs3= new Leg[gridSizeX]; angles3 = new float[gridSizeX]; for (int i=0;i<gridSizeX;i++) { legs3[i] =new Leg(pts[i][0].z+H, 10, 100); legs1[i]=new Leg(pts[i][gridSizeY-1].z+H, 10, 100); } for (int j = 0;j<gridSizeY;j++) { legs0[j] = new Leg(pts[0][j].z+H, 0, 10); legs2[j] = new Leg(pts[gridSizeX-1][j].z+H, 10, 100); } } void render() { physics.tick(); pushMatrix(); translate(0, 0, H); //calculation for (int i =0;i<gridSizeX;i++) { positions[i][0] = new PVector(particles[i] [0].position().x(), particles[i][0].position().y(), particles[i][0].position().z()); positions[i][gridSizeY-1] = new PVector(particles[i][gridSizeY-1].position().x(),

source code

particles[i][gridSizeY-1].position().y(), particles[i] [gridSizeY-1].position().z()); } for (int j=0;j<gridSizeY;j++) { positions[0][j] = new PVector(particles[0] [j].position().x(), particles[0][j].position().y(), particles[0][j].position().z()); positions[gridSizeX-1][j] = new PVector(particles[gridSizeX-1][j].position(). x(), particles[gridSizeX-1][j].position().y(), particles[gridSizeX-1][j].position().z()); } for (int i=1;i<gridSizeX-1;i++) { for (int j =1;j<gridSizeY-1;j++) { positions[i][j] = new PVector(particles[i] [j].position().x(), particles[i][j]. position().y(), particles[i][j].position(). z()*(1+gaussian(particles[i][j].position().x(), particles[i][j].position().y(), ga, gbx, gcx, gby, gcy))); } } for (int i=0;i<gridSizeX;i++) { Vec2D v= new Vec2D(positions[gridSizeX-1-i][1]. x-positions[gridSizeX-1-i][0].x, positions[gridSizeX1-i][1].y-positions[gridSizeX-1-i][0].y); angles3[i] = v.angleBetween(new Vec2D(1, 0), true); v = new Vec2D(positions[i][gridSizeY-1]. x-positions[i][gridSizeY-2].x, positions[i] [gridSizeY-1].y-positions[i][gridSizeY-2].y); angles1[i] = v.angleBetween(new Vec2D(-1, 0), true); } for (int j=0;j<gridSizeY;j++) { Vec2D v= new Vec2D(positions[0][j].x-positions[1] [j].x, positions[0][j].y-positions[1][j].y); angles0[j] = v.angleBetween(new Vec2D(-1, 0), true); v = new Vec2D(positions[gridSizeX-1] [gridSizeY-1-j].x-positions[gridSizeX-2][gridSizeY1-j].x, positions[gridSizeX-1][gridSizeY-1-j]. y-positions[gridSizeX-2][gridSizeY-1-j].y); angles2[j] = v.angleBetween(new Vec2D(-1, 0), true); } //rendering for (int j=0;j<gridSizeY;j++) { for (int i=0;i<gridSizeX-2;i=i+2) { stroke(0, 0, 360); beginShape(); vertex(positions[i][j].x, positions[i][j].y, positions[i][j].z); vertex(positions[i+1][j].x, positions[i+1][j]. y, positions[i+1][j].z); vertex(positions[i+2][j].x, positions[i+2][j]. y, positions[i+2][j].z); vertex(positions[i+2][j].x, positions[i+2][j]. y, positions[i+2][j].z-20); vertex(positions[i][j].x, positions[i][j].y, positions[i][j].z-20); endShape(CLOSE); } beginShape(); vertex(positions[gridSizeX-2][j].x, positions[gridSizeX-2][j].y, positions[gridSizeX-2] [j].z); vertex(positions[gridSizeX-1][j].x, positions[gridSizeX-1][j].y, positions[gridSizeX-1] [j].z); vertex(positions[gridSizeX-1][j].x, positions[gridSizeX-1][j].y, positions[gridSizeX-1] [j].z-20); vertex(positions[gridSizeX-2][j].x, positions[gridSizeX-2][j].y, positions[gridSizeX-2] [j].z-20); endShape(); } for (int i=0;i<gridSizeX;i++) { for (int j=0;j<gridSizeY-2;j=j+2) { stroke(0, 0, 360); beginShape(); vertex(positions[i][j].x, positions[i][j].y,

positions[i][j].z); vertex(positions[i][j+1].x, positions[i][j+1]. y, positions[i][j+1].z); vertex(positions[i][j+2].x, positions[i][j+2]. y, positions[i][j+2].z); vertex(positions[i][j+2].x, positions[i][j+2]. y, positions[i][j+2].z-20); vertex(positions[i][j].x, positions[i][j].y, positions[i][j].z-20); endShape(CLOSE); } beginShape( ); vertex(positions[i][gridSizeY-2].x, positions[i] [gridSizeY-2].y, positions[i][gridSizeY-2].z); vertex(positions[i][gridSizeY-1].x, positions[i] [gridSizeY-1].y, positions[i][gridSizeY-1].z); vertex(positions[i][gridSizeY-1].x, positions[i] [gridSizeY-1].y, positions[i][gridSizeY-1].z-20); vertex(positions[i][gridSizeY-2].x, positions[i] [gridSizeY-2].y, positions[i][gridSizeY-2].z-20); endShape(); } for (int i=1;i<gridSizeX-1;i++) { if (i!=roadEnd) { pushMatrix(); translate(pts[gridSizeX-1-i][0].x, pts[gridSizeX-1-i][0].y, pts[gridSizeX-1-i][0].z); rotate(angles3[gridSizeX-1-i]); legs3[gridSizeX-1-i].render(); popMatrix(); } } for (int i=1;i<gridSizeX-1;i++) { if (i!=roadStart) { pushMatrix(); translate(pts[i][gridSizeY-1].x, pts[i] [gridSizeY-1].y, pts[i][gridSizeY-1].z); rotate(-angles1[i]); legs1[i].render(); popMatrix(); } } for (int j=1;j<gridSizeY-1;j++) { pushMatrix(); translate(pts[0][j].x, pts[0][j].y, pts[0][j].z); rotate(angles0[j]); legs0[j].render(); popMatrix(); pushMatrix(); translate(pts[gridSizeX-1][j].x, pts[gridSizeX-1][j].y, pts[gridSizeX-1][j].z); rotate(angles2[j]); legs2[j].render(); popMatrix(); } popMatrix(); } void ptsCal() { for (int i= 0 ;i<gridSizeX;i++) { pts[i][0] = nDivArc(r4, p4, p1, gridSizeX)[i]; } for (int i= 0 ;i<gridSizeX;i++) { pts[i][gridSizeY-1] = nDivArc(r2, p2, p3, gridSizeX)[i]; } for (int j= 0 ;j<gridSizeY;j++) { pts[gridSizeX-1][gridSizeY-1-j] = nDivArc(r3, p3, p4, gridSizeY)[j]; }

}

for (int j= 0 ;j<gridSizeY;j++) { pts[0][j] = nDivArc(r1, p1, p2, gridSizeY)[j]; }

PVector[] nDivArc(float r, PVector p1, PVector p2, int numPt) { Vec2D pV1 = new Vec2D(p1.x, p1.y); Vec2D pV2 = new Vec2D(p2.x, p2.y);

Line2D l = new Line2D(pV1, pV2); PVector[] pts = new PVector[numPt]; PVector[] pts2 = new PVector[numPt]; Vec2D mid = l.getMidPoint(); //println(mid); float tmpr = sqrt(sq(r) - sq(l.getLength()/2)); // println(tmpr); Vec2D dir = l.getNormal(); dir.normalize(); dir = dir.scale(tmpr); Vec2D center = mid.add(dir); for (int i= 0 ;i<numPt;i++) { PVector cp = new PVector(p1.x - center.x, p1.ycenter.y, 0); PVector cq = new PVector(p2.x - center.x, p2.ycenter.y, 0); float theta = PVector.angleBetween(cp, cq); cp.rotate(i*theta/(numPt-1)); pts[i] = new PVector(); pts[i].add(center.x, center.y, 0); pts[i].add(cp);

} //get Z Vec3D zc = new Vec3D((p1.x+p2.x)/2, (p1.y+p2.y)/2, -sqrt(sq(r2)-(sq(p1.x-p2.x)+sq(p1.y-p2.y))/4)); for (int i=0;i<numPt;i++) { PVector cp = new PVector(pV1.x-zc.x, pV1.y-zc.y, -zc.z); PVector cq = new PVector(pV2.x-zc.x, pV2.y-zc.y, -zc.z); float theta = PVector.angleBetween(cp, cq); println(theta); PVector normal = cq.cross(cp); Vec3D normalt = new Vec3D(normal.x, normal.y, normal.z); //println(normalt); normalt = normalt.getNormalized(); Vec3D cpt = new Vec3D(cp.x, cp.y, cp.z); //println(cpt); cpt = cpt.getRotatedAroundAxis(normalt, -theta*i/ (numPt-1)); //println(add); pts2[i] = new PVector(); pts2[i].add(zc.x, zc.y, zc.z); pts2[i].add(cpt.x, cpt.y, cpt.z); } for (int i=0;i<numPt;i++) { pts[i].add(0, 0, pts2[i].z); } return pts; } }

float gaussian(float x, float y,float a, float bx, float cx,float by,float cy) { float z = a*exp(-sq(x-bx)/(2*sq(cx)))*exp(-sq(y-by)/ (2*sq(cy))); return z; }

source code

/* Ryuyu Ishihara Computational Solution for Architectural Design 1 unit = 1cm = 10mm REM KOOLHAAS not OMA //_________________________________________________*/ import traer.physics.*; import processing.dxf.*; boolean record; import org.processing.wiki.triangulate.*; import import import import import import import import import import import

import toxi.processing.*; import import import import

peasy.test.*; peasy.org.apache.commons.math.*; peasy.*; peasy.org.apache.commons.math.geometry.*;

PeasyCam cam; ToxiclibsSupport gfx; Plane gl; Structure structure; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1)); //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(9999999); //â&#x2020;&#x2018;stable settings. DO NOT TOUCH__ structure = new Structure( 8, //int _numStep, 52f, // float _stepW, 15f, // float _stepH, 1900f, // float _X1, -1650f, // float _X2, 500f, // float _Y1, 1300/2f, // float _Y2, // float _Y3, 370f, // float _Z1, 620f, // float _Z2, 720f, // float _Z3, 870f, // float _Z4, new Vec3D(0, 0, 120), // Vec3D _c1, //floor center 1050f, // float _r1, //outer wall 925f, // float _r2, //inner wall 40, // int _num 1500);

} //____________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ structure.render(); //record end______________

}

if (record) { endRaw(); record = false; }

yaw,

yaw, roll

} // that is all cam key___________________________

public class Polarpoints { Vec3D pt; float r; Vec3D c; int num; float theta; Polarpoints(Vec3D _c, float _r, int _num) { this.r = _r; this.c = _c; this.num = _num; this.theta = 2*PI/num; } Vec3D getPt(int i) { pt = new Vec3D(r*cos(theta*i)+c.x,r*sin(theta*i)+c. y,c.z); return pt; } }

public class Structure { int numStep; float stepW; float stepH; float X1; float X2; float Y1; float Y2; float Y3; float Z1; //baloon bottom float Z2; //inner wall height float Z3; //exterior wall height float Z4; //cieling top Polarpoints ptExF, ptExR, ptInF, ptInR; Vec3D c1; //floor center Vec3D c2; //inner wall top Vec3D c3; //outer wall top float r1; //outer wall float r2; //inner wall int num; float r3; Vec3D[][] pt; float theta; Structure(int _numStep, float _stepW, float _stepH, float _X1, float _X2, float _Y1, float _Y2, //float _Y3, float _Z1, float _Z2, float _Z3, float _Z4, Vec3D _c1, //floor center float _r1, //outer wall float _r2, //inner wall int _num, float _r3 ) { this.numStep = _numStep; this.stepW = _stepW; this.stepH = _stepH; this.X1 = _X1; this.X2 = _X2; this.Y1 = _Y1; this.Y2 = _Y2; // this.Y3 = _Y3; this.Z1 = _Z1; this.Z2 = _Z2; this.Z3 = _Z3; this.Z4 = _Z4; this.c1 = _c1; this.ptExF = new Polarpoints(_c1, _r1, _num); this.c3 = _c1.add(0, 0, _Z3); this.ptExR = new Polarpoints(c3, _r1, _num); this.ptInF = new Polarpoints(_c1, _r2, _num); this.c2 = _c1.add(0, 0, _Z2); this.ptInR = new Polarpoints(c2, _r2, _num); this.num = _num; this.r1 = _r1; this.r2 = _r2; this.r3 = _r3; this.pt = new Vec3D[_num][_num]; float theta = (acos(r1/r3)+HALF_PI)/(num-1); float phi =2* PI/num; for (int i=0;i<num;i++) {//gyoukaku for (int j=0;j<num;j++) {//xyplane angle // pt[i][j] =new Vec3D((1+gaussian(i, .2, 5*num/6, num*.2))*(1-gaussian(i,j,0.01,num/4,num/2,nu m*.2,num*.2))*r3*cos(i*theta-acos(r1/r3))*cos(j*phi), (1+gaussian(i, .2, 5*num/6, .2*num))*(1-gaussian(i, j,0.01,num/4,num/2,num*.2,num*.2))*r3*cos(i*thetaacos(r1/r3))*sin(j*phi), r3*sin(i*theta-acos(r1/r3))); pt[i][j] =new Vec3D((1-gaussian(i,j,0.2,num/ 3,num/10,3*num/8,num/20))*(1+gaussian(i, .1, .6*num, 4*num/7))*r3*cos(i*theta-acos(r1/r3))*cos(j*phi), (1-gaussian(i,j,0.2,num/3,num/10,3*num/8,num/20))*( 1+gaussian(i, .1, .6*num, 4*num/7))*r3*cos(i*thetaacos(r1/r3))*sin(j*phi), r3*sin(i*theta-acos(r1/r3))); //1-gaussian(i,j,pos in height,width,pos in rotation,width)

source code

}

//hanging partition wall beginShape(QUAD_STRIP); vertex(Y2, Y2, Z4); vertex(Y2, Y2, Z1); vertex(-Y2, Y2, Z4); vertex(-Y2, Y2, Z1); vertex(-Y2, -Y2, Z4); vertex(-Y2, -Y2, Z1); vertex(Y2, -Y2, Z4); vertex(Y2, -Y2, Z1); vertex(Y2, Y2, Z4); vertex(Y2, Y2, Z1); endShape();

} void render() { fill(90, 200, 360, 300); noStroke(); //floor beginShape(); for (int i=0;i<num;i++) { vertex(ptExF.getPt(i).x, ptExF.getPt(i).y, ptExF.getPt(i).z); } endShape(CLOSE); //stage beginShape(QUAD); vertex(X1, Y1, c1.z); vertex(X1, -Y1, c1.z); vertex(X2, -Y1, c1.z); vertex(X2, Y1, c1.z); endShape(); stroke(0, 0, 360, 360); //exwall fill(300, 280, 360, 280); beginShape(QUAD_STRIP); for (int i=0;i<num;i++) { vertex(ptExR.getPt(i).x, ptExR.getPt(i).y, ptExR.getPt(i).z); vertex(ptExF.getPt(i).x, ptExF.getPt(i).y, ptExF.getPt(i).z); } vertex(ptExR.getPt(0).x, ptExR.getPt(0).y, ptExR. getPt(0).z); vertex(ptExF.getPt(0).x, ptExF.getPt(0).y, ptExF. getPt(0).z); endShape(); //intwall fill(200, 280, 360, 280); beginShape(QUAD_STRIP); for (int i=0;i<num;i++) { vertex(ptInR.getPt(i).x, ptInR.getPt(i).y, ptInR.getPt(i).z); vertex(ptInF.getPt(i).x, ptInF.getPt(i).y, ptInF.getPt(i).z); } vertex(ptInR.getPt(0).x, ptInR.getPt(0).y, ptInR. getPt(0).z); vertex(ptInF.getPt(0).x, ptInF.getPt(0).y, ptInF. getPt(0).z); endShape(); //stair ArrayList<Vec3D> sPts1 = new ArrayList(); ArrayList<Vec3D> sPts2 = new ArrayList(); for (int i =0;i<=numStep;i++) { sPts1.add(new Vec3D(X2-i*stepW, -Y1, c1.z-c1. z*2*i/numStep)); sPts1.add(new Vec3D(X2-(i+1)*stepW, -Y1, c1.z-c1.z*2*i/numStep)); sPts2.add(new Vec3D(X2-i*stepW, Y1, c1.z-c1. z*2*i/numStep)); sPts2.add(new Vec3D(X2-(i+1)*stepW, Y1, c1.z-c1. z*2*i/numStep)); } beginShape(QUAD_STRIP); for (int i=0;i<=numStep;i++) { vertex(sPts1.get(i).x, sPts1.get(i).y, sPts1. get(i).z); vertex(sPts2.get(i).x, sPts2.get(i).y, sPts2. get(i).z); } endShape(); //cieling //top beginShape(); vertex(Y2, Y2, Z4); vertex(-Y2, Y2, Z4); vertex(-Y2, -Y2, Z4); vertex(Y2, -Y2, Z4); endShape(CLOSE);

z);

//baloon pushMatrix(); translate(0, 0, c3.z+r3*sin(acos(r1/r3))); for (int i=0;i<num-1;i++) { fill(i*360/num, 360, 360, 250); beginShape(TRIANGLE_STRIP); for (int j=0;j<num;j++) { curveVertex(pt[i][j].x, pt[i][j].y, pt[i][j].

curveVertex(pt[i+1][j].x, pt[i+1][j].y, pt[i+1][j].z); } curveVertex(pt[i][0].x, pt[i][0].y, pt[i][0].z); curveVertex(pt[i+1][0].x, pt[i+1][0].y, pt[i+1] [0].z); endShape(); } popMatrix(); } } float gaussian(float x, float y, float a, float bx, float cx, float by, float cy) { float z = a*exp(-sq(x-bx)/(2*sq(cx)))*exp(-sq(y-by)/ (2*sq(cy))); return z; } float gaussian(float x, float a, float bx, float cx) { float z = a*exp(-sq(x-bx)/(2*sq(cx))); return z; }

100

/* Ryuyu Ishihara Computational Solution for Architectural Design Snohetta //___________________________________________*/ import traer.physics.*; import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import import import import

peasy.test.*; peasy.org.apache.commons.math.*; peasy.*; peasy.org.apache.commons.math.geometry.*;

PeasyCam cam; ToxiclibsSupport gfx; Plane gl; int strtId; int divr, divz; float b1, b2; float c1, c2; float r1; Vec3D zentrum1; float h; float cutoff; Structure building; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(5); cam.setMaximumDistance(99999999); //__ gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1)); //write your own below__ strtId = 0; divr = 40; b1 = 842; b2 = 780; c1 =3;//this value should be integer in order to tile with beauty c2 = -1407; r1 = 1038; cutoff = 0.13; zentrum1 = new Vec3D(0, 100, 9000); h = 345; building = new Structure(2, 100, strtId, divr, b1, c1*h, b2, c2, zentrum1, r1, h, cutoff, 200, 60, .3); //(int _tileScale, float _slopeEndH, int _strtId, int _divr, float _b1, float _c1, float _b2, float _c2, Vec3D _zentrum1, float _r, float _h, float _cutoff1, float _ rampW, float railW, float railHr) building.create(); } //______________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ building.render();

}

//record end______________ if (record) { endRaw(); record = false; }

//cam key_______________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order }

yaw,

yaw, roll

} // that is all cam key________________________________ _____________________

101

source code

public class Cone { int tileScale; int strtId; int divr; int divz; float a; float b; float c; float r; Vec3D apex; Vec3D zentrum; boolean up; float h; Vec3D[][] pts; Vec3D[] ramp; Vec3D[][] irregular; float cutoff; int cutOffNum; float rampW; float railHratio; float railW; Vec3D[] rail; Vec3D[] topVertex; Ray3D[] geneLines; Plane cutter; // float cutterH; Cone(int _tileScale, int _strtId, int _divr, Vec3D _ zentrum, Vec3D _apex, float _r, float _h, float _cutoff, float _rampW, float _railW, float _railHratio) { //all variable in relative coordinates other than zentrum this.tileScale = _tileScale; this.zentrum =_zentrum; this.strtId = _strtId; this.divr = _divr; this.apex = _apex; this.a = apex.x-zentrum.x(); this.b = apex.y-zentrum.y(); this.c = apex.z-zentrum.z(); this.r = _r; this.railW = _railW; this.railHratio = _railHratio; if (c>0) { this.up = true; } else { this.up = false; } this.h = _h;

}

ramp[divr] = getExtPt(rampW, -h, 0); } // cutOffNum = floor(divz*cutoff/abs(c)); rail= new Vec3D[divr+1]; for (int j=0;j<divr+1;j++) { if (up) { rail[j] = getExtPt(rampW+railW, j*h/(divr), -j*TWO_PI/divr); } else { rail[j] = getExtPt(rampW+railW, -j*h/(divr), j*TWO_PI/divr); } rail[j].addSelf(0, 0, railHratio*h); } geneLines = new Ray3D[divr]; for (int j=0;j<divr;j++) { geneLines[j] = new Ray3D(pts[0][j], new Vec3D(apts[0][j].x(), b-pts[0][j].y(), c-pts[0][j].z())); } if (up) { cutter = new Plane(new Vec3D(a*(1-cutoff), b*(1cutoff), c*(1-cutoff)), new Vec3D(.4, .2, 1)); } else { cutter = new Plane(new Vec3D(0, 0, c*(1cutoff)), new Vec3D(0, 0, -1)); } topVertex = new Vec3D[divr]; for (int j =0;j<divr;j++) { topVertex[j] = new Vec3D(); topVertex[j].set(cutter.getIntersectionWithRay(g eneLines[j]).x(), cutter.getIntersectionWithRay(geneL ines[j]).y(), cutter.getIntersectionWithRay(geneLines [j]).z()); }

this.divz = 1+ceil(tileScale*abs(c)/h); this.cutoff = _cutoff; this.rampW = _rampW;

void set() { pts = new Vec3D[divz][divr]; for (int j=0;j<divr;j++) { for (int i=0;i<divz;i++) { if (up) { pts[i][j] = divisionPts(divz-2, new Vec3D(a, b, c), getPt(j*h/(divr), -j*TWO_PI/divr))[i]; } else { pts[i][j] = divisionPts(divz-2, new Vec3D(a, b, c), getPt(-j*h/(divr), j*TWO_PI/divr))[i]; } } } ramp = new Vec3D[divr+1]; for (int j=0;j<divr;j++) { if (up) { ramp[j] = getExtPt(rampW, j*h/(divr), -j*TWO_ PI/divr); } else { ramp[j] = getExtPt(rampW, -j*h/(divr), j*TWO_ PI/divr); } } if (up) { ramp[divr] = getExtPt(rampW, h, 0); } else {

}

for (int i=0;i<divz;i++) { for (int j=0;j<divr;j++) { if (up) { if (topVertex[j].z<pts[i][j].z) { pts[i][j] = topVertex[j]; } } else { if (topVertex[j].z>pts[i][j].z) { pts[i][j] = topVertex[j]; } } } } for (int j=0;j<divr;j++) { println(pts[0][j]); }

void render() { stroke(0, 0, 360); for (int j=1; j<divr;j++) { fill(j*360/divr, 300, 360, 190); beginShape(TRIANGLE_STRIP); for (int i=0;i<divz ;i++) { vertex(pts[i][j-1].x(), pts[i][j-1].y(), pts[i][j-1].z()); vertex(pts[i][j].x(), pts[i][j].y(), pts[i][j]. z()); } endShape(); } //make it circular beginShape(TRIANGLE_STRIP); for (int i=tileScale;i<divz;i++) { vertex(pts[i-tileScale][divr-1].x(), pts[itileScale][divr-1].y(), pts[i-tileScale][divr-1].z()); vertex(pts[i][0].x(), pts[i][0].y(), pts[i][0]. z()); } vertex(topVertex[divr-1].x(), topVertex[divr-1]. y(), topVertex[divr-1].z()); endShape(); /*//rampsphere___________________________________

102

noStroke(); for (int j=0;j<divr;j++) { pushMatrix(); fill(j*360/20, 360, 360); if (up) { translate(getPt(j*h/divr, -j*TWO_PI/divr).x, getPt(j*h/divr, -j*TWO_PI/divr).y, getPt(j*h/divr, -j*TWO_PI/divr).z); } else { translate(getPt(-j*h/divr, j*TWO_PI/divr).x, getPt(-j*h/divr, j*TWO_PI/divr).y, getPt(-j*h/divr, j*TWO_PI/divr).z); } sphere(10); popMatrix(); }*/ //ramp____________________________________ stroke(0, 0, 360); fill(200, 260, 360, 200); beginShape(QUAD_STRIP); for (int j=0;j<divr;j++) { vertex(pts[0][j].x(), pts[0][j].y(), pts[0][j]. z()); vertex(ramp[j].x(), ramp[j].y(), ramp[j].z()); } vertex(pts[tileScale][0].x(), pts[tileScale][0]. y(), pts[tileScale][0].z()); vertex(ramp[divr].x(), ramp[divr].y(), ramp[divr]. z()); endShape(); //handrail beginShape(QUAD_STRIP); for (int j=0;j<divr+1;j++) { vertex(ramp[j].x(), ramp[j].y(), ramp[j].z()); vertex(ramp[j].x(), ramp[j].y(), ramp[j]. z()+railHratio*h); } endShape(); beginShape(QUAD_STRIP); for (int j=0;j<divr+1;j++) { vertex(ramp[j].x(), ramp[j].y(), ramp[j]. z()+railHratio*h); vertex(rail[j].x(), rail[j].y(), rail[j].z()); } endShape(); } //functions_______________________________________ Vec3D getPt(float t, float theta) { Vec3D pt = new Vec3D(); pt.set((1-t/c)*r*cos(-theta+TWO_PI*strtId/ divr+HALF_PI)+a*t/c+zentrum.x(), (1-t/c)*r*sin(theta+TWO_PI*strtId/divr+HALF_PI)+b*t/c+zentrum.y(), t+zentrum.z()); return pt; } Vec3D getExtPt(float w, float t, float theta) { Vec3D pt = new Vec3D(); pt.set(((1-t/c)*r+w)*cos(-theta+TWO_PI*strtId/ divr+HALF_PI)+a*t/c+zentrum.x(), ((1-t/c)*r+w)*sin(theta+TWO_PI*strtId/divr+HALF_PI)+b*t/c+zentrum.y(), t+zentrum.z()); return pt; } }

public class Structure { int tileScale; float baseH; int strtId; int divr; float b1; float c1; float b2; float c2; float r; float R; Vec3D apexUp; Vec3D apexDown; Vec3D zentrum1; Vec3D zentrum2; float h; float cutoff; float rampW; Cone cUp; Cone cDown; Vec3D[][] wallPts; Vec3D[][] irrWallPts; Vec3D[][] slope; float railW; float railHr; Vec3D[] curtainA; Vec3D[] curtainB; Vec3D[] curtainC; float cutRatio; // Vec3D[][] irregulars; Structure(int _tileScale, float _slopeEndH, int _ strtId, int _divr, float _b1, float _c1, float _b2, float _c2, Vec3D _zentrum1, float _r, float _h, float _cutoff1, float _rampW, float railW, float railHr) { this.tileScale = _tileScale; this.strtId = _strtId; this.divr = _divr; this.b1 = _b1; this.c1 = _c1; this.b2 = _b2; this.c2 = _c2; this.r = _r; this.apexUp = new Vec3D(0, _b1, _c1); this.apexDown = new Vec3D(); // this.zentrum1 = _zentrum1; this.zentrum2 = new Vec3D(); this.h = _h;//rampe ceiling height this.baseH = _h+_slopeEndH; this.cutRatio = _cutoff1; this.rampW = _rampW; this.railW = railW; this.railHr = railHr; } void create() { //int _strtId, int _divr, Vec3D _apex, Vec3D _ zentrum, float _r, float _h, float _cutoff, float _rampW cUp = new Cone(tileScale, 0, divr, new Vec3D(), apexUp, r, h, cutRatio, rampW, railW, railHr); cUp.set(); float s = b1*h/(2*c1)-r*(1-h/ (2*c1))+(h/2)*(b2+r+(b1-r)*(h/(2*c1)))/(c2+h/2); zentrum2.set(0, (1-strtId*h/ (divr*c2))*(r+s)/2+b2*strtId*h/(divr*c2), strtId*h/ divr); R = (1+strtId*h/(divr*c2))*(r-s)/2; apexDown.set(0, b2+(1-strtId*h/ (divr*c2))*(r+s)/2+b2*strtId*h/(divr*c2), c2+strtId*h/ divr); cDown = new Cone(tileScale, strtId, divr, zentrum2, apexDown, R, h, 1 - baseH/abs(c2+strtId*h/ divr), rampW, railW, railHr); cDown.set(); wallPts = new Vec3D[tileScale+1][divr/2]; for (int i=0; i<tileScale+1 ;i++) { wallPts[i][0]=divisionPts(tileScale-1, cUp. pts[tileScale][0], cDown.pts[0][0])[i]; for (int j=1;j<divr/2;j++) wallPts[i][j]=divisionPts(tileScale-1, cUp. pts[0][divr-j], cDown.pts[0][j])[i]; } irrWallPts = new Vec3D[4][4]; for (int i=0;i<4;i++) {

103

source code

irrWallPts[i][0]=divisionPts(2, cUp.pts[0][0], cDown.pts[tileScale][0])[i]; for (int j=1;j<4;j++) { irrWallPts[i][j]=divisionPts(2, cUp.pts[0][j], cDown.pts[0][divr-j])[i]; } } slope=new Vec3D[2][ceil(divr*(baseH-h)/h)]; for (int j=0;j<ceil(divr*(baseH-h)/h);j++ ) { slope[0][j] = new Vec3D(cDown.pts[tileScale] [0].x()+(2*PI*r/divr)*j, cDown.pts[tileScale] [0].y(), (ceil(divr*(baseH-h)/h)-1-j)*(baseH-h)/ ceil(divr*(baseH-h)/h-1)); slope[1][j] = new Vec3D(cDown.ramp[divr]. x()+(2*PI*r/divr)*j, cDown.ramp[divr]. y(), (ceil(divr*(baseH-h)/h)-1-j)*(baseH-h)/ ceil(divr*(baseH-h)/h-1)); } curtainA = new Vec3D[3*divr+1]; for (int j=1;j<divr+1;j++) { curtainA[3*(j-1)] = divisionPts(2, cDown. rail[divr-j], cDown.rail[divr-(j-1)])[0]; curtainA[3*(j-1)+1] = divisionPts(2, cDown. rail[divr-j], cDown.rail[divr-(j-1)])[1]; curtainA[3*(j-1)+2] = divisionPts(2, cDown. rail[divr-j], cDown.rail[divr-(j-1)])[2]; } curtainA[3*divr] = divisionPts(2, cDown.rail[0], cDown.rail[1])[3]; curtainB = new Vec3D[3*divr+1]; for (int j=1;j<divr+1;j++) { curtainB[3*(j-1)] = divisionPts(2, cUp.rail[j], cUp.rail[j-1])[0]; curtainB[3*(j-1)+1] = divisionPts(2, cUp. rail[j], cUp.rail[j-1])[1]; curtainB[3*(j-1)+2] = divisionPts(2, cUp. rail[j], cUp.rail[j-1])[2]; } curtainB[3*divr] = divisionPts(2, cUp.rail[divr], cUp.rail[divr-1])[3]; curtainC = new Vec3D[3*divr+1]; for (int j=1;j<divr+1;j++) { curtainC[3*(j-1)] = divisionPts(2, cUp.ramp[j]. add(0, 0, railHr*h), cUp.ramp[j-1].add(0, 0, railHr*h)) [0]; curtainC[3*(j-1)+1] = divisionPts(2, cUp. ramp[j].add(0, 0, railHr*h), cUp.ramp[j-1].add(0, 0, railHr*h))[1]; curtainC[3*(j-1)+2] = divisionPts(2, cUp. ramp[j].add(0, 0, railHr*h), cUp.ramp[j-1].add(0, 0, railHr*h))[2]; } curtainC[3*divr] = divisionPts(2, cUp.ramp[divr]. add(0, 0, railHr*h), cUp.ramp[divr-1].add(0, 0, railHr*h))[3]; } void render() { pushMatrix(); translate(0, 0, baseH); cUp.render(); cDown.render(); noStroke(); /* for (int j=1;j<divr;j++) { pushMatrix(); translate(cUp.topVertex[j-1].x(), cUp. topVertex[j-1].y(), cUp.topVertex[j-1].z()); sphere(3); popMatrix(); } for (int j=0;j<divr;j++) { pushMatrix(); translate(cDown.topVertex[j].x(), cDown. topVertex[j].y(), cDown.topVertex[j].z()); sphere(10); popMatrix(); }*/ //wall between cones for (int j=1;j<divr/2;j++) {

beginShape(TRIANGLE_STRIP); for (int i=0;i<tileScale+1;i++) { vertex(wallPts[i][j].x(), wallPts[i][j].y(), wallPts[i][j].z()); vertex(wallPts[i][j-1].x(), wallPts[i][j-1]. y(), wallPts[i][j-1].z()); } endShape(); } //wall between cones 3 strip for (int j=1;j<4;j++) { beginShape(TRIANGLE_STRIP); for (int i=0;i<4;i++) { vertex(irrWallPts[i][j-1].x(), irrWallPts[i] [j-1].y(), irrWallPts[i][j-1].z()); vertex(irrWallPts[i][j].x(), irrWallPts[i][j]. y(), irrWallPts[i][j].z()); } endShape(); } //ramp end hand rail beginShape(QUAD); vertex(cUp.ramp[divr].x(), cUp.ramp[divr].y(), cUp.ramp[divr].z()); vertex(cUp.pts[tileScale][0].x(), cUp. pts[tileScale][0].y(), cUp.pts[tileScale][0].z()); vertex(cUp.pts[tileScale][0].x(), cUp. pts[tileScale][0].y(), cUp.pts[tileScale][0]. z()+railHr*h); vertex(cUp.ramp[divr].x(), cUp.ramp[divr].y(), cUp.ramp[divr].z()+railHr*h); endShape(); //curtain stroke(0, 0, 360); fill(0, 0, 360, 250); for (int j=1;j<3*divr+1;j++) { beginShape(QUAD); vertex(curtainA[j-1].x(), curtainA[j-1].y(), curtainA[j-1].z()); vertex(curtainA[j].x(), curtainA[j].y(), curtainA[j].z()); vertex(curtainB[j-1].x(), curtainB[j-1].y(), curtainB[j-1].z()); vertex(curtainC[j-1].x(), curtainC[j-1].y(), curtainC[j-1].z()); endShape(); } // gfx.plane(cUp.cutter, 9999); popMatrix(); //baseH shift till here__________________________ //ramp to ground beginShape(QUAD_STRIP); for (int j=0;j<ceil(divr*(baseH-h)/h);j++ ) { vertex(slope[0][j].x(), slope[0][j].y(), slope[0][j].z()); vertex(slope[1][j].x(), slope[1][j].y(), slope[1][j].z()); } endShape(); } }

104

Vec3D[] divisionPts(int num, Vec3D p, Vec3D q) {// divide q to p with num points Vec3D[] divPts = new Vec3D[num+2]; for (int i=0; i<num+2;i++) { divPts[i] = new Vec3D((i*p.x+(num+1-i)*q.x)/ (num+1), (i*p.y+(num+1-i)*q.y)/(num+1), (i*p.z+(num+1i)*q.z)/(num+1)); } return divPts; } Vec3D offset(Vec3D v, int W, float lang) { Vec3D newV = new Vec3D(v); if (W == 0) { newV.addSelf(lang, 0, 0); } if (W == 1) { newV.addSelf(0, lang, 0); } if (W == 2) { newV.addSelf(0, 0, lang); } return newV; }

/* Ryuyu Ishihara Computational Solution for Architectural Design railings F.O.Gehry //_________________________________________________*/ import processing.dxf.*; boolean record; import import import import import import import import import import

toxi.math.conversion.*; toxi.geom.*; toxi.math.*; toxi.util.datatypes.*; toxi.util.events.*; toxi.geom.mesh.subdiv.*; toxi.geom.mesh.*; toxi.math.waves.*; toxi.util.*; toxi.math.noise.*;

import toxi.processing.*; import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport gfx; Structure st; Plane gl; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //__ gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1)); //write your own below__ float stanceY =800; float stanceX =1500; float columnheight = 1000; float columnheightDiff = 500; float dim =80; Vec3D[] g = { new Vec3D(dim, 0, -5*columnheightDiff/6-200), new Vec3D(0, -2*dim, -3*columnheightDiff/6-100), new Vec3D(-dim+0, -2*dim-10, -columnheightDiff/6-100), new Vec3D(dim+0, 0, -columnheightDiff/6-200), new Vec3D(0, dim, -3*columnheightDiff/6-100), new Vec3D(dim+0, 2*dim, -5*columnheightDiff/6-100), new Vec3D(0, 0, -columnheightDiff/2-20), new Vec3D(0, 0, -columnheightDiff/2+100) }; Vec3D[] us = { new Vec3D(-stanceX/6, -2*dim, -80), new Vec3D(stanceX/6, -2*dim, -100), new Vec3D(-stanceX/6+100, -3*dim, -20), new Vec3D(-stanceX/6, -2*dim, -80), new Vec3D(-stanceX/6, -2*dim, 100), new Vec3D(stanceX/6+100+0, -3*dim,100), new Vec3D(-stanceX/5, -(stanceY-2*dim)/2, -200), new Vec3D(-stanceX/5, -stanceY/2, -columnheightDiff*.5+100) }; Vec3D[] vs = { new Vec3D(stanceX/6-200, -2*dim, -30), new Vec3D(stanceX/6, -2*dim, -100), new Vec3D(stanceX/6-100, -3*dim, -20), new Vec3D(stanceX/6dim, -2*dim, 140), new Vec3D(stanceX/6, -2*dim, 100), new Vec3D(stanceX/6-100+0, -3*dim, -40), new Vec3D(stanceX/5, -(stanceY-2*dim)/2, 200), new Vec3D(stanceX/5, -stanceY/2, -columnheightDiff*.5+100) }; float[] as = { 1.2, 1, 1, 1, 1, 1, 1, .9 }; float[] bs = { 0, .1, .1, .1, .1, .1, .1, 0 }; float[] stl1 = { 100, 170, 100, 130

105

source code

}; float[] stl2 = { 300, 170, 100, 120 }; float[] stz1 = { 10, -20, -10 }; float[] stz2 = { 20, -20, -10 }; st = new Structure( dim, //float _dim, columnheight, //float _columnH1, columnheightDiff, //float _columnHdif, 300, //float _shiftX, stanceX, //float _stanceX, stanceY, //float _stanceY, .5, // float gExt: 50, //float _floorH, 30, //float _stepHL, 10, //float _stepHS .5, //float _stairZig1, .2, //float _stairZig2, .7, //float _stairZig3>Zig2 g, // Vec3D[] _gPos, us, //Vec3D[] _plateUs, vs, //Vec3D[] _plateVs, as, //float[] _plateAs, bs, //float[] _plateBs, .1, //float _roofpos1, .1, //float _roofpos2, .1, //float _roofpos3, .1, //float _roofpos4, 20, //float _roofHdown 10, //float _stageH, 0, //float stage1Furi, roatetion angle from scala 0*QUARTER_PI, //float stage2Furi, .1, //float stage1Pos, 0-1 value to set the position .5, //float stage2Pos, 100, // float _stage1Strip, 100, // float _stage2Strip, stl1, // float[] _stage1L, stz1, // float[] _stage1Zig, stl2, // float[] _stage2L, stz2, // float[] _stage2Zig QUARTER_PI, //float _stageStepDir1, QUARTER_PI, //float _stageStepDir2 10, // float _stepUp, 20//float _stepW );

} //__________________________________________________ void draw() { //lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ fill(0, 0, 350); stroke(0, 0, 3); st.render(); }

yaw,

cam.setRotations(PI/2, PI, PI); // pitch, rotations are applied in that order }

yaw, roll

} // that is all cam key________________________________ ______________________________________________________ ________

106

class BoxUVW { Vec3D u; Vec3D v; Vec3D w; Vec3D[] pts;

class Plate { Vec3D dir1, dir2; Vec3D[] ver = new Vec3D[4];

BoxUVW( Vec3D _origin, Vec3D _u, Vec3D _v, Vec3D _w) { this.u = _u; this.v = _v; this.w = _w; pts = new Vec3D[8]; pts[0] = _origin; pts[1] = _origin.add(u); pts[2] = _origin.add(v.add(u)); pts[3] = _origin.add(v); pts[4] = _origin.add(w); pts[5]= _origin.add(u.add(w)); pts[6]= _origin.add(u.add(v.add(w))); pts[7]= _origin.add(v.add(w)); } void render() { quad(pts[0], pts[1], quad(pts[0], pts[1], quad(pts[1], pts[2], quad(pts[2], pts[3], quad(pts[3], pts[0], quad(pts[4], pts[5], }

pts[2], pts[5], pts[6], pts[7], pts[4], pts[6],

pts[3]); pts[4]); pts[5]); pts[6]); pts[7]); pts[7]);

void quad(Vec3D p, Vec3D q, Vec3D r, Vec3D s) { beginShape(QUAD); vertex(p.x, p.y, p.z); vertex(q.x, q.y, q.z); vertex(r.x, r.y, r.z); vertex(s.x, s.y, s.z); endShape(); } Vec3D onEdge(int i, float ratio) {//i starting vertex j ending vertex ratio is rational position on edge Vec3D pos = new Vec3D(pts[i]); Vec3D dir = new Vec3D((pts[i+4].x-pts[i].x)*ratio, (pts[i+4].y-pts[i].y)*ratio, (pts[i+4].z-pts[i]. z)*ratio); pos.addSelf(dir); return pos; } }

Plate(Vec3D gravic, Vec3D u, Vec3D v, float a, float b) {//a>b>=0 ver[0] = new Vec3D( gravic.add(u)); ver[1]= new Vec3D( gravic.add(v)); ver[2] =new Vec3D( gravic.add(u.scale(-a)).add(v. scale(-b))); ver[3] =new Vec3D( gravic.add(u.scale(-1+a)). add(v.scale(-1+b))); }

}

void render() { beginShape(QUAD); for (Vec3D v:ver) { vertex(v.x, v.y, v.z); } endShape(); }

107

source code

class Stick { Plate plate; BoxUVW beam; float[] ratio; Vec3D[] ptBeam; Vec3D[] ptPlate; int[] edgeId; int[] plateId; Stick(Plate _plate, BoxUVW _beam, int[] _edgeid, int[] _plateid, float[] _ratio) { Plate plate = _plate; BoxUVW beam = _beam; edgeId =_edgeid; plateId = _plateid; ratio = _ratio; ptBeam = new Vec3D[edgeId.length]; ptPlate = new Vec3D[edgeId.length]; for (int i=0;i<edgeId.length;i++) { ptBeam[i] = beam.onEdge(edgeId[i], ratio[i]); ptPlate[i] = plate.ver[plateId[i]]; } } void render() { for (int i=0;i<edgeId.length;i++) { line(ptBeam[i].x, ptBeam[i].y, ptBeam[i].z, ptPlate[i].x, ptPlate[i].y, ptPlate[i].z); } } }

public class Structure { float dim;//half of Member float columnH1; float columnH2; float shiftX; float stanceX; float stanceY; BoxUVW column1, column2, column3, column4; BoxUVW girder1, girder2; BoxUVW beam1, beam2;//cross beams float gExt; Vec3D[] step1; Vec3D[] step2; Vec3D[] step3; Vec3D[] step4; float floorH; float stepHL; float stepHS; float stairZig1, stairZig2, stairZig3;//large stair zigzag factor 0-1ratio to the stanceX Plate[] pl = new Plate[8]; Vec3D[] gPos; Vec3D[] plateUs; Vec3D[] plateVs; float[] plateAs; float[] plateBs; Vec3D[] roofPt; float roofpos1, roofpos2, roofpos3, roofpos4; float roofHdown; float stageH; float stage1Furi;//angle to rotate stage from large scala float stage2Furi; float stage1Pos; float stage2Pos; float stage1Strip; float stage2Strip; Vec3D[] stage1Pt; Vec3D[] stage2Pt; float[] stage1L; float[] stage1Zig; float[] stage2L; float[] stage2Zig; Vec3D[] stageSteps1; Vec3D[] stageSteps2; float stageStepDir1; float stageStepDir2; float stepUp; float stepW; Vec3D[] g1Division; Vec3D[] g2Division; Stick[] suporter; Structure( float _dim, float _columnH1, float _columnHdif, float _shiftX, //difference between start of girders float _stanceX, //columns stance X-direction float _stanceY, float _gExt, float _floorH, float _stepHL, float _stepHS, float _stairZig1, float _stairZig2, float _stairZig3, Vec3D[] _gPos, Vec3D[] _plateUs, Vec3D[] _plateVs, float[] _plateAs, float[] _plateBs, float _roofpos1, float _roofpos2, float _roofpos3, float _roofpos4, float _roofHdown, float _stageH, float _stage1Furi, float _stage2Furi, float _stage1Pos, float _stage2Pos, float _stage1Strip, float _stage2Strip,

108

float[] _stage1L, float[] _stage1Zig, float[] _stage2L, float[] _stage2Zig, float _stageStepDir1, float _stageStepDir2, float _stepUp, float _stepW )//columns stance Y-direction { this.dim = _dim; this.columnH1 = _columnH1; this.columnH2 = _columnH1-_columnHdif; this.shiftX = _shiftX; this.stanceX = _stanceX; this.stanceY = _stanceY; this.gExt = _gExt; this.floorH=_floorH; this.stepHL = _stepHL; this.stepHS = _stepHS; this.stairZig1 = _stairZig1; this.stairZig2 = _stairZig2; this.stairZig3 = _stairZig3; this.gPos = _gPos; this.plateUs = _plateUs; this.plateVs = _plateVs; this.plateAs = _plateAs; this.plateBs = _plateBs; this.roofpos1 = _roofpos1; this.roofpos2 = _roofpos2; this.roofpos3 = _roofpos3; this.roofpos4 = _roofpos4; this.roofHdown = _roofHdown; this.stageH = _stageH; this.stage1Furi = _stage1Furi; this.stage2Furi = _stage2Furi; this.stage1Pos = _stage1Pos; this.stage2Pos = _stage2Pos; this.stage1Strip = _stage1Strip; this.stage2Strip = _stage2Strip; this.stage1L = _stage1L; this.stage1Zig = _stage1Zig; this.stage2L = _stage2L; this.stage2Zig = _stage2Zig; this.stageStepDir1 = _stageStepDir1; this.stageStepDir2 = _stageStepDir2; this.stepUp = _stepUp; this.stepW = _stepW; //columns Vec3D dirV1 = new Vec3D(stanceX, -dim, 0); Vec3D v = dirV1.getNormalizedTo(dim); Vec3D u = v.getRotatedZ(HALF_PI); Vec3D w = new Vec3D(0, 0, columnH1); column1 = new BoxUVW(new Vec3D(), u, v, w); Vec3D origin = new Vec3D(); origin.set(dirV1.getNormalizedTo(stanceX)); origin.subSelf(u); w.set(0, 0, columnH2); column2 = new BoxUVW(origin, u, v, w); Vec3D dirV2 = new Vec3D(stanceX, dim, 0); origin = new Vec3D(); origin.set(shiftX, stanceY, 0); v = dirV2.getNormalizedTo(dim); u = v.getRotatedZ(HALF_PI ); column3 = new BoxUVW(origin, u, v, w); dirV2=dirV2.getNormalizedTo(stanceX); origin = new Vec3D(); origin.set(shiftX, stanceY, 0); origin.addSelf(dirV2); origin.subSelf(u); w.set(0, 0, columnH1); column4 = new BoxUVW(origin, u, v, w); //girder1 Vec3D girder1RayDir = new Vec3D(column1.pts[7]. sub(column2.pts[7])); Ray3D girder1Ray = new Ray3D(column2.pts[7], girder1RayDir); Plane girder1End = new Plane(column1.pts[0], column1.v.getInverted());

Vec3D tmp = new Vec3D(girder1End.getIntersectionWi thRay(girder1Ray));//girder1 end w = tmp.sub(column2.pts[7]); u = new Vec3D(w.y, -w.x, 0); u = u.getNormalizedTo(dim); v = u.getRotatedAroundAxis(w, -HALF_PI); v = v.getNormalizedTo(dim); girder1 = new BoxUVW(column2.pts[7], u, v, w); //girder2 Vec3D girder2RayDir = new Vec3D(column4.pts[5]. sub(column3.pts[5])); Ray3D girder2Ray = new Ray3D(column3.pts[5], girder2RayDir); Plane girder2End = new Plane(column4.pts[3], column4.v); tmp = new Vec3D(girder2End.getIntersectionWithRay( girder2Ray));//girder2 end w = tmp.sub(column3.pts[5]); u = new Vec3D(w.y, -w.x, 0); u = u.getNormalizedTo(dim); v = u.getRotatedAroundAxis(w, -HALF_PI); v = v.getNormalizedTo(dim); girder2 = new BoxUVW(column3.pts[5], u, v, w); //beam1 origin = new Vec3D(girder1.pts[3]); Vec3D beam1RayDir = new Vec3D(girder2.pts[6]. sub(origin)); Ray3D beam1Ray = new Ray3D(origin, beam1RayDir); Plane beam1End = new Plane(girder2.pts[4], girder2.u.getInverted()); tmp = new Vec3D(beam1End.getIntersectionWithRay(be am1Ray));//beam end point w = new Vec3D(tmp.sub(origin)); tmp = new Vec3D(girder1.pts[7].sub(girder1. pts[3]));//edge on girder. it is used for creating imaginary Cplane along with W-vector v = new Vec3D(w.cross(tmp)); v = v.getNormalizedTo(dim); u = v.getRotatedAroundAxis(w, -HALF_PI); u = u.getNormalizedTo(dim); beam1 = new BoxUVW(origin, u, v, w); //beam2 origin = new Vec3D(girder2.pts[3]); Vec3D beam2RayDir = new Vec3D(girder1.pts[6]. sub(origin)); Ray3D beam2Ray = new Ray3D(origin, beam2RayDir); Plane beam2End= new Plane(girder1.pts[4], girder1. u.getInverted()); tmp = new Vec3D(beam2End.getIntersectionWithRay(be am2Ray));//beam end point w = new Vec3D(tmp.sub(origin)); tmp = new Vec3D(girder2.pts[7].sub(girder2. pts[3]));//edge on girder. it is used for creating imaginary Cplane along with W-vector v = new Vec3D(w.cross(tmp)); v = v.getNormalizedTo(dim); u = v.getRotatedAroundAxis(w, -HALF_PI); u = u.getNormalizedTo(dim); beam2 = new BoxUVW(origin, u, v, w); //large stair1 step1 = new Vec3D[9]; step1[0] = column1.pts[2].add(column1.u).add(0, 0, floorH); for (int i=1;i<5;i++) { step1[2*i-1] = step1[0].add((column1. u.getInverted().scale(i-1)).add(new Vec3D(0, 0, stepHL*i))); step1[2*i] = step1[0].add((column1. u.getInverted().scale(i)).add(new Vec3D(0, 0, stepHL*i))); } step2 = new Vec3D[9]; step2[0] = column2.pts[1].add(column2.u).add(0, 0, floorH); for (int i=1;i<5;i++) { step2[2*i-1] = step2[0].add((column2. u.getInverted().scale(i-1)).add(new Vec3D(0, 0, stepHL*i))); step2[2*i] = step2[0].add((column2.

109

source code

u.getInverted().scale(i)).add(new Vec3D(0, 0, stepHL*i))); } step3 = new Vec3D[9]; step3[0] = column3.pts[3].add(column3. u.getInverted()).add(0, 0, floorH); for (int i=1;i<5;i++) { step3[2*i-1] = step3[0].add((column3. u.scale(i-1)).add(new Vec3D(0, 0, stepHL*i))); step3[2*i] = step3[0].add((column3.u.scale(i)). add(new Vec3D(0, 0, stepHL*i))); } step4 = new Vec3D[9]; step4[0] = column4.pts[0].add(column4. u.getInverted()).add(0, 0, floorH); for (int i=1;i<5;i++) { step4[2*i-1] = step4[0].add((column4. u.scale(i-1)).add(new Vec3D(0, 0, stepHL*i))); step4[2*i] = step4[0].add((column4.u.scale(i)). add(new Vec3D(0, 0, stepHL*i))); } //plates g1Division = divisionPts(5, girder1.pts[7], girder1.pts[3]); pl[0] = new Plate(new Vec3D(g1Division[5]. add(gPos[0])), plateUs[0], plateVs[0], plateAs[0], plateBs[0]); pl[1] = new Plate(new Vec3D(g1Division[3]. add(gPos[1])), plateUs[1], plateVs[1], plateAs[1], plateBs[1]); pl[2] = new Plate(new Vec3D(g1Division[1]. add(gPos[2])), plateUs[2], plateVs[2], plateAs[2], plateBs[2]); g2Division = divisionPts(5, girder2.pts[3], girder2.pts[7]); pl[3] = new Plate(new Vec3D(g2Division[5]. add(gPos[3])), plateUs[3], plateVs[3], plateAs[3], plateBs[3]); pl[4] = new Plate(new Vec3D(g2Division[3]. add(gPos[4])), plateUs[4], plateVs[4], plateAs[4], plateBs[4]); pl[5] = new Plate(new Vec3D(g2Division[1]. add(gPos[5])), plateUs[5], plateVs[5], plateAs[5], plateBs[5]); pl[6] = new Plate(new Vec3D((column1.pts[5]. add(column3.pts[4])).scale(.5).add(gPos[6])), plateUs[6], plateVs[6], plateAs[6], plateBs[6]); pl[7] = new Plate(new Vec3D((column2.pts[6]. add(column4.pts[7])).scale(.5).add(gPos[7])), plateUs[7], plateVs[7], plateAs[7], plateBs[7]); //roof plate roofPt = new Vec3D[4]; roofPt[0] = column1.pts[6].add(girder1RayDir. scale(roofpos1).getInverted()).sub(0, 0, roofHdown); roofPt[1] = column2.pts[5].add(girder1RayDir. scale(roofpos2)).sub(0, 0, roofHdown); roofPt[2] = column3.pts[7].add(girder2RayDir. scale(roofpos3)).sub(0, 0, roofHdown); roofPt[3] = column4.pts[4].add(girder2RayDir. scale(roofpos4).getInverted()).sub(0, 0, roofHdown); stage1Pt = new Vec3D[16]; tmp =step2[8].scale(stairZig1).add(step1[8]. scale(1-stairZig1)); origin = tmp.scale(stage1Pos).add(step2[8]. scale(1-stage1Pos)); origin.addSelf(0, 0, stageH); float phi = atan(-dim/stanceX); float theta1 = atan(stage1Zig[1]/stage1Strip); float theta2 = atan((stage1Zig[1]+stage1Zig[2])/ (2*stage1Strip)); if (abs(theta1-phi)>abs(theta2-phi)) { u = new Vec3D(dirV1.getRotatedZ(stage1Furitheta1+phi)); } else { u =new Vec3D(dirV1.getRotatedZ(stage1Furitheta2+phi)); }

v = new Vec3D(u.getRotatedZ(HALF_PI)); stage1Pt[2] = origin; stage1Pt[1] = origin.add(v. getNormalizedTo(stage1Zig[0])); stage1Pt[0] = stage1Pt[1].add(u. getNormalizedTo(stage1Strip).getInverted()); stage1Pt[3] = origin.add(u. getNormalizedTo(stage1Strip)); stage1Pt[4] = stage1Pt[3].add(v. getNormalizedTo(stage1Zig[1])); stage1Pt[5] = stage1Pt[4].add(u. getNormalizedTo(stage1Strip)); stage1Pt[6] = stage1Pt[5].add(v. getNormalizedTo(stage1Zig[2])); stage1Pt[7] = stage1Pt[6].add(u. getNormalizedTo(stage1Strip)); for (int i=0;i<4;i++) { stage1Pt[2*i+8] = stage1Pt[2*i].add(v. getNormalizedTo(stage1L[i]).getInverted()); stage1Pt[2*i+1+8] = stage1Pt[2*i+1].add(v. getNormalizedTo(stage1L[i]).getInverted()); } stageSteps1 = new Vec3D[4*ceil((floorH+stepHL*4)/ stepUp)+4+2];//4 must be exon u = u.getInverted(); u = u.rotateZ(stageStepDir1); v = u.getRotatedZ(-HALF_PI); v = v.getNormalizedTo(stage1Strip/2); u = v.getRotatedZ(HALF_PI); if (stageStepDir1<HALF_PI) { stageSteps1[0] = stage1Pt[8].add(u).add(v); stageSteps1[1] = stage1Pt[8].add(u).sub(v); } else { stageSteps1[0] = stage1Pt[9].add(u).add(v); stageSteps1[1] = stage1Pt[9].add(u).sub(v); } u = u.getNormalizedTo(stepW); for (int i=1;i<ceil((floorH+stepHL*4)/ stepUp)+1.25;i++) { stageSteps1[4*i-2] = stageSteps1[4*i-4].add(u); stageSteps1[4*i-1] = stageSteps1[4*i-3].add(u); stageSteps1[4*i] = stageSteps1[4*i-2].sub(0, 0, stepUp); stageSteps1[4*i+1] = stageSteps1[4*i-1].sub(0, 0, stepUp); } stageSteps1[4*ceil((floorH+stepHL*4)/stepUp)+4] = stageSteps1[4*ceil((floorH+stepHL*4)/stepUp)+2].sub(0, 0, stepUp); stageSteps1[4*ceil((floorH+stepHL*4)/stepUp)+5] = stageSteps1[4*ceil((floorH+stepHL*4)/stepUp)+3].sub(0, 0, stepUp); stage2Pt = new Vec3D[16]; tmp =step4[8].scale(stairZig3).add(step3[8]. scale(1-stairZig3)); origin = tmp.scale(stage2Pos).add(step4[8]. scale(1-stage2Pos)); origin.addSelf(0, 0, stageH); phi = atan(dim/stanceX); theta1 = atan(stage2Zig[1]/stage2Strip); theta2 = atan((stage2Zig[1]+stage2Zig[2])/ (2*stage2Strip)); if (abs(theta1-phi)>abs(theta2-phi)) { u = new Vec3D(dirV2. getRotatedZ(stage1Furi+theta1-phi)); } else { u =new Vec3D(dirV1.getRotatedZ(stage1Furi+theta2phi)); } v = new Vec3D(u.getRotatedZ(-HALF_PI)); stage2Pt[2] = origin; stage2Pt[1] = origin.add(v. getNormalizedTo(stage2Zig[0])); stage2Pt[0] = stage2Pt[1].add(u. getNormalizedTo(stage2Strip).getInverted()); stage2Pt[3] = origin.add(u. getNormalizedTo(stage2Strip)); stage2Pt[4] = stage2Pt[3].add(v. getNormalizedTo(stage2Zig[1]));

110

stage2Pt[5] = stage2Pt[4].add(u. getNormalizedTo(stage2Strip)); stage2Pt[6] = stage2Pt[5].add(v. getNormalizedTo(stage2Zig[2])); stage2Pt[7] = stage2Pt[6].add(u. getNormalizedTo(stage2Strip)); for (int i=0;i<4;i++) { stage2Pt[2*i+8] = stage2Pt[2*i].add(v. getNormalizedTo(stage2L[i]).getInverted()); stage2Pt[2*i+1+8] = stage2Pt[2*i+1].add(v. getNormalizedTo(stage2L[i]).getInverted()); } stageSteps2 = new Vec3D[4*ceil((floorH+stepHL*4)/ stepUp)+4+2];//4 must be exon u = u.rotateZ(stageStepDir2); v = u.getRotatedZ(-HALF_PI); v = v.getNormalizedTo(stage1Strip/2); u = v.getRotatedZ(HALF_PI); if (stageStepDir2>HALF_PI) { stageSteps2[0] = stage2Pt[8].add(u).add(v); stageSteps2[1] = stage2Pt[8].add(u).sub(v); } else { stageSteps2[0] = stage2Pt[9].add(u).add(v); stageSteps2[1] = stage2Pt[9].add(u).sub(v); } u = u.getNormalizedTo(stepW); for (int i=1;i<ceil((floorH+stepHL*4)/ stepUp)+1.25;i++) { stageSteps2[4*i-2] = stageSteps2[4*i-4].add(u); stageSteps2[4*i-1] = stageSteps2[4*i-3].add(u); stageSteps2[4*i] = stageSteps2[4*i-2].sub(0, 0, stepUp); stageSteps2[4*i+1] = stageSteps2[4*i-1].sub(0, 0, stepUp); } stageSteps2[4*ceil((floorH+stepHL*4)/stepUp)+4] = stageSteps2[4*ceil((floorH+stepHL*4)/stepUp)+2].sub(0, 0, stepUp); stageSteps2[4*ceil((floorH+stepHL*4)/stepUp)+5] = stageSteps2[4*ceil((floorH+stepHL*4)/stepUp)+3].sub(0, 0, stepUp); suporter = new Stick[8]; int[][] edge_id = { { 3, 3, 3, 2, 0 } , { 3, 3, 0, 0 } , { 3, 3, 3, 2, 1, 1 } , { 2, 2, 0, 3, 3, 3 } , { 0, 3, 3, 3 } , { 0, 0, 3, 3, 3 } , { 1, 2, 2, 1, 1 } , { 2, 0, 0, 0, 2 } }; /*id[0] = { 3, 3, 3, 2, 0 };*/ int[][] plate_id = { { 0, 1, 1, 2, 3 } , { 0, 1, 2, 3 } , { 0, 1, 1, 2, 3, 3 }

, { 0, } , { 0, } , { 0, } , { 0, } , { 0, }

0, 1, 2, 3, 3 1, 2, 3 1, 2, 3, 3 1, 2, 3, 3 1, 1, 2, 3

}; float[][] ratio= { { .95, .85, .8, .8, .9 } , { .6, .5, .65, .55 } , { .3, .1, .2, .15, .2, .25 } , { .1, .15, .3, .3, .1, .2 } , { .4, .5, .45, .45 } , { .7, .9, .85, .8, .6 } , { .8, .5, .2, .5, .3 } , { .3, .2, .5, .7, .9 } }; for (int i =0;i<3;i++) { suporter[i] = new Stick(pl[i], girder1, edge_ id[i], plate_id[i], ratio[i]);//Stick(Plate _ plate,BoxUVW _beam,int[] _edgeid,int[] _plateid,float[] _ratio) } for (int i=3;i<6;i++) { suporter[i] = new Stick(pl[i], girder2, edge_ id[i], plate_id[i], ratio[i]);//Stick(Plate _ plate,BoxUVW _beam,int[] _edgeid,int[] _plateid,float[] _ratio) } suporter[6] = new Stick(pl[6], beam2, edge_id[6], plate_id[6], ratio[6]); suporter[7] = new Stick(pl[7], beam1, edge_id[7], plate_id[7], ratio[7]); } //_________________________________________________ void render() { fill(0, 200, 300); column1.render(); fill(90, 200, 300); column2.render(); fill(180, 200, 300); column3.render(); fill(270, 200, 300); column4.render(); fill(250); girder1.render(); girder2.render(); fill(0, 200, 300); beam1.render(); fill(150, 200, 300); beam2.render(); for (int i=0;i<pl.length;i++) { fill(i*30, 200, 300); pl[i].render(); } stroke(360 ); for (int i=0;i<8;i++) {

111

source code

suporter[i].render(); } //large scala column12side beginShape(QUAD_STRIP); for (int i=0;i<7;i++) { vertex(step1[i].x, step1[i].y, step1[i].z); vertex(step2[i].x, step2[i].y, step2[i].z); } endShape(); beginShape(QUAD_STRIP); for (int i=6;i<9;i++) { Vec3D tmp = step1[i].scale(stairZig1). add(step2[i].scale(1-stairZig1)); vertex(tmp.x, tmp.y, tmp.z); vertex(step2[i].x, step2[i].y, step2[i].z); } endShape(); //side board beginShape(); vertex(step2[0].x, step2[0].y, 0); for (int i=0;i<9;i++) { vertex(step2[i].x, step2[i].y, step2[i].z); } vertex(step2[8].x, step2[8].y, 0); endShape(CLOSE); beginShape(QUAD_STRIP); for (int i=0;i<5;i++) { vertex(step3[i].x, step3[i].y, step3[i].z); vertex(step4[i].x, step4[i].y, step4[i].z); } endShape(); beginShape(QUAD_STRIP); for (int i=4;i<7;i++) { Vec3D tmp =step4[i].scale(stairZig2). add(step3[i].scale(1-stairZig2)); vertex(tmp.x, tmp.y, tmp.z); vertex(step4[i].x, step4[i].y, step4[i].z); } for (int i=6;i<9;i++) { Vec3D tmp =step4[i].scale(stairZig3). add(step3[i].scale(1-stairZig3)); vertex(tmp.x, tmp.y, tmp.z); vertex(step4[i].x, step4[i].y, step4[i].z); } endShape(); //side board beginShape(); vertex(step4[0].x, step4[0].y, 0); for (int i=0;i<9;i++) { vertex(step4[i].x, step4[i].y, step4[i].z); } vertex(step4[8].x, step4[8].y, 0); endShape(CLOSE); //floor beginShape( ); vertex(step1[0].x, step1[0].y, floorH); vertex(column4.pts[0].x(), step1[0].y+(column4. pts[0].x-column1.pts[2].x)*(step1[0].y-step2[0].y)/ (step1[0].x-step2[0].x), floorH); vertex(step4[0].x, step4[0].y, floorH); vertex(column1.pts[2].x(), step4[0].y-(column4. pts[0].x-column1.pts[2].x)*(step4[0].y-step3[0].y)/ (step4[0].x-step3[0].x), floorH); endShape(); //step down to ground beginShape(QUAD_STRIP); // vertex(column4.pts[0].x(), step1[0]. y+(column4.pts[0].x-column1.pts[2].x)*(step1[0]. y-step2[0].y)/(step1[0].x-step2[0].x), floorH); // vertex(step4[0].x, step4[0].y, floorH); for (int i=0;i<5;i++) { vertex(column4.pts[0].x()+i*stepW, step1[0]. y+(column4.pts[0].x-column1.pts[2].x)*(step1[0]. y-step2[0].y)/(step1[0].x-step2[0].x), floorHi*floorH/5); vertex(step4[0].x+i*stepW, step4[0].y, floorHi*floorH/5); vertex(column4.pts[0].x()+i*stepW, step1[0]. y+(column4.pts[0].x-column1.pts[2].x)*(step1[0].

y-step2[0].y)/(step1[0].x-step2[0].x), floorH(i+1)*floorH/5); vertex(step4[0].x+i*stepW, step4[0].y, floorH(i+1)*floorH/5); } endShape(CLOSE); //roof beginShape(); vertex(roofPt[0].x, roofPt[0].y, roofPt[0].z); vertex(roofPt[1].x, roofPt[1].y, roofPt[1].z); vertex(roofPt[2].x, roofPt[2].y, roofPt[2].z); endShape(CLOSE); beginShape(); vertex(roofPt[3].x, roofPt[3].y, roofPt[3].z); vertex(roofPt[1].x, roofPt[1].y, roofPt[1].z); vertex(roofPt[2].x, roofPt[2].y, roofPt[2].z); endShape(CLOSE);

z);

beginShape(); for (int i=0;i<8;i++) { vertex(stage1Pt[i].x, stage1Pt[i].y, stage1Pt[i].

} for (int i=0;i<8;i++) { vertex(stage1Pt[15-i].x, stage1Pt[15-i].y, stage1Pt[15-i].z); } endShape(CLOSE);

z);

for (int i=0;i<7;i++) { beginShape(QUAD); vertex(stage1Pt[i].x, stage1Pt[i].y, stage1Pt[i].

vertex(stage1Pt[i].x, stage1Pt[i].y, 0); vertex(stage1Pt[i+1].x, stage1Pt[i+1].y, 0); vertex(stage1Pt[i+1].x, stage1Pt[i+1].y, stage1Pt[i+1].z); endShape(); } beginShape(QUAD); vertex(stage1Pt[7].x, stage1Pt[7].y, stage1Pt[7]. z); vertex(stage1Pt[7].x, stage1Pt[7].y, 0); vertex(stage1Pt[15].x, stage1Pt[15].y, 0); vertex(stage1Pt[15].x, stage1Pt[15].y, stage1Pt[15].z); endShape(); for (int i=8;i<15;i++) { beginShape(QUAD); vertex(stage1Pt[i].x, stage1Pt[i].y, stage1Pt[i]. z); vertex(stage1Pt[i].x, stage1Pt[i].y, 0); vertex(stage1Pt[i+1].x, stage1Pt[i+1].y, 0); vertex(stage1Pt[i+1].x, stage1Pt[i+1].y, stage1Pt[i+1].z); endShape(); } beginShape(QUAD); vertex(stage1Pt[0].x, stage1Pt[0].y, stage1Pt[0]. z); vertex(stage1Pt[0].x, stage1Pt[0].y, 0); vertex(stage1Pt[8].x, stage1Pt[8].y, 0); vertex(stage1Pt[8].x, stage1Pt[8].y, stage1Pt[8]. z); endShape();

z);

beginShape(); for (int i=0;i<8;i++) { vertex(stage2Pt[i].x, stage2Pt[i].y, stage2Pt[i].

} for (int i=0;i<8;i++) { vertex(stage2Pt[15-i].x, stage2Pt[15-i].y, stage2Pt[15-i].z); } endShape(CLOSE); for (int i=0;i<7;i++) { beginShape(QUAD); vertex(stage2Pt[i].x, stage2Pt[i].y, stage2Pt[i]. z); vertex(stage2Pt[i].x, stage2Pt[i].y, 0); vertex(stage2Pt[i+1].x, stage2Pt[i+1].y, 0); vertex(stage2Pt[i+1].x, stage2Pt[i+1].y, stage2Pt[i+1].z);

112

z);

endShape(); } beginShape(QUAD); vertex(stage2Pt[7].x, stage2Pt[7].y, stage2Pt[7].

vertex(stage2Pt[7].x, stage2Pt[7].y, 0); vertex(stage2Pt[15].x, stage2Pt[15].y, 0); vertex(stage2Pt[15].x, stage2Pt[15].y, stage2Pt[15].z); endShape(); for (int i=8;i<15;i++) { beginShape(QUAD); vertex(stage2Pt[i].x, stage2Pt[i].y, stage2Pt[i]. z); vertex(stage2Pt[i].x, stage2Pt[i].y, 0); vertex(stage2Pt[i+1].x, stage2Pt[i+1].y, 0); vertex(stage2Pt[i+1].x, stage2Pt[i+1].y, stage2Pt[i+1].z); endShape(); } beginShape(QUAD); vertex(stage2Pt[0].x, stage2Pt[0].y, stage2Pt[0]. z); vertex(stage2Pt[0].x, stage2Pt[0].y, 0); vertex(stage2Pt[8].x, stage2Pt[8].y, 0); vertex(stage2Pt[8].x, stage2Pt[8].y, stage2Pt[8]. z); endShape(); //stage step beginShape(QUAD_STRIP); for (int i=0; i<4*ceil((floorH+stepHL*4)/stepUp)+4+2 ;i++) { vertex(stageSteps1[i].x, stageSteps1[i].y, stageSteps1[i].z); } endShape(); ////stage step sideboard beginShape(); for (int i=0;i<2*ceil((floorH+stepHL*4)/ stepUp)+3;i++) { vertex(stageSteps1[2*i+1].x, stageSteps1[2*i+1]. y, stageSteps1[2*i+1].z); } vertex(stageSteps1[1].x, stageSteps1[1].y, 0); endShape(CLOSE); beginShape(); for (int i=0;i<2*ceil((floorH+stepHL*4)/ stepUp)+3;i++) { vertex(stageSteps1[2*i].x, stageSteps1[2*i].y, stageSteps1[2*i].z); } vertex(stageSteps1[0].x, stageSteps1[0].y, 0); endShape(CLOSE); //stage step2 beginShape(QUAD_STRIP); for (int i=0; i<4*ceil((floorH+stepHL*4)/stepUp)+4+2 ;i++) { vertex(stageSteps2[i].x, stageSteps2[i].y, stageSteps2[i].z); } endShape(); } }

113

source code

/* Ryuyu Ishihara //<>// Computational Solution for Architectural Design sanaa //_________________________________________________*/ import processing.dxf.*; boolean record; import igeo.*; import igeo.p.*; import igeo.io.*; import igeo.gui.*; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.processing.*; import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport gfx; Plane gl; ArrayList<Vec3D> points = new ArrayList<Vec3D>(); ArrayList<Vec3D> anchors = new ArrayList<Vec3D>(); int beziernum; Roof roof; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1));// ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__ String lines[] = loadStrings("environ.txt");//point for (int i=0;i<lines.length;i++) { String data[] = split(lines[i], ",");//x / y / z // println(data[2]); Vec3D p = new Vec3D(float(data[0]), float(data[1]), float(data[2])); points.add(p); } points = bezieconverter(points); roof = new Roof(points); } //___________________________________________________ void draw() { //lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ noStroke(); // fill(0, 200, 360); pushMatrix(); translate(0, 00, 10); roof.render(); popMatrix(); //record end______________ if (record) { endRaw(); record = false; } }

PI, PI); // pitch, that order 0, PI); // pitch, that order

yaw,

yaw, roll

} // that is all cam key________________________________ ______________________________________________________ ________

114

class Environment { ArrayList vpos = new ArrayList(); Polygon2D road; float pos=1500; Ellipse lectureSpace; Vec2D zentrum; float rLecture; Environment() { vpos.add(new Vec2D(pos,-1000)); vpos.add(new Vec2D(pos+120,-1000)); vpos.add(new Vec2D(pos+120,2000)); vpos.add(new Vec2D(pos,2000)); road = new Polygon2D(vpos); zentrum=new Vec2D(950,350); rLecture = 150; lectureSpace = new Ellipse(zentrum,rLecture); }

}

class Roof { ArrayList<Vec3D> points; int resolution = 100; ArrayList<Vec2D> approBezier = new ArrayList<Vec2D>(); float maxX=0; float minX=0; float maxY=0; float minY=0; int numClmn = 30; float columnPitch = 100; ArrayList<Vec2D> columns; Environment env; Roof(ArrayList<Vec3D> _points) { env = new Environment(); points=_points; //column position calculation for (Vec3D point:points) { maxX = max(maxX, point.x()); minX = min(minX, point.x()); maxY = max(maxY, point.y()); minY = min(minY, point.y()); } Vec2D[] tmp = new Vec2D[resolution]; for (int i=1;i<ceil(points.size()/3);i++) { tmp = polygonize(points.get(3*i-3), points. get(3*i-2), points.get(3*i-1), points.get(3*i)); for (Vec2D point:tmp) { approBezier.add(point); } } tmp = polygonize(points.get(points.size()-1-2), points.get(points.size()-1-1), points.get(points. size()-1), points.get(0)); for (Vec2D point:tmp) { approBezier.add(point); } columns = columnPts(numClmn); float measure = 0; float counter = columnPitch; for (int i=1;i<approBezier.size();i++) { float dim = dist(approBezier.get(i).x, approBezier.get(i).y, approBezier.get(i-1).x, approBezier.get(i-1).y); if (measure<counter) { measure = measure+dim; } if ((measure>=counter)&(pixelInPoly(env.vpos, new Vec2D(approBezier.get(i)))==false) ) { columns.add(new Vec2D(approBezier.get(i).x, approBezier.get(i).y)); counter = counter+columnPitch; } } //enviromental correction ArrayList<Vec2D> tmp2= new ArrayList<Vec2D>(); for (int i=0;i<columns.size();i++) { Vec2D p = columns.get(i); if(dist(env.zentrum.x,env.zentrum.y,p.x,p. y)>env.rLecture){ tmp2.add(columns.get(i)); } } columns.clear(); columns = tmp2; } void render() { for (Vec3D anchor:anchors) { pushMatrix(); translate(anchor.x, anchor.y, anchor.z); sphere(10 ); popMatrix(); } fill(0, 200, 300); beginShape(); vertex(points.get(0).x, points.get(0).y, points. get(0).z); // first point for (int i=0;i<13;i++) { bezierVertex(points.get(3*i+1).x, points.

115

source code

get(3*i+1).y, points.get(3*i+1).z, points.get(3*i+2). x, points.get(3*i+2).y, points.get(3*i+2).z, points. get(3*i+3).x, points.get(3*i+3).y, points.get(3*i+3). z); } bezierVertex(points.get(40).x, points.get(40).y, points.get(40).z, points.get(41).x, points.get(41). y, points.get(41).z, points.get(0).x, points.get(0).y, points.get(0).z);//close crv endShape(); fill(300, 200, 200);

}

stroke(0, 0, 360); for (Vec2D clmn:columns) { line(clmn.x, clmn.y, 0, clmn.x, clmn.y(), 250); } gfx.polygon2D(env.road);

Vec2D[] polygonize(Vec3D p3_0, Vec3D p3_1, Vec3D p3_2, Vec3D p3_3) { Vec2D p0 = p3_0.to2DXY(); Vec2D p1 = p3_1.to2DXY(); Vec2D p2 = p3_2.to2DXY(); Vec2D p3 = p3_3.to2DXY(); Vec2D[] pts1= new Vec2D[resolution]; Vec2D[] pts2= new Vec2D[resolution]; Vec2D[] pts3= new Vec2D[resolution]; Vec2D[] bezierPts; pts1 = divisionPts(resolution-2, p1, p0); pts2 = divisionPts(resolution-2, p2, p1); pts3 = divisionPts(resolution-2, p3, p2); Vec2D[] tmp1 = new Vec2D[resolution]; Vec2D[] tmp2 = new Vec2D[resolution]; for (int i=0;i<resolution;i++) { tmp1[i] = divisionPts(resolution-2, pts2[i], pts1[i])[i]; tmp2[i] = divisionPts(resolution-2, pts3[i], pts2[i])[i]; } bezierPts = new Vec2D[resolution]; for (int i=0;i<resolution;i++) { bezierPts[i] = divisionPts(resolution, tmp2[i], tmp1[i])[i]; } }

return bezierPts;

ArrayList<Vec2D> columnPts(int nummer) { ArrayList<Vec2D> pts = new ArrayList<Vec2D>(); while (pts.size ()<nummer) { Vec2D pt = new Vec2D(random(minX, maxX), random(minY, maxY)); if (pixelInPoly(approBezier, pt)&(pixelInPoly(env.vpos, pt)==false)) { pts.add(pt); } } return pts; } boolean pixelInPoly(ArrayList<Vec2D> verts, Vec2D pos) { int i, j; boolean c=false; int sides = verts.size(); for (i=0,j=sides-1;i<sides;j=i++) { if (( ((verts.get(i).y <= pos.y) && (pos.y < verts.get(j).y)) || ((verts.get(j).y <= pos.y) && (pos. y < verts.get(i).y))) && (pos.x < (verts.get(j).x - verts.get(i).x) * (pos.y - verts.get(i).y) / (verts.get(j).y - verts. get(i).y) + verts.get(i).x)) { c = !c; } } return c; } }

Vec3D tPt(float s, Vec3D p, Vec3D q) { Vec3D v = new Vec3D((1-s)*p.x+s*q.x, (1-s)*p.y+s*q.y, (1-s)*p.z+s*q.z); return v; } public Vec2D[] divisionPts(int num, Vec2D p, Vec2D q) {//divide q to p with num points Vec2D[] divPts = new Vec2D[num+2]; for (int i=0; i<num+2;i++) { divPts[i] = new Vec2D((i*p.x+(num+1-i)*q.x)/ (num+1), (i*p.y+(num+1-i)*q.y)/(num+1)); } return divPts; } ArrayList<Vec3D> bezieconverter(ArrayList<Vec3D> vecs) { ArrayList<Vec3D> punkt = new ArrayList<Vec3D>(); punkt.add(tPt(vecs.get(0).x, vecs.get(vecs.size()1), vecs.get(1))); punkt.add(vecs.get(1)); for (int i=1;i<ceil(vecs.size()/3);i++) { punkt.add(vecs.get(3*i-1)); punkt.add(tPt(vecs.get(3*i).x, vecs.get(3*i-1), vecs.get(3*i+1))); punkt.add(vecs.get(3*i+1)); } punkt.add(vecs.get(vecs.size()-1)); for(Vec3D p:punkt){ p.scaleSelf(5); } return punkt; }

116

/* Ryuyu Ishihara Computational Solution for Architectural Design Ateliers Jean nouvel //_________________________________________________*/ import traer.physics.*; import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport gfx; Plane gl; Structure st; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1));// ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__ float X = 2700;//scale factor float Y = 1800;//scale factor st = new Structure( 650, //float boxD, 700, //float boxH, Y, //float cannopyW, 600, //float cannopyH1, 400, ///float cannopyH2, 300, //float cannopyH3, 230, //float cannopyH4, 500*X/2700, //float columnStance, 100, // float columnDim1; 25, // float columnDim2; 47, // float columnDim3; 300*Y/1800, //float screenPos, 1600*X/2700, //float screenW, 380, //float screenD, 1180, //float screenH, 100, //float screenT1, 10, //float screenT2 .3 //float rollDoorH ratio to boxH ); } //____________________________________________ void draw() { lights(); background(0); fill(0, 10, 200); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ stroke(360); fill(0, 360, 360 ); st.render(); //record end______________ if (record) { endRaw(); record = false; } }

//cam key__________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, rotations are applied in that order }

yaw, roll

void rightView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order }

yaw,

void leftView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, rotations are applied in } void backView() { cam.setRotations(PI/2, rotations are applied in }

PI, PI); // pitch, that order

yaw,

0, PI); // pitch, that order

yaw, roll

} // that is all cam key______________________

117

source code

class BoxUVW { Vec3D u; Vec3D v; Vec3D w; Vec3D[] pts; BoxUVW( Vec3D _origin, Vec3D _u, Vec3D _v, Vec3D _w) { this.u = _u; this.v = _v; this.w = _w; pts = new Vec3D[8]; pts[0] = _origin; pts[1] = _origin.add(u); pts[2] = _origin.add(v.add(u)); pts[3] = _origin.add(v); pts[4] = _origin.add(w); pts[5]= _origin.add(u.add(w)); pts[6]= _origin.add(u.add(v.add(w))); pts[7]= _origin.add(v.add(w)); }

}

void render() { quad(pts[0], pts[1], pts[2], pts[3]); quad(pts[0], pts[1], pts[5], pts[4]); quad(pts[1], pts[2], pts[6], pts[5]); quad(pts[2], pts[3], pts[7], pts[6]); quad(pts[3], pts[0], pts[4], pts[7]); quad(pts[4], pts[5], pts[6], pts[7]); } void quad(Vec3D p, Vec3D q, Vec3D r, Vec3D s) { beginShape(QUAD); vertex(p.x, p.y, p.z); vertex(q.x, q.y, q.z); vertex(r.x, r.y, r.z); vertex(s.x, s.y, s.z); endShape(); }

public class Structure { float boxD; float boxH; float canopyW; float canopyH1; float canopyH2; float canopyH3; float canopyH4; float columnStance; float columnDim1; BoxUVW column1; BoxUVW column2; BoxUVW column3; float columnDim2; float columnDim3; float screenPos; float screenW; float screenD; float screenH; float screenT1; float screenT2; float rollDoorH; Structure( float boxD, float boxH, float canopyW, float canopyH1, float canopyH2, float canopyH3, float canopyH4, float columnStance, float columnDim1, float columnDim2, float columnDim3, float screenPos, float screenW, float screenD, float screenH, float screenT1, float screenT2, float rollDoorH ) { this.boxD = boxD; this.boxH = boxH; this.canopyW = canopyW; this.canopyH1 = canopyH1; this.canopyH2 = canopyH2; this.canopyH3 = canopyH3; this.canopyH4 = canopyH4; this.columnStance=columnStance; this.columnDim1 = columnDim1; this.columnDim2 = columnDim2; this.columnDim3 = columnDim3; this.screenPos = screenPos; this.screenW = screenW; this.screenD = screenD; this.screenH = screenH; this.screenT1 = screenT1; this.screenT2 = screenT2; this.rollDoorH = rollDoorH*boxH; column1 = new BoxUVW(new Vec3D(), Vec3D(columnDim2, 0, 0), new Vec3D(0, new Vec3D(0, 0, canopyH1)); column2 = new BoxUVW(new Vec3D(), Vec3D(columnDim2, 0, 0), new Vec3D(0, new Vec3D(0, 0, canopyH2)); column3 = new BoxUVW(new Vec3D(), Vec3D(columnDim2, 0, 0), new Vec3D(0, new Vec3D(0, 0, boxH)); }

new columnDim1, 0), new columnDim3, 0), new columnDim2, 0),

void render() { //CUBE beginShape(); vertex(-boxD/2, canopyW, boxH); vertex(boxD/2, canopyW, boxH); vertex(boxD/2, canopyW+boxD, boxH); vertex(-boxD/2, canopyW+boxD, boxH); endShape(CLOSE); beginShape(); vertex(-boxD/2, canopyW, boxH); vertex(boxD/2, canopyW, boxH); vertex(boxD/2, canopyW, 0);

118

vertex(-boxD/2, canopyW, 0); endShape(CLOSE); beginShape(); vertex(boxD/2, canopyW, boxH); vertex(boxD/2, canopyW+boxD, boxH); vertex(boxD/2, canopyW+boxD, 0); vertex(boxD/2, canopyW, 0); endShape(CLOSE); beginShape(); vertex(-boxD/2, canopyW, boxH); vertex(-boxD/2, canopyW+boxD, boxH); vertex(-boxD/2, canopyW+boxD, rollDoorH); vertex(-boxD/2, canopyW, rollDoorH); endShape(CLOSE); beginShape(); vertex(boxD/2, canopyW+boxD, boxH); vertex(-boxD/2, canopyW+boxD, boxH); vertex(-boxD/2, canopyW+boxD, 0); vertex(boxD/2, canopyW+boxD, 0); endShape(CLOSE); //CUBE door pushMatrix(); translate(-boxD/2, canopyW+columnDim2+(boxD2*columnDim2)/4, 0); rotate(QUARTER_PI); beginShape(); vertex(-(boxD-2*columnDim2)/4, 0, 0); vertex(-(boxD-2*columnDim2)/4, 0, rollDoorH); vertex((boxD-2*columnDim2)/4, 0, rollDoorH); vertex((boxD-2*columnDim2)/4, 0, 0); endShape(CLOSE); popMatrix(); pushMatrix(); translate(-boxD/2, canopyW+boxD-(boxD2*columnDim2)/4-columnDim2, 0); rotate(QUARTER_PI); beginShape(); vertex(-(boxD-2*columnDim2)/4, 0, 0); vertex(-(boxD-2*columnDim2)/4, 0, rollDoorH); vertex((boxD-2*columnDim2)/4, 0, rollDoorH); vertex((boxD-2*columnDim2)/4, 0, 0); endShape(CLOSE); popMatrix(); //CUBE column pushMatrix(); translate(boxD/2-columnDim2, canopyW, 0); column3.render(); popMatrix(); pushMatrix(); translate(boxD/2-columnDim2, canopyW+boxDcolumnDim2, 0); column3.render(); popMatrix(); pushMatrix(); translate(-boxD/2, canopyW, 0); column3.render(); popMatrix(); pushMatrix(); translate(-boxD/2, canopyW+boxD-columnDim2, 0); column3.render(); popMatrix(); //canopy beginShape(); vertex(0, 0, canopyH1); vertex(0, canopyW, canopyH1); vertex(columnStance, canopyW, canopyH2); vertex(columnStance, 0, canopyH2); endShape(CLOSE); beginShape(); vertex(0, 0, canopyH1); vertex(0, canopyW, canopyH1); vertex(-columnStance, canopyW, canopyH2); vertex(-columnStance, 0, canopyH2); endShape(CLOSE); beginShape(); vertex(-columnStance, canopyW, canopyH2); vertex(-columnStance, 0, canopyH2); vertex(-columnStance*2, 0, canopyH3); vertex(-columnStance*2, canopyW, canopyH3); endShape(CLOSE); beginShape();

vertex(columnStance, canopyW, canopyH2); vertex(columnStance, 0, canopyH2); vertex(columnStance*2, 0, canopyH3); vertex(columnStance*2, canopyW, canopyH3); endShape(CLOSE); beginShape(); vertex(columnStance*2, 0, canopyH3); vertex(columnStance*2, canopyW, canopyH3); vertex(columnStance*3, canopyW, canopyH4); vertex(columnStance*3, 0, canopyH4); endShape(CLOSE); //canopy column pushMatrix(); translate(-columnDim2/2, -columnDim1, 0); column1.render(); popMatrix(); pushMatrix(); translate(-columnStance-columnDim2/2, 0, 0); column2.render(); popMatrix(); pushMatrix(); translate(-columnStance-columnDim2/2, canopyWcolumnDim3, 0); column2.render(); popMatrix(); pushMatrix(); translate(columnStance-columnDim2/2, 0, 0); column2.render(); popMatrix(); pushMatrix(); translate(columnStance-columnDim2/2, canopyWcolumnDim3, 0); column2.render(); popMatrix(); //screen beginShape(); vertex(-screenW/2, -screenPos, 0); vertex(screenW/2, -screenPos, 0); vertex(screenW/2, -screenPos+screenD, screenH); vertex(-screenW/2, -screenPos+screenD, screenH); endShape(CLOSE); beginShape(); vertex(-screenW/2, -screenPos+screenT1, 0); vertex(screenW/2, -screenPos+screenT1, 0); vertex(screenW/2, -screenPos+screenD+screenT2, screenH); vertex(-screenW/2, -screenPos+screenD+screenT2, screenH); endShape(CLOSE); beginShape(); vertex(screenW/2, -screenPos+screenT1, 0); vertex(screenW/2, -screenPos+screenD+screenT2, screenH); vertex(screenW/2, -screenPos+screenD, screenH); vertex(screenW/2, -screenPos, 0); endShape(CLOSE); beginShape(); vertex(-screenW/2, -screenPos+screenT1, 0); vertex(-screenW/2, -screenPos+screenD+screenT2, screenH); vertex(-screenW/2, -screenPos+screenD, screenH); vertex(-screenW/2, -screenPos, 0); endShape(CLOSE); beginShape(); vertex(screenW/2, -screenPos+screenD, screenH); vertex(screenW/2, -screenPos+screenD+screenT2, screenH); vertex(-screenW/2, -screenPos+screenD+screenT2, screenH); vertex(-screenW/2, -screenPos+screenD, screenH); endShape(CLOSE); } }

119

source code

/* Ryuyu Ishihara Computational Solution for Architectural Design peter zumthor //________________________________________________*/ import processing.dxf.*; boolean record; import import import import import import import import import import import

import toxi.processing.*; import import import import

peasy.test.*; peasy.org.apache.commons.math.*; peasy.*; peasy.org.apache.commons.math.geometry.*;

PeasyCam cam; ToxiclibsSupport gfx; Plane gl; Structure st; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); //seting camera perspective(PI/3.0, (float)width/height, 1, 100000); cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999000); //__ gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1)); //write your own below__ st = new Structure( 360, // float _courtWE, 2500, // float _courtNS, 140, //float _corridorW, 240, //float _nokishitaW, 560, //float _buildingH, .46, //float _roofHratio .1, //float _exDoorPos, ratio 0-1 .018, //float _exDoorW, ratio to wall lengthNS .33, // float _exDoorH ratio to buildingH .3, //float _inDoorPos,ratio 0-1 .012, //float _inDoor Wratio to wall lengthNS .9// float _inDoorH ratio to bulidingH*ratio );

} //__________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 20000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ st.render(); //record end______________ if (record) { endRaw(); record = false; } } //cam key_____________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order }

void rightView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order } void leftView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, PI, PI); // pitch, rotations are applied in that order }

yaw,

yaw, roll

120

class Structure { float lengthWE; float lengthNS; float corridorW; float nokishitaW; float buildingH; float roofHratio; float courtWE; float courtNS; float exDoorPos; float exDoorW; float exDoorH; float inDoorPos; float inDoorW; float inDoorH; Structure( float _courtWE, float _courtNS, float _corridorW, float _nokishitaW, float _buildingH, float _roofHratio, float _exDoorPos, float _exDoorW, float _exDoorH, float _inDoorPos, float _inDoorW, float _inDoorH ) { this.courtWE = _courtWE; this.courtNS = _courtNS; this.corridorW = _corridorW; this.nokishitaW = _nokishitaW; this.buildingH = _buildingH; this.roofHratio = _roofHratio; this.lengthWE = _courtWE+_corridorW*2+nokishitaW*2; this.lengthNS = _courtNS+_corridorW*2+nokishitaW*2; this.exDoorPos = _exDoorPos; this.exDoorW = _exDoorW*lengthNS; this.exDoorH = _exDoorH*buildingH; this.inDoorPos = _inDoorPos; this.inDoorW = _inDoorW*courtNS; this.inDoorH = _inDoorH*buildingH*roofHratio; } void render() { stroke(0, 0, 360); fill(360, 360, 360, 200); //wall west beginShape(); vertex(0, 0, 0); vertex(0, 0, buildingH); vertex(0, lengthNS, buildingH); vertex(0, lengthNS, 0); vertex(0, lengthNS*(1-exDoorPos), 0); vertex(0, lengthNS*(1-exDoorPos), exDoorH); vertex(0, lengthNS*(1-exDoorPos)-exDoorW, exDoorH); vertex(0, lengthNS*(1-exDoorPos)-exDoorW, 0); vertex(0, lengthNS*.5+exDoorW*.5, 0); vertex(0, lengthNS*.5+exDoorW*.5, exDoorH); vertex(0, lengthNS*.5-exDoorW*.5, exDoorH); vertex(0, lengthNS*.5-exDoorW*.5, 0); vertex(0, lengthNS*exDoorPos+exDoorW, 0); vertex(0, lengthNS*exDoorPos+exDoorW, exDoorH); vertex(0, lengthNS*exDoorPos, exDoorH); vertex(0, lengthNS*exDoorPos, 0); endShape(CLOSE); fill(30, 360, 360, 200); //wall north beginShape(); vertex(0, 0, 0); vertex(0, 0, buildingH); vertex(lengthWE, 0, buildingH); vertex(lengthWE, 0, 0); endShape(CLOSE); fill(200, 360, 360, 200); //wall east beginShape(); vertex(lengthWE, 0, 0); vertex(lengthWE, 0, buildingH); vertex(lengthWE, lengthNS, buildingH); vertex(lengthWE, lengthNS, 0); vertex(lengthWE, lengthNS*(1-exDoorPos), 0);

vertex(lengthWE, lengthNS*(1-exDoorPos), exDoorH); vertex(lengthWE, lengthNS*(1-exDoorPos)-exDoorW, exDoorH); vertex(lengthWE, lengthNS*(1-exDoorPos)-exDoorW, 0); vertex(lengthWE, lengthNS*.5+exDoorW*.5, 0); vertex(lengthWE, lengthNS*.5+exDoorW*.5, exDoorH); vertex(lengthWE, lengthNS*.5-exDoorW*.5, exDoorH); vertex(lengthWE, lengthNS*.5-exDoorW*.5, 0); vertex(lengthWE, lengthNS*exDoorPos+exDoorW, 0); vertex(lengthWE, lengthNS*exDoorPos+exDoorW, exDoorH); vertex(lengthWE, lengthNS*exDoorPos, exDoorH); vertex(lengthWE, lengthNS*exDoorPos, 0); endShape(CLOSE); fill(270, 360, 360, 200); //wall we-s beginShape(); vertex(lengthWE, lengthNS, 0); vertex(lengthWE, lengthNS, buildingH); vertex(0, lengthNS, buildingH); vertex(0, lengthNS, 0); endShape(CLOSE); fill(0, 360, 360, 200); //roof north beginShape(); vertex(0, 0, buildingH); vertex(corridorW+nokishitaW, corridorW+nokishitaW, buildingH*roofHratio); vertex(lengthWE-(corridorW+nokishitaW), corridorW+nokishitaW, buildingH*roofHratio); vertex(lengthWE, 0, buildingH); endShape(CLOSE); //roof east beginShape(); vertex(lengthWE, 0, buildingH); vertex(lengthWE-(corridorW+nokishitaW), corridorW+nokishitaW, buildingH*roofHratio); vertex(lengthWE-(corridorW+nokishitaW), lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(lengthWE, lengthNS, buildingH); endShape(CLOSE); //roof south beginShape(); vertex(lengthWE, lengthNS, buildingH); vertex(lengthWE-(corridorW+nokishitaW), lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(corridorW+nokishitaW, lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(0, lengthNS, buildingH); endShape(CLOSE); //roof west beginShape(); vertex(0, lengthNS, buildingH); vertex(corridorW+nokishitaW, lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(corridorW+nokishitaW, corridorW+nokishitaW, buildingH*roofHratio); vertex(0, 0, buildingH); endShape(CLOSE); fill(160, 360, 360, 200); //inner wall north beginShape(); vertex(corridorW, corridorW, 0); vertex(corridorW, corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); ////z-1, just for rendering no meaning vertex(lengthWE-corridorW, corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); vertex(lengthWE-corridorW, corridorW, 0); endShape(CLOSE); //inner wall east beginShape(); vertex(lengthWE-corridorW, corridorW, 0); vertex(lengthWE-corridorW, corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); ////z-1, just for rendering no meaning

121

source code

vertex(lengthWE-corridorW, lengthNS-corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); vertex(lengthWE-corridorW, lengthNS-corridorW, 0); vertex(lengthWE-corridorW, lengthNS-corridorW(lengthNS-corridorW*2)*inDoorPos, 0); vertex(lengthWE-corridorW, lengthNS-corridorW(lengthNS-corridorW*2)*inDoorPos, inDoorH); vertex(lengthWE-corridorW, lengthNS-corridorW(lengthNS-corridorW*2)*inDoorPos+inDoorW, inDoorH); vertex(lengthWE-corridorW, lengthNS-corridorW(lengthNS-corridorW*2)*inDoorPos+inDoorW, 0); vertex(lengthWE-corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW+inDoorW, 0); vertex(lengthWE-corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW+inDoorW, inDoorH); vertex(lengthWE-corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW, inDoorH); vertex(lengthWE-corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW, 0); endShape(CLOSE); //inner wall south beginShape(); vertex(lengthWE-corridorW, lengthNS-corridorW, 0); vertex(lengthWE-corridorW, lengthNS-corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); ////z-1, just for rendering no meaning vertex(corridorW, lengthNS-corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); vertex(corridorW, lengthNS-corridorW, 0); endShape(CLOSE); //inner wall west beginShape(); vertex(corridorW, corridorW, 0); vertex(corridorW, corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); ////z-1, just for rendering no meaning vertex(corridorW, lengthNS-corridorW, buildingH*(roofHratio+nokishitaW*(1-roofHratio)/ (nokishitaW+corridorW))-1); vertex(corridorW, lengthNS-corridorW, 0); vertex(corridorW, lengthNS-corridorW-(lengthNScorridorW*2)*inDoorPos, 0); vertex(corridorW, lengthNS-corridorW-(lengthNScorridorW*2)*inDoorPos, inDoorH); vertex(corridorW, lengthNS-corridorW-(lengthNScorridorW*2)*inDoorPos+inDoorW, inDoorH); vertex(corridorW, lengthNS-corridorW-(lengthNScorridorW*2)*inDoorPos+inDoorW, 0); vertex(corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW+inDoorW, 0); vertex(corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW+inDoorW, inDoorH); vertex(corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW, inDoorH); vertex(corridorW, inDoorPos*(lengthNS2*corridorW)+corridorW, 0); endShape(CLOSE); //nokiura north beginShape(); vertex(corridorW, corridorW, buildingH*roofHratio); vertex(corridorW+nokishitaW, corridorW+nokishitaW, buildingH*roofHratio); vertex(lengthWE-(corridorW+nokishitaW), corridorW+nokishitaW, buildingH*roofHratio); vertex(lengthWE-corridorW, corridorW, buildingH*roofHratio); endShape(CLOSE); //nokiura east beginShape(); vertex(lengthWE-corridorW, corridorW, buildingH*roofHratio); vertex(lengthWE-(corridorW+nokishitaW), corridorW+nokishitaW, buildingH*roofHratio); vertex(lengthWE-(corridorW+nokishitaW), lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(lengthWE-corridorW, lengthNS-corridorW,

buildingH*roofHratio); endShape(CLOSE); //nokiura south beginShape(); vertex(lengthWE-corridorW, lengthNS-corridorW, buildingH*roofHratio); vertex(lengthWE-(corridorW+nokishitaW), lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(corridorW+nokishitaW, lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(corridorW, lengthNS-corridorW, buildingH*roofHratio); endShape(CLOSE); //nokiura west beginShape(); vertex(corridorW, lengthNS-corridorW, buildingH*roofHratio); vertex(corridorW+nokishitaW, lengthNS(corridorW+nokishitaW), buildingH*roofHratio); vertex(corridorW+nokishitaW, corridorW+nokishitaW, buildingH*roofHratio); vertex(corridorW, corridorW, buildingH*roofHratio); endShape(CLOSE); } }

122

/* Ryuyu Ishihara Computational Solution for Architectural Design HdM kekomi curves //_________________________________________________*/ import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport gfx; Plane gl; //Floor flr; float roofR = 1000; float roofT =50; float roofH =500; float roofShiftX=512.5*sqrt(3); float roofShiftY=-512.5; float digH=300; float holesize = 1150.2; float extender = 99990; float floorHdiff = digH/11; void setup() { size(1000, 1000, P3D); colorMode(HSB, 360); gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1));// ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__ for (int i=0;i<121;i++) { print("//region"); println(i); println("beginShape();" ); println("endShape(CLOSE);" ); println("beginShape(QUAD_STRIP);" ); println("endShape();" ); }

} //_______________________________________________ void draw() { // lights(); background(0); fill(30, 10, 200, 350); noStroke(); // gfx.plane(gl, 10000); if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ //roof fill(200, 200, 300); // stroke(200, 200, 360); // noFill(); pushMatrix(); translate(roofShiftX, roofShiftY, roofH); arc(0, 0, 2*roofR, 2*roofR, -5*PI/6, 5*PI/6, CHORD); beginShape(QUAD_STRIP); for (int i=0;i<51;i++) { vertex(roofR*cos(-5*PI/6+i*PI/30), roofR*sin(5*PI/6+i*PI/30), 0);

vertex(roofR*cos(-5*PI/6+i*PI/30), roofR*sin(5*PI/6+i*PI/30), roofT); } vertex(roofR*cos(-5*PI/6), roofR*sin(-5*PI/6), 0); vertex(roofR*cos(-5*PI/6), roofR*sin(-5*PI/6), roofT); endShape(); translate(0, 0, roofT); arc(0, 0, 2*roofR, 2*roofR, -5*PI/6, 5*PI/6, CHORD); popMatrix(); //ground hole stroke(0, 0, 300); fill(30, 10, 200, 350); pushMatrix(); translate(1174.9, -271.1, digH); noStroke(); beginShape(); for (int i=0;i<61;i++) { vertex((holesize+extender)*cos(i*2*PI/60), (holesi ze+extender)*sin(i*2*PI/60), 0); } for (int i=0;i<61;i++) { vertex((holesize)*cos(-i*2*PI/60), (holesize)*sin(-i*2*PI/60), 0); } endShape(); beginShape(QUAD_STRIP); for (int i=0;i<61;i++) { vertex((holesize)*cos(-i*2*PI/60), (holesize)*sin(-i*2*PI/60), 0); vertex((holesize)*cos(-i*2*PI/60), (holesize)*sin(-i*2*PI/60), -digH); } endShape(); popMatrix(); fill(200, 200, 300, 200); //region1 /* translate(0, 0, *floorHdiff); beginShape(); endShape();*/ //region2 beginShape(); vertex(1083.4*cos(-144*PI/180)+1197.8, 144*PI/180)+-286, 6*floorHdiff); vertex(1083.4*cos(-133*PI/180)+1197.8, 133*PI/180)+-286, 6*floorHdiff); vertex(1083.4*cos(-122*PI/180)+1197.8, 122*PI/180)+-286, 6*floorHdiff); vertex(326, -929.3, 6*floorHdiff); vertex(621, -1203.2, 6*floorHdiff); vertex(608.9, -1138.1, 6*floorHdiff); vertex(371.6, -833, 6*floorHdiff); endShape(); beginShape(QUAD_STRIP); vertex(1083.4*cos(-144*PI/180)+1197.8, 144*PI/180)+-286, 6*floorHdiff); vertex(1083.4*cos(-144*PI/180)+1197.8, 144*PI/180)+-286, 0); vertex(1083.4*cos(-133*PI/180)+1197.8, 133*PI/180)+-286, 6*floorHdiff); vertex(1083.4*cos(-133*PI/180)+1197.8, 133*PI/180)+-286, 0); vertex(1083.4*cos(-122*PI/180)+1197.8, 122*PI/180)+-286, 6*floorHdiff); vertex(1083.4*cos(-122*PI/180)+1197.8, 122*PI/180)+-286, 0); vertex(608.9, -1138.1, 6*floorHdiff); vertex(608.9, -1138.1, 0); vertex(371.6, -833, 6*floorHdiff); vertex(371.6, -833, 0); vertex(1083.4*cos(-144*PI/180)+1197.8, 144*PI/180)+-286, 6*floorHdiff); vertex(1083.4*cos(-144*PI/180)+1197.8, 144*PI/180)+-286, 0); endShape(CLOSE); //region3 column

1083.4*sin(1083.4*sin(1083.4*sin(-

1083.4*sin(1083.4*sin(1083.4*sin(1083.4*sin(1083.4*sin(1083.4*sin(-

1083.4*sin(1083.4*sin(-

123

source code

fill(200, 200, 300, 200); beginShape(); vertex(604.587, -1114.34, roofH); vertex(608.986, -1138.14, roofH); vertex(621.096, -1203.25, roofH); vertex(624.907, -1223.56, roofH); vertex (693.073, -1261.67, roofH); vertex(682.621, -1205.01, roofH); vertex(663.751, -1103.35, roofH); vertex(604.587, -1114.34, roofH); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(604.587, -1114.34, roofH); vertex(604.587, -1114.34, 0); vertex(608.986, -1138.14, roofH); vertex(608.986, -1138.14, 0); vertex(621.096, -1203.25, roofH); vertex(621.096, -1203.25, 0); vertex(624.907, -1223.56, roofH); vertex(624.907, -1223.56, 0); vertex (693.073, -1261.67, roofH); vertex (693.073, -1261.67, 0); vertex(682.621, -1205.01, roofH); vertex(682.621, -1205.01, 0); vertex(663.751, -1103.35, roofH); vertex(663.751, -1103.35, 0); vertex(604.587, -1114.34, roofH); vertex(604.587, -1114.34, 0); endShape(CLOSE); //region4 beginShape(); vertex(779.863, -1118.57, 7*floorHdiff); vertex(806.958, -1264.22, 7*floorHdiff); vertex(816.697, -1316.29, 7*floorHdiff); vertex(881.897, -1337.88, 7*floorHdiff); vertex (872.615, -1287.93, 7*floorHdiff); vertex(849.72, -1164.71, 7*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(779.863, -1118.57, 7*floorHdiff); vertex(779.863, -1118.57, 0); vertex(806.958, -1264.22, 7*floorHdiff); vertex(806.958, -1264.22, 0); vertex(816.697, -1316.29, 7*floorHdiff); vertex(816.697, -1316.29, 0); vertex(881.897, -1337.88, 7*floorHdiff); vertex(881.897, -1337.88, 0); vertex (872.615, -1287.93, 7*floorHdiff); vertex (872.615, -1287.93, 0); vertex(849.72, -1164.71, 7*floorHdiff); vertex(849.72, -1164.71, 0); vertex(779.863, -1118.57, 7*floorHdiff); vertex(779.863, -1118.57, 0); endShape(); //region5 beginShape(); vertex(1058.44545, -1278.18945, 7*floorHdiff); vertex(967.84435, -1313.74747, 7*floorHdiff); vertex(895.86842, -1342.11920, 7*floorHdiff); vertex(1098.24153, -1379.37439, 7*floorHdiff); vertex(1079.61475, -1331.95723, 7*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1058.44545, -1278.18945, 7*floorHdiff); vertex(1058.44545, -1278.18945, 0); vertex(967.84435, -1313.74747, 7*floorHdiff); vertex(967.84435, -1313.74747, 0); vertex(895.86842, -1342.11920, 7*floorHdiff); vertex(895.86842, -1342.11920, 0); vertex(1098.24153, -1379.37439, 7*floorHdiff); vertex(1098.24153, -1379.37439, 0); vertex(1079.61475, -1331.95723, 7*floorHdiff); vertex(1079.61475, -1331.95723, 0); vertex(1058.44545, -1278.18945, 7*floorHdiff); vertex(1058.44545, -1278.18945, 0); endShape(); //region6 beginShape(); vertex(1989.72718, -895.43980, 7*floorHdiff); vertex(1895.89263, -918.73326, 7*floorHdiff); vertex(1895.89263, -951.75847, 7*floorHdiff); vertex(1895.89263, -990.28733, 7*floorHdiff);

vertex(1783.27526, -1095.28685, 7*floorHdiff); vertex(1774.38889, -1047.95966, 7*floorHdiff); vertex(1444.56974, -1309.09562, 7*floorHdiff); vertex(1383.40757, -1267.03235, 7*floorHdiff); vertex(1340.84552, -1328.14912, 7*floorHdiff); vertex(1315.00337, -1364.98082, 7*floorHdiff); vertex(1329.40502, -1375.13633, 7*floorHdiff); vertex(1779.45422, -1213.40464, 7*floorHdiff); vertex(1801.02236, -1190.18403, 7*floorHdiff); vertex(1792.16517, -1142.69592, 7*floorHdiff); vertex(1895.89263, -1028.80650, 7*floorHdiff); vertex(1895.89263, -1067.41433, 7*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1989.72718, -895.43980, 7*floorHdiff); vertex(1989.72718, -895.43980, 0); vertex(1895.89263, -918.73326, 7*floorHdiff); vertex(1895.89263, -918.73326, 0); vertex(1895.89263, -951.75847, 7*floorHdiff); vertex(1895.89263, -951.75847, 0); vertex(1895.89263, -990.28733, 7*floorHdiff); vertex(1895.89263, -990.28733, 0); vertex(1783.27526, -1095.28685, 7*floorHdiff); vertex(1783.27526, -1095.28685, 0); vertex(1774.38889, -1047.95966, 7*floorHdiff); vertex(1774.38889, -1047.95966, 0); vertex(1444.56974, -1309.09562, 7*floorHdiff); vertex(1444.56974, -1309.09562, 0); vertex(1383.40757, -1267.03235, 7*floorHdiff); vertex(1383.40757, -1267.03235, 0); vertex(1340.84552, -1328.14912, 7*floorHdiff); vertex(1340.84552, -1328.14912, 0); vertex(1315.00337, -1364.98082, 7*floorHdiff); vertex(1315.00337, -1364.98082, 0); vertex(1329.40502, -1375.13633, 7*floorHdiff); vertex(1329.40502, -1375.13633, 0); vertex(1779.45422, -1213.40464, 7*floorHdiff); vertex(1779.45422, -1213.40464, 0); vertex(1801.02236, -1190.18403, 7*floorHdiff); vertex(1801.02236, -1190.18403, 0); vertex(1792.16517, -1142.69592, 7*floorHdiff); vertex(1792.16517, -1142.69592, 0); vertex(1895.89263, -1028.80650, 7*floorHdiff); vertex(1895.89263, -1028.80650, 0); vertex(1895.89263, -1067.41433, 7*floorHdiff); vertex(1895.89263, -1067.41433, 0); endShape(); //region7 beginShape(); vertex(1895.89263, -1067.41433, 9*floorHdiff); vertex(1801.02236, -1190.18403, 9*floorHdiff); vertex(1808.65523, -1231.10794, 9*floorHdiff); vertex(1895.89263, -1167.67495, 9*floorHdiff); vertex(1895.89263, -1124.07237, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1895.89263, -1067.41433, 9*floorHdiff); vertex(1895.89263, -1067.41433, 0); vertex(1801.02236, -1190.18403, 9*floorHdiff); vertex(1801.02236, -1190.18403, 0); vertex(1808.65523, -1231.10794, 9*floorHdiff); vertex(1808.65523, -1231.10794, 0); vertex(1895.89263, -1167.67495, 9*floorHdiff); vertex(1895.89263, -1167.67495, 0); vertex(1895.89263, -1124.07237, 9*floorHdiff); vertex(1895.89263, -1124.07237, 0); endShape(); //region8 beginShape(); vertex(1895.89263, -1028.80650, vertex(1792.16517, -1142.69592, vertex(1801.02236, -1190.18403, vertex(1895.89263, -1067.41433, endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1895.89263, -1028.80650, vertex(1895.89263, -1028.80650, vertex(1792.16517, -1142.69592, vertex(1792.16517, -1142.69592, vertex(1801.02236, -1190.18403, vertex(1801.02236, -1190.18403, vertex(1895.89263, -1067.41433, vertex(1895.89263, -1067.41433,

8*floorHdiff); 8*floorHdiff); 8*floorHdiff); 8*floorHdiff); 8*floorHdiff); 0); 8*floorHdiff); 0); 8*floorHdiff); 0); 8*floorHdiff); 0);

124

vertex(1895.89263, -1028.80650, 8*floorHdiff); vertex(1895.89263, -1028.80650, 0); endShape(); //region9 beginShape(); vertex(1895.89263, -951.75847, 6*floorHdiff); vertex(1774.38889, -1047.95966, 6*floorHdiff); vertex(1783.27526, -1095.28685, 6*floorHdiff); vertex(1895.89263, -990.28733, 6*floorHdiff); endShape(CLOSE); vertex(1895.89263, -951.75847, 6*floorHdiff); vertex(1895.89263, -951.75847, 0); vertex(1774.38889, -1047.95966, 6*floorHdiff); vertex(1774.38889, -1047.95966, 0); vertex(1783.27526, -1095.28685, 6*floorHdiff); vertex(1783.27526, -1095.28685, 0); vertex(1895.89263, -990.28733, 6*floorHdiff); vertex(1895.89263, -990.28733, 0); vertex(1895.89263, -951.75847, 6*floorHdiff); vertex(1895.89263, -951.75847, 0); beginShape(QUAD_STRIP); endShape(); //region10 beginShape(); vertex(1895.89263, -918.73326, 5*floorHdiff); vertex(1757.86629, -959.80303, 5*floorHdiff); vertex(1774.38889, -1047.95966, 5*floorHdiff); vertex(1895.89263, -951.75847, 5*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1895.89263, -918.73326, 5*floorHdiff); vertex(1895.89263, -918.73326, 0); vertex(1757.86629, -959.80303, 5*floorHdiff); vertex(1757.86629, -959.80303, 0); vertex(1774.38889, -1047.95966, 5*floorHdiff); vertex(1774.38889, -1047.95966, 0); vertex(1895.89263, -951.75847, 5*floorHdiff); vertex(1895.89263, - 951.75847, 0); vertex(1895.89263, -918.73326, 5*floorHdiff); vertex(1895.89263, -918.73326, 0); endShape(); //region11 beginShape(); vertex(2163.03600, -859.88530, 9*floorHdiff); vertex(2142.29503, -863.69988, 9*floorHdiff); vertex(2059.34937, -880.00183, 9*floorHdiff); vertex(1895.89263, -1124.07237, 9*floorHdiff); vertex(1895.89263, -1167.67495, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(2163.03600, -859.88530, 9*floorHdiff); vertex(2163.03600, -859.88530, 0); vertex(2142.29503, -863.69988, 9*floorHdiff); vertex(2142.29503, -863.69988, 0); vertex(2059.34937, -880.00183, 9*floorHdiff); vertex(2059.34937, -880.00183, 0); vertex(1895.89263, -1124.07237, 9*floorHdiff); vertex(1895.89263, -1124.07237, 0); vertex(1895.89263, -1167.67495, 9*floorHdiff); vertex(1895.89263, -1167.67495, 0); vertex(2163.03600, -859.88530, 9*floorHdiff); vertex(2163.03600, -859.88530, 0); endShape(); //region12 beginShape(); vertex(2059.34937, -880.00183, 8*floorHdiff); vertex(1989.72718, -895.43980, 8*floorHdiff); vertex(1895.89263, -1067.41433, 8*floorHdiff); vertex(1895.89263, -1124.07237, 8*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(2059.34937, -880.00183, 8*floorHdiff); vertex(2059.34937, -880.00183, 0); vertex(1989.72718, -895.43980, 8*floorHdiff); vertex(1989.72718, -895.43980, 0); vertex(1895.89263, -1067.41433, 8*floorHdiff); vertex(1895.89263, -1067.41433, 0); vertex(1895.89263, -1124.07237, 8*floorHdiff); vertex(1895.89263, -1124.07237, 0); endShape(); //region13 beginShape(); vertex(2265.91648, -571.55970, 8*floorHdiff); vertex(2238.91127, -611.88338, 8*floorHdiff);

vertex(2059.34937, -880.00183, 8*floorHdiff); vertex(2142.29503, -863.69988, 8*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(2265.91648, -571.55970, 8*floorHdiff); vertex(2265.91648, -571.55970, 0); vertex(2238.91127, -611.88338, 8*floorHdiff); vertex(2238.91127, -611.88338, 0); vertex(2059.34937, -880.00183, 8*floorHdiff); vertex(2059.34937, -880.00183, 0); vertex(2142.29503, -863.69988, 8*floorHdiff); vertex(2142.29503, -863.69988, 0); vertex(2265.91648, -571.55970, 8*floorHdiff); vertex(2265.91648, -571.55970, 0); endShape(); //region14 beginShape(); vertex(2255.75289, -32.18147, 7*floorHdiff); vertex(2138.83513, -58.21128, 7*floorHdiff); vertex(2019.94405, -84.68042, 7*floorHdiff); vertex(1989.72718, -895.43980, 7*floorHdiff); vertex(2059.34937, -880.00183, 7*floorHdiff); vertex(2238.91127, -611.88338, 7*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(2255.75289, -32.18147, 7*floorHdiff); vertex(2255.75289, -32.18147, 0); vertex(2138.83513, -58.21128, 7*floorHdiff); vertex(2138.83513, -58.21128, 0); vertex(2019.94405, -84.68042, 7*floorHdiff); vertex(2019.94405, -84.68042, 0); vertex(1989.72718, -895.43980, 7*floorHdiff); vertex(1989.72718, -895.43980, 0); vertex(2059.34937, -880.00183, 7*floorHdiff); vertex(2059.34937, -880.00183, 0); vertex(2238.91127, -611.88338, 7*floorHdiff); vertex(2238.91127, -611.88338, 0); vertex(2255.75289, -32.18147, 7*floorHdiff); vertex(2255.75289, -32.18147, 0); endShape(); //region15 beginShape(); vertex(373.14654, -829.89838, 5*floorHdiff); vertex(371.63479, -833.08836, 5*floorHdiff); vertex(608.98637, -1138.14160, 5*floorHdiff); vertex(604.58652, -1114.34197, 5*floorHdiff); vertex(580.87633, -987.32295, 5*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(373.14654, -829.89838, 5*floorHdiff); vertex(373.14654, -829.89838, 0); vertex(371.63479, -833.08836, 5*floorHdiff); vertex(371.63479, -833.08836, 0); vertex(608.98637, -1138.14160, 5*floorHdiff); vertex(608.98637, -1138.14160, 0); vertex(604.58652, -1114.34197, 5*floorHdiff); vertex(604.58652, -1114.34197, 0); vertex(580.87633, -987.32295, 5*floorHdiff); vertex(580.87633, -987.32295, 0); vertex(373.14654, -829.89838, 5*floorHdiff); vertex(373.14654, -829.89838, 0); endShape(); //region16 beginShape(); vertex(580.87633, -987.32295, 6*floorHdiff); vertex(604.58652, -1114.34197, 6*floorHdiff); vertex(663.75131, -1103.35182, 6*floorHdiff); vertex(650.73161, -1033.04456, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(580.87633, -987.32295, 6*floorHdiff); vertex(580.87633, -987.32295, 0); vertex(604.58652, -1114.34197, 6*floorHdiff); vertex(604.58652, -1114.34197, 0); vertex(663.75131, -1103.35182, 6*floorHdiff); vertex(663.75131, -1103.35182, 0); vertex(650.73161, -1033.04456, 6*floorHdiff); vertex(650.73161, -1033.04456, 0); vertex(580.87633, -987.32295, 6*floorHdiff); vertex(580.87633, -987.32295, 0); endShape(); //region17 // fill(0, 200, 360); beginShape();

125

source code

vertex(1018.06552, 530.96141, 4*floorHdiff); vertex(904.33485, 290.85518, 4*floorHdiff); vertex(1038.97170, 296.78394, 4*floorHdiff); vertex(1079.19127, 298.47787, 4*floorHdiff); vertex(1089.77996, 299.32484, 4*floorHdiff); vertex(1087.66093, 351.82702, 4*floorHdiff); vertex(1153.70325, 341.28800, 4*floorHdiff); vertex(1153.70325, 352.24404, 4*floorHdiff); vertex(1215.51721, 352.24404, 4*floorHdiff); vertex(1215.51721, 333.19378, 4*floorHdiff); vertex(1201.54550, 333.19378, 4*floorHdiff); vertex(1201.54550, 328.88022, 4*floorHdiff); vertex(1288.76682, 297.21389, 4*floorHdiff); vertex(1357.34843, -71.55568, 4*floorHdiff); vertex(1414.92271, -53.77587, 4*floorHdiff); vertex(1356.07474, 262.06804, 4*floorHdiff); vertex(1409.89883, 226.15660, 4*floorHdiff); vertex(1489.01605, 158.34382, 4*floorHdiff); vertex(1522.46140, -21.54165, 4*floorHdiff); vertex(1580.09957, -4.09283, 4*floorHdiff); vertex(1567.76448, 61.81234, 4*floorHdiff); vertex(1602.97521, 2.83233, 4*floorHdiff); vertex(1632.94144, 11.90401, 4*floorHdiff); vertex(1796.40323, 61.38886, 4*floorHdiff); vertex(1895.89263, -91.03266, 4*floorHdiff); vertex(1895.89263, -765.89311, 4*floorHdiff); vertex(1857.91476, -782.40571, 4*floorHdiff); vertex(1748.97638, -829.77161, 4*floorHdiff); vertex(1730.35283, -837.86904, 4*floorHdiff); vertex(1692.24906, -812.89648, 4*floorHdiff); vertex(1665.57934, -792.22751, 4*floorHdiff); vertex(1665.57934, -882.32343, 4*floorHdiff); vertex(1653.29510, -907.30246, 4*floorHdiff); vertex(1572.84628, -903.07409, 4*floorHdiff); vertex(1557.61706, -820.94265, 4*floorHdiff); vertex(1617.30875, -749.38051, 4*floorHdiff); vertex(1556.75716, -696.45807, 4*floorHdiff); vertex(1538.97411, -720.17150, 4*floorHdiff); vertex(1530.52549, -674.48564, 4*floorHdiff); vertex(1459.42230, -620.45174, 4*floorHdiff); vertex(1488.60227, -777.32391, 4*floorHdiff); vertex(1247.69431, -932.70650, 4*floorHdiff); vertex(1075.11923, -972.05774, 4*floorHdiff); vertex(1064.56557, -1010.61451, 4*floorHdiff); vertex(1052.94179, -1053.78552, 4*floorHdiff); vertex(1328.99447, -1050.82438, 4*floorHdiff); vertex(1515.27200, -1050.82438, 4*floorHdiff); vertex(1374.28128, -1115.60595, 4*floorHdiff); vertex(1181.64827, -1219.75527, 4*floorHdiff); vertex(1172.32518, -1225.26701, 4*floorHdiff); vertex(1117.29342, -1188.42561, 4*floorHdiff); vertex(1030.50528, -1130.43270, 4*floorHdiff); vertex(939.05236, -1069.46247, 4*floorHdiff); vertex(944.28522, -1051.20549, 4*floorHdiff); vertex(955.98683, -1010.61451, 4*floorHdiff); vertex(966.45724, -972.51526, 4*floorHdiff); vertex(983.93509, -903.06440, 4*floorHdiff); vertex(944.55602, -895.87327, 4*floorHdiff); vertex(944.55602, -850.57353, 4*floorHdiff); vertex(944.55602, -306.10542, 4*floorHdiff); vertex(904.75671, -317.95647, 4*floorHdiff); vertex(904.76156, -875.97604, 4*floorHdiff); vertex(889.94289, -885.28781, 4*floorHdiff); vertex(864.96386, -880.42618, 4*floorHdiff); vertex(794.25515, -866.66426, 4*floorHdiff); vertex(720.59013, -471.22981, 4*floorHdiff); vertex(659.62476, -471.22981, 4*floorHdiff); vertex(694.34227, -659.62476, 4*floorHdiff); vertex(695.60949, -665.13973, 4*floorHdiff); //arc here!! vertex(707.46701, -729.48327, 4*floorHdiff); //arc here!! vertex(709.58119, -739.64686, 4*floorHdiff); vertex(729.05979, -845.06825, 4*floorHdiff); vertex(589.34275, -752.77483, 4*floorHdiff); vertex(561.39935, -795.11020, 4*floorHdiff); vertex(541.40571, -775.11790, 4*floorHdiff); vertex(452.50126, -662.44998, 4*floorHdiff); vertex(373.14654, -829.89838, 4*floorHdiff); vertex(580.87633, -987.32295, 4*floorHdiff); vertex(650.73161, -1033.04456, 4*floorHdiff); vertex(663.75131, -1103.35182, 4*floorHdiff); vertex(682.62099, -1205.01060, 4*floorHdiff); vertex(806.95802, -1264.21774, 4*floorHdiff);

vertex(779.86319, -1118.57033, 4*floorHdiff); vertex(849.72010, -1164.71380, 4*floorHdiff); vertex(872.61544, -1287.93255, 4*floorHdiff); vertex(967.84435, -1313.74747, 4*floorHdiff); vertex(1058.44545, -1278.18945, 4*floorHdiff); vertex(1079.61475, -1331.95723, 4*floorHdiff); vertex(1340.84552, -1328.14912, 4*floorHdiff); vertex(1383.40757, -1267.03235, 4*floorHdiff); vertex(1444.56974, -1309.09562, 4*floorHdiff); vertex(1774.38889, -1047.95966, 4*floorHdiff); vertex(1757.86629, -959.80303, 4*floorHdiff); vertex(1895.89263, -918.73326, 4*floorHdiff); vertex(1989.72718, -895.43980, 4*floorHdiff); vertex(2019.94405, -84.68042, 4*floorHdiff); vertex(1838.73213, 242.17081, 4*floorHdiff); vertex(1520.35379, 317.52491, 4*floorHdiff); vertex(1494.94482, 453.86055, 4*floorHdiff); vertex(1490.63461, 476.99298, 4*floorHdiff); vertex(1440.76163, 468.67598, 4*floorHdiff); vertex(1366.23509, 456.83726, 4*floorHdiff); vertex(1232.88001, 435.23053, 4*floorHdiff); vertex(1054.21224, 519.06075, 4*floorHdiff); endShape(CLOSE); /*beginShape(QUAD_STRIP); vertex(1018.06552, 530.96141, 4*floorHdiff); vertex(904.33485, 290.85518, 4*floorHdiff); vertex(1038.97170, 296.78394, 4*floorHdiff); vertex(1079.19127, 298.47787, 4*floorHdiff); vertex(1089.77996, 299.32484, 4*floorHdiff); vertex(1087.66093, 351.82702, 4*floorHdiff); vertex(1153.70325, 341.28800, 4*floorHdiff); vertex(1153.70325, 352.24404, 4*floorHdiff); vertex(1215.51721, 352.24404, 4*floorHdiff); vertex(1215.51721, 333.19378, 4*floorHdiff); vertex(1201.54550, 333.19378, 4*floorHdiff); vertex(1201.54550, 328.88022, 4*floorHdiff); vertex(1288.76682, 297.21389, 4*floorHdiff); vertex(1357.34843, -71.55568, 4*floorHdiff); vertex(1414.92271, -53.77587, 4*floorHdiff); vertex(1356.07474, 262.06804, 4*floorHdiff); vertex(1409.89883, 226.15660, 4*floorHdiff); vertex(1489.01605, 158.34382, 4*floorHdiff); vertex(1522.46140, -21.54165, 4*floorHdiff); vertex(1580.09957, -4.09283, 4*floorHdiff); vertex(1567.76448, 61.81234, 4*floorHdiff); vertex(1602.97521, 2.83233, 4*floorHdiff); vertex(1632.94144, 11.90401, 4*floorHdiff); vertex(1796.40323, 61.38886, 4*floorHdiff); vertex(1895.89263, -91.03266, 4*floorHdiff); vertex(1895.89263, -765.89311, 4*floorHdiff); vertex(1857.91476, -782.40571, 4*floorHdiff); vertex(1748.97638, -829.77161, 4*floorHdiff); vertex(1730.35283, -837.86904, 4*floorHdiff); vertex(1692.24906, -812.89648, 4*floorHdiff); vertex(1665.57934, -792.22751, 4*floorHdiff); vertex(1665.57934, -882.32343, 4*floorHdiff); vertex(1653.29510, -907.30246, 4*floorHdiff); vertex(1572.84628, -903.07409, 4*floorHdiff); vertex(1557.61706, -820.94265, 4*floorHdiff); vertex(1617.30875, -749.38051, 4*floorHdiff); vertex(1556.75716, -696.45807, 4*floorHdiff); vertex(1538.97411, -720.17150, 4*floorHdiff); vertex(1530.52549, -674.48564, 4*floorHdiff); vertex(1459.42230, -620.45174, 4*floorHdiff); vertex(1488.60227, -777.32391, 4*floorHdiff); vertex(1247.69431, -932.70650, 4*floorHdiff); vertex(1075.11923, -972.05774, 4*floorHdiff); vertex(1064.56557, -1010.61451, 4*floorHdiff); vertex(1052.94179, -1053.78552, 4*floorHdiff); vertex(1328.99447, -1050.82438, 4*floorHdiff); vertex(1515.27200, -1050.82438, 4*floorHdiff); vertex(1374.28128, -1115.60595, 4*floorHdiff); vertex(1181.64827, -1219.75527, 4*floorHdiff); vertex(1172.32518, -1225.26701, 4*floorHdiff); vertex(1117.29342, -1188.42561, 4*floorHdiff); vertex(1030.50528, -1130.43270, 4*floorHdiff); vertex(939.05236, -1069.46247, 4*floorHdiff); vertex(944.28522, -1051.20549, 4*floorHdiff); vertex(955.98683, -1010.61451, 4*floorHdiff); vertex(966.45724, -972.51526, 4*floorHdiff); vertex(983.93509, -903.06440, 4*floorHdiff); vertex(944.55602, -895.87327, 4*floorHdiff); vertex(944.55602, -850.57353, 4*floorHdiff); vertex(944.55602, -306.10542, 4*floorHdiff);

126

vertex(904.75671, -317.95647, 4*floorHdiff); vertex(904.76156, -875.97604, 4*floorHdiff); vertex(889.94289, -885.28781, 4*floorHdiff); vertex(864.96386, -880.42618, 4*floorHdiff); vertex(794.25515, -866.66426, 4*floorHdiff); vertex(720.59013, -471.22981, 4*floorHdiff); vertex(659.62476, -471.22981, 4*floorHdiff); vertex(694.34227, -659.62476, 4*floorHdiff); vertex(695.60949, -665.13973, 4*floorHdiff); //arc here!! vertex(707.46701, -729.48327, 4*floorHdiff); //arc here!! vertex(709.58119, -739.64686, 4*floorHdiff); vertex(729.05979, -845.06825, 4*floorHdiff); vertex(589.34275, -752.77483, 4*floorHdiff); vertex(561.39935, -795.11020, 4*floorHdiff); vertex(541.40571, -775.11790, 4*floorHdiff); vertex(452.50126, -662.44998, 4*floorHdiff); vertex(373.14654, -829.89838, 4*floorHdiff); vertex(580.87633, -987.32295, 4*floorHdiff); vertex(650.73161, -1033.04456, 4*floorHdiff); vertex(663.75131, -1103.35182, 4*floorHdiff); vertex(682.62099, -1205.01060, 4*floorHdiff); vertex(806.95802, -1264.21774, 4*floorHdiff); vertex(779.86319, -1118.57033, 4*floorHdiff); vertex(849.72010, -1164.71380, 4*floorHdiff); vertex(872.61544, -1287.93255, 4*floorHdiff); vertex(967.84435, -1313.74747, 4*floorHdiff); vertex(1058.44545, -1278.18945, 4*floorHdiff); vertex(1079.61475, -1331.95723, 4*floorHdiff); vertex(1340.84552, -1328.14912, 4*floorHdiff); vertex(1383.40757, -1267.03235, 4*floorHdiff); vertex(1444.56974, -1309.09562, 4*floorHdiff); vertex(1774.38889, -1047.95966, 4*floorHdiff); vertex(1757.86629, -959.80303, 4*floorHdiff); vertex(1895.89263, -918.73326, 4*floorHdiff); vertex(1989.72718, -895.43980, 4*floorHdiff); vertex(2019.94405, -84.68042, 4*floorHdiff); vertex(1838.73213, 242.17081, 4*floorHdiff); vertex(1520.35379, 317.52491, 4*floorHdiff); vertex(1494.94482, 453.86055, 4*floorHdiff); vertex(1490.63461, 476.99298, 4*floorHdiff); vertex(1440.76163, 468.67598, 4*floorHdiff); vertex(1366.23509, 456.83726, 4*floorHdiff); vertex(1232.88001, 435.23053, 4*floorHdiff); vertex(1054.21224, 519.06075, 4*floorHdiff); endShape();*/ fill(200, 200, 300, 200); //region18//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1126.61004, -1182.50009, roofH); vertex(1126.61004, -1182.50009, 0); vertex(1117.29342, -1188.42561, roofH); vertex(1117.29342, -1188.42561, 0); vertex(1172.32518, -1225.26701, roofH); vertex(1172.32518, -1225.26701, 0); vertex(1181.64827, -1219.75527, roofH); vertex(1181.64827, -1219.75527, 0); vertex(1126.61004, -1182.50009, roofH); vertex(1126.61004, -1182.50009, 0); endShape(); //region19 beginShape(); vertex(944.28522, -1051.20549, 3*floorHdiff); vertex(939.05236, -1069.46247, 3*floorHdiff); vertex(1030.50528, -1130.43270, 3*floorHdiff); vertex(1052.94179, -1053.78552, 3*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region20 beginShape(); vertex(1328.99447, -1050.82438); vertex(1052.94179, -1053.78552); vertex(1053.78552, -1130.43270); vertex(1117.29342, -1188.42561); vertex(1126.61004, -1182.50009); vertex(1181.64827, -1219.75527); vertex(1374.28128, -1115.60595); endShape(CLOSE);

beginShape(QUAD_STRIP); endShape(); //region21 beginShape(); vertex(1328.99447, -1050.82438, floorHdiff); vertex(1374.28128, -1115.60595, floorHdiff); vertex(1515.27200, -1050.82438, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region22 beginShape(); vertex(230.74485, -773.51742, 6*floorHdiff); vertex(286.62843, -872.15984, 6*floorHdiff); vertex(318.35322, -805.68645, 6*floorHdiff); vertex(251.49067, -780.71663, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region23 beginShape(); vertex(1004.26738, 708.30913, 7*floorHdiff); vertex(970.82231, 658.32243, 7*floorHdiff); vertex(1011.87849, 657.92759, 7*floorHdiff); vertex(959.72301, 547.86824, 7*floorHdiff); vertex(864.96386, 347.88738, 7*floorHdiff); vertex(859.88045, 337.00835, 7*floorHdiff); vertex(801.03249, 212.95372, 7*floorHdiff); vertex(651.58020, -102.03999, 7*floorHdiff); vertex(607.99218, -194.42881, 7*floorHdiff); vertex(526.65513, -366.08354, 7*floorHdiff); vertex(482.71058, -458.82466, 7*floorHdiff); vertex(416.72546, -598.08045, 7*floorHdiff); vertex(372.99955, -690.10906, 7*floorHdiff); vertex(335.24498, -770.03787, 7*floorHdiff); vertex(330.23424, -780.28668, 7*floorHdiff); vertex(318.35322, -805.68645, 7*floorHdiff); vertex(286.62843, -872.15984, 7*floorHdiff); vertex(279.43084, -887.82871, 7*floorHdiff); vertex(318.80505, -944.56572, 7*floorHdiff); vertex(326.00103, -929.32034, 7*floorHdiff); vertex(371.63479, -833.08836, 7*floorHdiff); vertex(373.14654, -829.89838, 7*floorHdiff); vertex(452.50126, -662.44998, 7*floorHdiff); vertex(501.31097, -559.45540, 7*floorHdiff); vertex(626.60117, -295.09486, 7*floorHdiff); vertex(665.12518, -213.81038, 7*floorHdiff); vertex(670.62885, -202.37958, 7*floorHdiff); vertex(836.59697, 147.74705, 7*floorHdiff); vertex(869.19546, 216.34805, 7*floorHdiff); vertex(904.33485, 290.85518, 7*floorHdiff); vertex(1018.06552, 530.96141, 7*floorHdiff); vertex(1044.07224, 585.83885, 7*floorHdiff); vertex(1076.23012, 653.69599, 7*floorHdiff); vertex(1312.30977, 604.93471, 7*floorHdiff); vertex(1236.01431, 708.30913, 7*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region24 beginShape(); vertex(955.98683, -1010.61451, 2*floorHdiff); vertex(944.28522, -1051.20549, 2*floorHdiff); vertex(1052.94179, -1053.78552, 2*floorHdiff); vertex(1064.56557, -1010.61451, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region25 beginShape(); vertex(966.45724, -972.51526, floorHdiff); vertex(955.98683, -1010.61451, floorHdiff); vertex(1064.56557, -1010.61451, floorHdiff); vertex(1075.11923, -972.05774, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); // //region26 // beginShape(); // endShape(CLOSE); // beginShape(QUAD_STRIP); // endShape(); //region27//column

127

source code

beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1505.95214, -870.89263, roofH); vertex(1505.95214, -870.89263, 0); vertex(1267.59591, -1010.60643, roofH); vertex(1267.59591, -1010.60643, 0); vertex(1527.55300, -1010.60643, roofH); vertex(1527.55300, -1010.60643, 0); vertex(1528.39997, -992.40636, roofH); vertex(1528.39997, -992.40636, 0); vertex(1505.95214, -870.89263, roofH); vertex(1505.95214, -870.89263, 0); endShape(); //region28//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1584.28678, -963.62084, roofH); vertex(1584.28678, -963.62084, 0); vertex(1593.17346, -1010.61451, roofH); vertex(1593.17346, -1010.61451, 0); vertex(1647.78336, -1010.60643, roofH); vertex(1647.78336, -1010.60643, 0); vertex(1649.90400, -966.99577, roofH); vertex(1649.90400, -966.99577, 0); vertex(1584.28678, -963.62084, roofH); vertex(1584.28678, -963.62084, 0); endShape(); //region29 beginShape(); vertex(163.85071, -550.39687, vertex(251.49067, -780.71663, vertex(318.35322, -805.68645, vertex(330.23424, -780.28668, vertex(263.34011, -693.92526, vertex(299.32969, -641.00282, vertex(182.47750, -562.67141, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region30 beginShape(); vertex(307.37425, -646.49840, vertex(275.62111, -693.49531, vertex(335.24498, -770.03787, vertex(372.99955, -690.10906, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region31 beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(299.32969, -641.00282, vertex(299.32969, -641.00282, vertex(263.34011, -693.92526, vertex(263.34011, -693.92526, vertex(330.23424, -780.28668, vertex(330.23424, -780.28668, vertex(335.24498, -770.03787, vertex(335.24498, -770.03787, vertex(275.62111, -693.49531, vertex(275.62111, -693.49531, vertex(307.37425, -646.49840, vertex(307.37425, -646.49840, vertex(299.32969, -641.00282, vertex(299.32969, -641.00282, endShape();

5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff);

5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff);

roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0);

//region32 beginShape(); vertex(501.31097, -559.45540, 3*floorHdiff); vertex(452.50126, -662.44998, 3*floorHdiff); vertex(541.40571, -775.11790, 3*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region33 beginShape();

vertex(864.96386, -206.8769, 2*floorHdiff); vertex(673.1949, -216.01179, 2*floorHdiff); vertex(679.52360, -251.06395, 2*floorHdiff); vertex(729.05656, -251.06395, 2*floorHdiff); vertex(729.05656, -331.08444, 2*floorHdiff); vertex(633.37690, -331.08444, 2*floorHdiff); vertex(626.60117, -295.09486, 2*floorHdiff); vertex(501.31097, -559.45540, 2*floorHdiff); vertex(541.40571, -775.11790, 2*floorHdiff); vertex(561.39935, -795.11020, 2*floorHdiff); vertex(589.34275, -752.77483, 2*floorHdiff); vertex(729.05979, -845.06825, 2*floorHdiff); vertex(709.58119, -739.64686, 2*floorHdiff); vertex(649.03930, -739.64686, 2*floorHdiff); vertex(649.03930, -659.62476, 2*floorHdiff); vertex(694.34227, -659.62476, 2*floorHdiff); vertex(659.62476, -471.22981, 2*floorHdiff); vertex(720.59013, -471.22981, 2*floorHdiff); vertex(794.25515, -866.66426, 2*floorHdiff); vertex(864.96386, -880.42618, 2*floorHdiff); vertex(864.96386, -220.58611, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region34//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(694.34227, -659.62476, roofH); vertex(694.34227, -659.62476, 0); vertex(649.03930, -659.62476, roofH); vertex(649.03930, -659.62476, 0); vertex(649.03930, -739.64686, roofH); vertex(649.03930, -739.64686, 0); vertex(709.58119, -739.64686, roofH); vertex(709.58119, -739.64686, 0); endShape(); //region35 beginShape(); vertex(1089.20642, -152.70108, floorHdiff); vertex(944.55602, -196.45082, floorHdiff); vertex(904.76156, -208.30511, floorHdiff); vertex(864.96386, -220.58611, floorHdiff); vertex(864.96386, -880.42618, floorHdiff); vertex(889.94289, -885.28781, floorHdiff); vertex(904.76156, -875.97604, floorHdiff); vertex(904.75671, -317.95647, floorHdiff); vertex(944.55602, -306.10542, floorHdiff); vertex(944.55602, -850.57353, floorHdiff); vertex(983.08489, -826.43662, floorHdiff); vertex(997.05659, -848.45450, floorHdiff); vertex(1089.20642, -152.70108, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region36//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(983.08489, -826.43662, roofH); vertex(983.08489, -826.43662, 0); vertex(944.55602, -850.57353, roofH); vertex(944.55602, -850.57353, 0); vertex(944.55602, -895.87327, roofH); vertex(944.55602, -895.87327, 0); vertex(983.93509, -903.06440, roofH); vertex(983.93509, -903.06440, 0); vertex(997.05659, -848.45450, roofH); vertex(997.05659, -848.45450, 0); vertex(983.08489, -826.43662, roofH); vertex(983.08489, -826.43662, 0); endShape(); //region37 beginShape(); vertex(1436.86778, -47.45344); vertex(1414.92271, -53.77587); vertex(1357.34843, -71.55568); vertex(1089.20642, -152.70108); vertex(997.05659, -848.45450); vertex(983.93509, -903.06440); vertex(966.45724, -972.51526); vertex(1075.11923, -972.05774); vertex(1129.99629, -724.83143 ); vertex(1459.42230, -620.5174);

128

vertex(1530.52549, -674.48564); vertex(1556.75716, -696.45807); vertex(1617.30875, -749.38051); vertex(1665.57934, -792.22751); vertex(1665.57934, -651.58181); vertex(1611.80683, -604.99368 ); vertex(1625.35169, -575.79777); vertex(1600.86380, -444.17259); vertex(1436.86778, -47.45344); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region38//water fill(200, 360, 100); beginShape(); vertex(1129.99629, -724.83143, 0); vertex(1075.11923, -972.05774, 0); vertex(1247.69431, -932.70650, 0); endShape(CLOSE); /* beginShape(QUAD_STRIP); vertex(1129.99629, -724.83143, roofH); vertex(1129.99629, -724.83143, 0); vertex(1075.11923, -972.05774, roofH); vertex(1075.11923, -972.05774, 0); vertex(1247.69431, -932.70650, roofH); vertex(1247.69431, -932.70650, 0); vertex(1129.99629, -724.83143, roofH); vertex(1129.99629, -724.83143, 0); endShape();*/ fill(200, 200, 300, 200); //region39 beginShape(); vertex(1459.42230, -620.45174, vertex(1129.99629, -724.83143, vertex(1247.69431, -932.70650, vertex(1488.60227, -777.32391, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region40 beginShape(); vertex(1617.30875, -749.38051, vertex(1557.61706, -820.94265, vertex(1572.84628, -903.07409, vertex(1653.29510, -907.30246, vertex(1665.57934, -882.32343, vertex(1665.57934, -792.22751, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region41 beginShape(); vertex(1665.57934, -651.58181, vertex(1665.57934, -792.22751, vertex(1692.24906, -812.89648, vertex(1723.56740, -703.65890, vertex(1707.90823, -689.68719, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region42 beginShape(); vertex(1723.56740, -703.65890, vertex(1692.24906, -812.89648, vertex(1730.35283, -837.86904, vertex(1748.97638, -829.77161, vertex(1748.97638, -724.09682, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region43 beginShape(); vertex(1748.97638, -724.09682, vertex(1748.97638, -829.77161, vertex(1857.91476, -782.40571, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region44 beginShape();

floorHdiff); floorHdiff); floorHdiff); floorHdiff);

floorHdiff); floorHdiff); floorHdiff); floorHdiff); floorHdiff); floorHdiff);

floorHdiff); floorHdiff); floorHdiff); floorHdiff); floorHdiff);

2*floorHdiff); 2*floorHdiff); 2*floorHdiff); 2*floorHdiff); 2*floorHdiff);

3*floorHdiff); 3*floorHdiff); 3*floorHdiff);

vertex(1895.89263, -91.03266, floorHdiff); vertex(1791.73199, -99.53180, floorHdiff); vertex(1791.73199, -179.51431, floorHdiff); vertex(1749.82349, -179.54128, floorHdiff); vertex(1705.41464, -591.79134, floorHdiff); vertex(1707.90823, -689.68719, floorHdiff); vertex(1723.56740, -703.65890, floorHdiff); vertex(1748.97638, -724.09682, floorHdiff); vertex(1857.91476, -782.40571, floorHdiff); vertex(1895.89263, -765.89311, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region45 beginShape(); vertex(405.59481, -45.29974, floorHdiff); vertex(384.67848, -100.26472, floorHdiff); vertex(352.39093, -265.25614, floorHdiff); vertex(384.00688, -516.10607, floorHdiff); vertex(416.72546, -598.08045, floorHdiff); vertex(482.71058, -458.82466, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region46 beginShape(); vertex(1079.19127, 298.47787, 2*floorHdiff); vertex(1038.97170, 296.78394, 2*floorHdiff); vertex(1042.78305, 225.23796, 2*floorHdiff); vertex(869.19546, 216.34805, 2*floorHdiff); vertex(836.59697, 147.74705, 2*floorHdiff); vertex(864.96386, 40.07363, 2*floorHdiff); vertex(881.89672, -167.66691, 2*floorHdiff); vertex(864.96386, -206.18769, 2*floorHdiff); vertex(864.96386, -220.58611, 2*floorHdiff); vertex(904.76156, -208.30511, 2*floorHdiff); vertex(904.76156, -87.22132, 2*floorHdiff); vertex(1091.04556, -87.22132, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region47 beginShape(); vertex(1434.40615, -157.92357, vertex(1376.40192, -175.27990, vertex(1433.13247, -480.53997, vertex(1502.14403, -522.45346, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff);

//region48 beginShape(); vertex(1791.73199, -99.53180, 4*floorHdiff); vertex(1791.73199, -87.21485, 4*floorHdiff); vertex(1705.37703, -127.44250, 4*floorHdiff); vertex(1665.57934, -127.44250, 4*floorHdiff); vertex(1664.30566, -457.25811, 4*floorHdiff); vertex(1602.90710, -127.44250, 4*floorHdiff); vertex(1541.93849, -127.44250, 4*floorHdiff); vertex(1600.86380, -444.17259, 4*floorHdiff); vertex(1625.35169, -575.79777, 4*floorHdiff); vertex(1611.80683, -604.99368, 4*floorHdiff); vertex(1665.57934, -651.58181, 4*floorHdiff); vertex(1707.90823, -689.68719, 4*floorHdiff); vertex(1705.41464, -591.79134, 4*floorHdiff); vertex(1749.82349, -179.54128, 4*floorHdiff); vertex(1791.73199, -179.51431, 4*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region49 beginShape(); vertex(728.83990, vertex(613.47643, vertex(613.47643, vertex(583.41561, vertex(563.11220, vertex(571.98480, vertex(512.69027, vertex(402.63204, vertex(422.53089,

580.09715, 576.86740, 375.52590, 375.52590, 375.52590, 328.12168, 318.48175, 300.58882, 193.47674,

4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff);

129

source code

vertex(361.94351, 190.33828, 4*floorHdiff); vertex(260.80244, 185.01031, 4*floorHdiff); vertex(182.47750, -562.67141, 4*floorHdiff); vertex(299.32969, -641.00282, 4*floorHdiff); vertex(307.37425, -646.49840, 4*floorHdiff); vertex(372.99955, -690.10906, 4*floorHdiff); vertex(416.72546, -598.08045, 4*floorHdiff); vertex(384.00688, -384.00688, 4*floorHdiff); vertex(352.39093, -265.25614, 4*floorHdiff); vertex(384.67848, -100.26472, 4*floorHdiff); vertex(311.60746, -67.31762, 4*floorHdiff); vertex(381.88785, -82.12982, 4*floorHdiff); vertex(405.59481, -45.29974, 4*floorHdiff); vertex(482.71058, -458.82466, 4*floorHdiff); vertex(526.65513, -366.08354, 4*floorHdiff); vertex(474.18611, -83.83992, 4*floorHdiff); vertex(450.90101, -41.06168, 4*floorHdiff); vertex(542.34746, 157.49039, 4*floorHdiff); vertex(562.64954, 48.65162, 4*floorHdiff); vertex(607.99218, -194.42881, 4*floorHdiff); vertex(651.58020, -102.03999, 4*floorHdiff); vertex(610.51043, 119.80364, 4*floorHdiff); vertex(595.26990, 202.36665, 4*floorHdiff); vertex(668.26457, 206.12243, 4*floorHdiff); vertex(722.69292, 287.47055, 4*floorHdiff); vertex(771.42000, 360.29759, 4*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region50//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(381.88785, 82.12982, roofH); vertex(381.88785, 82.12982, 0); vertex(311.60746, -67.31762, roofH); vertex(311.60746, -67.31762, 0); vertex(384.67848, -100.26472, roofH); vertex(384.67848, -100.26472, 0); vertex(405.59481, -45.29974, roofH); vertex(405.59481, -45.29974, 0); vertex(381.88785, 82.12982, roofH); vertex(381.88785, 82.12982, 0); endShape(); //region51 beginShape(); vertex(542.34746, 157.49039, 3*floorHdiff); vertex(450.90101, 41.06168, 3*floorHdiff); vertex(474.18611, -83.83992, 3*floorHdiff); vertex(562.64954, 48.65162, 3*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region52 beginShape(); vertex(562.64954, 48.65162, 2*floorHdiff); vertex(474.18611, -83.83992, 2*floorHdiff); vertex(526.65513, -366.08354, 2*floorHdiff); vertex(607.99218, -194.42881, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region53 beginShape(); vertex(801.03249, 212.95372, 2*floorHdiff); vertex(668.26457, 206.12243, 2*floorHdiff); vertex(610.51043, 119.80364, 2*floorHdiff); vertex(651.58020, -102.03999, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region54 beginShape(); vertex(836.59697, vertex(670.62885, vertex(673.11949, vertex(864.96386, vertex(864.96386, endShape(CLOSE);

147.74705, 3*floorHdiff); -202.37958, 3*floorHdiff); -216.01179, 3*floorHdiff); -206.18769, 3*floorHdiff); 40.07363, 3*floorHdiff);

beginShape(QUAD_STRIP); endShape(); //region55 beginShape(); vertex(665.12518, -213.81038, vertex(626.60117, -295.09486, vertex(633.37690, -331.08444, vertex(729.05656, -331.08444, vertex(729.05656, -251.06395, vertex(679.52360, -251.06395, vertex(673.11949, -216.01179, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff);

//region56//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(864.96386, 40.07363, roofH); vertex(864.96386, 40.07363, 0); vertex(864.96386, -206.18769, roofH); vertex(864.96386, -206.18769, 0); vertex(881.89672, -167.66691, roofH);//temprorarily positioned point vertex(881.89672, -167.66691, 0);//temprorarily positioned point vertex(864.96386, 40.07363, roofH); vertex(864.96386, 40.07363, 0); endShape(); //region57 beginShape(); vertex(904.76156, -87.22132, 4*floorHdiff); vertex(904.76156, -208.30511, 4*floorHdiff); vertex(944.55602, -196.45082, 4*floorHdiff); vertex(944.55602, -127.44250, 4*floorHdiff); vertex(1090.20021, -127.44250, 4*floorHdiff); vertex(1091.04556, -87.22132, 4*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region58 beginShape(); vertex(944.55602, -127.44250, 2*floorHdiff); vertex(944.55602, -196.45082, 2*floorHdiff); vertex(1089.20642, -152.70108, 2*floorHdiff); vertex(1090.20021, -127.44250, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region59 beginShape(); vertex(1087.66093, 351.82702, floorHdiff); vertex(1089.77996, 299.32484, floorHdiff); vertex(1079.19127, 298.47787, floorHdiff); vertex(1091.04556, -87.22132, floorHdiff); vertex(1090.20021, -127.44250, floorHdiff); vertex(1089.20642, -152.70108, floorHdiff); vertex(1357.34843, -71.55568, floorHdiff); vertex(1288.76682, 297.21389, floorHdiff); vertex(1201.54550, 328.88022, floorHdiff); vertex(1201.54550, 290.43493, floorHdiff); vertex(1182.49200, 290.43493, floorHdiff); vertex(1182.49200, 333.19378, floorHdiff); vertex(1153.70325, 333.19378, floorHdiff); vertex(1153.70325, 341.28800, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region60 beginShape(); vertex(1356.07474, 262.06804, vertex(1414.92271, -53.77587, vertex(1436.86778, -47.45344, vertex(1409.89883, 226.15660, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

floorHdiff); floorHdiff); floorHdiff); floorHdiff);

130

//region61 beginShape(); vertex(1580.09957, -4.09283, floorHdiff); vertex(1522.46140, -21.54165, floorHdiff); vertex(1436.86778, -47.45344, floorHdiff); vertex(1600.86380, -444.17259, floorHdiff); vertex(1541.93849, -127.44250, floorHdiff); vertex(1602.90710, -127.44250, floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region62 beginShape(); vertex(1567.76448, 61.81234, 2*floorHdiff); vertex(1580.09957, -4.09283, 2*floorHdiff); vertex(1602.90710, -127.044250, 2*floorHdiff); vertex(1664.30566, -457.25811, 2*floorHdiff); vertex(1665.57934, -127.44250, 2*floorHdiff); vertex(1665.56317, -87.21485, 2*floorHdiff); vertex(1677.84741, -87.22132, 2*floorHdiff); vertex(1632.94144, 11.90401, 2*floorHdiff); vertex(1602.97521, 2.83233, 2*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region63 beginShape(); vertex(1796.40323, 61.38886, 3*floorHdiff); vertex(1632.94144, 11.90401, 3*floorHdiff); vertex(1677.84741, -87.22132, 3*floorHdiff); vertex(1705.37703, -87.21485, 3*floorHdiff); vertex(1791.73199, -99.53180, 3*floorHdiff); vertex(1895.89263, -91.03266, 3*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region64//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1705.37703, -87.21485, roofH); vertex(1705.37703, -87.21485, 0); vertex(1665.56317, -87.21485, roofH); vertex(1665.56317, -87.21485, 0); vertex(1665.57934, -127.44250, roofH); vertex(1665.57934, -127.44250, 0); vertex(1705.37703, -127.44250, roofH); vertex(1705.37703, -127.44250, 0); vertex(1705.37703, -87.21485, roofH); vertex(1705.37703, -87.21485, 0); endShape(); //region65//slope beginShape(); vertex(1494.94482, 453.86055, vertex(1520.35379, 317.52491, vertex(1838.73213, 242.17081, vertex(2019.94405, -84.68042, vertex(2138.83513, -58.21128, vertex(1931.87735, 350.54721, vertex(1864.98484, 364.43920, vertex(1674.77516, 407.61595, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region66 beginShape(); vertex(343.23665, 290.83492, vertex(280.91631, 280.77711, vertex(226.51164, 183.32285, vertex(260.80244, 185.01031, vertex(361.94351, 190.33828, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

4*floorHdiff); 4*floorHdiff); 6*floorHdiff); 7*floorHdiff); 7*floorHdiff); 6*floorHdiff); 6*floorHdiff); 5*floorHdiff);

5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff);

//region67 beginShape(); vertex(327.47169, 375.52590, 6*floorHdiff); vertex(343.23665, 290.83492, 6*floorHdiff); vertex(361.94351, 190.33828, 6*floorHdiff);

vertex(422.53089, 193.47674, 6*floorHdiff); vertex(402.63204, 300.58882, 6*floorHdiff); vertex(388.66196, 375.52590, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region68 beginShape(); vertex(859.88045, 337.00835, vertex(795.10535, 317.95486, vertex(722.69292, 287.47055, vertex(668.26457, 206.12243, vertex(801.03249, 212.95372, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

3*floorHdiff); 3*floorHdiff); 3*floorHdiff); 3*floorHdiff); 3*floorHdiff);

//region69 beginShape(); vertex(668.26457, 206.12243, 3*floorHdiff); vertex(595.26990, 202.36665, 3*floorHdiff); vertex(610.51043, 119.80364, 3*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region70 beginShape(); vertex(1038.97170, 296.78394, 3*floorHdiff); vertex(904.33485, 290.85518, 3*floorHdiff); vertex(869.19546, 216.34805, 3*floorHdiff); vertex(1042.78305, 225.23796, 3*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region71//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(1153.70325, 352.24404, vertex(1153.70325, 352.24404, vertex(1153.70325, 333.19378, vertex(1153.70325, 333.19378, vertex(1182.49200, 333.19378, vertex(1182.49200, 333.19378, vertex(1182.49200, 290.43493, vertex(1182.49200, 290.43493, vertex(1201.54550, 290.43493, vertex(1201.54550, 290.43493, vertex(1201.54550, 333.19378, vertex(1201.54550, 333.19378, vertex(1215.51721, 333.19378, vertex(1215.51721, 333.19378, vertex(1215.51721, 352.24404, vertex(1215.51721, 352.24404, vertex(1153.70325, 352.24404, vertex(1153.70325, 352.24404, endShape(); //region72 beginShape(); vertex(1409.89883, 226.15660, vertex(1436.86778, -47.45344, vertex(1522.46140, -21.54165, vertex(1489.01605, 158.34382, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0);

//region73 beginShape(); vertex(290.86165, 375.52590, vertex(222.69868, 271.38143, vertex(280.91631, 280.77711, vertex(343.23665, 290.83492, vertex(327.47169, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region74 beginShape();

2*floorHdiff); 2*floorHdiff); 2*floorHdiff); 2*floorHdiff);

10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff);

131

source code

vertex(388.66196, 375.52590, vertex(402.63204, 300.58882, vertex(512.69027, 318.48175, vertex(502.12952, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region75//column beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); vertex(819.66412, 368.33316, vertex(819.66412, 368.33316, vertex(771.42000, 360.29759, vertex(771.42000, 360.29759, vertex(722.69292, 287.47055, vertex(722.69292, 287.47055, vertex(795.10535, 317.95486, vertex(795.10535, 317.95486, vertex(819.66412, 368.33316, vertex(819.66412, 368.33316, endShape();

6*floorHdiff); 6*floorHdiff); 6*floorHdiff); 6*floorHdiff);

//region76 beginShape(); vertex(864.96386, 500.10738, vertex(771.42000, 360.29759, vertex(819.66412, 368.33316, vertex(795.10535, 317.95486, vertex(859.88045, 337.00835, vertex(864.96386, 347.88738, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

roofH); 0); roofH); 0); roofH); 0); roofH); 0); roofH); 0);

//region77 beginShape(); vertex(905.09713, 560.09019, vertex(864.96386, 500.10738, vertex(864.96386, 347.88738, vertex(959.72301, 547.86824, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff); 4*floorHdiff);

5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff);

//region78 beginShape(); vertex(1044.07224, 585.83885, 6*floorHdiff); vertex(1018.06552, 530.96141, 6*floorHdiff); vertex(1054.21224, 519.06075, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region79 beginShape(); vertex(1048.33133, 594.82605, vertex(1044.07224, 585.83885, vertex(1054.21224, 519.06075, vertex(1232.88001, 435.23053, vertex(1366.23509, 456.83726, vertex(1355.81753, 493.72655, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff);

//region80 beginShape(); vertex(1355.81753, 493.72655, 6*floorHdiff); vertex(1366.23509, 456.83726, 6*floorHdiff); vertex(1440.76163, 468.67598, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region81 beginShape(); vertex(1562.46720, 488.63159, vertex(1490.63461, 476.99298, vertex(1494.94482, 453.86055, vertex(1674.77516, 407.61595, endShape(CLOSE); beginShape(QUAD_STRIP);

8*floorHdiff); 8*floorHdiff); 8*floorHdiff); 8*floorHdiff);

endShape(); //region82 beginShape(); vertex(1734.57149, 516.51662, vertex(1562.46720, 488.63159, vertex(1674.77516, 407.61595, vertex(1864.98484, 364.43920, vertex(1864.98484, 429.30177, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff);

//region83 beginShape(); vertex(1864.98484, 429.30177, 10*floorHdiff); vertex(1864.98484, 364.43920, 10*floorHdiff); vertex(1931.87735, 350.54721, 10*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region84//slope beginShape(); vertex(1461.07265, 842.51765, vertex(1394.76232, 743.86553, vertex(1447.94791, 708.30913, vertex(1734.57149, 516.51662, vertex(1864.98484, 429.30177, vertex(1931.87735, 350.54721, vertex(2138.83513, -58.21128, vertex(2255.75289, -32.18147, vertex(1976.95870, 512.65211, temporarily endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region85 beginShape(); vertex(314.86856, 443.23120, vertex(291.52894, 425.52318, vertex(253.60485, 375.52590, vertex(290.86165, 375.52590, vertex(327.47169, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region86 beginShape(); vertex(369.06285, 480.77126, vertex(314.86856, 443.23120, vertex(327.47169, 375.52590, vertex(388.66196, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region87 beginShape(); vertex(432.69448, 519.09793, vertex(369.06285, 480.77126, vertex(388.66196, 375.52590, vertex(432.69448, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region88 beginShape(); vertex(471.50339, 539.71980, vertex(432.69448, 519.09793, vertex(432.69448, 375.52590, vertex(502.12952, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 10*floorHdiff); 8*floorHdiff); 8*floorHdiff); 7*floorHdiff); 7*floorHdiff); 9*floorHdiff);//

11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff);

10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff);

9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff);

8*floorHdiff); 8*floorHdiff); 8*floorHdiff); 8*floorHdiff);

//region89 beginShape(); vertex(527.84474, 566.25685, 7*floorHdiff); vertex(471.50339, 539.71980, 7*floorHdiff); vertex(512.69027, 318.48175, 7*floorHdiff);

132

vertex(571.98480, 328.12168, 7*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region90 beginShape(); vertex(583.41561, 573.94617, vertex(527.84474, 566.25685, vertex(563.11220, 375.52590, vertex(583.41561, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region91 beginShape(); vertex(613.47643, 576.86740, vertex(583.41561, 573.94617, vertex(583.41561, 375.52590, vertex(613.47643, 375.52590, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

6*floorHdiff); 6*floorHdiff); 6*floorHdiff); 6*floorHdiff);

//region92 beginShape(); vertex(728.83990, 580.09715, vertex(771.42000, 360.29759, vertex(864.96386, 500.10738, vertex(864.96386, 567.39668, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

5*floorHdiff); 5*floorHdiff); 5*floorHdiff); 5*floorHdiff);

//region93 beginShape(); vertex(864.96386, 567.39668, 6*floorHdiff); vertex(864.96386, 500.10738, 6*floorHdiff); vertex(905.09713, 560.09019, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region94 beginShape(); vertex(1011.87849, 657.92759, 6*floorHdiff); vertex(970.82231, 658.32243, 6*floorHdiff); vertex(905.09713, 560.09019, 6*floorHdiff); vertex(959.72301, 547.86824, 6*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region95 beginShape(); vertex(1076.23012, 653.69599, vertex(1048.33133, 594.82605, vertex(1355.81753, 493.72655, vertex(1312.30977, 604.93471, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region96 beginShape(); vertex(1312.30977, 604.93471, vertex(1355.81753, 493.72655, vertex(1440.76163, 468.67598, vertex(1490.63461, 476.99298, vertex(1479.69578, 535.70066, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

6*floorHdiff); 6*floorHdiff); 6*floorHdiff); 6*floorHdiff);

7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff);

//region97 beginShape(); vertex(1479.69578, 535.70066, 9*floorHdiff); vertex(1490.63461, 476.99298, 9*floorHdiff); vertex(1562.46720, 488.63159, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

//region98 beginShape(); vertex(432.70329, 546.00304, vertex(388.35204, 533.13498, vertex(356.90559, 522.87210, vertex(211.68974, 356.90235, vertex(291.52894, 425.52318, vertex(314.86856, 443.23120, vertex(369.06285, 480.77126, vertex(432.69448, 519.09793, endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region99 beginShape(); vertex(527.84474, 566.25685, vertex(432.70329, 546.00304, vertex(432.69448, 519.09793, vertex(471.50339, 539.71980, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff); 11*floorHdiff);

//region100 beginShape(); vertex(583.41561, 686.71473, vertex(388.35204, 533.13498, vertex(432.70329, 546.00304, vertex(527.84474, 566.25685, vertex(583.41561, 588.75408, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff);

//region101 beginShape(); vertex(732.78095, 632.78531, vertex(583.41561, 588.75408, vertex(527.84474, 566.25685, vertex(583.41561, 573.94617, vertex(613.47643, 576.86740, vertex(728.83990, 580.09715, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff);

//region102 beginShape(); vertex(864.96386, 653.45332, vertex(732.78095, 632.78531, vertex(728.83990, 580.09715, vertex(864.96386, 567.39668, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff);

//region103 beginShape(); vertex(1236.01431, 708.30913, vertex(1312.30977, 604.93471, vertex(1479.69578, 535.70066, vertex(1447.94791, 708.30913, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

6*floorHdiff); 6*floorHdiff); 6*floorHdiff); 6*floorHdiff);

//region104 beginShape(); vertex(1447.94791, 708.30913, vertex(1479.69578, 535.70066, vertex(1562.46720, 488.63159, vertex(1734.57149, 516.51662, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

8*floorHdiff); 8*floorHdiff); 8*floorHdiff); 8*floorHdiff);

//region105 beginShape(); vertex(721.43710, vertex(583.41561, vertex(583.41561, vertex(732.78095, vertex(788.50764,

743.86553, 668.93491, 588.75408, 632.78531, 743.86553,

9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff);

9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff); 9*floorHdiff);

133

source code

endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region106 beginShape(); vertex(788.50764, 743.86553, vertex(732.78095, 632.78531, vertex(864.96386, 653.45332, vertex(864.96386, 743.86553, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

vertex(1394.76232, 743.86553, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region115 beginShape(); vertex(1061.10019, 793.25092, 10*floorHdiff); vertex(864.96386, 782.24256, 10*floorHdiff); vertex(864.96386, 743.86553, 10*floorHdiff); vertex(1028.05744, 743.86553, 10*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

//region107 beginShape(); vertex(970.82231, 658.32243, vertex(864.96386, 653.45332, vertex(864.96386, 567.39668, vertex(905.09713, 560.09019, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff);

//region116 beginShape(); vertex(1061.10019, 793.25092, 9*floorHdiff); vertex(1028.05744, 743.86553, 9*floorHdiff); vertex(1188.81933, 743.86553, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff);

//region108 beginShape(); vertex(864.96386, 708.30913, 8*floorHdiff); vertex(864.96386, 653.45332, 8*floorHdiff); vertex(970.82231, 658.32243, 8*floorHdiff); vertex(1004.26738, 708.30913, 8*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

//region117 beginShape(); vertex(1117.33866, 877.30439, 11*floorHdiff); vertex(864.96386, 836.20957, 11*floorHdiff); vertex(864.96386, 782.24256, 11*floorHdiff); vertex(1061.10019, 793.25092, 11*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

//region109 beginShape(); endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

//region118 beginShape(); vertex(1218.81123, 861.57115, vertex(1104.59378, 858.18652, vertex(1061.10019, 793.25092, vertex(1188.81933, 743.86553, vertex(1394.76232, 743.86553, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

//region110 beginShape(); vertex(864.96386, 813.72082, vertex(686.29933, 743.86553, vertex(788.50764, 743.86553, vertex(864.96386, 782.24256, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff);

//region111 beginShape(); vertex(864.96386, 782.24256, 9*floorHdiff); vertex(788.50764, 743.86553, 9*floorHdiff); vertex(864.96386, 743.86553, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region112 beginShape(); vertex(864.96386, 743.86553, 9*floorHdiff); vertex(864.96386, 708.30913, 9*floorHdiff); vertex(1004.26738, 708.30913, 9*floorHdiff); vertex(1028.05744, 743.86553, 9*floorHdiff); endShape(CLOSE); beginShape(QUAD_STRIP); endShape(); //region113 beginShape(); vertex(1028.05744, 743.86553, vertex(1004.26738, 708.30913, vertex(1236.01431, 708.30913, vertex(1188.81933, 743.86553, endShape(CLOSE); beginShape(QUAD_STRIP); endShape();

7*floorHdiff); 7*floorHdiff); 7*floorHdiff); 7*floorHdiff);

//region114 beginShape(); vertex(1188.81933, 743.86553, 9*floorHdiff); vertex(1236.01431, 708.30913, 9*floorHdiff); vertex(1447.94791, 708.30913, 9*floorHdiff);

}

10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff); 10*floorHdiff);

//record end______________ if (record) { endRaw(); record = false; }

//cam key__________________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order } void leftView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order } void frontView() { cam.setRotations(PI/2, rotations are applied in } void backView() { cam.setRotations(PI/2, rotations are applied in }

PI, PI); // pitch, that order 0, PI); // pitch, that order

yaw,

yaw, roll

void setPerpetiveView() { perspective(PI/3.0, (float)width/height, 1, 100000); } void setOrthoView() { ortho(0, width*2, 0, height*2, -100, 10000); } void keyPressed()

134

{

if (key == 't' || key == 'T') { topView(); } if (key == 'R' || key == 'r') { rightView(); } if (key == 'L' || key == 'l') { leftView(); } if (key == 'B' || key == 'b') { backView(); } if (key == 'f' || key == 'F') { frontView(); } if (key == 'p' || key == 'P') { setPerpetiveView(); } if (key == 'o' || key == 'O') { setOrthoView(); } if (key == 'd' || key =='D') { record = true; } if (key == 'p'||key =='P') { saveFrame("line-######.jpg"); }

} // that is all cam key________________________

void spRender(float _x, float _y, float _z) { pushMatrix(); noStroke(); // fill(200, 200, 360); translate(_x, _y, _z); sphere(20); popMatrix(); } PVector[] nDivArc(float r, PVector p1, PVector p2, int numPt) { Vec2D pV1 = new Vec2D(p1.x, p1.y); Vec2D pV2 = new Vec2D(p2.x, p2.y); Line2D l = new Line2D(pV1, pV2); PVector[] pts = new PVector[numPt]; PVector[] pts2 = new PVector[numPt]; Vec2D mid = l.getMidPoint(); //println(mid); float tmpr = sqrt(sq(r) - sq(l.getLength()/2)); // println(tmpr); Vec2D dir = l.getNormal(); dir.normalize(); dir = dir.scale(tmpr); Vec2D center = mid.add(dir); for (int i= 0 ;i<numPt;i++) { PVector cp = new PVector(p1.x - center.x, p1.ycenter.y, 0); PVector cq = new PVector(p2.x - center.x, p2.ycenter.y, 0); float theta = PVector.angleBetween(cp, cq); cp.rotate(i*theta/(numPt-1));

}

pts[i] = new PVector(); pts[i].add(center.x, center.y, 0); pts[i].add(cp);

return pts; } float gaussian(float x, float y, float a, float bx, float cx, float by, float cy) { float z = a*exp(-sq(x-bx)/(2*sq(cx)))*exp(-sq(y-by)/ (2*sq(cy))); return z; }

135

source code

/* Ryuyu Ishihara Computational Solution for Architectural Design Sou Fujimoto Version 2.0 //_______________________________________________*/ import traer.physics.*; import processing.dxf.*; boolean record; import toxi.math.conversion.*; import toxi.geom.*; import toxi.math.*; import toxi.geom.mesh2d.*; import toxi.util.datatypes.*; import toxi.util.events.*; import toxi.geom.mesh.subdiv.*; import toxi.geom.mesh.*; import toxi.math.waves.*; import toxi.util.*; import toxi.math.noise.*; import toxi.processing.*; import peasy.org.apache.commons.math.*; import peasy.*; import peasy.org.apache.commons.math.geometry.*; PeasyCam cam; ToxiclibsSupport Plane gl; ArrayList<Vec3D> ArrayList<Vec3D> ArrayList<BoxCD> ArrayList<BoxCD>

gfx; posL= new ArrayList<Vec3D>(); posS= new ArrayList<Vec3D>(); boxesL= new ArrayList<BoxCD>(); boxesS= new ArrayList<BoxCD>();

if (record) { beginRaw(DXF, "output.dxf"); } //write your own below__ noFill(); for (BoxCD box:boxesL) { stroke(0, 200, 360); box.render(); }

}

for (BoxCD box:boxesS) { stroke(200, 360, 360); box.render(); } //record end______________ if (record) { endRaw(); record = false; }

//cam key_____________________________________ void topView() { cam.setRotations(0, 0, 0); // pitch, yaw, roll rotations are applied in that order } void rightView() { cam.setRotations(PI/2, -PI/2, PI); // pitch, roll rotations are applied in that order }

void setup() { size(1000, 1000, P3D); colorMode(HSB, 360);

void leftView() { cam.setRotations(PI/2, PI/2, PI); // pitch, roll rotations are applied in that order }

gfx=new ToxiclibsSupport(this); gl = new Plane(new Vec3D(), new Vec3D(0, 0, 1));// ground plane //seting camera cam = new PeasyCam(this, 400, 300, 0, 1000); cam.setMinimumDistance(50); cam.setMaximumDistance(999999); //write your own below__

void frontView() { cam.setRotations(PI/2, rotations are applied in } void backView() { cam.setRotations(PI/2, rotations are applied in }

String lines[] = loadStrings("800gc.txt"); for (int i=0; i<lines.length ;i++) { String data[]= split(lines[i], ","); // println(data[0]); String xelem[] = split(data[0], "("); String zelem[] = split(data[2], ")"); posL.add(new Vec3D( float( xelem[1])/10, float(data[1])/10, float(zelem[0])/10)); } for (Vec3D p:posL) { println(p); boxesL.add(new BoxCD(p, 800/10)); } String lines2[] = loadStrings("400gc.txt"); for (int i=0; i<lines2.length ;i++) { String data[]= split(lines2[i], ","); // println(data[0]); String xelem[] = split(data[0], "("); String zelem[] = split(data[2], ")"); posS.add(new Vec3D( float( xelem[1])/10, float(data[1])/10, float(zelem[0])/10)); } for (Vec3D p:posS) { println(p); boxesS.add(new BoxCD(p, 400/10)); } } //________________________________________________ void draw() { lights(); background(0); fill(30, 10, 200, 350); noStroke(); gfx.plane(gl, 10000);

PI, PI); // pitch, that order 0, PI); // pitch, that order

yaw,

yaw, roll

136

public class BoxCD { Vec3D centerPt = new Vec3D(); float dim; BoxCD(Vec3D _centerPt, float _dim) { this.centerPt = _centerPt; this.dim = _dim; } void render() { line(centerPt.x-dim/2, centerPt.y-dim/2, z+dim/2, centerPt.x-dim/2, centerPt.y+dim/2, z+dim/2);//line1 line(centerPt.x-dim/2, centerPt.y+dim/2, z+dim/2, centerPt.x+dim/2, centerPt.y+dim/2, z+dim/2);//line2 line(centerPt.x+dim/2, centerPt.y+dim/2, z+dim/2, centerPt.x+dim/2, centerPt.y-dim/2, z+dim/2);//line3 line(centerPt.x+dim/2, centerPt.y-dim/2, z+dim/2, centerPt.x-dim/2, centerPt.y-dim/2, z+dim/2);//line4 line(centerPt.x-dim/2, centerPt.y-dim/2, z+dim/2, centerPt.x-dim/2, centerPt.y-dim/2, z-dim/2);//line5 line(centerPt.x-dim/2, centerPt.y+dim/2, z+dim/2, centerPt.x-dim/2, centerPt.y+dim/2, z-dim/2);//line6 line(centerPt.x+dim/2, centerPt.y+dim/2, z+dim/2, centerPt.x+dim/2, centerPt.y+dim/2, z-dim/2);//line7 line(centerPt.x+dim/2, centerPt.y-dim/2, z+dim/2, centerPt.x+dim/2, centerPt.y-dim/2, z-dim/2);//line8 line(centerPt.x-dim/2, centerPt.y-dim/2, z-dim/2, centerPt.x-dim/2, centerPt.y+dim/2, z-dim/2);//line1 line(centerPt.x-dim/2, centerPt.y+dim/2, z-dim/2, centerPt.x+dim/2, centerPt.y+dim/2, z-dim/2);//line2 line(centerPt.x+dim/2, centerPt.y+dim/2, z-dim/2, centerPt.x+dim/2, centerPt.y-dim/2, z-dim/2);//line3 line(centerPt.x+dim/2, centerPt.y-dim/2, z-dim/2, centerPt.x-dim/2, centerPt.y-dim/2, z-dim/2);//line4 } }

centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt. centerPt.

137

8. 文献目録

8. 文献目録東浩紀・北田暁大『思想地図：特集 = アーキテクチャ』第 3 巻、日本放送出版協会、 2009 年。磯崎新「プロセス・プランニング論」『空間へ』美術出版社、1971 年所収。磯崎新『手法が』美術出版社、1979 年。磯崎新「模型的思考」『建築文化 : 特集 ― 情報空間』27 巻 , 310 号、1972 年 8 月。磯崎新・浅田彰監修『Anywise: 知の諸問題』NTT 出版、1999 年 a。磯崎新・浅田彰監修『Anybody: 建築的身体の諸問題』NTT 出版、1999 年 b。磯崎新・浅田彰監修『Anyhow: 実践の諸問題』NTT 出版、2000 年。磯崎新・浅田彰監修『Anytime: 時間の諸問題』NTT 出版、2001 年。磯崎新・浅田彰監修『Anymore: グローバル化の諸問題』NTT 出版、2003 年。磯崎新・浅田彰監修『Anything: 建築と物質 / ものをめぐる諸問題』NTT 出版、 2007 年。ウィトルーウィウス『ウィトルーウィウス建築書』普及版、東海大学出版会、1979 年。柄沢祐輔他『設計の設計』INAX 出版、2011 年。柄谷行人『隠喩としての建築』定本柄谷行人集、第 2 巻、岩波書店、2004 年。菊竹清訓『代謝建築論：か・かた・かたち』復刻版、彰国社、2008 年。クリストファー・アレグザンダー『形の合成に関するノート』鹿島出版会、1978 年。クリストファー・アレグザンダー、サラ・イシカワ、マレー・シルバースタイン『パターン・ランゲージ』平田翰那訳、鹿島出版会、1984 年。佐々木睦朗『Fluxstructure』TOTO 出版、2005 年。ジル・ドゥルーズ『襞：ライプニッツとバロック』宇野邦一訳、河出書房新社、1998 年。ジル・ドゥルーズ、フェリックス・ガタリ『千のプラトー：資本主義と分裂症』改訂三分冊版、宇野邦一他訳、河出書房新社、2010 年。スチュアート・カウフマン『自己組織化と進化の論理―宇宙を貫く複雑系の法則』筑摩書房、2008 年。セシル・バルモンド『Number 9』高橋啓訳、飛鳥新社、1999 年。ソフィア・ヴィゾヴィティ「フォールディング・アーキテクチャー──その実践の系譜」日埜直彦訳、『10 ＋ 1：建築の技法── 19 の建築的冒険』35 号、 2004 年 06月、47-62頁。http://db.10plus1.jp/backnumber/article/articleid/1021/(最終アクセス 2014/01/24) 東京大学生命科学教科書編集委員会 ( 編『理系総合のための生命科学 ) : 分子・細胞・個体から知る" 生命 " のしくみ』第 3 版、羊土社、2013 年。豊田啓介「＜建築情報学＞の必要」『建築雑誌』vol.129, no.1653, 2014 年 1 月 , 36-37 頁。日本建築学会編『アルゴリズミック・デザイン―建築・都市の新しい設計手法』鹿島出版会、2009 年。野口廣『トポロジーの世界』筑摩書房、2009 年。二川幸夫編『妹島和世西沢立衛：2006-2011』A.D.A.EDITA Tokyo,2011 年、192-195 頁。麓和善他「CAD による日本伝統建築の軒反り曲線設計法」日本建築学会計画系論文集、第 490 号、1996 年 12 月、155-162 頁。ベルナール・カシュ「柔らかい大地：テリトリーを備える」メディアデザイン研究所編『10+1: 神経都市論―身体・都市・クライシス』40 号、2005 年 9 月所収。

138

南泰裕・瀧本雅志・松田達「90 年代都市・建築キーワード／キーパーソン」メディア・デザイン研究所編『10 ＋ 1：特集 = 都市建築クロニクル 1990-2000』19 号、 2000 年 3 月。メディア・デザイン研究所編『10 ＋ 1：特集＝アルゴリズム的思考と建築』48 号、2007 年 9 月。森美術館 ( 編 )、『アーキラボ : 建築・都市・アートの新たな実験 1950-2005』平凡社、 2005 年。柳井良文「情報空間論の変遷に関する歴史的研究―日本建築界における議論を中心に―」修士論文、東京大学大学院、2009 年。吉田信之編『a+u: 建築と都市：Cecil Balmond』臨時増刊、2006 年 11 月。吉田信之編『a+u: 建築と都市』2012 年 8 月、14-21 頁。吉田信之編『a+u: 建築と都市：Serpentine Gallery Pavilions』臨時増刊、2013 年 9 月。吉田義男編『新建築：建築 20 世紀』臨時増刊 part2、1991 年 6 月。 Gerald Farin『CAGD のための曲線・曲面理論：実践的利用法』木村文彦監修、山口泰監訳、共立出版、1991 年。 < 続き・外国語文献は次頁 >

139

8. 文献目録

Aubin, David. "the Catastrophe Theory of Rene Thom." Growing Explanations: Historical Perspective on the Sciences of Complexity . http://www.math. jussieu.fr/ daubin/publis/2004a.pdf(accessed 2014/01/20). Beaucé, Patrick and Bernard Cache. Objectile: Fast-Wood: A Brouillon Project. Springer-Verlag, Wien, 2007. Blin, James F. "A Generalization of Algebraic Surface Drawing." ACM Transactions on Graphics 1, No. 3, July 1982, pp. 235-256. http://www.ks.uiuc.edu/ Research/vmd/projects/ece498/surf/blinn82.pdf(accessed January 20, 2014). Coon, Steven A. and R.W. Mann. "Computer-Aided Design Related to the Engineering Design Process." Technical Memorandum , M.I.T 1961. Cache, Bernard. Earth Moves:The Furnishing of Territoiries . translated by Anne Boyman.edited by Michael Speaks,Cambridge,MA, The MIT Press, 1995 Cache, Bernard. Projectiles . translated by Clare Barrett and Pamela Johnston, AA Publications, London, 2011. Carlson,Wayne. A Critical History of Computer Graphics and Animation--Section 10:CAD/CAM/CADD/CAE . The Ohio State University Department of Design. http://design.osu.edu/carlson/history/lesson10.html(accessed January 20, 2014). Davidson,Cynthia C. Anybody . Cambridge, MA, MIT Press, 1997. Ferguson, James. "Multivariable Curve Interpolation." Journal of the Association for Computing Machinery 11, no.2(April, 1964), pp.221-228. http://dl.acm. org/citation.cfm?id=321217.321225&coll=DL&dl=ACM&CFID=284257244& CFTOKEN=95594791(accessed January 20,2014). Gordon, William J. and Richard F.Riesenfeld. "Bernstein-Bézier Methods for the Computer-Aided Design of Free-Form Curves and Surfaces." Journal of the Association for Computing Machinery 21, no.2. April 1974, pp.293-310. http://dl.acm.org/citation.cfm?id=321824(accessed January 20,2014). Hovestadt, Ludger and others. Jenseits des Rasters -- Architektur und Informationstechnologie : Anwendungen einer digitalen Architektonik = Beyond the grid -- architecture and information technology : applications of a digital architectonic. Wirkhäuser, Basel, 2009. Hurst, Jan. "Retrospectives: The Erly Years in Computer Graphics at MIT, Lincoln Lab and Harvard." SIGGRAPH '89 Panel Proceedings, pp.39-73.http:// dl.acm.org/citation.cfm?doid=77277.77280 Jodidio, Philip. Serpentine Gallery Pavilions. Taschen, 2011. Kwinter, Sanford and Umberto Boccioni." Landscapes of Change: Boccioni's "Stati d'animo" as a General Theory of Models." Assemblage no.19, Dec. 1992. http://www.jstor.org/stable/3171176(accessed 2014/01/20). Lenoir, Timothy and Casey. Alt, Flow, Process, Fold: Intersections in Bioinformatics and Contemporary Architecture.http://www.stanford.edu/dept/HPS/ TimLenoir/Publications/Lenoir_FlowProcessFold.pdf(accessed January 20 2014). Lynn, Greg. "Architectural Curvilinearity: The Folded, the Pliant and the Supple."

140

in Architectural Design: Folding architecture 63, no.3/4, March/April, 1993. Lynn, Greg. Animate Form. New York, Princeton Architectural Press, 1999. Lynn, Greg and Mark Rappolt(ed.). Greg Lynn Form. New York ,Rizzoli International Publications, 2008. Schumacher, Patrik. "Parametricism as Style - Parametricist Manifesto." London, 2008. http://www.patrikschumacher.com/Texts/Parametricism%20as%20 Style.htm. Schumacher, Patrik."Parametricism - A New Global Style for Architecture and Urban Design."Architectural Design: Digital Cities 79, no.4, July/August, 2009. Schumacher, Patrik."Parametricism and the Autopoiesis of Architecture." Lecture at Colombia University, New York, NY. September 15, 2010. http://www. youtube.com/watch?v=1pqh77TnLoQ&feature=share&list=PLC25009FF2 9065321(accessed January 22, 2014). Stroup, Bjarne. Bjarne Stroustrup's homepage. http://www.stroustrup.com/index. html.(accessed January 25,2014). Sutherland, Ivan Edward. "Sketchpad: A man-machine graphical communication system."University of Cambridge Computer Laboratory,http://www. cl.cam.ac.uk/techreports/UCAM-CL-TR-574.pdf(accessed January 20, 2014). Yares, Evan. "50 Years of CAD." Design World . February 13, 2013.(accessed January 24, 2014). http://www.designworldonline.com/50-years-of-cad/ "History of Autodesk 3dsMax." Area: Digital Enterainment and Visualization community. http://area.autodesk.com/maxturns20/history. "History of Rhino." McNeel wiki .http://wiki.mcneel.com/rhino/rhinohistory. (accessed January 24, 2014).

謝辞まず、隈研究室でご指導いただいた隈研吾教授、中村航助教、ならびに慶應義塾大学松川昌平先生に感謝の意を表します。研究内容とは直結しませんが、アルゴリズミック・デザインやコンピューテーションに関する基礎的な理論と技術はミュンヘン工科大学の Emerging Technologies, Architectural Informatics 研究室での学習、とくに Aedas の Christian Derix 氏の指導に負うところが多々あります。 Danke. また、直接・間接に資料や重要な示唆を頂いた、隈研の伊藤さん、平野さん、柳井さん、 Aris, 山岡くん、 OB の友枝さん、松川研の学生のみなさまに感謝します。さらには建築家の河野裕さん、松畑強さん、米田 Kaz さんには研究テーマが厳密にきまる前の段階からひろく建築論や翻訳に関して示唆を頂きました。ありがとうございます。また、資料整理を手伝ってくれた大坂くんと西川くんにも感謝します。