Blok kódu je jedinečná funkce aplikace Dynamo, která dynamicky propojuje prostředí vizuálního programování s textovým. Blok kódu má přístup ke všem uzlům aplikace Dynamo a umožňuje definovat celý graf v jediném uzlu. Doporučujeme této kapitole věnovat zvýšenou pozornost, protože blok kódu je základním stavebním kamenem aplikace Dynamo.

Bloky kódu umožňují pracovat v jazyce DesignScript, což je programovací jazyk používaný v aplikaci Dynamo. Jazyk DesignScript je čitelný a stručný jazyk, který nabízí okamžitou zpětnou vazbu k malým úsekům kódu, ale je v něm možné vytvářet také velké a složité programy. DesignScript také tvoří základ systému, který aplikace Dynamo používá „pod pokličkou“. Protože většina funkcí uzlů aplikace Dynamo je s tímto skriptovacím jazykem v rovnocenném vztahu, znamená to, že se lze plynule přesunout od uzlů ke skriptování.

Pro začátečníky lze uzly převést automaticky na text, což jim usnadní proces učení jazyka DesignScript, případně tím lze zpřehlednit velké části grafu. K tomu slouží proces „Uzel na kód“, který je podrobněji popsán v části Syntaxe jazyka DesignScript. Pokročilejší uživatelé si mohou pomocí bloků kódu přizpůsobovat existující funkce a vytvářet standardní programátorské konstrukce. Pro všechny uživatele nezávisle na zkušenostech je k dispozici velké množství útržků s kódem, které jim pomohou při práci na návrzích. Ačkoliv výraz „blok kódu“ může být pro neprogramátory poněkud zastrašující, ve skutečnosti se jedná o snadno použitelnou funkci. Začátečník dokáže používat blok kódu efektivně i s minimem programování, zatímco pokročilý uživatel může vytvořit skriptované definice, které bude možné vyvolat na jiném místě definice aplikace Dynamo.

Blok kódu: stručný přehled

Stručně řečeno, bloky kódu představují rozhraní pro textové skriptování v rámci prostředí vizuálního programování. Lze je používat jako čísla, řetězce, vzorce a další datové typy. Blok kódu je navržen přímo pro aplikaci Dynamo – uživatel může v bloku kódu definovat proměnné a ty budou následně automaticky přidány k uzlu jako vstupy:

Bloky kódu umožňují uživatelům flexibilně určit, které vstupy bude uzel obsahovat. Zde je několik způsobů, jak vytvořit základní bod se souřadnicemi (10, 5, 0):

Jakmile se seznámíte s pokročilejšími funkcemi v knihovně, zjistíte, že ruční zadání textu „Point.ByCoordinates“ je rychlejší, než hledání správného uzlu v knihovně. Pokud například zadáte Point., aplikace Dynamo zobrazí seznam možných funkcí, které lze použít pro výraz Point. Díky tomu je skriptování intuitivnější a usnadní vám používání funkcí v aplikaci Dynamo.

Tvorba uzlů pro bloky kódu

Blok kódu se nachází v části Core>Input>Actions>Code Block. Stačí však dvakrát kliknout na pracovní plochu a blok kódu se ihned zobrazí. Tento uzel se používá tak často, že jej lze vytvořit i dvojím kliknutím.

Čísla, řetězce a vzorce

Bloky kódu umožňují flexibilní práci s datovými typy. Uživatel může rychle definovat čísla, řetězce a vzorce a blok kódu nastaví požadovaný výstup.

Na obrázku níže vidíte starý způsob práce, který je poněkud zdlouhavý: uživatel musí vyhledat požadovaný uzel v rozhraní, přidat uzel na pracovní plochu a poté zadat data. S blokem kódu uživateli stačí, když dvakrát klikne na pracovní plochu, čímž vytvoří uzel, a poté zadá požadovaná data splňující základní syntaxi.

Uzly number, string a formula představují příklady uzlů aplikace Dynamo, které jsou v porovnání s blokem kódu poněkud zastaralé.

1. „Stará škola“

2. Bloky kódu

Možná jste si všimli běžného tématu v názvech uzlů v aplikaci Dynamo: každý uzel používá syntaxi se znakem "." bez mezer. Je tomu tak proto, že text v horní části každého uzlu představuje skutečnou syntaxi pro skriptování a "." (neboli tečková notace) odděluje prvek od možných metod, které je možné volat. Toto umožňuje snadný přesun od vizuálního skriptování k textovému.

Jak v rámci obecné analogie tečkové notace postupovat u parametrického jablka v aplikaci Dynamo? Níže je uvedeno několik metod, které použijeme na jablko než se rozhodneme, zda je sníst. (Poznámka: Nejedná se o skutečné metody aplikace Dynamo):

Nevím, jak ty, ale soudě podle výstupů v tabulce výše, to vypadá, že jablko je chutné. Myslím, že provedu operaci Jablko.snist().

Tečková notace v bloku kódu

S ohledem na analogii jablka se podívejte na uzel Point.ByCoordinates a určete, jak můžeme vytvořit bod pomocí bloku kódu.

Syntaxe bloku kódu Point.ByCoordinates(0,10); předává stejný výsledek jako uzel Point.ByCoordinates v aplikaci Dynamo, s výjimkou toho, že je možné vytvořit bod pomocí jednoho uzlu. Je to mnohem efektivnější než připojení dvou samostatných uzlů k hodnotám „X“ a „Y“.

1. Pokud použijete uzel Point.ByCoordinates v bloku kódu, určíte vstupy ve stejném pořadí jako uzel ve výchozím natavení (X,Y).

Volání uzlů – Tvorba, Akce, Dotaz

Jakýkoliv běžný uzel v knihovně je možné volat prostřednictvím bloku kódu, pokud uzel není speciálním „uzlem uživatelského rozhraní“: uzly se speciální funkcí uživatelského rozhraní. Můžete například volat uzel Circle.ByCenterPointRadius, ale nemělo by smysl volat uzel Watch 3D.

Běžné uzly (většina knihovny) jsou obvykle tří typů. Můžete vidět, že knihovna je organizována s ohledem na tyto kategorie. Metody nebo uzly těchto tří typů jsou při volání v bloku kódu zpracovávány odlišně.

1. Tvorba – něco se vytvoří (nebo zkonstruuje).

2. Akce – provede u položky nějakou akci.

3. Dotaz – získá vlastnost položky, která již existuje.

Tvorba

Kategorie „Tvorba“ vytvoří geometrii od začátku. V bloku kódu se zadají vstupní hodnoty zleva doprava. Tyto vstupy jsou ve stejném pořadí jako vstupy uzlu shora dolů.

Pokud použijete uzel Line.ByStartPointEndPoint a porovnáte výsledek s odpovídající syntaxí v bloku kódu, zjistíte, že výsledky jsou stejné.

Akce

Akce je něco, co se provede u objektu daného typu. Aplikace Dynamo používá k provedení akce u určité položky tečkovou notaci, která je běžná v mnoha jazycích kódů. Jakmile zadáte název položky, zadejte tečku a poté název akce. Vstup metody typu Akce je umístěn v závorkách stejně jako u metody typu Tvorba, jen není třeba určovat první vstup, který uvidíte na odpovídajícím uzlu. Místo toho určíte, u kterého prvku se akce provede:

1. Uzel Point.Add je uzel typu Akce, takže syntaxe funguje trochu jinak.

2. Vstupy jsou (1) bod a (2) vektor, které se mají přidat. V bloku kódu jsme bod (položku) pojmenovali výrazem „pt“. Chcete-li přidat vektor s názvem *„vec *k bodu „pt“, zadejte výraz pt.Add(vec) neboli položka, tečka, akce. Akce Add má pouze jeden vstup nebo všechny vstupy z uzlu **Point.Add **kromě prvního. První vstup uzlu Point.Add je samotný bod.

Dotaz

Metody typu Dotaz získají vlastnost objektu. Vzhledem k tomu, že objekt samotný je vstupem, není třeba určovat žádné vstupy. Nejsou třeba žádné závorky.

Jak je to s vázáním?

Vázání na uzly se poněkud liší od vázání na blok kódu. U uzlů klikne uživatel pravým tlačítkem na uzel a vybere možnost vázání, kterou chce provést. Díky bloku kódu má uživatel mnohem větší kontrolu nad tím, jak jsou data strukturována. Metoda zkratky bloku kódu používá vodítka replikací k nastavení způsobu, jakým by mělo být párováno několik jednorozměrných seznamů. Čísla v šikmých závorkách „<>“ definují hierarchii výsledného vnořeného seznamu: <1>,<2>,<3> atd.

1. V tomto příkladu definujeme dva rozsahy pomocí zkratky (více o zkratkách naleznete v následující části této kapitoly). Stručně řečeno, 0..1; je ekvivalentní {0,1} a -3..-7 je ekvivalentní {-3,-4,-5,-6,-7}. Výsledkem je seznam 2 hodnot X a 5 hodnot Y. Pokud se nepoužijí vodítka replikací společně s těmito neshodujícími se seznamy, vznikne seznam dvou bodů, který má délku nejkratšího seznamu. Pomocí vodítek replikací je možné najít všechny možné kombinace 2 a 5 souřadnic (neboli kartézský součin).

