Revit Dynamo: Kompletny Kurs Automatyzacji BIM

W tej lekcji omawiam szczegółowo, z czego składa się każdy node w Dynamo. Pokazuję, jak rozpoznawać inputy i outputy, w jaki sposób są oznaczone dopuszczalne typy danych, oraz jak odczytywać jednostki i wymagania wejściowe. Przedstawiam również, gdzie znaleźć opis i definicję danego noda, co pozwala zrozumieć jego działanie nawet wtedy, gdy nie jesteśmy pewni jego funkcji.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika poprawnego czytania i interpretowania struktury noda — tak, aby potrafił samodzielnie zrozumieć, jakie dane może do niego podłączyć, co node zwraca i jak działa.

Najważniejsze wnioski

• Zrozumienie budowy noda oraz tego, jak są oznaczone wejścia (inputy) i wyjścia (outputy).

• Umiejętność rozpoznawania typów danych akceptowanych przez dany input.

• Wiedza, jak sprawdzić jednostki, ograniczenia oraz kontekst działania danego noda.

• Poznanie sposobu odczytywania opisu i dokumentacji noda, aby szybciej zrozumieć jego zastosowanie.

Na czym się skupić podczas oglądania

• Zwróć uwagę na symbole i kolory przy inputach — to często wskazuje, jakiego typu dane node oczekuje.

• Obserwuj, gdzie znajduje się opis noda oraz jak szybko dotrzeć do informacji o jego funkcji.

• Zapamiętaj sposób interpretacji jednostek i danych wejściowych — będzie to kluczowe przy tworzeniu poprawnie działających skryptów.

W tej lekcji omawiam podstawowe funkcje matematyczne dostępne w Dynamo, takie jak dodawanie, odejmowanie, mnożenie i dzielenie. Następnie pokazuję, jak tworzyć punkty (Point) na podstawie współrzędnych oraz jak na ich bazie generować linie (Line). Prezentuję również, jak wyznaczać kluczowe informacje geometryczne, np. środek odcinka pomiędzy dwoma punktami.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika używania podstawowych funkcji matematycznych oraz budowania prostych elementów geometrycznych — punktów i linii — które stanowią podstawę bardziej zaawansowanych operacji w Dynamo.

Najważniejsze wnioski

• Poznanie podstawowych funkcji matematycznych i ich zastosowania w skryptach.

• Umiejętność tworzenia punktów na podstawie współrzędnych X, Y, Z.

• Zrozumienie, jak z punktów tworzyć linie i jak interpretować zależności geometryczne.

• Wiedza, jak wyznaczać elementy pomocnicze, np. punkt środkowy między dwoma punktami.

Na czym się skupić podczas oglądania

• Zwróć uwagę na sposób łączenia funkcji matematycznych z danymi geometrycznymi — to częsta praktyka w Dynamo.

• Przyjrzyj się strukturze punktów tworzonych na bazie współrzędnych, bo geometryczne dane będą się pojawiać w wielu kolejnych lekcjach.

• Zauważ, jak generowanie linii i obliczanie środka odcinka otwiera drogę do bardziej złożonych operacji geometrycznych.

W tej lekcji omawiam funkcje logiczne i warunkowe w Dynamo, zaczynając od If oraz ScopeIf, które pozwalają wykonywać różne działania w zależności od tego, czy warunek jest prawdziwy czy fałszywy. Następnie prezentuję nody służące do porównywania wartości — większe, mniejsze, równe i ich kombinacje. Pokazuję również działanie Loop While, który umożliwia zapętlanie działań na podstawie zadanych warunków logicznych.
Kolejnym elementem są nody And oraz Or, które pozwalają łączyć wartości boolean i tworzyć złożone warunki.
Na końcu omawiam funkcje dotyczące stringów, takie jak String.Join, String.Concat czy String.Contains, które umożliwiają łączenie, budowanie i przeszukiwanie tekstów.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika pracy z logiką i warunkami w Dynamo, tworzenia pętli opartych na warunkach, porównywania wartości oraz wykonywania podstawowych operacji na tekstach.

Najważniejsze wnioski

• Zrozumienie działania funkcji If i ScopeIf oraz ich zastosowania przy podejmowaniu decyzji w skryptach.

• Umiejętność korzystania z node’ów porównujących wartości (>, <, ==, ≥, ≤).

• Poznanie sposobu działania Loop While i jego użycia do powtarzalnych operacji opartych na logice.

• Wiedza, jak łączyć wartości boolean przy pomocy And oraz Or.

• Zrozumienie podstawowych operacji na tekstach: łączenia stringów (Join, Concat) oraz wyszukiwania fraz (Contains).

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak warunki logiczne sterują przepływem danych — to kluczowe przy tworzeniu inteligentnych skryptów.

• Obserwuj, w jaki sposób porównania integrują się z funkcjami If, ScopeIf oraz z pętlą Loop While.

• Przyjrzyj się pracy z booleanami — połączone w logiczne schematy są fundamentem automatyzacji.

• Szczególnie zapamiętaj działanie String.Contains — często używa się go do filtrowania i wyszukiwania danych projektowych.

