How to get perimeter of panels ?

[loicseg]

I'd like to get or find if there's a function to get the perimeter for panels ?

Thanks !

[Brunner246]

Hi @loicseg

you could do something like this

def calculate_perimeter(element_id: int) -> float:
    vertices_reference_face = geometry_controller.get_element_reference_face_vertices(element_id)
    perimeter = 0.0
    num_vertices = len(vertices_reference_face)
    for i in range(num_vertices):
        start_vertex = vertices_reference_face[i]
        end_vertex = vertices_reference_face[(i + 1) % num_vertices]
        edge_length = start_vertex.distance(end_vertex)
        perimeter += edge_length

    return perimeter

[loicseg]

thanks but I tried it from now and it doesn't seems to work, i'll try to modify to get it work

[Brunner246]

Could you give us an example of what doesn't work?

[loicseg]

success

import cadwork
import element_controller as ec
import attribute_controller as ac
import utility_controller as uc
import geometry_controller as gc

import tkinter as tk
from tkinter import ttk

def calculer_perimetres_panneaux():
"""
Calcule le périmètre total des panneaux sélectionnés,
en tenant compte de la quantité, et regroupe par épaisseur.
Affiche le tout dans une fenêtre Tkinter.
"""

elements = ec.get_active_identifiable_element_ids()

if len(elements) == 0:
    uc.print_message("Erreur : aucun élément sélectionné.", 0, 0)
    return

# Dictionnaire : clé = épaisseur, valeur = périmètre total
perimetres_par_epaisseur = {}

for element_id in elements:

    # Filtrage : uniquement les panneaux
    try:
        if not ac.is_panel(element_id):
            continue
    except:
        continue

    # Quantité
    try:
        quantite = ac.get_list_quantity(element_id)
    except:
        quantite = 1

    # Épaisseur (height)
    try:
        epaisseur = round(gc.get_height(element_id))  # en mm
    except:
        epaisseur = 0

    # Vertices (face de référence)
    try:
        vertices = gc.get_element_reference_face_vertices(element_id)
    except:
        continue

    if len(vertices) < 3:
        continue

    # Calcul du périmètre
    perimetre = 0.0
    n = len(vertices)
    for i in range(n):
        p1 = vertices[i]
        p2 = vertices[(i + 1) % n]
        dx = p2.x - p1.x
        dy = p2.y - p1.y
        dz = p2.z - p1.z
        perimetre += (dx*dx + dy*dy + dz*dz) ** 0.5

    # Multiplication par la quantité
    perimetre_total = perimetre * quantite

    # Ajout dans le dictionnaire (regroupement par épaisseur)
    if epaisseur in perimetres_par_epaisseur:
        perimetres_par_epaisseur[epaisseur] += perimetre_total
    else:
        perimetres_par_epaisseur[epaisseur] = perimetre_total

# --- Trier par épaisseur ---
resultats = sorted(perimetres_par_epaisseur.items(), key=lambda x: x[0])

# Affichage Tkinter
afficher_tableau(resultats)

def afficher_tableau(resultats):
"""Affiche les résultats dans une fenêtre Tkinter sous forme de tableau."""

fen = tk.Tk()
fen.title("Périmètres totaux des panneaux (par épaisseur)")

colonnes = ("Épaisseur (mm)", "Périmètre total (mm)")
tree = ttk.Treeview(fen, columns=colonnes, show="headings", height=15)

for col in colonnes:
    tree.heading(col, text=col)
    tree.column(col, anchor="center", width=180)

for epaisseur, perimetre_total in resultats:
    tree.insert("", "end", values=(f"{epaisseur:.1f}", f"{perimetre_total:.1f}"))

tree.pack(padx=10, pady=10)

bouton = tk.Button(fen, text="Fermer", command=fen.destroy)
bouton.pack(pady=10)

fen.mainloop()

if name == "main":
calculer_perimetres_panneaux()

but problem when there's holes, perimeter goes wrong

[usai-sylvain]

It seems like get_element_reference_face_vertices isn't differentiating between outer vertices (the outline of the panel) and inner vertices (holes).
You could try to create a convex hull of all the vertices first and then applying the perimeter calculation. You would need to use an external library for that...

[Brunner246]

there are also functions on the class facet_list that could help

class facet_list:
# .......
      def get_vertices_for_reference_face(self) -> vertex_list:
          """get vertices for reference face
  
          Returns:
              vertex_list
          """
  
      def get_external_polygon_for_reference_face(self) -> vertex_list:
          """get external polygon for reference face
  
          Returns:
              vertex_list
          """
  
      def get_internal_polygons_for_reference_face(self) -> polygon_list:
          """get internal polygons for reference face
  
          Returns:
              polygon_list
          """

import element_controller
import geometry_controller

[element] = element_controller.get_active_identifiable_element_ids()
facets = geometry_controller.get_element_facets(element)
polygon_vertices = facets.get_external_polygon_for_reference_face()
for vertice in polygon_vertices:
    print(vertice)

    
>>> [598.000000, -2.000000, 1269.333333]
>>> [2.000000, -2.000000, 1269.333333]
>>> [2.000000, -2.000000, 1520.000000]
>>> [598.000000, -2.000000, 1520.000000]

[usai-sylvain]

Convex hull would ignore "inner corners" though, so it might not be accurate if you have concave cuts on your panel.

Alternatively, you could retrieve all panel faces with geometry_controller->get_element_facets and calculate the perimeter for each using facet_list->get_external_polygon. I'm assuming that the external polygon ignores the "holes" because there is also a get_internal_polygons method.

Once you calculate the perimeter for all faces, keep the largest value and use it as the panel perimeter.

Let us know if that works :)

edit : michi beat me to it 😆 I didn't realize get_external_polygon_for_reference_face would give you the correct perimeter already, nice solution !

[loicseg]

hum, dont see how to adapt to my code

[usai-sylvain]

go step by step :

1. find where the vertices are retrieved in your original code
2. make sure your original method and @Brunner246 method return the same type
3. replace your original vertices with @Brunner246 vertices

good luck!