[ SKETCHUP SCRIPTS ] Help ! Par quoi ou comment remplacer l'ancienne methode "nitems" dans plugins anciens

Bonjour,

Dans un ancien plugin pour SketchUp, qui donc ne fonctionne plus sous SU 2022, et que  je cherche à réutiliser, une définition de fonction utilise une ancienne Class de

réseau ( nitems) ( arr.nitems -> anInteger, Returns the number of non-nil elements in arr. May be zero. ) qui depuis un certain temps (passage à Ruby 2, Su2014 et

+) est obsolète et ne peut plus être utilisé dans les codages actuels .

La petite fonction "rect_face_selected" qui me pose problème vérifie simplement que la face sélectionnée est bien un rectangle.

Pour cela elle vérifie que l'élément sélectionné est : 1 - bien une face, 2 - qu'elle comporte bien 4 arrêtes et - 3 que le ces arrêtes sont bien

perpendiculaires entres elles.

Si ces 3 conditions sont respectées, alors la face sélectionnée est bien un rectangle.

La définition de cette fonction utilise deux fois la Class nitems dans le code "edges.nitems" ( pour la vérification du nombre de coté de la face et pour vérifier que ces cotés

sont bien perpendiculaires entre eux)

Quelqu'un peu t-il me conseiller comment remplacer et par quoi cette Class pour que la définition de la fonction "rect_face_selected" soit compatible avec les derniers API de SketchUp.

J'ai testé de mon coté diverses variantes sans succès, mes connaissances en ruby pour SU sont hélas très limitées

Merci aux spécialistes par avance.

Voici le code de la fonction "rect_face_selected" qui pose problème.

Code:

# Check if rectangular face is selected
        def rect_face_selected

            selset = Sketchup.active_model.selection
            edges = []

            # Check if single object is selected
            if (not selset.single_object?)
                return false
            end

            selset.each {|entity|
                # Check if the object is a face
                if entity.typename != "Face"
                    return false
                else
                    # Check if the face has 4 edges
                    edges = entity.edges
                    if edges.nitems != 4
                        return false
                    end
                end
            }

            #Thus far we have the face with 4 edges, is it a rectangle?
            #Loop and see if each edge is at right angle to the next
            edges[edges.length]=edges[0]
            for i in (0...edges.nitems-1)
                #line[1] is where edge vector object lives
                if (not edges[i].line[1].perpendicular? edges[i+1].line[1])
                    return false
                end
            end

            #Yay, it's a rectangle
            return true
        end

JDD

@JDD

j'ai demandé à chatgpt de le modifier et d'ajouter des boites de dialogues

Code:

module MonNom
  module MonPluginRectangle

    # Vérifie si une face rectangulaire est sélectionnée
    def self.rect_face_selected?
      selset = Sketchup.active_model.selection

      unless selset.size == 1 && selset[0].is_a?(Sketchup::Face)
        UI.messagebox("Aucune face ou plusieurs objets sélectionnés.")
        return false
      end

      edges = selset[0].edges

      unless edges.size == 4
        UI.messagebox("La face sélectionnée n'a pas 4 arêtes.")
        return false
      end

      edges << edges.first

      if edges.each_cons(2).all? { |edge1, edge2| edge1.line[1].perpendicular?(edge2.line[1]) }
        UI.messagebox("La face sélectionnée est un rectangle.")
        true
      else
        UI.messagebox("La face sélectionnée n'est pas un rectangle.")
        false
      end
    end

    # Ajoute une commande au menu pour exécuter la vérification
    unless file_loaded?(__FILE__)
      menu = UI.menu('Plugins')
      menu.add_item('Vérifier Rectangle') {
        self.rect_face_selected?
      }
      file_loaded(__FILE__)
    end

  end # module MonPluginRectangle
end # module MonNom


Dans cette version :