W tej lekcji omawiam kluczowe funkcje służące do tworzenia i przekształcania list w Dynamo. Zaczynam od podstawowych node’ów, takich jak List.Create, Range oraz generowanie list za pomocą Code Block. Następnie przechodzę do bardziej zaawansowanych operacji łączenia list, omawiając działanie List.Join oraz trzy sposoby łączenia danych: Shortest, Longest i Cartesian Product.
W kolejnych krokach przedstawiam funkcje List.Transpose i List.Flatten, pokazując ich wpływ na strukturę danych. Na końcu omawiam List.FilterByBoolMask, który pozwala filtrować listy na podstawie wartości logicznych, co jest jednym z najczęściej wykorzystywanych narzędzi w praktycznych skryptach.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika tworzenia, łączenia i przekształcania list oraz zrozumienia, jak różne operacje wpływają na strukturę danych i przepływ informacji w skrypcie.

Najważniejsze wnioski

• Umiejętność tworzenia list przy pomocy List.Create, Range i Code Block.

• Znajomość możliwości funkcji List.Join oraz różnic między metodami łączenia: Shortest, Longest i Cartesian Product.

• Zrozumienie działania List.Transpose (zamiana orientacji list) oraz List.Flatten (spłaszczanie struktury danych).

• Umiejętność filtrowania list przy użyciu List.FilterByBoolMask, co pozwala selekcjonować elementy na podstawie logicznych kryteriów.

Na czym się skupić podczas oglądania

• Zwróć uwagę na to, jak zmienia się struktura list przy różnych metodach łączenia — to jedno z fundamentalnych zagadnień Dynamo.

• Przyjrzyj się różnicom między Transpose a Flatten — ich działanie jest często mylone, a ma kluczowe znaczenie w dalszych etapach automatyzacji.

• Obserwuj sposób działania List.FilterByBoolMask, bo to narzędzie regularnie pojawia się przy filtrowaniu danych projektowych.

• Zauważ, jak operacje na listach wpływają na dalszy przepływ danych i działanie kolejnych node’ów.

W tej lekcji pokazuję, w jaki sposób można tworzyć nody bezpośrednio w Code Blocku, wywołując funkcje tak samo, jak tradycyjne nody z biblioteki. Omawiam różne formy zapisu oraz to, jak Code Block potrafi zastąpić wiele graficznych node’ów, znacząco upraszczając i kompresując skrypt. Dzięki temu uczestnik zobaczy, jak za pomocą kilku linijek zapisu można uporządkować i zminimalizować wizualną złożoność całego grafu.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika, jak wywoływać funkcje i tworzyć ich odpowiedniki w Code Blocku oraz jak wykorzystać tę możliwość do budowania bardziej czytelnych i kompaktowych skryptów.

Najważniejsze wnioski

• Zrozumienie, że Code Block może pełnić funkcję klasycznego noda, pozwalając wywoływać funkcje w formie tekstowej.

• Umiejętność zastąpienia wielu połączonych node’ów pojedynczym, uporządkowanym zapisem w Code Blocku.

• Świadomość, jak Code Block wpływa na czytelność i organizację skryptu.

• Poznanie podstaw tworzenia „skompresowanych” wersji skryptów, które są łatwiejsze do analizy i utrzymania.

Na czym się skupić podczas oglądania

• Zwróć uwagę na składnię wywoływania node’ów w Code Blocku — od niej zależy poprawne działanie funkcji.

• Obserwuj, jak duży wpływ na przejrzystość skryptu ma zastępowanie wielu node’ów pojedynczym wpisem.

• Spróbuj zrozumieć logikę mapowania funkcji z biblioteki na ich tekstowe odpowiedniki — ta umiejętność przyspieszy późniejszą pracę.

• Skup się na przykładach, w których Code Block realnie upraszcza skrypt — wykorzystasz to w bardziej zaawansowanych projektach.

W tej lekcji wyjaśniam, czym są levele w node’ach i jak wpływają na sposób działania funkcji w Dynamo. Na przykładzie node’a List.Count pokazuję w praktyce, jak wybór odpowiedniego levelu zmienia wynik działania noda, jak pozwala odwoływać się do różnych poziomów danych i jak modyfikuje strukturę operacji. Dzięki wizualnemu i intuicyjnemu przykładowi uczestnik zrozumie, jak levele sterują zakresem zastosowania funkcji w listach zagnieżdżonych.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika rozumienia i poprawnego używania leveli, aby potrafił świadomie kontrolować, na jakich poziomach list działają node’y i jak zarządzać złożonymi strukturami danych.

Najważniejsze wnioski

• Zrozumienie, czym są levele i dlaczego mają kluczowe znaczenie w pracy z listami.

• Umiejętność obserwowania, jak zmienia się działanie noda przy wyborze różnych poziomów danych.

• Wiedza, jak dzięki levelom odwoływać się do konkretnych elementów, grup lub całych struktur list.

• Świadomość, że prawidłowe używanie leveli jest niezbędne przy tworzeniu własnych rozwiązań i bardziej zaawansowanych skryptów.

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak różne ustawienia leveli wpływają na wynik działania List.Count — to idealny, obrazowy przykład działania tego mechanizmu.

• Obserwuj, jak levele zmieniają kontekst działania node’a — od pojedynczych elementów, przez podlisty, aż po całą strukturę.

• Zapamiętaj logikę, według której levele pomagają kontrolować przepływ danych — ta wiedza będzie niezbędna przy pracy z bardziej złożonymi listami.

• Skup się na strukturze wejściowej listy — to ona determinuje, jak levele będą działały w praktyce.