2. Pomocí syntaxe Point.ByCoordinates(x_vals<1>,y_vals<2>); získáte dva seznamy s pěti položkami v každém seznamu.

3. Pomocí syntaxe Point.ByCoordinates(x_vals<2>,y_vals<1>); získáte pět seznamů s dvěma položkami v každém seznamu.

Pomocí této notace můžeme také určit, který seznam bude dominantní: 2 seznamy 5 položek nebo 5 seznamů 2 položek. V tomto příkladu změna pořadí vodítek replikací vytvoří seznam řádků bodů v osnově nebo seznam sloupců bodů v osnově.

Uzel na kód

Zatímco na výše uvedené metody bloku kódu si možná budete chvíli zvykat, v aplikace Dynamo existuje i funkce s názvem „Uzel na blok“ která celý proces usnadní. Chcete-li tuto funkci použít, vyberte pole uzlů v grafu aplikace Dynamo, klikněte pravým tlačítkem na kreslicí plochu a vyberte položku „Uzel na kód“. Aplikace Dynamo tyto uzly zhustí do bloku kódu včetně všech vstupů a výstupů. Nejenže se jedná o skvělý nástroj k výuce práce s blokem kódu, ale tato funkce také umožňuje práci s efektivnějším a parametrickým grafem aplikace Dynamo. Cvičení je zakončeno využitím funkce „Uzel na kód“, nepropásněte tuto část.

Cvičení: Atraktor povrchu

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

Nyní demonstrujeme sílu bloku kódu převedením existující definice pole atraktoru do tvaru bloku kódu. Práce s existující definicí ukazuje, jak blok kódu souvisí s vizuálním skriptem, a je užitečná k seznámení se se syntaxí jazyka DesignScript.

Začněte znovuvytvořením definice na obrázku výše (nebo otevřením vzorového souboru).

1. Všimněte si, že vázání uzlu Point.ByCoordinates bylo nastaveno na hodnotu Kartézský součin.

2. Každý bod v osnově se posune nahoru ve směru Z podle jeho vzdálenosti od referenčního bodu.

3. Povrch je znovu vytvořen a zesílen, čímž se vytvoří vyboulení v geometrii relativně ke vzdálenosti od referenčního bodu.

1. Na začátku nejprve definujeme referenční bod: Point.ByCoordinates(x,y,0);. Použijeme stejnou syntaxi Point.ByCoordinates, jaká je zadána v horní části uzlu referenčního bodu.

2. Proměnné x a y se vloží do bloku kódu, aby bylo možné je dynamicky aktualizovat pomocí posuvníků.

3. Přidejte posuvníky ke vstupům bloku kódu, které se pohybují v rozsahu od -50 do 50. Tímto zajistíme dosah přes celou výchozí osnovu aplikace Dynamo.

1. Ve druhém řádku bloku kódu definujeme zkratku, která nahradí uzel posloupnosti čísel: coordsXY = (-50..50..#11);. Tímto se budeme dále zabývat v další části. V tuto chvíli si všimněte, že tato zkratka odpovídá uzlu Number Sequence ve vizuálním skriptu.

1. Nyní chceme vytvořit osnovu z bodů v posloupnosti položek coordsXY. Za tímto účelem je vhodné použít syntaxi Point.ByCoordinates, ale také je nutné spustit Kartézský součin seznamu stejným způsobem, jako to bylo provedeno ve vizuálním skriptu. Zadejte následující řádek: gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);. Šikmé závorky označují odkaz na kartézský součin.

2. Všimněte si, že v uzlu Watch3D se nachází osnova bodů přes celou osnovu aplikace Dynamo.

1. Nyní nastává ta náročná část: Je třeba přesunout osnovu bodů nahoru podle vzdáleností bodů od referenčního bodu. Nejprve pojmenujte tuto novou sadu bodů transPts. A vzhledem k tomu, že převod je akce na existujícím prvku, použijte místo výrazu Geometry.Translate... výraz gridPts.Translate.

2. Při čtení ze skutečného uzlu na kreslicí ploše je vidět, že obsahuje tři vstupy. Geometrie, kterou chcete převést, je již deklarována, protože na tomto prvku provádíme akci (pomocí metody gridPts.Translate). Zbývající dva vstupy budou vloženy do závorek funkce: směr a vzdálenost.

3. Směr je jednoduchý vstup, k jeho vertikálnímu posunutí se použije výraz Vector.ZAxis().

4. Dále je třeba vypočítat vzdálenost mezi referenčním bodem a každým bodem osnovy. Toto provedeme stejným způsobem jako akci u referenčního bodu: refPt.DistanceTo(gridPts).

5. Poslední řádek kódu nám poskytuje převedené body: transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));

1. Nyní máme osnovu bodů s vhodnou datovou strukturou k vytvoření povrchu Nurbs. Vytvoříme povrch pomocí srf = NurbsSurface.ByControlPoints(transPts);.

1. A nakonec, abychom povrchu dodali trochu hloubky, vytvoříme těleso pomocí výrazu solid = srf.Thicken(5);. V tomto případě jsme v kódu zesílili povrch o 5 jednotek, tuto hodnotu bychom však mohli deklarovat jako proměnnou (kterou můžete nazvat například tloušťka) a poté řídit její hodnotu pomocí posuvníku.

Zjednodušení grafu pomocí možnosti „Uzel na kód“

Funkce „Uzel na kód“ automatizuje celé toto právě dokončené cvičení pomocí kliknutí na tlačítko. Nejenže se jedná o výkonné řešení tvorby vlastních definic a opakovaně použitelných bloků kódu, ale také je to velmi užitečný nástroj k výuce skriptování v aplikaci Dynamo:

1. Začněte existujícím vizuálním skriptem z kroku 1 tohoto cvičení. Vyberte všechny uzly, klikněte pravým tlačítkem na kreslicí plochu a vyberte možnost Uzel na kód. Až tak jednoduché to je.

Aplikace Dynamo má automatizovanou textovou verzi vizuálního grafu, vázání a dalších. Vyzkoušejte si tuto funkci u vašich vizuálních skriptů a využijte výkon bloku kódu.

V této části naleznete několik cvičení zabývajících se tvorbou geometrie pomocí jazyka DesignScript. Pokračujte tím, že zkopírujete ukázkový kód v jazyce DesignScript do bloků kódů aplikace Dynamo.

Souřadnicový systém

Aplikace Dynamo sice umožňuje vytvářet mnoho složitých geometrických útvarů, ale jednoduchá geometrická primitiva tvoří základ jakéhokoliv výpočetního návrhu: mohou být použita přímo v konečném návrhu nebo mohou sloužit jako základ pro generování složitějších geometrií.

Ačkoliv se nejedná o geometrii, objekt CoordinateSystem je důležitým nástrojem pro jejich tvorbu. V objektu CoordinateSystem je uložena pozice a geometrické transformace, například otočení, kolmý posun a změna měřítka.

Chcete-li vytvořit objekt CoordinateSystem na souřadnicích X = 0, Y = 0, Z = 0 bez otočení, změny měřítka nebo kolmého posunu, jednoduše zavolejte konstruktor Identity:

Objekty CoordinateSystems s geometrickými transformacemi jsou mimo rozsah této kapitoly, nicméně souřadnicový systém v zadaném bodě je možné vytvořit pomocí konstruktoru CoordinateSystem.ByOriginVectors:

Bod

Nejjednodušším geometrickým primitivem je bod, který představuje bezrozměrné místo v trojrozměrném prostoru. Jak již bylo zmíněno, bod v určitém souřadnicovém systému lze vytvořit několika způsoby: Konstruktor Point.ByCoordinates vytvoří bod se zadanými souřadnicemi X, Y a Z, konstruktor Point.ByCartesianCoordinates vytvoří bod se zadanými souřadnicemi X, Y a Z v určitém souřadnicovém systému, konstruktor Point.ByCylindricalCoordinates vytvoří bod ležící na válci s poloměrem, úhlem otočení a výškou a konstruktor Point.BySphericalCoordinates vytvoří bod ležící na kouli s poloměrem a dvěma úhly otočení.

Tento příklad ukazuje body vytvořené v různých souřadnicových systémech:

Čára

Primitivum s vyšším rozměrem v aplikaci Dynamo je úsečka, která představuje nekonečné množství bodů mezi dvěma koncovými body. Čáry lze vytvořit explicitním zadáním dvou okrajových bodů do konstruktoru Line.ByStartPointEndPoint nebo zadáním počátečního bodu, směru a délky v tomto směru do konstruktoru Line.ByStartPointDirectionLength.

3D primitiva – kvádr, kužel, válec, koule atd.

