Veress_Portfolio

SZABOLCS VERESS ARCHITECTURE PORTFOLIO

MEDICAL SCHOOL

Shenzhen, China

Gerber Architekten 2020-2022

- developed multiple concepts and facades under considerable time pressure

- set-up Archicad file structure in order to optimize workflow for fellow team members

- managed Archicad Teamwork files during competition phase and Schematic Design phase

- coordinated file exchange between partners and other stakeholders

- set up Grasshopper scripts for updating facades, in case partners have introduced volumetric changes

- created renderings and diagrams for presentations

HOSPITAL

Sunlight Study and Sunshading Optimization Shenzhen, China Gerber Architekten 2020-2022

- done weather studies with Grasshopper and Ladybug - analyzed the effect of solar protection on Summer and Winter Solstice - created a parametric 3D model in Grasshopper to test different overhang sizes - based on sunlight study, developed a strategy to optimize material resources and maximize solar protection

COMMERCIAL REFURBISHMENT

Jinan, China

Gerber Architekten 2019-2021

- worked on BIM-Model in Archicad Teamwork together with other colleagues

- developed curtain wall system and pattern in Archicad and Rhino+Grasshopper

- used Archicad-Grasshopper live-sync - created renderings for presentations - drafted technical details in different scales

Main Facade Persepctive

OFFICE BUILDINGS

Jinan, China

Gerber Architekten 2019

- developed multiple design concepts under time pressure

- 3D modeled numerous iterations of building designs in Archicad and Rhino+Grasshopper

- created scripts for generating and updating 3D landscape elements in Grasshopper. The scripts written have been reused in other projects for similar purposes.

- worked together with other team members in Archicad Teamwork environment. Coordinated the process of 3D creation with 2D plan graphics in order to keep everything in sync and updatable.

规划总平面图（1:750）

THE HOUSE OF MUSIC

Bochum, Germany dreibund architekten 2022-2024

- worked on conceptual design and schematic design phases

- set-up and managed BIM model in order to organize Existing, To-be-demolished and New construction elements

- developed multiple design options - in 3D, with sketches and with Generative AI

- prepared drawings, cost estimates and other schedules for submissions

- wrote numerous Python scripts for automatic errorchecking

- created intelligent GDL Objects, to speed up design work, but also to automatically check norm conformity

Masterplan

Ground

NATURAL HISTORY MUSEUM

Shenzhen, China

Gerber Architekten

2020

- developed different designs for internal discussions - managed Archicad teamwork file during competition phase - created Grasshopper script for randomized facade elements, giving shape to architectural concept - produced diagramms for final presentation

Aerial view

CULTURAL CENTER

Tineretului Park Bucharest, Romania

5th year project

-designed cultural center with theater (capacity 700), multifunctional rooms (cap. 120), classrooms, coffe shop and library

-created project for evacuating users safely in case of emergency, according to the Romanian Fire Safety Regulations -made algorithm in Grasshopper in order to generate exterior shell and structure more easily and flexibly -made detailed 3D model in Archicad -printed out architectural model for final presentation

The aim of the project was to revitalize the area around Tineretului park, by creating an architectural landmark. This would attract future investments for the development of the neighbourhood, while also managing to change the cultural scene of the Capital by moving out the major institutions from the city center.

The sloping, irregular terrain helped define the final shape of the building, which instead of being overly respectful with the plot chooses to ondulate together with the land below it.

The Cultural Center includes a theater with a capacity of 700, two multifunctional rooms for 120 people, three rooms for different leisure activities, a coffee shop and a library.

1st Floor Plan

Groundfloor plan

3D Printed model

2D/3D

AIP VISUALIZER

AIP Planung, Düsseldorf

In-house AI Rendering Software 2024-on going

- developed an easy-to-use rendering software using Generative AI Engine Stable Diffusion, optimized for quick architectural visualizations

- scripted UI and Backend using Python

- created multiple presets for Photorealistic, Interior,Aerial shots, but also Sketch and Physical model, transforming any input image to a desired output style

- held in-house courses for teaching coworkers how to use program

- AIP Visualizer was implemented and used at firm level

Sketch to Photorealistic

Screenshot to Photorealistic

Photo to Sketch

Photo to Physical model

AUTOMATION BOOKLET

Gerber Architekten, Dortmund 2020-2022

- created booklet in German and English about the potential of task-automation at firm level.