W tej lekcji przedstawiam podstawowe funkcje Package Managera w Dynamo. Pokazuję, jak wyszukiwać interesujące paczki stworzone przez społeczność, jak analizować ich opisy oraz jak sprawdzać, do czego mogą się przydać w codziennej pracy. Omawiam również, co zrobić w sytuacji, gdy dana paczka nie działa poprawnie — jak ją naprawić, zaktualizować lub zainstalować ponownie. Na przykładzie konkretnej pobranej paczki pokazuję również jej strukturę oraz wskazuję miejsca, gdzie można znaleźć dodatkowe informacje o rozszerzeniach Dynamo.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika skutecznego korzystania z Package Managera: wyszukiwania paczek, analizowania ich działania, rozwiązywania problemów z instalacją oraz znajdowania informacji o dostępnych rozszerzeniach.

Najważniejsze wnioski

• Poznanie działania Package Managera i jego najważniejszych funkcji.

• Umiejętność wyszukiwania i instalowania paczek udostępnionych przez innych użytkowników Dynamo.

• Wiedza, jak postępować w sytuacji, gdy paczka przestaje działać lub jest niekompatybilna.

• Zrozumienie podstawowej struktury pobranej paczki i tego, gdzie znaleźć o niej informacje.

• Świadomość, gdzie szukać zestawień i opisów ciekawych paczek, które mogą usprawnić codzienną pracę.

Na czym się skupić podczas oglądania

• Zwróć uwagę na kryteria wyboru paczek — opis, liczbę pobrań, wersję oraz kompatybilność z Dynamo.

• Obserwuj, jak wygląda struktura paczki po pobraniu — to pomoże w zrozumieniu, jak działają jej node’y.

• Zapamiętaj proces naprawiania paczek — będzie przydatny, gdy pojawią się problemy w projektach.

• Skup się na miejscach, gdzie można znaleźć listy polecanych paczek — to oszczędzi wiele czasu podczas pracy.

W tej lekcji przedstawiam jedno z najważniejszych i najbardziej pomocnych rozszerzeń do Dynamo — Monocle. To nie klasyczna paczka z node’ami, lecz plugin, który znacząco rozszerza funkcjonalność samego środowiska. Pokazuję, jak Monocle usprawnia pracę dzięki zaawansowanej wyszukiwarce node’ów, automatycznemu łączeniu node’ów w listy, szybkiemu opisywaniu i komentowaniu elementów, a także wygodnemu grupowaniu i organizowaniu skryptów. Omawiam najpraktyczniejsze funkcje Monocle oraz to, jak realnie wpływa on na szybkość i wygodę tworzenia skryptów.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika korzystania z rozszerzenia Monocle, aby mógł efektywniej wyszukiwać node’y, szybciej organizować skrypty i czytelniej zarządzać strukturą całego grafu.

Najważniejsze wnioski

• Zrozumienie, czym jest Monocle i dlaczego jest to jedno z najprzydatniejszych rozszerzeń dla użytkowników Dynamo.

• Poznanie możliwości zaawansowanej wyszukiwarki node’ów dostępnej w Monocle.

• Umiejętność automatycznego tworzenia i łączenia list za pomocą narzędzi dodatku.

• Wiedza, jak szybko opisywać, komentować i grupować node’y, aby skrypty były bardziej czytelne i uporządkowane.

• Świadomość, że Monocle znacząco przyspiesza pracę i poprawia ergonomię korzystania z Dynamo.

Na czym się skupić podczas oglądania

• Zwróć uwagę na różnice między standardową wyszukiwarką a wyszukiwarką Monocle — te ulepszenia odczujesz natychmiast.

• Obserwuj, jak narzędzia Monocle automatyzują powtarzalne działania, takie jak łączenie node’ów czy tworzenie list.

• Przyjrzyj się funkcjom organizacyjnym — to one najbardziej poprawiają czytelność skryptów.

• Zapamiętaj, jak korzystać z narzędzi Monocle przy rozbudowanych projektach — tam jego funkcje pokazują pełnię możliwości.

W tej lekcji pokazuję różne sposoby wybierania elementów z modelu Revit w zależności od potrzeb projektowych. Omawiam podstawowe i najczęściej wykorzystywane node’y służące do wyboru pojedynczych elementów, wielu elementów, elementów według kategorii czy określonych filtrów. Uczestnik zobaczy, jak wybór odpowiednich elementów stanowi fundament dalszej pracy w skrypcie — od edycji parametrów, przez generowanie zestawień, aż po automatyczne tworzenie nowych obiektów.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika poprawnego i świadomego wybierania elementów z modelu Revit, tak aby mógł rozpocząć pracę z danymi konkretnych obiektów i rozwijać kolejne etapy skryptu.

Najważniejsze wnioski

• Poznanie podstawowych metod wybierania elementów w Dynamo.

• Zrozumienie, dlaczego wybór właściwych elementów jest kluczowym krokiem przy tworzeniu każdego skryptu.

• Umiejętność dopasowania odpowiedniej metody wyboru do aktualnych potrzeb projektu.

• Świadomość, że poprawnie wybrane elementy umożliwiają dalsze działania: edycję parametrów, łączenie informacji, generowanie zestawień i automatyzację pracy.

Na czym się skupić podczas oglądania

• Zwróć uwagę na to, jak różne sposoby wyboru wpływają na strukturę danych, które trafiają do skryptu.

• Obserwuj, jak działa wybór pojedynczy vs. wybór wielu elementów — te opcje stosuje się w różnych scenariuszach.

• Zauważ, jak ważny jest etap selekcji elementów przed ich przetwarzaniem — to od niego zależy poprawność całego skryptu.