Aplikace Dynamo nabízí objekty reprezentující nejzákladnější trojrozměrná geometrická primitiva: kvádry vytvářené konstruktorem Cuboid.ByLengths, kužely vytvářené konstruktory Cone.ByPointsRadius a Cone.ByPointsRadii, válce vytvářené konstruktorem Cylinder.ByRadiusHeight a koule vytvářené konstruktorem Sphere.ByCenterPointRadius.

Aplikace Dynamo představuje skvělou příležitostí, jak začít kódovat pro svět AEC. Mohly by vás zajímat některá z těchto témat, která vám pomohou začít s kódováním:

Funkce lze vytvořit v bloku kódu a lze je znovu načíst jinde v definici aplikace Dynamo. Tím se vytvoří další hladina ovládacího prvku v parametrickém souboru a lze ji zobrazit jako textovou verzi vlastního uzlu. V tomto případě je „nadřazený“ blok kódu snadno dostupný a může být umístěn kdekoli na grafu. Nepotřebuje žádné dráty!

Nadřazený blok kódu

První řádek obsahuje klíčové slovo „def“, pak název funkce a názvy vstupů v závorkách. Závorky definují tělo funkce. Vrátí hodnotu s „return =“. Uzly bloku kódu, které definují funkci, nemají vstupní nebo výstupní porty, protože se volají z jiných uzlů bloku kódu.

/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};

Podřazené bloky kódu

Volejte funkci s jiným uzlem bloku kódu ve stejném souboru, a to poskytnutím stejného názvu a stejného počtu argumentů. Funguje stejně uzly v knihovně.

FunctionName(in1,in2);

Cvičení: Koule podle Z

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

V tomto cvičení vytvoříme obecnou definici, která vytvoří koule ze vstupního seznamu bodů. Poloměr těchto koulí je řízen vlastností Z každého bodu.

Začneme řadou deseti hodnot v rozsahu od 0 do 100. Tyto položky můžete vložit do uzlů Point.ByCoordinates za účelem vytvoření diagonální úsečky.

Vytvořte blok kódu a vložte naši definici.

1. Použijte tyto řádky kódu:

   Copy

   def sphereByZ(inputPt)
   {
   
   };

InputPt je název, který jsme zadali k reprezentaci bodů, které budou řídit funkci. Zatím funkce nic nedělá, ale v následujících krocích ji rozšíříme.

1. Přidáme-li funkci bloku kódu, umístíme komentář a proměnnou sphereRadius, která dotazuje pozici Z každého bodu. Nezapomeňte, že metoda inputPt.Z nevyžaduje jako metoda závorky. Toto je dotaz vlastností existujícího prvku, takže nejsou nutné žádné vstupy:

Copy

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};

1. Nyní si připomeňme funkci, kterou jsme vytvořili v jiném bloku kódu. Pokud dvakrát klikneme na kreslicí plochu a vytvoříme nový blok kódu a zadáme jej do položky sphereB, všimneme si, že aplikace Dynamo navrhne funkci sphereByZ, kterou jsme definovali. Vaše funkce byla přidána do knihovny intellisense. Působivé.

1. Nyní zavoláme funkci a vytvoříme proměnnou s názvem Pt, která bude zahrnovat body vytvořené v dřívějších krocích:

   Copy

   sphereByZ(Pt)

2. Ve výstupu si všimneme, že máme všechny hodnoty null. Jak je to možné? Když jsme definovali funkci, vypočítali jsme proměnnou sphereRadius, ale nedefinovali jsme, co by měla funkce vrátit jako výstup. To můžeme opravit v dalším kroku.

1. Důležitý krok je, abychom definovali výstup funkce přidáním řádku return = sphereRadius; do funkce sphereByZ.

2. Nyní vidíme, že výstupem bloku kódu jsou souřadnice Z každého bodu.

Nyní vytvoříme skutečné koule úpravou nadřazené funkce.

1. Nejprve definujeme kouli pomocí řádku kódu: sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);

2. Dále změníme návratovou hodnotu na sphere místo sphereRadius: return = sphere;. Díky tomu uvidíme v náhledu aplikace Dynamo obří koule!

1. Chcete-li zmírnit velikost těchto koulí, aktualizujte hodnotu sphereRadius přidáním oddělovače: sphereRadius = inputPt.Z/20;. Nyní můžeme vidět jednotlivé koule a začít chápat vztah mezi poloměrem a hodnotou Z.

1. V uzlu Point.ByCoordinates změnou vázání z možnosti Nejkratší seznam na Kartézský součin vytvoříme osnovu bodů. Funkce sphereByZ je stále plně funkční, takže všechny body vytvářejí koule s poloměry na základě hodnot Z.

1. A jen tak na zkoušku připojíme původní seznam čísel do vstupu X uzlu Point.ByCoordinates. Teď máme krychli koulí.

2. Poznámka: Pokud výpočet trvá na vašem počítači dlouhou dobu, zkuste změnit číslo #10 na hodnotu #5.

Pamatujte, že funkce sphereByZ, kterou jsme vytvořili, je obecná funkce, takže můžeme vyvolat šroubovici z předchozí lekce a použít na ni tuto funkci.

Jeden poslední krok: Pojďme řídit poměr poloměru s uživatelem definovaným parametrem. Chcete-li to udělat, je nutné vytvořit nový vstup pro funkci a také nahradit rozdělovač 20 parametrem.

1. Aktualizujte definici sphereByZ na:

   Copy

   def sphereByZ(inputPt,radiusRatio)
   {
   //get Z Value, use it to drive radius of sphere
   sphereRadius=inputPt.Z/radiusRatio;
   //Define Sphere Geometry
   sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
   //Define output for function
   return sphere;
   };

2. Aktualizujte podřazené bloky kódu přidáním proměnné ratio ke vstupu: sphereByZ(Pt,ratio);. Připojte posuvník k nově vytvořenému vstupu bloku kódu a změňte velikost poloměrů podle poměru poloměrů.

Určité geometrické objekty je možné vytvářet přímým zadáním souřadnic X, Y a Z v trojrozměrném prostoru. Geometrie se však častěji do konečné pozice přesunují pomocí geometrických transformací samotného objektu nebo souvisejícího objektu CoordinateSystem.

Posunutí

Nejjednodušší geometrickou transformací je posunutí, čímž se objekt posune o zadaný počet jednotek ve směru X, Y a Z.

// create a point at x = 1, y = 2, z = 3
p = Point.ByCoordinates(1, 2, 3);

// translate the point 10 units in the x direction,
// -20 in y, and 50 in z
// p2’s new position is x = 11, y = -18, z = 53
p2 = p.Translate(10, -20, 50);

Otočení

Ačkoliv lze všechny objekty v aplikaci Dynamo posunout připojením metody .Translate na konec názvu objektu, pro složitější transformace je nutné provést transformaci souvisejícího objektu CoordinateSystem na nový. Například pro otočení objektu o 45 stupňů okolo osy Z je nutné pomocí metody .Transform provést transformaci existujícího objektu CoordinateSystem bez otočení na objekt CoordinateSystem s otočením 45 stupňů kolem osy X:

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    10, 10, 10);

new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Rotate(Point.ByCoordinates(0, 0),
    Vector.ByCoordinates(1,0,0.5), 25);

// get the existing coordinate system of the cube
old_cs = CoordinateSystem.Identity();

cube2 = cube.Transform(old_cs, new_cs2);

Měřítko

Kromě posunutí a otočení lze u objektů CoordinateSystem také měnit měřítko nebo provádět kolmý posun. Měřítko objektu CoordinateSystem lze změnit metodou .Scale:

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    10, 10, 10);

new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Scale(20);

old_cs = CoordinateSystem.Identity();

cube2 = cube.Transform(old_cs, new_cs2);

Objekty CoordinateSystem s kolmým posunem lze vytvořit zadáním neortogonálních vektorů jako vstup konstruktoru CoordinateSystem.

new_cs = CoordinateSystem.ByOriginVectors(
    Point.ByCoordinates(0, 0, 0),
	Vector.ByCoordinates(-1, -1, 1),
	Vector.ByCoordinates(-0.4, 0, 0));

old_cs = CoordinateSystem.Identity();

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    5, 5, 5);

new_curves = cube.Transform(old_cs, new_cs);

Změny měřítka a kolmý posun jsou mnohem složitější geometrické transformace než otočení nebo posunutí, proto je na některé objekty aplikace Dynamo nemusí být možné použít. Následující tabulka uvádí, u kterých objektů aplikace Dynamo lze provést nerovnoměrnou změnu měřítka nebo kolmý posun u jejich objektů CoordinateSystem.

Bod

Nejjednodušším geometrickým objektem v knihovně standardních geometrií aplikace Dynamo je bod. Všechny geometrie se vytvářejí pomocí speciálních funkcí nazvaných konstruktory, které vrací nové instance geometrií daného typu. V aplikaci Dynamo konstruktory začínají názvem typu objektu, v tomto případě Point, a dále obsahují metodu jejich tvorby. Chcete-li vytvořit trojrozměrný bod určený kartézskými souřadnicemi X, Y a Z, použijte konstruktor ByCoordinates:

// create a point with the following x, y, and z
// coordinates:
x = 10;
y = 2.5;
z = -6;

p = Point.ByCoordinates(x, y, z);

Konstruktory aplikace Dynamo obvykle obsahují předponu „By“ a po spuštění vrací nově vytvořený objekt daného typu. Tento nově vytvořený objekt se uloží do proměnné, jejíž název se nachází na levé straně rovnítka.

Většina objektů má mnoho různých konstruktorů, pomocí konstruktoru BySphericalCoordinates je možné vytvořit bod ležící na kouli, je nutné zadat poloměr koule, první úhel otáčení a druhý úhel otáčení (ve stupních):

// create a point on a sphere with the following radius,
// theta, and phi rotation angles (specified in degrees)
radius = 5;
theta = 75.5;
phi = 120.3;
cs = CoordinateSystem.Identity();

p = Point.BySphericalCoordinates(cs, radius, theta,
    phi);

Od bodu k čáře

Body je možné použít k vytvoření geometrie vyššího rozměru, například čáry. Pomocí konstruktoru ByStartPointEndPoint je možné vytvořit mezi dvěma body objekt čáry:

// create two points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

// construct a line between p1 and p2
l = Line.ByStartPointEndPoint(p1, p2);

Od čáry k ploše

Podobně lze čáry použít k tvorbě geometrie vyššího rozměru (plocha), například pomocí konstruktoru Loft, který jako vstup přijímá řadu čar nebo křivek a interpoluje mezi nimi plochu.

// create points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

p5 = Point.ByCoordinates(9, -10, -2);
p6 = Point.ByCoordinates(-11, -12, -4);

// create lines:
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
l3 = Line.ByStartPointEndPoint(p5, p6);

// loft between cross section lines:
surf = Surface.ByLoft([l1, l2, l3]);

Od plochy k tělesu

Plochy lze použít k vytvoření geometrie vyššího rozměru (těleso), například zesílením plochy o určitou vzdálenost. K mnoha objektům jsou připojeny funkce, kterým se říká metody, a které umožňují nad daným objektem spouštět příkazy. Všechny geometrie mají společné metody Translate a Rotate, které posunou respektive otočí geometrii o zadanou hodnotu. Plochy mají metodu Thicken, která jako vstup přijímá novou tloušťku plochy.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

// true indicates to thicken both sides of the Surface:
solid = surf.Thicken(4.75, true);

Průnik

Příkazy pro průsečík umožňují získat geometrii nižšího rozměru z objektů vyššího rozměru. Extrahované geometrie nižšího rozměru lze použít jako základ geometrií vyššího rozměru, čímž vzniká cyklický pracovní postup tvorby, extrahování a opakované tvorby geometrií. V tomto příkladu pomocí vygenerovaného tělesa vytvoříme plochu a plochu použijeme k vytvoření křivky.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

solid = surf.Thicken(4.75, true);

p = Plane.ByOriginNormal(Point.ByCoordinates(2, 0, 0),
    Vector.ByCoordinates(1, 1, 1));

int_surf = solid.Intersect(p);

int_line = int_surf.Intersect(Plane.ByOriginNormal(
    Point.ByCoordinates(0, 0, 0),
    Vector.ByCoordinates(1, 0, 0)));

Zkratka

V bloku kódu je několik základních metod zkratky, které umožňují správu dat velice usnadnit. Rozdělíme si základy níže a prodiskutujeme, jak lze tuto zkratku použít k vytváření a zadávání dotazů na data.

Další syntaxe

Rozsahy a posloupnosti

Metodu definování rozsahů a posloupností lze redukovat na základní zkratku. Při definování seznamu číselných dat v bloku kódu pomocí syntaxe „..“ použijte jako vodítko obrázek níže. Po osvojení této notace je vytváření číselných dat skutečně efektivní proces:

1. V tomto příkladu je číselný rozsah nahrazen základní syntaxí bloku kódu definující beginning..end..step-size;. Číselně vyjádřeno získáte: 0..10..1;.

2. Všimněte si, že syntaxe 0..10..1; je ekvivalentní 0..10;. Velikost kroku 1 je výchozí hodnotou pro notaci zkratky. Proto 0..10; přidělí posloupnost od 0 do 10 s velikostí kroku 1.

3. Příklad s uzlem Sequence je podobný, ale s tím rozdílem, že použijeme znak „#“, abychom určili, že chceme v seznamu zadat 15 hodnot, nikoli seznam, který pokračuje do 15. V tomto případě definujeme: beginning..#ofSteps..step-size:. Skutečná syntaxe posloupnosti je 0..#15..2.

4. Pomocí „#“ z předchozího kroku nyní ji nyní umístíme do části step-size syntaxe. Nyní máme číselný rozsah sahající od beginning do end a notace step-size rovnoměrně rozděluje počet hodnot mezi obě části: beginning..end..#ofSteps.

Pokročilé rozsahy

Vytváření pokročilých rozsahů umožňuje jednoduše pracovat se seznamem seznamů. V příkladech níže izolujeme proměnnou od uzlu primárního rozsahu a vytvoříme další rozsah tohoto seznamu.

1. Vytvořte vnořené rozsahy a porovnejte notaci s „#“ a bez ní. Stejná logika se používá v základních rozsazích, ale je trochu složitější.

2. Můžeme definovat podrozsah na libovolném místě v primárním rozsahu a všimněte si, že můžeme mít také dva podrozsahy.

3. Řízením hodnoty „end“ v rozsahu vytvoříme více rozsahů různých délek.

V rámci logického cvičení porovnejte dvě výše uvedené zkratky a zkuste analyzovat, jak notace podrozsahů a # určují výsledný výstup.

Tvorba seznamů a získání položek ze seznamu

Kromě vytváření seznamů pomocí zkratky můžeme také vytvořit seznamy za běhu. Tento seznam může obsahovat širokou škálu typů prvků a lze jej také dotazovat (nezapomeňte, že seznamy jsou samy o sobě objekty). Stručně řečeno, pomocí bloku kódu můžete vytvářet seznamy a získávat položky ze seznamu pomocí hranatých závorek:

1. Seznamy můžete rychle vytvářet pomocí řetězců a dotazovat je pomocí položek indexů.

2. Pomocí notace zkratky můžete vytvářet seznamy s proměnnými a dotazy.

Správa s vnořenými seznamy je podobný proces. Při použití více sad hranatých závorek si dávejte pozor na pořadí seznamu:

1. Definujte seznam seznamů.

2. Získání seznamu s použitím notace s jednou hranatou závorkou.

3. Získání položky s použitím notace se dvěma hranatými závorkami.

Cvičení: Sinusový povrch

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

V tomto cvičení vyzkoušíme naše nové dovednosti zápisu a vytvoříme zábavný zvlněný povrch definovaný rozsahy a vzorci. Během tohoto cvičení si všimněte, jak se používá blok kódu a existující uzly aplikace Dynamo společně: K oddělení práce s daty použijeme blok kódu, zatímco uzly aplikace Dynamo jsou vizuálně rozvrženy pro čitelnost definice.

Začněte vytvořením povrchu spojením výše uvedených uzlů. Místo použití číselného uzlu k definování šířky a délky dvakrát klikněte na kreslicí plochu a do bloku kódu zadejte hodnotu 100;.

1. Definujte rozsah mezi 0 a 1 s 50 děleními zadáním hodnoty 0..1..#50 do bloku kódu.

2. Připojte rozsah k uzlu Surface.PointAtParameter, který nabývá hodnot u a v v rozsahu 0 až 1 v celém povrchu. Nezapomeňte změnit hodnotu vázání na Kartézský součin kliknutím pravým tlačítkem myši na uzel Surface.PointAtParameter.

V tomto kroku použijeme první funkci k přesunutí rastru bodů nahoru v ose Z. Tento rastr bude řídit generovaný povrch podle základní funkce. Přidejte nové uzly, jak je znázorněno na obrázku níže.