La méthode rect_face_selected? commence par vérifier si un seul objet est sélectionné et si cet objet est une face (Sketchup::Face).
Ensuite, elle récupère les arêtes (edges) de la face sélectionnée et vérifie si la face a exactement 4 arêtes, ce qui est une condition nécessaire pour qu'une face soit un rectangle.
La méthode each_cons(2) est utilisée pour itérer sur chaque paire consécutive d'arêtes dans le tableau edges, qui inclut maintenant la première arête à la fin pour faciliter la vérification de la perpendicularité entre la dernière et la première arête.
Pour chaque paire d'arêtes, la méthode vérifie si elles sont perpendiculaires en utilisant perpendicular? sur les vecteurs directionnels (line[1]) des arêtes.
Si toutes les paires d'arêtes sont perpendiculaires, la méthode retourne true, indiquant que la face sélectionnée est un rectangle. Sinon, elle retourne false.
Cette version complète de la fonction devrait fonctionner correctement dans SketchUp 2022 et au-delà, en respectant les conventions de Ruby modernes et en évitant l'utilisation de méthodes obsolètes.

Hello,

Merci @tenrev, je vais tester cela.
Je n'avais pas pensé à consulter ton nouvel et redoutable ami virtuel.

Je te tiens informé du résultat.

JDD

Hello
On fait du Ruby sans moi ?

Voici une version plus condensée et plus human reading !

Code:



# Check if rectangular face is selected
def rect_face_selected
  # On récupère la sélection
  sel = Sketchup.active_model.selection
  
  # test si la sélection ne contient qu'un seul element
  return false unless sel.length == 1
  
  # Test si l'objet sélectionné est une face
  return false unless sel[0].is_a? Sketchup::Face
  
  # on définit la variable face comme étant la face sélectionnée
  face = sel[0]
  
  # test si la face a 4 arrêtes
  return false unless face.edges.length == 4
  
  # on définit la variables edges contenant les 4 arrêtes
  edges = face. Edges
  
  # Test si les arrêtes consécutives sont perpendiculaires
  # on test les vecteurs des lignes portant les arrêtes
  return false unless edges.each_cons(2).all? { |edge1, edge2| edge1.line[1].perpendicular?(edge2.line[1]) }
  
  # Toutes les conditions sont remplies renvoie vrai
  return true
end

Hello @simjoubert

J'ai fait appel aux spécialistes en pensant que tu serais le premier à répondre.
Eh bien non, le maitre est dépassé par ses élèves.
J'ai testé de rentrer le code transmis par l'ami de @tenrev et avec quelques légères modifications cette définition rentrée dans mon vieux plugin initialement écrit par Jim Foltznommé round_corners semble fonctionner correctement.

Je termine quelques test et si cela intéresse certaines personnes je peux le poster.

C'est un simple plugin permettant de réaliser des rectangles avec des angles arrondis .