W tej lekcji, korzystając ze skryptu stworzonego wcześniej podczas wybierania elementów, pokazuję, jak sortować i filtrować listy danych, aby odnaleźć różnice i podobieństwa pomiędzy dwoma zestawami elementów. Przedstawiam działanie funkcji takich jak List.FilterByBoolMask, dzięki której możemy łatwo zidentyfikować elementy wspólne dla dwóch list, a także te, które występują wyłącznie w jednej z nich.
Na praktycznym przykładzie pokazuję, jak takie podejście pozwala przeprowadzić audyt modelu w sytuacji, gdy elementy przypisane do danego poziomu (level) nie są widoczne w aktualnym widoku. Dzięki filtrowaniu możemy szybko wykryć, które elementy są ukryte, niewyświetlane lub niepoprawnie przypisane, co pozwala ocenić poprawność modelu.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika pracy z filtrowaniem i porównywaniem list w Dynamo oraz pokazywanie, jak wykorzystać te operacje w realnych scenariuszach, takich jak analiza widoczności elementów w modelu Revit.

Najważniejsze wnioski

• Umiejętność sortowania, filtrowania i porównywania list elementów.

• Zrozumienie działania List.FilterByBoolMask oraz sposobu identyfikowania elementów wspólnych lub unikalnych między listami.

• Poznanie praktycznego zastosowania filtrowania do analizy widoczności elementów na widokach.

• Świadomość, jak filtrowanie list pomaga wykrywać błędy w modelu (np. ukryte elementy, brakujące elementy, nieprawidłowe przypisania do poziomów).

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak budujemy listę elementów widocznych i niewidocznych — to kluczowe do zrozumienia procesu audytu.

• Obserwuj, jak bool mask jest generowana i jak wpływa na wynik filtrowania.

• Skup się na sposobie porównywania dwóch list — technika ta powróci wielokrotnie w bardziej zaawansowanych skryptach.

• Zauważ, jak proste operacje listowe mogą zwiastować realne problemy w modelu Revit.

W tej lekcji pokazuję, jak stworzyć skrypt, który umożliwia wyciąganie interesujących nas elementów z modelu Revit, a następnie eksportowanie ich parametrów do pliku CSV. Uczestnik dowiaduje się, jak dodać do skryptu parametry, które mają zostać zapisane, jak przygotować dane do eksportu oraz jak wygenerować plik CSV możliwy do otwarcia w Excelu lub innym arkuszu kalkulacyjnym.
Skrypt tworzony w tej lekcji został zaprojektowany tak, aby pozwalał później na ponowne zaimportowanie danych — co będzie tematem kolejnej lekcji.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika przygotowywania danych do eksportu oraz tworzenia plików CSV, które mogą służyć do analizy, raportowania lub późniejszej edycji i ponownego importowania danych do modelu.

Najważniejsze wnioski

• Umiejętność zbierania wybranych elementów i ich parametrów z modelu Revit.

• Zrozumienie sposobu budowania struktury danych przygotowanej do eksportu.

• Poznanie procesu generowania pliku CSV z poziomu Dynamo.

• Świadomość, jak tworzyć eksport zgodny z formatem umożliwiającym późniejszy import i przetwarzanie danych.

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak budowana jest lista parametrów przeznaczonych do eksportu — ich struktura musi być spójna, by poprawnie trafić do CSV.

• Obserwuj sposób przygotowania danych wejściowych tak, aby były łatwe do otwarcia w Excelu i dalszej obróbki.

• Skup się na logice eksportu — przyda się ona przy budowaniu skryptów raportujących i kontrolnych.

• Zapamiętaj sposób organizacji danych, ponieważ w kolejnej lekcji te same informacje zostaną wykorzystane do importowania zmian z powrotem do modelu.

W tej lekcji pokazuję, jak zaimportować zmodyfikowane dane z pliku CSV i przypisać je z powrotem do elementów w modelu Revit. Korzystając ze skryptu stworzonego w poprzedniej lekcji, uczestnik uczy się, jak pobierać dane z pliku, jak je odczytywać oraz jak dopasowywać je do konkretnych elementów w modelu. Omawiam node’y odpowiedzialne za import danych oraz pokazuję, w jaki sposób przypisywać wartości do parametrów elementów, tak aby zmiany wprowadzone w Excelu poprawnie aktualizowały model.

Cel lekcji

Celem lekcji jest nauczenie uczestnika importowania danych z plików CSV i aktualizowania parametrów elementów w modelu Revit na podstawie zmodyfikowanych informacji.

Najważniejsze wnioski

• Zrozumienie procesu importowania danych z pliku CSV do Dynamo.

• Umiejętność odczytywania danych i dopasowywania ich do odpowiednich elementów modelu.

• Poznanie sposobu przypisywania nowych wartości do parametrów elementów.

• Wiedza, jak odnaleźć odpowiednie elementy w modelu i zaktualizować ich dane na podstawie informacji z pliku.

• Świadomość, jak import danych może wspierać automatyczne aktualizacje modelu i procesy koordynacyjne.

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak dane z CSV są strukturyzowane i parowane z konkretnymi elementami — poprawne dopasowanie jest kluczowe dla działania skryptu.

• Obserwuj, jak przypisywane są nowe wartości do parametrów — w tym miejscu najczęściej pojawiają się błędy, jeśli dane wejściowe są niespójne.

• Skup się na node’ach odpowiedzialnych za odczyt i interpretację plików CSV — wrócą one w wielu podobnych skryptach.

• Przyjrzyj się procesowi identyfikacji elementów, ponieważ ten etap jest krytyczny w każdym procesie importu danych.