- explained to fellow colleagues and project leaders why this process would be benefitial, tackling a number of different types of problems

- presented already existing scripts written during previous project-work, but also ideas that could be implemented, if resources would be invested.

During our workhours we need to tackle many different tasks. Some of them are very difficult and require a large amount of brain power, others are simply repetitive and time consuming. Most of us find a pleasure in overcoming the difficult ones and get extremely bored or frustrated when we do the repetitive ones. Nevertheless, everything has to be done for the project to be finalized.

Most of the time, we just accept that time consuming and boring tasks are just part of life and do not even think about the possibility of doing something differently. In other cases, even if we do try to do something against it, we do not know where to look for it.

I think there is a big potential in programmable automatization for easing our lives as architects. The larger the company, the more the projects and the more the times a repetitive task occurs. Valuable brainpower and workhours are lost. In the last couple of years computer programming became more and more approachable for professionals outside of the field of “Computer Science”, so that it became easier to make use of “custom-made tools” on our computers.

This booklet tries to show the potential of automating a number of these repetetive tasks, saving energy and time at a company level.

The

4. Erstellung von 3D Logos basierend auf schwarz-weißen Bilder in Archicad

- Das Problem: es könnte Situationen geben, wenn wir editierbare 3D logos für renderings brauchen. Um sie zu erhalten müssen wir möglicherweise manuell über Bilder zeichnen. Das ist zeitintensiv und es kann auch Kopien von schlechter Qualität entstehen.

- Was macht der Algorithmus: er bestimmt die Konturen der schwarz-weißen Logos, er erstellt saubere Umrissen und er extrudiert sie um die 3D varianten der Logos zu erhalten.

- Zeit gespart: das ist wieder eine Aufgabe, wenn wir Zeit sparren während des manuell Überzeichnen wollen, könnte das Endprodukt suboptimal sein. Vektorisierung ist auch in Adobe Illustrator möglich, aber das ist auch nicht perfekt. Der Algorithmus, der auf ein “open-source” Code basiert ist, erstellt die 3D Logos in ein paar Sekunden.

Potenzial der Aufgabenautomatisierung bei Gerber Architekten 5. Auswechslung den 2D Elementen mit Archicad Objekten

Richtung der Neunummerierung

Beispiele. Automatisierung

1. Automatische Neunummerierung der “Zones” in Archicad

- Das Problem: um saubere Tabelle zu haben, ist es erforderlich alle Grundrisse durchzugehen und nachprüfen, ob die Räumen haben verschiedene ID-Nummer und/oder ob die Reihenfolge der Nummer logisch ist oder nicht. Das kann ein paar Stunden dauern. Außerdem muss es jedes Mal aktualisiert werden, wenn ein Raum von dem Entwurf hinzugefügt oder entfernt wird.

- Was macht der Algorithmus: er sucht nach doppelte ID-Nummern und er überschreibt diese mit eindeutigen Nummern. Die Regeln und Reihenfolge der Neunummerierung sind flexible. Das Programm kann simultan an allem Grundrisse ausgeführt werden.

- Zeit gespart: für Wettbewerb No. 1463_Landtagserweiterung in Düsseldorf hat das Prüfen und das Aktualisieren den ID-Nummern (zirca 650 insgesamt) im Durchschnitt ungefähr 2-3 Stunden gedauert. Mit dem Algorithmus wurde es nur in 15-20 Minuten fertiggestellt.

Das Potenzial der bei

Das Potenzial der Aufgabenautomatisierung bei Gerber Architekten

22.09.2020

2. Erstellung von 3D Umgebungen basierend auf eine Farbkode (oder anderen Kriterien) in Archicad

- Das Problem: ein städtebaulicher Grundriss enthält normalerweise die Analyse den umliegenden Gebäude. Es kann ein arbeitsam und/oder zeitintensiv Aufgabe sein, ein 3D Model basierend auf diese Grundrisse, nehmend die Farben eine nach der andere, aufzubauen.

- Was macht der Algorithmus: er organisiert den Farben gemäß den Präferenzen des Benutzers und er extrudiert die Kontur basierend auf die Farbkode

Das Potenzial der Aufgabenautomatisierung bei Gerber Architekten