1. Místo použití uzlu vzorce použijeme blok kódu s řádkem: (0..Math.Sin(x*360)..#50)*5;. Jednoduše řečeno, definujeme rozsah se vzorcem uvnitř něj. Tento vzorec je funkce Sinus. Funkce sinus získá v aplikaci Dynamo vstupy ve stupních, takže abychom získali plnou sinusovou vlnu, je nutné násobit hodnoty x (toto je vstup rozsahu od 0 do 1) hodnotou 360. Dále chceme stejný počet dělení jako řídicí body rastru pro každý řádek, takže definujeme padesát oddílů pomocí #50. Nakonec násobitel hodnoty 5 jednoduše zvýší amplitudu převodu, abychom viděli účinek v náhledu aplikace Dynamo.

1. I když předchozí blok kódu fungoval dobře, nebyl zcela parametrický. Chceme dynamicky řídit jeho parametry, takže nahradíme řádek z předchozího kroku řetězcem (0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;. Díky tomu můžeme definovat tyto hodnoty podle vstupů.

Změnou posuvníků (v rozmezí od 0 do 10) získáme zajímavé výsledky.

1. Provedením transpozice na číselný rozsah obrátíme směr vlny závěsu: transposeList = List.Transpose(sineList);.

1. Pokud do kódu přidáme sineList a tranposeList, vytvoří se deformovaný povrch vaječné skořápky: eggShellList = sineList+transposeList;.

Změňte hodnoty posuvníků uvedené níže, abychom získali klidnější průběh tohoto algoritmu.

Nakonec se budeme dotazovat na izolované části dat pomocí bloku kódu. Chcete-li regenerovat povrch s určitým rozsahem bodů, přidejte blok kódu nad uzel Geometry.Translate a NurbsSurface.ByPoints. Tento blok kódu obsahuje řádek s následujícím textem: sineStrips[0..15..1];. Tím se vybere prvních 16 řádků bodů (z 50). Při dalším vytvoření povrchu vidíme, že jsme vytvořili izolovanou část rastru bodů.

1. V posledním kroku, abychom tento blok kódu vytvořili více parametrický, budeme dotaz řídit pomocí posuvníku v rozsahu od 0 do 1. Provedeme to pomocí tohoto řádku kódu: sineStrips[0..((List.Count(sineStrips)-1)*u)];. Může se to zdát matoucí, ale řádek kódu nám umožňuje rychle změnit měřítko délky seznamu na násobitel mezi 0 a 1.

Hodnota 0.53 na posuvníku vytvoří povrch těsně za středem osnovy.

Posuvník 1 podle očekávání vytvoří povrch z plné osnovy bodů.

Při pohledu na vizuální graf můžeme zvýraznit bloky kódu a zobrazit jednotlivé funkce.

1. První blok kódu nahrazuje uzel Number.

2. Druhý blok kódu nahrazuje uzel Number Range.

3. Třetíblok kódu nahrazuje uzel Formula (a také uzly List.Transpose, List.Count a Number Range).

4. Čtvrtý blok kódu se dotazuje na seznam seznamů, přičemž nahrazuje uzel List.GetItemAtIndex.

Objekty ve výpočetních návrzích se výjimečně vytvářejí přímo v jejich konečných pozicích a tvarech, většinou jsou přesouvány, otáčeny a jinak transformovány. Vektorová matematika slouží jako geometrická pomůcka, která dává geometrii směr a orientaci, a také slouží ke konceptualizaci pohybů ve 3D prostoru bez vizuální reprezentace.

Na nejzákladnější úrovni představuje vektor pozici ve 3D prostoru a často je reprezentován jako bod s šipkou od pozice (0, 0, 0) do jiné pozice. Vektory je možné vytvořit pomocí konstruktoru ByCoordinates, který jako vstup přijímá souřadnice X, Y a Z nově vytvořeného vektoru. Vektory nejsou geometrickými objekty a nezobrazují se v okně aplikace Dynamo. Informace o nově vytvořeném nebo upraveném vektoru je možné vypsat do konzolového okna:

// construct a Vector object
v = Vector.ByCoordinates(1, 2, 3);

s = v.X + " " + v.Y + " " + v.Z;

U vektorových objektů je definována sada matematických operací, které umožňují přičítat, odečítat, násobit a jinak přesouvat objekty ve 3D prostoru, podobně jako lze tyto operace provádět v 1D prostoru na číselné ose.

Součet vektorů

Součet vektorů je definován jako součet komponent dvou vektorů a lze si jej představit tak, že na špičku jednoho vektoru umístíme druhý vektor. Součet vektorů lze provést metodou Add a je znázorněn na diagramu vlevo.

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 9, y = 6, z = 0
c = a.Add(b);

Odčítání vektorů

Podobně lze metodou Subtract od sebe dva vektorové objekty odečíst. Odečtení vektoru si lze představit tak, že se jedná o vektor směřující od prvního vektoru k druhému vektoru.

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 1, y = 4, z = 0
c = a.Subtract(b);

Násobení vektorů

Násobení vektorů si lze představit jako přesun koncového bodu vektoru v jeho směru o určený faktor měřítka.

a = Vector.ByCoordinates(4, 4, 0);

// c has value x = 20, y = 20, z = 0
c = a.Scale(5);

Normalizace délky vektorů

Při změně měřítka vektoru je často potřeba, aby výsledná délka odpovídala hodnotě měřítka. Toho lze snadno dosáhnout normalizací vektoru, jinými slovy nastavením jeho délky na 1.

a = Vector.ByCoordinates(1, 2, 3);
a_len = a.Length;

// set the a's length equal to 1.0
b = a.Normalized();
c = b.Scale(5);

// len is equal to 5
len = c.Length;

Vektor c má stejný směr jako vektor a (1, 2, 3), ale jeho délka je nyní přesně 5.

Kartézský součin

Ve vektorové matematice existují dvě další metody, pro které v 1D matematice neexistují podobné operace, jedná se o vektorový a skalární součin. Vektorový součin vytváří vektor, který je kolmý (90 stupňů) ke dvěma existujícím vektorům. Například vektorový součin os X a Y je osa Z, ale vstupní vektory na sebe nemusí být nutně kolmé. Vektorový součin lze vypočítat metodou Cross.

a = Vector.ByCoordinates(1, 0, 1);
b = Vector.ByCoordinates(0, 1, 1);

// c has value x = -1, y = -1, z = 1
c = a.Cross(b);

Skalární součin

Další pokročilejší funkcí vektorové matematiky je skalární součin. Skalární součin mezi dvěma vektory je reálné číslo (a nikoliv vektor), které souvisí s úhlem mezi dvěma vektory (ale nejedná se přímo o úhel). Jednou z užitečných vlastností skalárního součinu je, že skalární součin je nulový pouze v případě, kdy jsou na sebe vektory kolmé. Skalární součin lze vypočítat metodou Dot.

a = Vector.ByCoordinates(1, 2, 1);
b = Vector.ByCoordinates(5, -8, 4);

// d has value -7
d = a.Dot(b);

V aplikaci Dynamo existují dva základní způsoby, jak vytvořit křivky volného tvaru: určením kolekce bodů a interpolací vyhlazené křivky mezi nimi, nebo určením řídicích bodů křivky. Interpolované křivky jsou užitečné, když konstruktér přesně ví, jaký tvar má linie mít, nebo pokud návrh obsahuje konkrétní omezení, kudy křivka může a nemůže procházet. Křivky určené řídicími body jsou vlastně úsečky, které algoritmus vyhladí do podoby konečné křivky. Určení křivky pomocí řídicích bodů je užitečné pro zkoušení různých tvarů s různou mírou vyhlazení, nebo pokud je potřeba dosáhnout plynulého přechodu mezi úsečkami.

Interpolovaná křivka

Chcete-li vytvořit interpolovanou křivku, jednoduše zadejte kolekci bodů do metody NurbsCurve.ByPoints.

num_pts = 6;

s = Math.Sin(0..360..#num_pts) * 4;

pts = Point.ByCoordinates(1..30..#num_pts, s, 0);

int_curve = NurbsCurve.ByPoints(pts);

Vygenerovaná křivka protne všechny vstupní body, počínaje prvním bodem a konče posledním bodem v kolekci. Pomocí volitelného parametru lze vytvořit periodickou uzavřenou křivku. Aplikace Dynamo chybějící segment automaticky vytvoří, proto není potřeba zadávat koncový bod stejný jako počáteční bod.

pts = Point.ByCoordinates(Math.Cos(0..350..#10),
    Math.Sin(0..350..#10), 0);

// create an closed curve
crv = NurbsCurve.ByPoints(pts, true);

// the same curve, if left open:
crv2 = NurbsCurve.ByPoints(pts.Translate(5, 0, 0),
    false);

Křivka řídicích bodů

Křivky Nurbs lze vygenerovat stejným způsobem, vstupní body reprezentují koncové body úsečky a druhý parametr určuje sílu a typ vyhlazení, kterému se říká stupeň.* Křivka se stupněm 1 nemá žádné vyhlazení, jedná se o křivku polyline.

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 1 is a polyline
ctrl_curve = NurbsCurve.ByControlPoints(pts, 1);

Křivka se stupněm 2 je vyhlazená, takže prochází středy lomených čar a v průsečíku je k nim tečná:

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 2 is smooth
ctrl_curve = NurbsCurve.ByControlPoints(pts, 2);

Aplikace Dynamo podporuje křivky NURBS (Non-Uniform Rational B-Spline) až do stupně 20 a následující skript demonstruje účinek vyšších stupňů vyhlazení na tvar křivky:

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

def create_curve(pts : Point[], degree : int)
{
	return = NurbsCurve.ByControlPoints(pts,
        degree);
}

ctrl_crvs = create_curve(pts, 1..11);

Poznámka: křivka musí mít alespoň o jeden řídicí bod více, než je její stupeň.

Další výhodou tvorby křivek pomocí řídicích bodů je možnost zachování tečnosti mezi jednotlivými segmenty. To lze provést tak, že se získá směr mezi posledními dvěma řídicími body a v tomto směru se bude pokračovat u prvních dvou řídicích bodů následující křivky. V následujícím příkladu jsou vytvořeny dvě samostatné křivky NURBS, které jsou vyhlazené jako jedna křivka:

pts_1 = {};

pts_1[0] = Point.ByCoordinates(0, 0, 0);
pts_1[1] = Point.ByCoordinates(1, 1, 0);
pts_1[2] = Point.ByCoordinates(5, 0.2, 0);
pts_1[3] = Point.ByCoordinates(9, -3, 0);
pts_1[4] = Point.ByCoordinates(11, 2, 0);

crv_1 = NurbsCurve.ByControlPoints(pts_1, 3);

pts_2 = {};

pts_2[0] = pts_1[4];
end_dir = pts_1[4].Subtract(pts_1[3].AsVector());

pts_2[1] = Point.ByCoordinates(pts_2[0].X + end_dir.X,
    pts_2[0].Y + end_dir.Y, pts_2[0].Z + end_dir.Z);

pts_2[2] = Point.ByCoordinates(15, 1, 0);
pts_2[3] = Point.ByCoordinates(18, -2, 0);
pts_2[4] = Point.ByCoordinates(21, 0.5, 0);

crv_2 = NurbsCurve.ByControlPoints(pts_2, 3);

Ve výpočetních návrzích se křivky a plochy často používají jako základ pro tvorbu složitějších geometrií. Aby se tyto jednoduché geometrie daly použít jako základ pro složitější geometrie, skript musí být schopen získat hodnoty, například pozici a orientaci, na jakémkoliv místě objektu. Získávání těchto hodnot křivky i plochy podporují a tomuto procesu se říká parametrizace.

Všem bodům na křivce lze přiřadit jedinečný parametr v rozsahu od 0 do 1. Pokud bychom chtěli vytvořit objekt NurbsCurve podle několika řídicích nebo interpolovaných bodů, první bod by měl parametr 0 a poslední bod by měl parametr 1. Přesnou hodnotu parametrů jednotlivých bodů nelze předem zjistit, což může znít jako omezení – tento problém však řeší několik pomocných funkcí. Plochy mají podobnou parametrizaci jako křivky, ale se dvěma parametry (u a v) místo jednoho. Pokud bychom chtěli vytvořit plochu s následujícími body:

pts = [ [p1, p2, p3],
        [p4, p5, p6],
        [p7, p8, p9] ];

Pak by měl bod p1 parametry u = 0, v = 0 a bod p9 by měl parametry u = 1, v = 1.

Parametrizace primárně neslouží k určování bodů použitých ke generování křivek, jejím hlavním použitím je určení pozic bodů vygenerovaných konstruktory NurbsCurve a NurbsSurface.

Křivky mají metodu PointAtParameter, která přijímá jeden parametr typu double v rozsahu od 0 do 1 a vrací objekt Point v tomto parametru. Například tento skript vyhledá body v parametrech 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 a 1.0:

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(6, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(3, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);

crv = NurbsCurve.ByPoints(pts);

pts_at_param = crv.PointAtParameter(0..1..#11);

// draw Lines to help visualize the points
lines = Line.ByStartPointEndPoint(pts_at_param,
    Point.ByCoordinates(4, 6, 0));

Podobně plochy mají metodu PointAtParameter, která přijímá dva parametry U a V generovaného bodu.

Ačkoliv získávání bodů na křivce nebo ploše může být užitečné, skripty často vyžadují určité geometrické vlastnosti v daném parametru, například směr křivky nebo plochy. Pomocí metody CoordinateSystemAtParameter lze získat nejen pozici, ale rovnou úplný orientovaný objekt CoordinateSystem v daném parametru křivky nebo plochy. Například následující skript získá orientované objekty CoordinateSystem podél rotované plochy a použije jejich orientaci k vygenerování čar, které budou vycházet z plochy kolmo:

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);

crv = NurbsCurve.ByPoints(pts);

axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);

surf = Surface.ByRevolve(crv, axis_origin, axis, 90,
    140);

cs_array = surf.CoordinateSystemAtParameter(
    (0..1..#7)<1>, (0..1..#7)<2>);

def make_line(cs : CoordinateSystem) {
	lines_start = cs.Origin;
    lines_end = cs.Origin.Translate(cs.ZAxis, -0.75);

    return = Line.ByStartPointEndPoint(lines_start,
        lines_end);
}

lines = make_line(Flatten(cs_array));

Jak bylo zmíněno dříve, parametrizace není po celé délce křivky nebo plochy rovnoměrná, to znamená, že hodnota parametru 0.5 nemusí vždy znamenat střed a hodnota 0.25 nemusí vždy znamenat jednu čtvrtinu délky křivky nebo plochy. Z tohoto důvodu mají křivky další sadu parametrizačních příkazů, pomocí kterých lze najít bod v určité délce křivky.

Dvourozměrná varianta objektu NurbsCurve je objekt NurbsSurface, který lze stejně jako křivku Nurbs volného tvaru vytvořit dvěma základními způsoby: zadáním sady základních bodů a interpolací mezi nimi, nebo explicitním zadáním řídicích bodů plochy. Interpolované plochy jsou užitečné jako křivky volného tvaru v případě, kdy konstruktér zná přesný tvar potřebné plochy, nebo pokud musí plocha procházet určitými body. Na druhou stranu, plochy vytvořené pomocí řídicích bodů mohou být užitečnější pro průzkum různých návrhových možností a úrovní vyhlazování.

Interpolovaná plocha

Chcete-li vytvořit interpolovanou plochu, jednoduše vygenerujte dvourozměrnou kolekci bodů s přibližným tvarem plochy. Kolekce musí mít rovné, nezubaté hrany. Plochu z těchto bodů lze vytvořit metodou NurbsSurface.ByPoints.

// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_1);

Plocha vytvořená pomocí řídicích bodů

Plochu Nurbs volného tvaru lze vytvořit také určením řídicích bodů plochy. Podobně jako u křivek Nurbs, řídicí body si lze představit jako reprezentaci čtyřúhelníkové sítě s rovnými segmenty, která bude v závislosti na stupni plochy vyhlazena do konečné podoby. Chcete-li vytvořit plochu Nurbs pomocí řídicích bodů, zadejte do metody NurbsSurface.ByPoints další dva parametry, které budou naznačovat stupně podřazených křivek v obou směrech plochy.

// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

// create a surface of degree 2 with smooth segments
surf = NurbsSurface.ByPoints(python_points_1, 2, 2);

Stupeň objektu NurbsSurface lze zvýšit a změnit tím výslednou geometrii plochy:

// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

// create a surface of degree 6
surf = NurbsSurface.ByPoints(python_points_1, 6, 6);

Šablonovaná plocha

Podobně jako lze plochy vytvářet interpolací mezi sadou vstupních bodů, lze je vytvářet také interpolací mezi sadou základních křivek. Tomu se říká šablonování. Šablonovanou křivku lze vytvořit pomocí konstruktoru Surface.ByLoft, jediným jeho parametrem je kolekce vstupních křivek.

// python_points_2, 3, and 4 are generated with
// Python scripts found in Chapter 12, Section 10

c1 = NurbsCurve.ByPoints(python_points_2);
c2 = NurbsCurve.ByPoints(python_points_3);
c3 = NurbsCurve.ByPoints(python_points_4);

loft = Surface.ByLoft([c1, c2, c3]);

Plochy rotace

Plochy rotace jsou dalším typem ploch vytvořených tažením základní křivky kolem střední osy. Pokud jsou interpolované plochy dvourozměrnou analogií interpolovaných křivek, pak rotační plochy jsou dvourozměrnou analogií kružnic a oblouků.

Plochy rotace se určují pomocí základní křivky, která reprezentuje „hranu“ plochy, dále pomocí počátku osy, základního bodu plochy, směru osy, středního „hlavního“ směru a počátečního a koncového úhlu tažení. Tyto parametry se zadávají jako vstup do konstruktoru Surface.Revolve.

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);

crv = NurbsCurve.ByPoints(pts);

axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);

surf = Surface.ByRevolve(crv, axis_origin, axis, 0,
    360);

Metody Intersect, Trim a SelectTrim se používají zejména u méněrozměrných geometrií, například u bodů, křivek a ploch. Geometrie těles obsahují další sadu metod, které umožňují upravovat jejich tvar, například odebráním materiálu podobně jako u metody Trim, nebo prvky kombinovat a vytvářet tak větší celky.

Union (Sjednocení)

Metoda Union přijímá dvě tělesa a z prostoru, který tyto objekty zaujímají, vytváří jedno těleso. Překrývající se prostor mezi objekty se zkombinuje do konečného tvaru. Tento příklad kombinuje kouli a kvádr do jednoho tvaru:

s1 = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin, 6);

s2 = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin.Translate(4, 0,
    0), 6);

combined = s1.Union(s2);

Difference (Rozdíl)

Metoda Difference funguje podobně jako metoda Trim odečítá obsah vstupního tělesa od základního tělesa. V tomto příkladu odřízneme od koule malý kus:

s = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin, 6);

tool = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin.Translate(10, 0,
    0), 6);

result = s.Difference(tool);

Průnik

Metoda Intersect vrací těleso tvořené překrývajícím se prostorem dvou vstupních těles. V následujícím příkladu je metoda Difference změněna na Intersect, výsledným tělesem je kus, který byl v předchozím příkladu odříznut:

s = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin, 6);

tool = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin.Translate(10, 0,
    0), 6);

result = s.Intersect(tool);

Mnoho příkladů se dosud soustředilo na tvorbu vícerozměrných geometrií z méněrozměrných geometrií. Pomocí metod průsečíků je možné z vícerozměrných geometrií vygenerovat méněrozměrné objekty a po vytvoření geometrií lze jejich tvar dále upravit pomocí příkazů oříznutí.

Metoda Intersect je definována u všech geometrií aplikace Dynamo, teoreticky lze tedy provést průnik libovolných dvou geometrií. Některé průniky samozřejmě nedávají smysl, například průnik s body, protože výsledným objektem bude vždy samotný vstupní bod. Další možné kombinace průniků mezi objekty jsou uvedeny v následujícím diagramu. Následující tabulka uvádí výsledky různých operací průniku:

Průnik

Následující velmi jednoduchý příklad ukazuje průnik roviny s plochou Nurbs. Průnik vygeneruje pole objektů NurbsCurve, které lze používat jako kterékoliv jiné objekty NurbsCurve.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

WCS = CoordinateSystem.Identity();

pl = Plane.ByOriginNormal(WCS.Origin.Translate(0, 0,
    0.5), WCS.ZAxis);

// intersect surface, generating three closed curves
crvs = surf.Intersect(pl);

crvs_moved = crvs.Translate(0, 0, 10);

Metoda Trim je velmi podobná metodě Intersect v tom, že je definována u téměř všech geometrií. Metoda Trim je však omezenější než metoda Intersect.

Oříznutí

U metody Trim je nutné zadat výběrový bod, který určuje, která geometrie má být zahozena a která má být zachována. Aplikace vyhledá a zahodí oříznutou geometrii, která bude výběrovému bodu nejblíže.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

tool_pts = Point.ByCoordinates((-10..20..10)<1>,
    (-10..20..10)<2>, 1);

tool = NurbsSurface.ByPoints(tool_pts);

pick_point = Point.ByCoordinates(8, 1, 3);

result = surf.Trim(tool, pick_point);

Následující skripty jazyka Python vytvářejí pole bodů pro několik příkladů. Vložte je do uzlu skriptu jazyka Python následovně:

python_points_1

python_points_2

python_points_3

python_points_4

python_points_5

​Python je široce používaný programovací jazyk, jehož popularita souvisí s jeho stylem syntaxe. Je velmi čitelný, a proto je snazší se ho naučit v porovnání s mnoha jinými jazyky. Python podporuje moduly a balíčky a může být začleněn do existujících aplikací. Dobrým zdrojem informací o tom, jak začít pracovat s jazykem Python, je část na stránce .

Proč byste měli používat textové programování ve vizuálním programovacím prostředí aplikace Dynamo? má mnoho výhod. Umožňuje vytvářet programy bez použití speciální syntaxe v intuitivním vizuálním rozhraní. Vizuální program však může být nepřehledný a v některých případech může mít menší funkčnost. Například jazyk Python nabízí mnohem jednodušší metody pro zápis podmínek (if/then) a cyklů. Python je výkonný nástroj, který umožňuje rozšířit možnosti aplikace Dynamo a umožňuje nahradit mnoho uzlů několika stručnými řádky kódů.

Vizuální program:

Textový program:

Uzel Python

Stejně jako bloky kódu jsou uzly Python skriptovacím rozhraním v prostředí vizuálního programování. Uzel jazyka Python naleznete v knihovně v části Script > Editor > Python Script.

Dvojitým kliknutím na uzel otevřete editor skriptů jazyka Python (můžete také kliknout pravým tlačítkem na uzel a vybrat možnost Upravit). Všimněte si, že se v horní části nachází výchozí text, který vám má pomoci odkazovat na knihovny, které budete potřebovat. Vstupy jsou uloženy v poli IN. Hodnoty se vrátí do aplikace Dynamo jejich přiřazením k proměnné OUT.

Metody zahrnují konstruktory, například ByCoordinates, akce, například Add, a dotazy, například souřadnice X, Y a Z.

Cvičení: Vlastní uzel se skriptem jazyka Python k vytváření vzorů z modulu tělesa

Část I: Nastavení skriptu jazyka Python

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

V tomto příkladu napíšeme skript jazyka Python, který vytvoří vzory z modulu tělesa a převede je na vlastní uzel. Nejprve vytvoříme náš modul tělesa pomocí uzlů aplikace Dynamo.

1. Rectangle.ByWidthLength: Vytvořte obdélník, který bude základem našeho tělesa.

2. Surface.ByPatch: Spojte obdélník se vstupem closedCurve a vytvořte tak dolní povrch.

1. Geometry.Translate: Připojte obdélník ke vstupu geometrie, aby se posunul nahoru pomocí bloku kódu, který určuje základní tloušťku našeho tělesa.

2. Polygon.Points: Pomocí dotazu na převedený obdélník extrahujte rohové body.

3. Geometry.Translate: Pomocí bloku kódu vytvořte seznam čtyř hodnot odpovídajících čtyřem bodům. Tím posunete jeden roh tělesa nahoru.

4. Polygon.ByPoints: Pomocí převedených bodů rekonstruujte horní polygon.

5. Surface.ByPatch: Připojením polygonu vytvořte horní povrch.

Nyní, když máme horní a dolní povrch, vytvoříme boky tělesa šablonováním mezi dvěma profily.

1. List.Create: Spojte dolní obdélník a horní polygon se vstupy indexu.

2. Surface.ByLoft: Šablonováním dvou profilů vytvořte strany tělesa.

3. List.Create: Připojte horní, boční a dolní povrchy ke vstupům indexu a vytvořte tak seznam povrchů.

4. Solid.ByConnectedSurfaces: Spojením povrchů vytvořte modul tělesa.

Nyní, když máme naše těleso, přetáhneme do pracovního prostoru uzel skriptu jazyka Python.

1. Chcete-li do uzlu přidat další vstupy, klikněte na ikonu + v uzlu. Vstupy jsou pojmenovány IN[0], IN[1] atd., což označuje, že představují položky v seznamu.

Začneme definováním našich vstupů a výstupu. Dvojitým kliknutím na uzel otevřete editor jazyka Python. Při úpravách kódu v editoru postupujte podle kódu uvedeného níže.

Tento kód začne dávat větší smysl, jak budeme cvičením procházet. Dále musíme přemýšlet o tom, jaké informace jsou potřeba k vytvoření pole našeho modulu tělesa. Nejprve je nutné znát rozměry tělesa, abychom mohli určit vzdálenost posunutí. Kvůli chybě ohraničujícího kvádru bude nutné k jeho vytvoření použít geometrii křivky hrany.

Podívejte se na uzel Python v aplikaci Dynamo. Všimněte si, že používáme stejnou syntaxi, jakou vidíme v názvech uzlů v aplikaci Dynamo. Prohlédněte si níže uvedený kód s komentáři.

Protože budeme převádět i otáčet moduly těles, použijeme operaci Geometry.Transform. Při pohledu na uzel Geometry.Transform zjistíme, že k transformaci tělesa budeme potřebovat zdrojový souřadnicový systém a cílový souřadnicový systém. Zdroj je kontextový souřadnicový systém našeho tělesa, zatímco cíl bude odlišný souřadnicový systém pro každý modul v poli. To znamená, že bude nutné projít hodnoty X a Y a transformovat souřadnicový systém pokaždé jinak.

Klikněte na tlačítko Spustit a poté uložte kód. Připojte uzel jazyka Python k existujícímu skriptu níže uvedeným způsobem.

1. Připojte výstup z uzlu Solid.ByConnectedSurfaces jako první vstup uzlu jazyka Python a pomocí uzlu CodeBlock definujte ostatní vstupy.

2. Vytvořte uzel Topology.Edge a jako vstup použijte výstup z uzlu jazyka Python.

3. Nakonec vytvořte uzel Edge.CurveGeometry a jako vstup použijte výstup z uzlu Topology.Edge.

Zkuste změnit výchozí hodnotu a vytvořte jiné vzory. Můžete také změnit parametry samotného modulu tělesa a dosáhnout tak různých efektů.

Část II: Převod uzlu Python Script na vlastní uzel

Nyní, když jsme vytvořili užitečný skript jazyka Python, uložte jej jako uživatelský uzel. Vyberte uzel Python Script, klikněte pravým tlačítkem na pracovní prostor a vyberte možnost Vytvořit vlastní uzel.

Přiřaďte název, popis a kategorii.

Tím se otevře nový pracovní prostor, ve kterém se má upravit uživatelský uzel.

1. Vstupy: Změňte vstupní názvy tak, aby byly popisnější, a přidejte typy dat a výchozí hodnoty.

2. Výstup: Změňte název výstupu.

Uzel uložte jako soubor .dyf a měli byste vidět, že vlastní uzel odráží změny, které jsme právě provedli.

V aplikaci Dynamo 2.0 je možné určit výchozí šablonu (.py extension), která se použije při prvním otevření okna jazyka Python. Tato funkce byla dlouho požadována, protože urychluje používání jazyka Python v aplikaci Dynamo. Díky šabloně je možné při vývoji vlastního skriptu v jazyce Python mít připraveny veškeré importy.

Šablona se nachází v umístění APPDATA instalace aplikace Dynamo.

Obvykle je to následující umístění: ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Nastavení šablony

Aby bylo možné tuto funkci používat, je nutné přidat do souboru DynamoSettings.xml následující řádek. (Upravte v poznámkovém bloku)

Řetězec <PythonTemplateFilePath /> je možné jednoduše nahradit následujícím řetězcem:

Dále je nutné vytvořit šablonu s funkcemi, které má obsahovat. V tomto případě do ní zahrneme importy související s aplikací Revit a další položky, které se s aplikací Revit obvykle používají.

Otevřete prázdný dokument v poznámkovém bloku a vložte do něj následující kód:

Poté tento soubor uložte pod názvem PythonTemplate.py do umístění APPDATA.

Chování skriptu jazyka Python

Po definování šablony jazyka Python aplikace Dynamo tuto šablonu vyhledá při každém vložení uzlu jazyka Python. Pokud ji nenajde, okno jazyka Python bude vypadat jako ve výchozím nastavení.

Pokud se podaří šablonu jazyka Python nalézt (například náš skript pro aplikaci Revit), zobrazí se všechny položky, které obsahuje.

Další informace o této skvělé nové funkci (autor: Radu Gidei) naleznete zde: https://github.com/DynamoDS/Dynamo/pull/8122

Python a Revit

Nyní, když jsme ukázali, jak používat skripty jazyka Python v aplikaci Dynamo, podívejme se na připojení knihoven aplikace Revit do prostředí skriptování. Pamatujte, importovali jsme standardní knihovny jazyka Python a hlavní uzly aplikace Dynamo pomocí prvních čtyř řádků v níže uvedeném bloku kódu. Chcete-li importovat uzly aplikace Revit, prvky aplikace Revit a správce dokumentů aplikace Revit, stačí přidat pouze několik dalších řádků:

To nám poskytuje přístup k rozhraní API aplikace Revit a nabízí vlastní skriptování pro libovolnou úlohu aplikace Revit. Díky kombinaci procesu vizuálního programování se skriptováním rozhraní API aplikace Revit se spolupráce a vývoj nástrojů výrazně zlepšují. Například správce BIM i konstruktér schémat mohou spolupracovat na stejném grafu. Při této spolupráci mohou zlepšit návrh a provedení modelu.

Rozhraní API pro konkrétní platformu

Cvičení 1

Vytvořte nový projekt aplikace Revit.

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

V těchto cvičeních prozkoumáme základní skripty jazyka Python v rozhraní Dynamo pro aplikaci Revit. Toto cvičení se zaměří na práci se soubory a prvky aplikace Revit a také na komunikaci mezi aplikacemi Revit a Dynamo.

Jedná se o jednoduchou metodu získávání souborů doc, uiapp a app aplikace Revit připojených k vaší relaci Dynamo. Programátoři, kteří předtím pracovali v rozhraní API aplikace Revit, si mohou všimnout položek v seznamu sledovaných položek. Pokud se vám to nezdá povědomé, tak to nevadí. Použijeme další příklady ve cvičeních níže.

Zde je způsob importu služeb aplikace Revit a získání dat dokumentu v aplikaci Dynamo.

Podívejte se na uzel Python v aplikaci Dynamo. Kód můžete také najít níže:

Cvičení 2

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

V tomto cvičení vytvoříme pomocí uzlu Python aplikace Dynamo jednoduchou křivku modelu v aplikaci Revit.

Začněte vytvořením nové rodiny Koncepční objem v aplikaci Revit.

Otevřete složku rodiny Koncepční objem a použijte soubor šablony Metric Mass.rft.

V aplikaci Revit pomocí klávesové zkratky un vyvolejte nastavení jednotek projektu a změňte jednotku délky na metry.

Spusťte aplikaci Dynamo a vytvořte sadu uzlů jako na obrázku níže. Nejprve vytvoříme dva referenční body v aplikaci Revit z uzlů aplikace Dynamo.

1. Vytvořte blok kódu a zadejte hodnotu "0;".

2. Tuto hodnotu připojte ke vstupům X, Y a Z uzlu ReferencePoint.ByCoordinates.

3. Vytvořte tři posuvníky v rozsahu od -100 do 100 s velikostí kroku 1.

4. Připojte všechny posuvníky k uzlu ReferencePoint.ByCoordinates.

5. Přidejte do pracovního prostoru uzel Python, kliknutím na tlačítko „+“ v uzlu přidejte další vstup a připojte dva referenční body, jeden ke každému vstupu. Otevřete uzel Python.

Podívejte se na uzel Python v aplikaci Dynamo. Celý kód najdete níže.

1. System.Array: Aplikace Revit vyžaduje jako vstup systémové pole (místo seznamu jazyka Python). Jedná se pouze o jeden další řádek kódu, ale zohlednění typů argumentů usnadní programování v aplikaci Revit v jazyce Python.

V aplikaci Dynamo jsme pomocí jazyka Python vytvořili dva referenční body a čáru, která je spojuje. V dalším cvičení zkusíme něco složitějšího.

Cvičení 3

Kliknutím na odkaz níže si stáhněte vzorový soubor.

Úplný seznam vzorových souborů najdete v dodatku.

Toto cvičení vysvětluje témata připojení dat a geometrie z aplikace Revit do aplikace Dynamo a zpět. Začneme otevřením souboru Revit-StructuralFraming.rvt. Po otevření spusťte aplikaci Dynamo a otevřete soubor Revit-StructuralFraming.dyn.

Tento soubor aplikace Revit je jeden z nejzákladnějších. Dvě referenční křivky: jedna nakreslená na Podlaží 1 a druhá na Podlaží 2. Chceme tyto křivky dostat do aplikace Dynamo a zachovat živé propojení.

V tomto souboru máme sadu uzlů zapojených do pěti vstupů uzlu Python.

1. Uzly Select Model Element: Klikněte na tlačítko Vybrat pro každý prvek a vyberte odpovídající křivku v aplikaci Revit.

2. Uzel Code Block: Pomocí syntaxe 0..1..#x;, připojte posuvník celého čísla v rozsahu od 0 do 20 ke vstupu x. Označuje počet nosníků, které se mají kreslit mezi dvěma křivkami.

3. Uzel Structural Framing Types: Zde vybereme v rozevírací nabídce výchozí nosník W12x26.

4. Uzel Levels: Vyberte možnost Podlaží 1.

Tento kód v jazyce Python je trochu hustší, ale komentáře v kódu popisují, co se v procesu děje.

V aplikaci Revit je k dispozici pole nosníků, které pokrývají dvě křivky jako konstrukční prvky. Poznámka: Toto není realistický příklad... Konstrukční prvky se používají jako příklad pro nativní instance aplikace Revit vytvořené z aplikace Dynamo.

Výsledky jsou v aplikaci Dynamo zobrazeny také. Nosníky v uzlu Watch3D odkazují na geometrii dotazovanou z prvků aplikace Revit.

Všimněte si, že máme nepřetržitý proces převodu dat z prostředí aplikace Revit do prostředí aplikace Dynamo. Toto je souhrn průběhu procesu:

1. Vybrat prvek aplikace Revit

2. Převést prvek aplikace Revit na křivku aplikace Dynamo

3. Rozdělit křivku aplikace Dynamo na řadu bodů aplikace Dynamo

4. Vytvořit čáry aplikace Dynamo pomocí bodů aplikace Dynamo mezi dvěma křivkami

5. Vytvořit nosníky aplikace Revit pomocí odkazů na čáry aplikace Dynamo

6. Vytvořit výstup povrchů aplikace Dynamo pomocí dotazů na geometrii nosníků aplikace Revit

Může to znít složitě, ale díky skriptu je to stejně jednoduché jako úprava křivky v aplikaci Revit a opětovné spuštění řešiče (i když je možné, že při tom budete muset odstranit předchozí nosníky). Důvodem je skutečnost, že nosníky umísťujeme do jazyka Python, a tím porušujeme asociaci uzlů OOTB.

Pomocí aktualizace referenčních křivek v aplikaci Revit získáte nové pole nosníků.