W tej lekcji pokazuję, jak zbudować skrypt, który automatycznie umieszcza wybrane elementy (np. lampy) w pomieszczeniach znajdujących się w modelu Revit. Zaczynamy od omówienia koncepcji działania skryptu – co po kolei musi się wydarzyć, aby elementy zostały poprawnie wstawione. Następnie krok po kroku przechodzimy przez cały proces:
– wybór interesujących nas pomieszczeń i typów elementów,
– wyznaczenie współrzędnych, według których elementy mają być umieszczane,
– umieszczenie elementów w modelu,
– wstępna weryfikacja, czy zostały poprawnie rozmieszczone.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika, jak zbudować skrypt, który automatycznie umieszcza elementy w pomieszczeniach na podstawie ich położenia i wyznaczonych współrzędnych, oraz zrozumienie całej logiki stojącej za takim procesem.

Najważniejsze wnioski

• Zrozumienie koncepcji skryptu umieszczającego elementy w pomieszczeniach.

• Umiejętność wyboru odpowiednich pomieszczeń i typów rodzin (np. lamp) do umieszczenia.

• Poznanie sposobu wyznaczania współrzędnych punktów, w których mają zostać umieszczone elementy.

• Wiedza, jak za pomocą Dynamo umieścić elementy w modelu i wstępnie zweryfikować wynik.

Na czym się skupić podczas oglądania

• Zwróć uwagę na logikę całego procesu: od wyboru danych, przez obliczenia, aż po umieszczenie elementów.

• Obserwuj, jak wyznaczane są współrzędne – to kluczowy etap, który decyduje o poprawnym położeniu lamp w pomieszczeniach.

• Skup się na node’ach odpowiedzialnych za wstawianie elementów do modelu – będą one wykorzystywane także w innych automatyzacjach.

• Zauważ, jak ważna jest końcowa weryfikacja – bez niej trudno ocenić, czy skrypt działa zgodnie z założeniami.

W tej lekcji skupiam się na walidacji wyników skryptu, który automatycznie umieszczał elementy (np. lampy) w pomieszczeniach. Omawiam typowe błędy, które mogą pojawić się podczas działania skryptu oraz pokazuję, jak je diagnozować i korygować. Zwracam uwagę na najczęstsze pułapki i problemy – wynikające zarówno z ograniczeń skryptu, jak i z jakości oraz złożoności modelu Revit.
Podkreślam kluczową zasadę: skrypt jest tak dobry, jak osoba, która go stworzyła, co oznacza, że zawsze musimy sprawdzić rezultat działania automatyzacji oraz przewidzieć miejsca, w których może ona zawieść lub wymagać ulepszeń.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika weryfikowania działania skryptów, wykrywania błędów i oceniania, czy automatyczne działania zostały przeprowadzone poprawnie oraz czy nie wymagają dalszych korekt.

Najważniejsze wnioski

• Zrozumienie, dlaczego walidacja jest niezbędnym etapem każdej automatyzacji.

• Umiejętność rozpoznawania typowych błędów przy umieszczaniu elementów w modelu.

• Wiedza, na co zwrócić szczególną uwagę podczas analizy wyników skryptu.

• Świadomość ograniczeń automatycznych procesów i znaczenia jakości danych wejściowych.

• Zrozumienie, że błędy w modelu mogą być bezpośrednio powielane przez skrypt, jeśli nie zostaną wcześniej wychwycone.

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak wyglądają błędy po umieszczeniu elementów — często wynikają one z geometrii lub danych pomieszczeń.

• Obserwuj, jak analizujemy wyniki działania skryptu — ta praktyka jest kluczowa przy wszystkich automatyzacjach.

• Skup się na miejscach, w których model może być niepoprawnie przygotowany — skrypt takich problemów nie naprawi sam.

• Zapamiętaj główną zasadę: po każdym automatycznym działaniu należy sprawdzić jakość wyniku, szczególnie jeśli model jest skomplikowany.

W tej lekcji pokazuję, jak zbudować skrypt, który koloruje elementy w modelu Revit na podstawie wartości wybranych parametrów. Dzięki temu możemy wizualnie oznaczyć elementy, które nie spełniają określonych kryteriów lub wymagają dodatkowej uwagi. Omawiam również, jak wykorzystać te narzędzia do dowolnego kolorowania elementów — np. według kategorii, poziomu, statusu lub preferencji użytkownika.
Uczestnik uczy się, jak pobierać parametry, porównywać je z ustalonymi wartościami i przypisywać elementom odpowiednie kolory za pomocą node’ów odpowiadających za override’y graficzne.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika, jak tworzyć skrypty umożliwiające wizualne oznaczanie elementów w Revit — w szczególności na podstawie wartości parametrów — co ułatwia weryfikację modelu oraz analizę jakości danych projektowych.

Najważniejsze wnioski

• Umiejętność pobierania wartości parametrów i porównywania ich z wybranymi kryteriami.

• Poznanie sposobu nadawania kolorów elementom w Revit poprzez override’y graficzne.

• Zrozumienie, jak wizualne oznaczanie elementów pomaga w analizie modelu i wykrywaniu błędów.

• Świadomość, że ten sam mechanizm można wykorzystać do dowolnego kolorowania elementów, nie tylko do walidacji.

Na czym się skupić podczas oglądania

• Zwróć uwagę, jak pobieramy parametry i tworzymy logiczne warunki określające kolor elementu.

• Obserwuj sposób zastosowania override’ów graficznych — to jedno z najpraktyczniejszych narzędzi w Dynamo.

• Skup się na tym, jak dobieramy kolory dla poszczególnych wartości — to często klucz do czytelnej wizualizacji.