- Zeit gespart: In Archicad ist es kompliziert eine große Menge Schraffuren (2D Elementen) in Morphs (3D Elementen) umzuwandeln. Außerdem ist mehrfache Morphs gleichzeitig zu extrudieren problematisch. Während meiner Studienzeit habe ich dichte Stadtlandschaften basierend auf Gebäudehöheanalyse modeliert. Es hat sehr viele Stunden gedauert. Mit dem Algorithmus soll es nur in ein paar Minuten fertig werden.

1. Erstellung von unterschidlichen Grundriss Konfigurationen (IDEE) - Das Problem: wir brauchen unterschiedliche Grundrisse auf unterschiedliche Ebenen. Einige sollen mehr Benutzer in grössere Büros haben, die Anderen sollen weniger Benutzer in kleinere Büros haben. Wir könnten auch eine bestimmte Konfiguration (30% Büro A, 30% Büro C, 20% Büro B, 10% Büro D) wollen. Wenn das Tragwerksraster gemäß einiger Standardgröße ausgelegt ist, (wie in Wettbewerb no. 1463 Landtagserweiterung in Düsseldorf), dann ist es eine solche Aufgabe, wo wir nur unterschiedliche Rechtecke bewegen müssen, bis alles gut zusammenpasst. Es ist ein

for i, currentZone in enumerate(zones):

currentLayerName = zoneLayers[i]

currentHomeStoryNumber = int(zoneHomeStoryNumbers[i])

currentZoneNumber = zoneNumbers[i]

currentZoneName = zoneNames[i]

currentZoneArea = zoneAreas[i]

currentZoneWohnungsart = zoneWohnungsart[i]

currentBuildingNumber = zoneBuidingNumber[i]

#check HomeStory if(currentHomeStoryNumber >= 0):

#Check if first character in ZoneNumber is among PossibleStartingNumbers if len(currentZoneNumber)>0 : for possibleStartingNumber in possibleApartmentStartingNumbers: firstCharacter = currentZoneNumber[0] if str(possibleStartingNumber) in firstCharacter:

#Check if layer name for current zone is among PossibleLayerNames for possibleLayerName in zone_PossibleLayerNames: if(currentLayerName == possibleLayerName): apartmentZones.append(currentZone)

apartmentZoneNumbers.append(currentZoneNumber) apartmentZoneNames.append(currentZoneName) apartmentZoneAreas.append(currentZoneArea) apartmentZoneWohnungsart.append(currentZoneWohnungsart) apartmentBuildingNumber.append(currentBuildingNumber)

testLength = len(objectLayerNames)

if(testLength != len(objectHomeStoryNumbers)): print(‘Error with length of objectHomeStoryNumbers’)

if(testLength != len(objectRelatedToZoneNumbers)): print(‘Error with length of objectRelatedToZoneNumbers’)

if(testLength != len(objectRelatedToZoneNames)): print(‘Error with length of objectRelatedToZoneNames’)

if(testLength != len(objectNames)): print(‘Error with length of objectNames’)

‘’’ for i, prop in enumerate(objectHomeStoryNumberPropertyValues):

if(‘normal’ in objectHomeStoryNumberPropertyValues[i].propertyValues[0].propertyValue.status):

print(str(objectNames[i]) + ‘ - ‘ + str(objectHomeStoryNumberPropertyValues[i].propertyValues[0].propertyValue.value))

print(str(objectNames[i]) + ‘ - ‘ + str(objectHomeStoryNumbers[i]))

print(str(objectNames[i]) + ‘ - ‘ + str(objectHomeStoryNumberPropertyValues[i].propertyValues[0].propertyValue.status)) else:

‘’’

print(‘Error’)

print(str(objectNames[i]) + ‘ - ‘ + str(objectHomeStoryNumberPropertyValues[i].propertyValues[0].propertyValue.status))

#filter our objects that are bathtubs, are part of furniture layer and are above Ground Floor bathtubs = []

bathtub_RelatedToZoneNumbers = []

bathtub_RelatedToZoneNames = []

for i, currentObject in enumerate(objects):

#objectLayerPropertyValue = GetBuiltInPropertyIds (‘ModelView_LayerName’, objects[i]) currentLayerName = objectLayerNames[i] currentObjectName =objectNames[i]