Sur un projet en cours ( cockpit d'un simulateur Airbus A320-200) j'en ai une très grande quantité à réaliser.
Et me coltiner un après l'autre ces rectangles pour la mise en place de rayons dans les angles  devenait un calvaire.
Je me suis souvenu avoir disposé de ce vieux plugin que j'ai retrouvé dans mes archives.

Mais il est possible que d'autres plugins que j'ignore peuvent aussi réaliser cela.
Je suis preneur de ces variantes si elles existent.

EDIT :

Il semble bien fonctionné et je le joins à cette conversation pour ceux intéressés.

Nom du plugin : Round Corners
Auteur : Jim Foltz + rev JDD

Usage :

Créer un rectangle avec l'outil "Rectangle" de SketchUp

Sélectionner la face et faire un Clic Droit pour accéder au menu contextuel de SketchUp
Activer le plugin en cliquant sur "Rectangle Arrondi"
Dans la fenêtre qui s'ouvre fixer :

1- La valeur du rayon des arrondis pour remplacer les angles droits du rectangle ( défaut = 25 mm)
2 -Choisir la qualité des rayons en fixant le nombre de segment constituant l'arc des rayons (défaut = 6)
3 -Choisir de supprimer ou de garder les segment des angles droits après mise en place des arrondis (défaut = Oui = supprimer)

JDD

Hello JDD
Tu aurais pu appeler "Rectangle round corner" pour éviter la confusion avec le plugin de Fredo6 !
je regarde t je te donnerai mon avis
Merci et bravo

Hello @simjoubert,

Oui, mais je n'ai pas voulu changer le nom de la version originale donné par Jim Foltz que j'ai juste mise à jour pour qu'elle fonctionne (et pour un usage perso)

JDD

simjoubert a écrit:Hello
On fait du Ruby sans moi ?

Voici une version plus condensée et plus human reading !

  oui grand maitre

tu sais @simjoubert que dans ma série de tuto et vidéo sur les plugins que je viens de publier sur youtube ,  il y a une partie :  mini script à l'aide de chatgpt , j'ai précisé  que ca ne remplaçait pas un programmeur ou codeur pro et que ca leurs faisait dresser les cheveux  

Hello
Voici une petite variante du code qui permet de sélectionner plusieurs faces de n'importe quelle forme, des faces pleines ou perforées.

Le résultat est mis dans un groupe et des sous-groupes si plusieurs faces.

Code:


#*************************************************************************************************
#     FACES ROUND CORNERS
#     Auteur Simon Joubert
#     Version 1.1 2024/02/28
#
#   Arrondis tous les angles des faces sélectionnées
#   Crée des points de guidage sur le centre de l'arrondi et ses extremités
#*************************************************************************************************
# Paramètres :
#   radius de l'arrondis
#     par défaut 0.5.m
#     le radius sera réduit si est trop grand pour etre accueilli par la moitié du plus petit côté
#
#   Circle_segments Nombre d'arrêtes pour faire 360°
#     le nombres d'arrêtes sera proportionel selon l'angle décrit
#     valeur par défaut 48
#
#   Erase efface la face originale
#     Par défaut true
#*********************************************************************************************
# Retourne le groupe contenant des sous groupes contenant une des faces arrondis.
# S'il n'y a qu'une face de sélectionnée la face arrondie est directement dans le groupe
#
# Exemple new_round_faces = faces_round_corners(0.5.m, 48, true)
#
#**********************************************************************************************

def faces_round_corners(radius = 50.cm, circle_segments = 48, erase = true)

  circle_segments = circle_segments.to_i.to_f
  pi = Math::PI

  model = Sketchup.active_model
  model.start_operation("Faces Round Corners", true)

  entities = model.entities
  faces = model.selection.grep(Sketchup::Face)

  raise "Error No faces selected !" unless faces

  # Groupe qui contiendra le résultat
  super_group = entities.add_group
  super_group.name = "Faces_round_corners"
  super_group_ents = super_group.entities

  # Boucle sur chaque faces
  faces.each do |face|

    # Création d'un sous group pour contenir la face arrondie
    group = super_group_ents.add_group
    ents = group.entities

    normal = face.normal
    loops = face.loops
    # Si la face est ajourée on ordonne les loops [outer, inner1, inner...]
    if loops.size > 1
      inner_loops = loops.filter { |loop| !loop.outer? }
      outer_loops = loops.filter { |loop| loop.outer? }
      loops = outer_loops + inner_loops
      loops.flatten!
    end
    
    # Boucle sur chaque loops
    loops.each_with_index do |loop, index|

      #On récupère les points
      pts = loop.vertices.map{|v|v.position}
      pts_a = pts + pts[0..1]

      arcs = []
      egdes_pts = []
      edges = []

      # Boucle sur chaque triplet de points de la face
      array = pts_a.each_cons(3).map do |p1,p2,p3|      

        pt = p2
        v21 = p2.vector_to(p1).normalize
        v23 = p2.vector_to(p3).normalize
        d21 = p2.distance(p1)
        d23 = p2.distance(p3)
        dmin = [d21,d23].min/2

        # Test si les points sont colineaires
        if v21.parallel?(v23)
          next
        end

        # Calul du centre de l'arc
        v = (v21 + v23).normalize
        l1 = [p2, v21]
        l2 = [p2,v23]
        angle = v21.angle_between(v23)

        # Test si le plus petit coté peux  accueillir l'arrondi sinon réduit le radius
        if radius / Math.tan(angle / 2) > dmin
          angle_complementaire = pi / 2 - angle / 2
          radius_local = dmin / Math.tan(angle_complementaire)
        else
          radius_local = radius
        end      

        # Calcule de la position sur la bisectrice de l'angle
        hypo = radius_local / Math.sin(angle / 2)
        arc_center = p2.offset(v, hypo)
        ents.add_cpoint(arc_center)

        #Calcule des points de tengeance
        arc_start = arc_center.project_to_line(l1)
        ents.add_cpoint(arc_start)      

        arc_end = arc_center.project_to_line(l2)
        ents.add_cpoint(arc_end)      

        xaxis = arc_center.vector_to(arc_start)
        endaxis = arc_center.vector_to(arc_end)

        angle = xaxis.angle_between(endaxis)

        # Test si angle rentrant ou sortant
        v2z = v21.cross(v23)
        sens = Z_AXIS.dot(v2z)      

        if Z_AXIS.dot(normal)>= 0
          if sens > 0
            angle = 0 - angle
          end
        else
          if sens < 0
            angle = 0 - angle
          end
        end

            

        #calcule du nombre de segments suivant l'angle décrit
        angle_a = angle.abs()
        num_segments = ((circle_segments * angle_a) / (2 * pi)).round()      

        # On dessine l'arc
        arc = ents.add_arc( arc_center, xaxis, normal, radius_local, 0, angle, num_segments)
        arcs << arc      

        [arc_start, arc_end]

      end

      

      # Nettoyage des collineaires
      array = array.filter { |a| a != nil }
      array << array[0]

      # dessin des arrêtes
      array.each_cons(2).map do |arc1,arc2|

        pt1 = arc1[1]
        pt2 = arc2[0]

        # Test si les points sont difféerents
        if pt1 != pt2
          edge = ents.add_line(pt1,pt2)
          edges << edge
        end

      end

      # Création de la face
      join = arcs + edges
      newface = ents.add_face(join.flatten)
      
      #Orientation de la face pour être identique à l'originale
      if newface
        newface.reverse! unless newface.normal == normal
      end

      # Effacement de la face pour créer le trou si loop est inner
      if index > 0
        newface.erase! if newface.valid?
      end      

      

    end#Fin loop

  end#Fin face


  # Eclatemt du sous groupe s'il n'y avait qu'une seule face
  if super_group_ents.size ==1
    super_group_ents[0].explode
  end

  

  #Effacement de l'originale
  if erase
    edges = faces.map { |f| f.edges}.flatten.uniq
    edges.each { |e| e.erase! if e.valid? }
  end

  model.commit_operation  

  return super_group

end


Je créerai l'outil si cela vous intéresse

@simjoubert t'es le meilleurs , bien meilleur que chatgpt

mais du coup tu as laissé tombé le plugin composant dynamique ?

Hello Mais non c'était un challenge de la soirée !
Histoire de changé un peu !

J'ai rajouté deux autres options:
Make group true/false par défaut :true
Extrude épaisseur d'extrusion par défaut 0. Pour 5cm il faut saisir 5.cm

Du coup on peut faire de choses sympas :

La bande de roulement des pneus



Une boule de noel


voila le nouveau code

Code:


#*************************************************************************************************
#     FACES ROUND CORNERS
#     Auteur Simon Joubert
#     Version 1.2 2024/02/28
#
#   Arrondis tous les angles des faces sélectionnées
#   Crée des points de guidage sur le centre de l'arrondi et ses extremités
#   Extrude les faces arrondies
#*************************************************************************************************
# Paramètres :
#   radius de l'arrondis
#     par défaut 0.5.m
#     le radius sera réduit si est trop grand pour etre accueilli par la moitié du plus petit côté
#
#   Circle_segments Nombre d'arrêtes pour faire 360°
#     le nombres d'arrêtes sera proportionel selon l'angle décrit
#     valeur par défaut 48
#
#   Erase efface la face originale
#     Par défaut true
#  
#   Make_Group Le résultat est dans un groupe et chaque faces arrondies dans un sous group
#     Par defaut true
#
#   Extrude permet d'extruder les faces arrondies
#     Par défaut 0.cm
#*********************************************************************************************
# Retourne le groupe contenant des sous groupes contenant une des faces arrondis.
# S'il n'y a qu'une face de sélectionnée la face arrondie est directement dans le groupe
#
# Exemple new_round_faces = faces_round_corners(0.5.m, 48, true, true, 3.cm)
#
#**********************************************************************************************

def faces_round_corners(radius = 50.cm, circle_segments = 48, erase = true, make_group = true, extrude = 0)

  circle_segments = circle_segments.to_i.to_f
  pi = Math::PI

  model = Sketchup.active_model
  model.start_operation("Faces Round Corners", true)

  active_path = model.active_path[-1]

  case
  when active_path.class == Sketchup::ComponentInstance
    entities = active_path.definition.entities
  when active_path.class == Sketchup::Group
    entities = active_path.entities
  else
    entities = model.entities
  end  

  
  faces = model.selection.grep(Sketchup::Face)

  raise "Error No faces selected !" unless faces

  # Groupe qui contiendra le résultat
  super_group = entities.add_group
  super_group.name = "Faces_round_corners"
  super_group_ents = super_group.entities

  # Boucle sur chaque faces
  faces.each do |face|

    # Création d'un sous group pour contenir la face arrondie
    group = super_group_ents.add_group
    ents = group.entities

    normal = face.normal
    loops = face.loops
    # Si la face est ajourée on ordonne les loops [outer, inner1, inner...]
    if loops.size > 1
      inner_loops = loops.filter { |loop| !loop.outer? }
      outer_loops = loops.filter { |loop| loop.outer? }
      loops = outer_loops + inner_loops
      loops.flatten!
    end
    
    # Boucle sur chaque loops
    loops.each_with_index do |loop, index|

      #On récupère les points
      pts = loop.vertices.map{|v|v.position}
      pts_a = pts + pts[0..1]

      arcs = []
      egdes_pts = []
      edges = []

      # Boucle sur chaque triplet de points de la face
      array = pts_a.each_cons(3).map do |p1,p2,p3|      

        pt = p2
        v21 = p2.vector_to(p1).normalize
        v23 = p2.vector_to(p3).normalize
        d21 = p2.distance(p1)
        d23 = p2.distance(p3)
        dmin = [d21,d23].min/2

        # Test si les points sont colineaires
        if v21.parallel?(v23)
          next
        end

        # Calul du centre de l'arc
        v = (v21 + v23).normalize
        l1 = [p2, v21]
        l2 = [p2,v23]
        angle = v21.angle_between(v23)

        # Test si le plus petit coté peux  accueillir l'arrondi sinon réduit le radius
        if radius / Math.tan(angle / 2) > dmin
          angle_complementaire = pi / 2 - angle / 2
          radius_local = dmin / Math.tan(angle_complementaire)
        else
          radius_local = radius
        end      

        # Calcule de la position sur la bisectrice de l'angle
        hypo = radius_local / Math.sin(angle / 2)
        arc_center = p2.offset(v, hypo)
        ents.add_cpoint(arc_center)

        #Calcule des points de tengeance
        arc_start = arc_center.project_to_line(l1)
        ents.add_cpoint(arc_start)      

        arc_end = arc_center.project_to_line(l2)
        ents.add_cpoint(arc_end)      

        xaxis = arc_center.vector_to(arc_start)
        endaxis = arc_center.vector_to(arc_end)

        angle = xaxis.angle_between(endaxis)

        # Test si angle rentrant ou sortant
        v2z = v21.cross(v23)
        sens = Z_AXIS.dot(v2z)      

        if Z_AXIS.dot(normal)>= 0
          if sens > 0
            angle = 0 - angle
          end
        else
          if sens < 0
            angle = 0 - angle
          end
        end

            

        #calcule du nombre de segments suivant l'angle décrit
        angle_a = angle.abs()
        num_segments = ((circle_segments * angle_a) / (2 * pi)).round()      

        # On dessine l'arc
        arc = ents.add_arc( arc_center, xaxis, normal, radius_local, 0, angle, num_segments)
        arcs << arc      

        [arc_start, arc_end]

      end

      

      # Nettoyage des collineaires
      array = array.filter { |a| a != nil }
      array << array[0]

      # dessin des arrêtes
      array.each_cons(2).map do |arc1,arc2|

        pt1 = arc1[1]
        pt2 = arc2[0]

        # Test si les points sont difféerents
        if pt1 != pt2
          edge = ents.add_line(pt1,pt2)
          edges << edge
        end

      end

      # Création de la face
      join = arcs + edges
      newface = ents.add_face(join.flatten)
      
      #Orientation de la face pour être identique à l'originale
      if newface
        newface.reverse! unless newface.normal == normal
      end

      # Effacement de la face pour créer le trou si loop est inner
      if index > 0
        newface.erase! if newface.valid?
      end      

      

    end#Fin loop

    if extrude != 0
      new_round_faces = ents.grep(Sketchup::Face)
      new_round_faces.each do |new_round_face|
        new_round_face.pushpull(extrude, true)
      end
    end

  end#Fin face

  #Effacement de l'originale
  if erase
    edges = faces.map { |f| f.edges}.flatten.uniq
    edges.each { |e| e.erase! if e.valid? }
  end

  # Eclatemt du sous groupe s'il n'y avait qu'une seule face
  if super_group_ents.size ==1
    super_group_ents[0].explode
  end

  unless make_group
    sous_groups = super_group_ents.grep(Sketchup::Group)
    sous_groups.each { |g| g.explode if g.valid?  }
    super_group.explode
  end  
  
  model.commit_operation  

  return super_group

end



Hello @simjoubert,

Alors comme cela, le grand maitre se défoule pendant que le big boss piaffe d'impatience!

En tous cas, Super sympa ta nouvelle extension.

Si tu as ou trouves un jour le temps de créer l'outil, je pense que la variable radius devrait être accessible par l'utilisateur via une fenêtre ou autre moyen.

En tout cas je suis preneur.

Encore Bravo

JDD

JDD a écrit:Alors comme cela, le grand maitre se défoule pendant que le big boss piaffe d'impatience!

ouai c'est clair ca fait quinze jours qu'il nous dit que c'est pour demain  bon on attendra le temps qu'il faudra
j'avais déja quelques idées de composants à faire avec la fonction qui va chercher un sous composant externe , mais bon je patiente , je patiente

Hello @JDD
C'était un jet pour s'amuser !
Si le challenge de le mettre sous forme d'outils te tente lat's go, sinon il faudra attendre un peu car la liste des doléances s'allonge.

simjoubert a écrit:Hello  @JDD
C'était un jet pour s'amuser !
Si le challenge de le mettre sous forme d'outils te tente lat's go, sinon il faudra attendre un peu car la liste des doléances s'allonge.

c'est quand que tu remplaces dan burnes chez sketchup ? en tout cas tu es chaud pour vendre des plugins

Pour ma défense,
J'ai trouvé une parade avec un observateur pour corriger le bug dans le texte 3d, et je veux implémenter cette idée pour que les opérations booléennes se mettent à jour également, ainsi qu'anticollision.
Mais la bestiole est encore capricieuse. Pour le texte 3d j'ai fait au moins 300 itérations de la fonction pour trouver la bonne ! Je suis lent mais tenace !
L'idée est d'avoir des outils productifs et fiable.

Le plus long même si j'ai presque tout désactivé c'est de redémarrer SU à chaque fois !