• Zauważ, że ten rodzaj skryptów jest przydatny nie tylko przy kontroli modelu, ale także w codziennych zadaniach projektowych.

W tej lekcji budujemy skrypt, który umożliwia automatyczne określanie, w którym pomieszczeniu znajduje się dany element. Zaczynamy od omówienia koncepcji działania skryptu — jakie kroki musi wykonać, by poprawnie przypisać lokalizację — a następnie przechodzimy przez każdy etap realizacji.
Uczestnik uczy się wybierać elementy z modelu, identyfikować ich położenie względem pomieszczeń oraz zapisywać wynik analizy w odpowiednim parametrze. Na końcu przeprowadzamy walidację działania skryptu, aby upewnić się, że wartości lokalizacji zostały przypisane poprawnie.

Cel lekcji

Celem lekcji jest nauczenie uczestnika, jak zbudować skrypt, który automatycznie przypisuje informacje o lokalizacji elementów w pomieszczeniach oraz jak wykorzystać dane geometryczne i parametry do przeprowadzenia takiej analizy.

Najważniejsze wnioski

• Umiejętność tworzenia skryptu określającego, w jakim pomieszczeniu znajduje się dany element.

• Poznanie sposobów analizowania położenia elementów względem przestrzeni w modelu.

• Zrozumienie, jak pobierać, łączyć i zapisywać parametry elementów w celu aktualizacji modelu.

• Wiedza, jak przeprowadzać walidację wyników i upewnić się, że przypisane informacje są poprawne.

Na czym się skupić podczas oglądania

• Zwróć uwagę na sposób identyfikowania położenia elementów — to kluczowa część działania skryptu.

• Obserwuj, jak łączymy informacje geometryczne i parametry, aby uzyskać pełną informację o lokalizacji.

• Skup się na procesie zapisywania danych do parametrów — to powtarzalny schemat, który pojawi się w wielu innych skryptach.

• Zauważ, jak ważna jest końcowa walidacja — niewłaściwe dane wejściowe mogą prowadzić do błędnych przypisań.

W tej lekcji pokazuję, jak przygotować skrypt Dynamo tak, aby mógł działać w Dynamo Playerze. Najpierw omawiam, czym jest Dynamo Player, jak funkcjonuje, jakie są jego możliwości oraz w jakich sytuacjach sprawdza się najlepiej — szczególnie w pracy zespołowej i przy powtarzalnych zadaniach.
W drugiej części lekcji przechodzimy do adaptowania wcześniej przygotowanego skryptu (do importu i eksportu danych), tak aby użytkownik mógł uruchamiać go z poziomu Dynamo Playera bez konieczności otwierania pełnego środowiska Dynamo. Prowadzę krok po kroku przez to, jakie elementy trzeba odpowiednio oznaczyć, jak przygotować inputy i outputy oraz jak strukturyzować skrypt, żeby działał poprawnie w tym uproszczonym trybie.

Cel lekcji

Celem tej lekcji jest nauczenie uczestnika przygotowywania i dostosowywania skryptów tak, aby mogły być uruchamiane w Dynamo Playerze przez użytkowników nietechnicznych lub tych, którzy chcą korzystać ze skryptów bez otwierania całego środowiska Dynamo.

Najważniejsze wnioski

• Zrozumienie, czym jest Dynamo Player i jakie są jego największe zalety.

• Wiedza, jak przygotować skrypt do działania w Dynamo Playerze.

• Umiejętność oznaczania inputów, outputów i logicznego porządkowania skryptu.

• Poznanie procesu adaptacji istniejącego skryptu (np. import/eksport danych), aby był łatwy w obsłudze i intuicyjny.

• Świadomość, jak Dynamo Player przyspiesza pracę w organizacjach i umożliwia udostępnianie narzędzi osobom, które nie korzystają bezpośrednio z Dynamo.

Na czym się skupić podczas oglądania

• Zwróć uwagę na różnice między dynamicznym środowiskiem Dynamo a uproszczonym interfejsem Dynamo Playera.

• Obserwuj, jak oznaczane są inputy — to one decydują, co użytkownik końcowy będzie mógł modyfikować.

• Skup się na logicznym uporządkowaniu skryptu — w Dynamo Playerze nie widać pełnej struktury, więc czytelność jest kluczowa.

• Zauważ, jak adaptacja znanego skryptu (import/eksport) zmienia jego sposób użycia i otwiera możliwości pracy bez otwierania całego Dynamo.

W tej lekcji pokazuję, jak stworzyć skrypt Dynamo, który automatycznie generuje arkusze wydruku na podstawie danych z modelu Revit. Uczestnik uczy się, jak pobierać informacje potrzebne do określenia zestawu arkuszy, jak dobierać odpowiedni szablon (template) arkusza oraz jak przypisywać do niego właściwe parametry, takie jak nazwa, numer, lokalizacja czy typ arkusza.
Skrypt tworzony w lekcji umożliwia automatyczne tworzenie całych pakietów arkuszy zgodnych z wymaganiami projektu, co znacząco przyspiesza proces przygotowania dokumentacji.

Cel lekcji

Celem lekcji jest nauczenie uczestnika tworzenia skryptu, który generuje arkusze w Revit automatycznie, z wykorzystaniem wybranego szablonu oraz zasad nazewnictwa i organizacji wynikających z wymagań projektowych.

Najważniejsze wnioski

• Umiejętność pobierania danych z modelu potrzebnych do określenia zestawu arkuszy.

• Poznanie procesu automatycznego tworzenia arkuszy w Revit przy użyciu Dynamo.

• Zrozumienie, jak wykorzystać gotowy szablon (template) do generowania spójnych arkuszy wydruku.