#if(‘normal’ in objectHomeStoryNumberPropertyValues[i].propertyValues[0].propertyValue.status): #for some reason some objects cannot access Home Story Number in AC, we need to skip these if(‘Error’ not in str(objectHomeStoryNumbers[i])): currentHomeStoryNumber = int(objectHomeStoryNumbers[i]) for possibleLayerName in bathtub_PossibleLayerNames: if(currentLayerName == possibleLayerName): if(currentHomeStoryNumber >= 0): if(“Badewanne” in currentObjectName): bathtubs.append(currentObject) bathtub_RelatedToZoneNumbers.append(objectRelatedToZoneNumbers[i]) bathtub_RelatedToZoneNames.append(objectRelatedToZoneNames[i])

Check room numbers and room names

Update object properties directly in Archicad

Check funding eligiblity

Check Excel tables and overwrite with correct values

SCRIPTS FOR PROJECT CONTENT CHECKING

Computer program - Python + Archicad dreibund architekten 2023

- Created a script in Python to check and correct various aspects of the project directly in Archicad. The data/errors are either difficult to detect or time-consuming and repetitive to check manually. Therefore, it is also difficult to ensure whether the user has performed a 100% accurate and correct job.

- Automated tasks include: Checking the eligibility of the apartments; Checking the number of rooms in apartments and their categorization in Archicad; Correction of incorrect spellings of room names; Checking whether room names are correct based on the furniture; Checking whether Excel files have current data and, if necessary, overwriting it.

ARHITOOLBOX

Computer Program

-created a complex Windows Form Application in Microsoft Visual Studio using C# coding language which would calculate dimensions of reinforced concrete elements, based on formulas studied at University -made interactive Graphic User Interface for ease-of-use

-wrote 6 different subprograms which could dimension slabs, beams, columns, structural walls -enjoyed considerable success among university colleagues and professors as well as real-life professionals

During university years the subjects related to structural engineering mainly consisted of methods of understanding and approximating the behaviour of structures used in contemporary constructions. We used to solve different types of problems regarding the dimensions of structural elements, in order to used them in our architectural design. Many of the formulas are actually used by professionals in the field, so they are particularly useful in practice.

Having studied computer science in high school, I created a Windows Form Application in Microsoft Visual Studio, which manages to solve a considerable amount of these problems in as many different configurations as possible. I also updated the calculation methods with additional useful pieces of information from the Romanian structural normatives. Presenting it to my professors and colleagues, the software was very wellreceived and was found useful by many, including practising architects.

import * as THREE from “three” import * as OBC from “openbim-components” import {OrbitControls} from “three/examples/jsm/controls/OrbitControls” import {GUI} from “three/examples/jsm/libs/lil-gui.module.min” import {OBJLoader} from “three/examples/jsm/loaders/OBJLoader” import {MTLLoader} from “three/examples/jsm/loaders/MTLLoader” import {GLTFLoader} from “three/examples/jsm/loaders/GLTFLoader” import {IProject, Project, ProjectStatus, UserRole, IToDo, ToDo, ToDoStatus, UserName} from “./class/Project” import { ProjectsManager } from “./class/ProjectsManager”; import { createErrorMessage, checkDate, toggleModal, addOrEditTask } from “./class/Functions”; import { FragmentsGroup, IfcProperties } from “bim-fragment” import { TodoCreator } from “./bim-components/TodoCreator” import { SimpleQTO } from “./bim-components/SimpleQTO” //this method calls a button from our main html file const newProjectButton = document.getElementById(“new-project-button”)

var modalShown = false; var errorShown = false;

/*/

const showModal = (id:string) =>{

const modal = document.getElementById(id); if(modal && modal instanceof HTMLDialogElement){ modal.showModal(); } else{

console.warn(“the provided modal was not found, man. ID: “,id)

/*/

const projectsListUI = document.getElementById(“projects-list”) as HTMLElement const projectsManager= new ProjectsManager(projectsListUI) if(projectsListUI.innerHTML === “”){

const projectData: IProject = { name: “Project Name”, description: “Description”, status: “Active”, userRole: “Architect”, finishDate: new Date(“2023-12-08”), }

const project = projectsManager.newProject(projectData); } if(newProjectButton){ newProjectButton.addEventListener(“click”, () => toggleModal(“new-project-modal”)); } else{ console.warn(“project button was not found, man!”); }