• Wiedza, jak poprawnie przypisywać parametry arkuszy, takie jak nazwa, numer i lokalizacja.

• Świadomość, jak skrypty tego typu przyspieszają przygotowanie dokumentacji i eliminują błędy manualne.

Na czym się skupić podczas oglądania

• Zwróć uwagę na node’y odpowiedzialne za tworzenie arkuszy — będą niezbędne w wielu automatyzacjach dokumentacyjnych.

• Obserwuj, jak pobierane są dane wejściowe, takie jak nazwy, poziomy czy typy arkuszy.

• Skup się na sposobie przypisywania szablonu arkusza — to klucz do uzyskania poprawnego i spójnego wyglądu.

• Zauważ, jak ważna jest struktura danych — każda lista musi być zgodna, aby arkusze generowały się prawidłowo.

W tej lekcji pokazuję, jak stworzyć skrypt Dynamo, który automatycznie generuje arkusze wydruku na podstawie danych z modelu Revit. Uczestnik uczy się, jak pobierać informacje potrzebne do określenia zestawu arkuszy, jak dobierać odpowiedni szablon (template) arkusza oraz jak przypisywać do niego właściwe parametry, takie jak nazwa, numer, lokalizacja czy typ arkusza.
Skrypt tworzony w lekcji umożliwia automatyczne tworzenie całych pakietów arkuszy zgodnych z wymaganiami projektu, co znacząco przyspiesza proces przygotowania dokumentacji.

Cel lekcji

Celem lekcji jest nauczenie uczestnika tworzenia skryptu, który generuje arkusze w Revit automatycznie, z wykorzystaniem wybranego szablonu oraz zasad nazewnictwa i organizacji wynikających z wymagań projektowych.

Najważniejsze wnioski

• Umiejętność pobierania danych z modelu potrzebnych do określenia zestawu arkuszy.

• Poznanie procesu automatycznego tworzenia arkuszy w Revit przy użyciu Dynamo.

• Zrozumienie, jak wykorzystać gotowy szablon (template) do generowania spójnych arkuszy wydruku.

• Wiedza, jak poprawnie przypisywać parametry arkuszy, takie jak nazwa, numer i lokalizacja.

• Świadomość, jak skrypty tego typu przyspieszają przygotowanie dokumentacji i eliminują błędy manualne.

Na czym się skupić podczas oglądania

• Zwróć uwagę na node’y odpowiedzialne za tworzenie arkuszy — będą niezbędne w wielu automatyzacjach dokumentacyjnych.

• Obserwuj, jak pobierane są dane wejściowe, takie jak nazwy, poziomy czy typy arkuszy.

• Skup się na sposobie przypisywania szablonu arkusza — to klucz do uzyskania poprawnego i spójnego wyglądu.

• Zauważ, jak ważna jest struktura danych — każda lista musi być zgodna, aby arkusze generowały się prawidłowo.

W tej lekcji przedstawiam podstawowe funkcje, zasady logiki oraz najważniejsze elementy składni języka Python, które są wykorzystywane w node’ach Pythonowych w Dynamo. Lekcja nie ma na celu nauczenia uczestnika programowania w Pythonie od podstaw — zamiast tego skupia się na tym, jak rozumieć strukturę skryptów Pythonowych generowanych lub modyfikowanych w Dynamo.
Omawiam typowe konstrukcje, które pojawiają się w skryptach wykorzystywanych w node’ach, tak aby uczestnik mógł swobodnie interpretować kod wygenerowany przez duże modele językowe, takie jak GPT czy Claude, oraz wykonywać jego drobne korekty.

Cel lekcji

Celem lekcji jest wprowadzenie uczestnika w podstawy logiki i składni Pythona w takim stopniu, aby potrafił rozumieć i wykorzystywać skrypty generowane przez AI oraz przygotować się do tworzenia własnego, customowego node’a Pythonowego w kolejnej lekcji.

Najważniejsze wnioski

• Zrozumienie, jak wyglądają podstawowe struktury języka Python używane w node’ach Dynamo.

• Poznanie najważniejszych funkcji, metod i konstrukcji logicznych, które pojawiają się w skryptach Pythonowych.

• Umiejętność interpretowania kodu wygenerowanego przez modele językowe (GPT, Claude itp.).

• Przygotowanie do stworzenia własnego, spersonalizowanego node’a Pythonowego w następnej lekcji.

• Świadomość, że znajomość pełnego Pythona nie jest wymagana, aby skutecznie korzystać z node’ów Python Script.

Na czym się skupić podczas oglądania

• Zwróć uwagę na podstawowe konstrukcje kodu, takie jak instrukcje warunkowe, pętle i operacje na danych — będą stale pojawiać się w skryptach.

• Skup się na tym, jak Python Script w Dynamo przetwarza wejścia (IN[]) i zwraca wyniki (OUT) — to kluczowa część tworzenia customowych node’ów.

• Zapamiętaj, że ta lekcja stanowi fundament do kolejnego etapu, czyli tworzenia własnego node’a przy wsparciu modeli językowych.

Opis lekcji

W tej lekcji przechodzimy krok po kroku przez proces tworzenia własnego customowego noda w oparciu o kod Pythonowy. Jako przykład wykorzystujemy praktyczne zadanie: wyznaczenie punktów wstawienia lamp w pomieszczeniach w zależności od ich wymiarów.
Pokazuję, jak formułować zadanie dla dużego modelu językowego (np. GPT), jak otrzymany kod zaadaptować do noda Python Script w Dynamo oraz jak iteracyjnie poprawiać skrypt, aż zacznie działać zgodnie z naszymi wymaganiami.