export function fillOutModal(id: string, projectData: Project){ const projectForm = document.getElementById(id+”-form”); if(projectForm && projectForm instanceof HTMLFormElement){

//const formData = new FormData(projectForm);

//const projectData = projectsManager.getProject(projectId) as Project if(projectData){

const name = projectForm.querySelector(“name = name”) as HTMLElement name.textContent = projectData.name

const description = projectForm.querySelector(“name = description”) as HTMLElement description.textContent = projectData.description

const role = projectForm.querySelector(“name = userRole”) as HTMLSelectElement role.value = projectData.userRole

const status = projectForm.querySelector(“name = status”) as HTMLSelectElement status.value = projectData.status

const date = projectForm.querySelector(“name = finishDate”) as HTMLInputElement date.valueAsDate = projectData.finishDate

//projectForm.setAttribute(“name”) =

- Visualize your email conversations with the help of LLMs - “Best Hack for Humans“ at AEC Hackathon Munich 2024

BIM AND SCRIPTING - AEC HACKATHONS

Software Development 2023 - on going

- created multiple programs as part of AEC Hackathons and passion projects - several of our projects have received prizes on AEC Hackathons - in Copenhagen 2024 “Best Mashup” prize, Munich 2024 “Best Hack for Humans“ - technologies used include: Python, C#, LLM, Gen-AI, Javascript, Typescript, Node.js, React.js, Open BIM Components etc.

Online IFC Clipper for infrastructure projects - Project from AEC Hackathon Zurich 2024

GraphMail

from flask import Flask, render_template, jsonify import pandas as pd import sqlite3 import json from openai import OpenAI import openai from pdfminer.high_level import extract_text from flask_cors import CORS

def load_config(file_name):

# Load the config file with open(file_name) as f: return json.load(f)

config = load_config(‘config.json’) app = Flask(__name__) CORS(app) app.config[‘TEMPLATES_AUTO_RELOAD’] = True

def read_pdf(file_path): try: text = extract_text(file_path) return text except FileNotFoundError: print(f”Error: The file ‘{file_path}’ was not found.”) return None except Exception as e: print(f”An error occurred while reading the PDF: {e}”) return None

@app.route(‘/’)

def home(): jobs = read_jobs_from_db() conn = sqlite3.connect(config[“db_path”]) js_code = update_stars_ui(conn, config[‘jobs_tablename’]) date_options = get_date_options(conn, config[‘jobs_tablename’]) conn.close() return render_template(‘jobs.html’, jobs=jobs, js_code=js_code, date_options=date_options) def get_date_options(conn, table_name): cursor = conn.cursor() cursor.execute(f”SELECT DISTINCT date FROM {table_name} ORDER BY date DESC”) dates = cursor.fetchall() return [date[0] for date in dates]

@app.route(‘/job/<int:job_id>’) def job(job_id): jobs = read_jobs_from_db() return render_template(‘./templates/job_description.html’, job=jobs[job_id])

@app.route(‘/get_all_jobs’) def get_all_jobs(): conn = sqlite3.connect(config[“db_path”]) query = “SELECT * FROM jobs” df = pd.read_sql_query(query, conn) df = df.sort_values(by=’id’, ascending=False) df.reset_index(drop=True, inplace=True) jobs = df.to_dict(‘records’) return jsonify(jobs)

@app.route(‘/job_details/<int:job_id>’) def job_details(job_id): conn = sqlite3.connect(config[“db_path”]) cursor = conn.cursor() cursor.execute(“SELECT * FROM jobs WHERE id = ?”, (job_id,)) job_tuple = cursor.fetchone() conn.close() if job_tuple is not None:

# Get the column names from the cursor description column_names = [column[0] for column in cursor.description]

# Create a dictionary mapping column names to row values job = dict(zip(column_names, job_tuple)) return jsonify(job) else: return jsonify({“error”: “Job not found”}), 404

@app.route(‘/mark_interview/<int:job_id>’, methods=[‘POST’]) def mark_interview(job_id):

LINKEDIN AEC JOB SCRAPER

Computer Program

- created a LinkedIn Scraper, to better differentiate “Architect” positions from the AEC industry from “Architect” positions from the Software Development Industry LinkedIn website not particularly helpful

- Backend: program scrapes LinkedIn for job postings based on location and keywords, Chatgpt filters out ambigous postings, then creates database

- Frontend: ability to search, rate, categorize job postings. With the help of OpenAI API - create Cover Letter based on Resume and Job Description

- technologies used: Python, Flask, Requests, Pandas, SQLite3, OpenAI API