Cel lekcji

Celem lekcji jest pokazanie uczestnikowi, jak wykorzystywać modele językowe do tworzenia własnych rozwiązań w Dynamo przy użyciu Pythona, bez konieczności bycia zaawansowanym programistą.

Najważniejsze wnioski

• Zrozumienie całego procesu tworzenia customowego noda Pythonowego dopasowanego do konkretnego zadania.

• Nauka poprawnego promptowania (formułowania poleceń) dla modeli językowych na potrzeby generowania kodu.

• Umiejętność analizowania wygenerowanego kodu, wychwytywania błędów i testowania działania skryptu.

• Lepsze zrozumienie logiki działania skryptów Pythonowych używanych w Dynamo.

• Świadomość, że AI może pełnić rolę „asystenta programisty”, a nie zastępować zrozumienie procesu.

Na czym się skupić podczas oglądania

• Zwróć uwagę na sposób zadawania pytań (promptów) – to od nich w dużej mierze zależy jakość generowanego kodu.

• Obserwuj, jak krok po kroku naprowadzam model na coraz lepsze, bardziej dopasowane rozwiązanie.

• Skup się na tym, jak analizujemy wygenerowany kod: co sprawdzamy, jakie fragmenty wymagają szczególnej uwagi.

• Zauważ, jak łączymy wiedzę o Dynamo, geometrii pomieszczeń i Pythonie w jednym, praktycznym rozwiązaniu.

Opis lekcji

W tej lekcji przechodzimy krok po kroku przez proces tworzenia własnego customowego noda w oparciu o kod Pythonowy. Jako przykład wykorzystujemy praktyczne zadanie: wyznaczenie punktów wstawienia lamp w pomieszczeniach w zależności od ich wymiarów.
Pokazuję, jak formułować zadanie dla dużego modelu językowego (np. GPT), jak otrzymany kod zaadaptować do noda Python Script w Dynamo oraz jak iteracyjnie poprawiać skrypt, aż zacznie działać zgodnie z naszymi wymaganiami.

Cel lekcji

Celem lekcji jest pokazanie uczestnikowi, jak wykorzystywać modele językowe do tworzenia własnych rozwiązań w Dynamo przy użyciu Pythona, bez konieczności bycia zaawansowanym programistą.

Najważniejsze wnioski

• Zrozumienie całego procesu tworzenia customowego noda Pythonowego dopasowanego do konkretnego zadania.

• Nauka poprawnego promptowania (formułowania poleceń) dla modeli językowych na potrzeby generowania kodu.

• Umiejętność analizowania wygenerowanego kodu, wychwytywania błędów i testowania działania skryptu.

• Lepsze zrozumienie logiki działania skryptów Pythonowych używanych w Dynamo.

• Świadomość, że AI może pełnić rolę „asystenta programisty”, a nie zastępować zrozumienie procesu.

Na czym się skupić podczas oglądania

• Zwróć uwagę na sposób zadawania pytań (promptów) – to od nich w dużej mierze zależy jakość generowanego kodu.

• Obserwuj, jak krok po kroku naprowadzam model na coraz lepsze, bardziej dopasowane rozwiązanie.

• Skup się na tym, jak analizujemy wygenerowany kod: co sprawdzamy, jakie fragmenty wymagają szczególnej uwagi.

• Zauważ, jak łączymy wiedzę o Dynamo, geometrii pomieszczeń i Pythonie w jednym, praktycznym rozwiązaniu.

Opis lekcji

W tej lekcji przechodzimy krok po kroku przez proces tworzenia własnego customowego noda w oparciu o kod Pythonowy. Jako przykład wykorzystujemy praktyczne zadanie: wyznaczenie punktów wstawienia lamp w pomieszczeniach w zależności od ich wymiarów.
Pokazuję, jak formułować zadanie dla dużego modelu językowego (np. GPT), jak otrzymany kod zaadaptować do noda Python Script w Dynamo oraz jak iteracyjnie poprawiać skrypt, aż zacznie działać zgodnie z naszymi wymaganiami.

Cel lekcji

Celem lekcji jest pokazanie uczestnikowi, jak wykorzystywać modele językowe do tworzenia własnych rozwiązań w Dynamo przy użyciu Pythona, bez konieczności bycia zaawansowanym programistą.

Najważniejsze wnioski

• Zrozumienie całego procesu tworzenia customowego noda Pythonowego dopasowanego do konkretnego zadania.

• Nauka poprawnego promptowania (formułowania poleceń) dla modeli językowych na potrzeby generowania kodu.

• Umiejętność analizowania wygenerowanego kodu, wychwytywania błędów i testowania działania skryptu.

• Lepsze zrozumienie logiki działania skryptów Pythonowych używanych w Dynamo.

• Świadomość, że AI może pełnić rolę „asystenta programisty”, a nie zastępować zrozumienie procesu.

Na czym się skupić podczas oglądania

• Zwróć uwagę na sposób zadawania pytań (promptów) – to od nich w dużej mierze zależy jakość generowanego kodu.

• Obserwuj, jak krok po kroku naprowadzam model na coraz lepsze, bardziej dopasowane rozwiązanie.

• Skup się na tym, jak analizujemy wygenerowany kod: co sprawdzamy, jakie fragmenty wymagają szczególnej uwagi.

• Zauważ, jak łączymy wiedzę o Dynamo, geometrii pomieszczeń i Pythonie w jednym, praktycznym rozwiązaniu.