[ Ruby ] Automatisation sketchup grace à excel

Bonjour à tous,

J'avais crée un topic il y a un mois pour savoir si il existai un plugin permettant de récupérer des valeurs situées dans un tableau excel afin de les exploiter dans un composant dynamique. N'existant pas j'ai du passer à de la programmation en ruby

Pour résumé ce que je veux faire, j'ai plusieurs composants que je veux positionner sur sketchup.

Les composants restent figés (il n'y a pas de changement de dimensions au sein de ces composants), les seuls valeurs que je veux piloter à partir d'excel sont le positionnement de ces composants et de leurs copies.

Voilà ce que ça donne pour l'instant :

Code:


def visu

model = Sketchup.active_model
entities = model.entities
selection = model.selection
definitions = model.definitions[0]
view = model.active_view


# excel call
require 'win32ole'

xl = WIN32OLE.new('Excel.Application')
xl.visible=1

wb = xl.Workbooks.Open('C:\Users\vince\Desktop\fichiersrb\dbvisuclient')

worksheet = wb.Worksheets('Feuil1')

l = worksheet.Range('a1').Value


# conversion cm en inch
# l = position 1ere objet sur la longueur (en metre)
# b = position 1ere objet sur la longueur (en inch)
# z = facteur de conversion metre en inch

z = 0.3937007874
b = l*z

#déplacement

t1 = Geom::Transformation.new
a1 = t1.to_a
a1[-4] = b
a1[-3] = 0
t1 = Geom::Transformation.new(a1)
entities.transform_entities(t1,entities[0])

# création de l'instance (qui prend pour réference l'origine de Sketchup et pas l'origine du composant instancé)
transformation = Geom::Transformation.new([0,0,0])
componentinstance = entities.add_instance(definitions, transformation)
new_transformation = Geom::Transformation.new([b+(200*z),0,0])
componentinstance.move! new_transformation


end


J'arrive donc à contrôler le positionnement d'un objet ainsi qu'une seul de ses copies.

Les 2 points manquants à mon projet sont :
_créer plusieurs instances de mon composant et réussir à les positionnées (pour l'instant seulement une instance est crée et positionné)
_réussir à faire tout ceci avec plusieurs composants (pour l'instant je ne contrôle le positionnement et l'instance que d'un seul composant, je ne comprend pas encore bien comment interagir avec plusieurs composants au sein d'un même code)

Voilà voilà j’espère que c'est compréhensible et que vous saurez me guider sur ces 2 points.  

Longue vie au Ruby !    

super , ca m’intéresse fortement ce que tu fais  et que tu partages avec nous
mais je pense que tu es déja plus avancé que moi

j'espère que notre ami et nouveau membre Samuel , pourras t'éclairer et nous faire partager ses connaissances en ruby

merci et à plus les amis

Sa fait plaisir de poster du contenu qui pourra peut-être servir à d'autres, j'ai fait exprès de mettre des annotations dans le code pour que ça soit le plus lisible possible.
Mais honnêtement mon niveau en ruby reste très faible et il y a certaine subtilités (même au sein de mon code) qui m'échappent.
Espérons que quelques personnes éclairées sur le sujet passent dans le coin

Bonjour mgsvinc

mgsvinc a écrit:
[...] il y a certaine subtilités (même au sein de mon code) qui m'échappent.

Quels sont les morceaux dans ton code Ruby que tu souhaiterais éclaircir ?

Une simplification : Tu n'as pas besoin de gérer, à la main, la conversion des centimètres en inches.
Il suffit d'indiquer l'unité de la longueur en entrée. SketchUp se chargera de la convertir en inches.

Exemple :

Code:


# Entrée :
longueur = 1
longueur.cm
# Sortie :
# 0.39370078740157477


La méthode cm s'applique à un objet Numeric. Penses à convertir la longueur avec la méthode to_i

Ce qui donne concrètement dans ton code :

Code:


# ...
l = worksheet.Range('a1').Value
# Conversion de centimètre vers inch. Car SketchUp gère les longueurs en inches.
l = l.to_i.cm
# ...
a1[-4] = l
# ...
new_transformation = Geom::Transformation.new([l+200.cm,0,0])
# ...


Les variables z et b sont devenues inutiles.

mgsvinc a écrit:
[...] je ne comprend pas encore bien comment interagir avec plusieurs composants au sein d'un même code)

Je te conseille de factoriser les différentes parties de ton code. C'est-à-dire "rassembler les suites d'instructions identiques [...] en une fonction". Tu peux imaginer un jeu de rôle pour t'aider...

Tu es le chef d'une entreprise. Le but de ton entreprise est de positionner des composants SketchUp à partir de coordonnées écrites dans des classeurs Excel. Cela requiert une organisation. Tu vas créer des fonctions. Tu vas embaucher du personnel puis assigner à chaque employé des responsabilités uniques :

- Une secrétaire va réceptionner les classeurs Excel. Cela pourrait donner une boîte de dialogue.
- Un employé va lire chaque classeur Excel et enregistrer les coordonnées dans une pile de dossiers.
- Un autre employé va dépiler ces dossiers et positionner les composants SketchUp et ainsi de suite...

Retour à la réalité du code Quelles pourraient être les entrées et les sorties de chaque fonction ?
Il y aura aussi des variables. Car qui dit "pile de dossiers" dit : variable pour mémoriser les dossiers.

super interessant , merci pour ton aide samuel

j'aime bien ta pédagogie du code

Bonjour Samuel,

Le point de mon code que j'aimerais éclaircir concerne principalement le début de mon code quand j'appelle mes variables. Plus précisément quand je détermine "model = Sketchup.active_model" je ne sais pas trop comment ça se passe, comment le code identifie ce qu'il y a au sein de mon modelè sketchup si il y a plusieurs composants.
Je ne comprend également pas le [0] dans "definitions = model.definitions[0]"

Merci beaucoup la méthode .cm, je ne pensais pas qu'elle existait car j'avais suivi un tuto où ils disaient que ce n'était pas le cas (le tuto devait surement un peu daté).

Je ne suis pas sur de bien comprendre l’intérêt de rassembler les suites d'instructions identiques en une fonction. Je compte bien organiser mon code parties par parties (avec chaque parties qui effectue la totalité d'une tache précise (ex : récupérer les données excel), mais pourquoi séparer ces parties avec des fonctions (du type "def" ... "end") ?
Concernant la réception des classeurs excel pourquoi pense tu que passer par une boite de dialogue serait utile ? sachant que le code va déjà chercher les informations nécessaires dans les cellules correspondante et les associe à des variables.

mgsvinc a écrit:
Le point de mon code que j'aimerais éclaircir concerne principalement le début de mon code quand j'appelle mes variables. Plus précisément quand je détermine "model = Sketchup.active_model" je ne sais pas trop comment ça se passe, comment le code identifie ce qu'il y a au sein de mon modelè sketchup si il y a plusieurs composants.

A la racine du module Sketchup, il y a des méthodes. Lorsque tu appelles la méthode active_model : SketchUp te renvoie une instance de type Model qui référence le modèle actif. C'est SketchUp qui crée et garde à jour cette instance. Sachant que le modèle contient (entre autres) les composants, le bout de code Sketchup.active_model te donne accès (entre autres) aux composants du modèle actif.

mgsvinc a écrit:
Je ne comprend également pas le [0] dans "definitions = model.definitions[0]"

model est une variable créée par le codeur.  Elle référence une instance Model – celle du modèle actif.
definitions est une méthode de la classe Model. Elle renvoie la liste des composants de ce modèle.
[] est une méthode de la classe DefinitionList. [0] donne accès au 1er composant de cette liste.
Pourquoi 0 et pas 1 ? Je t'invite à lire ce cours sur Ruby pour apprendre ce qu'est un Tableau.

mgsvinc a écrit:
Je ne suis pas sur de bien comprendre l’intérêt de rassembler les suites d'instructions identiques en une fonction.

Les fonctions permettent de réutiliser des portions de code. En principe : moins il y a de redondances dans ton code, plus ton code est maintenable. Voici un exemple hors de ton projet :

J'ai une classe VoitureA qui contient une méthode demarrer.
J'ai une classe VoitureB qui contient aussi une méthode demarrer avec un code identique.
J'observe que VoitureA et VoitureB ont un trait commun : la méthode demarrer.
Si je devais corriger la méthode démarrer... j'aurai tout intérêt à le faire une seule fois.

Cela prend encore plus de sens lorsque la méthode attend un ou plusieurs paramètres en entrée.

mgsvinc a écrit:
Je compte bien organiser mon code parties par parties (avec chaque parties qui effectue la totalité d'une tache précise (ex : récupérer les données excel), mais pourquoi séparer ces parties avec des fonctions (du type "def" ... "end") ?

Pour l'instant, ton script compte une cinquantaine de lignes. N'est-ce pas exagéré de le découper en fonctions ? Peut-être, mais attention : le nombre de lignes peut vite augmenter.
Les fonctions dessinent une sorte de plan qui facilite la navigation dans le code.

mgsvinc a écrit:
Concernant la réception des classeurs excel pourquoi pense tu que passer par une boite de dialogue serait utile ? sachant que le code va déjà chercher les informations nécessaires dans les cellules correspondante et les associe à des variables.

Cela dépend si tu veux un programme dynamique ou statique. C'est à toi d'évaluer si tu en as besoin.

tenrev a écrit:super interessant , merci pour ton aide samuel

j'aime bien ta pédagogie du code

Merci

Samuel Tallet-Sabathé a écrit:Je t'invite à lire ce cours sur Ruby pour apprendre ce qu'est un Tableau.

https://fr.wikiversity.org/wiki/Ruby/Tableaux_et_hachages

Merci pour le lien , hop dans mes favoris

Samuel Tallet-Sabathé a écrit:

mgsvinc a écrit:
Le point de mon code que j'aimerais éclaircir concerne principalement le début de mon code quand j'appelle mes variables. Plus précisément quand je détermine "model = Sketchup.active_model" je ne sais pas trop comment ça se passe, comment le code identifie ce qu'il y a au sein de mon modelè sketchup si il y a plusieurs composants.

A la racine du module Sketchup, il y a des méthodes. Lorsque tu appelles la méthode active_model : SketchUp te renvoie une instance de type Model qui référence le modèle actif. C'est SketchUp qui crée et garde à jour cette instance. Sachant que le modèle contient (entre autres) les composants, le bout de code Sketchup.active_model te donne accès (entre autres) aux composants du modèle actif.

mgsvinc a écrit:
Je ne comprend également pas le [0] dans "definitions = model.definitions[0]"

model est une variable créée par le codeur.  Elle référence une instance Model – celle du modèle actif.
definitions est une méthode de la classe Model. Elle renvoie la liste des composants de ce modèle.
-instance_method][] est une méthode de la classe DefinitionList. [0] donne accès au 1er composant de cette liste.
Pourquoi 0 et pas 1 ? Je t'invite à lire ce cours sur Ruby pour apprendre ce qu'est un Tableau.

mgsvinc a écrit:
Je ne suis pas sur de bien comprendre l’intérêt de rassembler les suites d'instructions identiques en une fonction.

Les fonctions permettent de réutiliser des portions de code. En principe : moins il y a de redondances dans ton code, plus ton code est maintenable. Voici un exemple hors de ton projet :

J'ai une classe VoitureA qui contient une méthode demarrer.
J'ai une classe VoitureB qui contient aussi une méthode demarrer avec un code identique.
J'observe que VoitureA et VoitureB ont un trait commun : la méthode demarrer.
Si je devais corriger la méthode démarrer... j'aurai tout intérêt à le faire une seule fois.

Cela prend encore plus de sens lorsque la méthode attend un ou plusieurs paramètres en entrée.

mgsvinc a écrit:
Je compte bien organiser mon code parties par parties (avec chaque parties qui effectue la totalité d'une tache précise (ex : récupérer les données excel), mais pourquoi séparer ces parties avec des fonctions (du type "def" ... "end") ?

Pour l'instant, ton script compte une cinquantaine de lignes. N'est-ce pas exagéré de le découper en fonctions ? Peut-être, mais attention : le nombre de lignes peut vite augmenter.
Les fonctions dessinent une sorte de plan qui facilite la navigation dans le code.

mgsvinc a écrit:
Concernant la réception des classeurs excel pourquoi pense tu que passer par une boite de dialogue serait utile ? sachant que le code va déjà chercher les informations nécessaires dans les cellules correspondante et les associe à des variables.

Cela dépend si tu veux un programme dynamique ou statique. C'est à toi d'évaluer si tu en as besoin.

Merci pour toutes ces précisions, pour l'instant je ne pense pas qu'il y est un intérêt à découper mon code avec des fonctions (mais je garde ça dans un coin de ma tête pour quand le code aura pris un peu d'ampleur).
Je vais étudier le lien que tu m'a passé mais ce que tu m'a dit apporte déjà pas mal de réponses.
Je reviens vers toi (si ça ne te dérange pas) quand j'ai avancé sur tout ça.

D'accord. Bonne continuation.

Bonjour, je reviens vers vous avec des nouvelles questions sur mon code

Code:


def visu

model = Sketchup.active_model
entities = model.entities
selection = model.selection
definitions1 = model.definitions[0] #définition du 1er composant
definitions2 = model.definitions[1] #définition du 2éme composant
view = model.active_view

# excel call

require 'win32ole'

xl = WIN32OLE.new('Excel.Application')
xl.visible=1

wb = xl.Workbooks.Open('C:\Users\vince\Desktop\fichiersrb\dbvisuclient')

worksheet = wb.Worksheets('Feuil1')

l = worksheet.Range('a1').Value

# Méthode.cm

l = l.to_i.cm

#déplacement 1er composant

t1 = Geom::Transformation.new
a1 = t1.to_a
a1[-4] = l
a1[-3] = 0
t1 = Geom::Transformation.new(a1)
entities.transform_entities(t1,entities[0])

#déplacement 2éme composant

t2 = Geom::Transformation.new
a2 = t2.to_a
a2[-4] = 100.cm
a2[-3] = 0
t2 = Geom::Transformation.new(a2)
entities.transform_entities(t2,entities[1])

# création des copies du 1er composant (qui prend pour réference l'origine de Sketchup et pas l'origine du composant instancé)

for i in 1..4
transformation = Geom::Transformation.new([0,0,0])
componentinstance = entities.add_instance(definitions1, transformation)
new_transformation = Geom::Transformation.new([i*200.cm,0,0])
componentinstance.move! new_transformation
end

end


J'ai donc placé 2 composants dans mon modèle sketchup (le but final étant de le faire avec plus de composants), et je les ai identifiés grâce aux crochets [0] et [1].
J'avais hésiter avec du code qui les chargent dans le modèle sketchup en allant les chercher dans leur dossiers d'origine, mais je me suis dit que sa prendrai moins de temps si le code les avait directement à disposition dans le modèle. Pensez-vous que c'est la meilleurs méthode pour définir mes différents composants ?

Ensuite pour crée et gérer les copies j'ai fait une boucle qui permet de faire varier la distance de création des nouvelles instances (avec la variable "i")
Le problème est que j'indique bien definition1 dans "componentinstance = entities.add_instance(definitions1, transformation)" mais la transformation s’applique sur le 2ème composant. Et d'autre part les copies sont décalé sur l'axe y alors que je n'ai effectué que des changement de valeurs sur l'axe x, et je ne comprend pas pourquoi.


Voilà, j’espère que vous saurez me guider ou me réorienter vers de meilleurs solutions

mgsvinc a écrit:
J'ai donc placé 2 composants dans mon modèle sketchup (le but final étant de le faire avec plus de composants), et je les ai identifiés grâce aux crochets [0] et [1].
J'avais hésiter avec du code qui les chargent dans le modèle sketchup en allant les chercher dans leur dossiers d'origine, mais je me suis dit que sa prendrai moins de temps si le code les avait directement à disposition dans le modèle. Pensez-vous que c'est la meilleurs méthode pour définir mes différents composants ?

Meilleur me semble relatif aux besoins et surtout aux moyens dont vous disposez. Peut-être avez-vous seulement besoin de travailler sur des composants pré-chargés ? Quel est le flux de travail envisagé ?

mgsvinc a écrit:
Ensuite pour crée et gérer les copies j'ai fait une boucle qui permet de faire varier la distance de création des nouvelles instances (avec la variable "i")

Je vous conseille de nommer variables (et fonctions) de manière explicite. C'est une bonne pratique.
Cela permettrait dans ce cas au relecteur du code de comprendre sans effort l'utilité de la variable i.

mgsvinc a écrit:
Le problème est que j'indique bien definition1 dans "componentinstance = entities.add_instance(definitions1, transformation)" mais la transformation s’applique sur le 2ème composant. Et d'autre part les copies sont décalé sur l'axe y alors que je n'ai effectué que des changement de valeurs sur l'axe x, et je ne comprend pas pourquoi.

Ce problème vient peut-être du placement des axes...

J'ai factorisé la majorité de votre code pour démontrer ce que j'ai dit dans un message précédent :

Cela prend encore plus de sens lorsque la méthode attend un ou plusieurs paramètres en entrée.

Je vous laisse étudier ce code. Sentez-vous libre de l'adapter : lecture des longueurs depuis un .xls, etc.
Il suffit de passer la longueur en second paramètre à la fonction clone_and_move_components.

Code:


# Clone un composant SketchUp.
#
# @param [Sketchup::ComponentInstance] component Composant original.
#
# @return [Sketchup::ComponentInstance] Un composant-clone.
def clone_component(component)

  return Sketchup.active_model.entities.add_instance(

    component.definition,

    # La transformation du composant-clone est relative à l'original.
    component.transformation

  )

end

# Déplace un composant SketchUp à une distance X.
#
# @param [Sketchup::ComponentInstance] component Composant.
# @param [Length] x_distance Distance dans l'axe X.
#
# @return [void]
def move_component(component, x_distance)

 transformation_values = Geom::Transformation.new.to_a

 transformation_values[-4] = x_distance
 transformation_values[-3] = 0

 Sketchup.active_model.entities.transform_entities(

    Geom::Transformation.new(transformation_values),
    component

  )

end

# Clone et déplace plusieurs composants SketchUp à une distance X.
#
# @param [Array<Sketchup::ComponentInstance>, String] components Composants. Par défaut : tous.
# @param [Length] x_distance Distance dans l'axe X. Par défaut : 1m.
#
# @return [void]
def clone_and_move_components(components = 'all', x_distance = 1.m)

  if components == 'all'

    components = Sketchup.active_model.entities.grep(Sketchup::ComponentInstance)

  end

  components.each do |component|

    move_component(clone_component(component), x_distance)

  end

end


merci Samuel pour ces infos

Bonjour Samuel, je vais me permettre de te tutoyer, j’espère que ça ne te dérange pas.

Tout d'abord merci pour ton bout de code, ça m'a permis de bien comprendre l’intérêt de factoriser le code avec des fonctions dont on peut faire varier les variables d'entrées.
J'ai passé pas mal de temps à essayer d'adapter mon code dessus, mais sans succès. Il y a des morceaux que je ne comprends pas et je pense que mon échec vient de là.

Si j'ai bien capté le truc, tu définit des fonctions que tu combine ensuite (et tu peux ensuite rappeler ses fonctions en modifiant leurs variables).
Je ne comprend pas dans la fonction "clone_and_move_components" pourquoi tu met un "s" à la fin de components" alors qu'il n'y en a pas clone_component et move_component.
Pourquoi met-tu "components = all" ? cela ne va t'il pas entrainer le déplacement de tous les composants au même endroit ? (pour la même raison je ne comprend pas la fin du code, ni le if, ,ni "components.each do |component|"

Enfin je voudrais te demander si quand j'appelle l'une de ces fonctions je dois changer "component" par "entities[0]", par exemple "def move_component(entities[0], x_distance)" pour exécuter la fonction sur le 1er composant

Pour répondre à tes questions sur le message précédant :

Samuel Tallet-Sabathé a écrit:Meilleur me semble relatif aux besoins et surtout aux moyens dont vous disposez. Peut-être avez-vous seulement besoin de travailler sur des composants pré-chargés ? Quel est le flux de travail envisagé ?

Oui je pense que l'utilisation de composants près-chargés est plus adapté à mon projet. Le flux de travail envisagé est important mais dans un premier temps je m'en contenterai.

Samuel Tallet-Sabathé a écrit:Je vous conseille de nommer variables (et fonctions) de manière explicite. C'est une bonne pratique. sourire
Cela permettrait dans ce cas au relecteur du code content de comprendre sans effort l'utilité de la variable i.

Je vais faire un effort pour que ça soit plus compréhensible

Samuel Tallet-Sabathé a écrit:Ce problème vient peut-être du placement des axes...

J'ai bien veillez à faire correspondre les axes de mon modèle avec ceux des composants que j'ai placé.

mgsvinc a écrit:
Si j'ai bien capté le truc, tu définit des fonctions que tu combine ensuite (et tu peux ensuite rappeler ses fonctions en modifiant leurs variables).

Oui. J'appelle des fonctions avec des paramètres (variables). Ces fonctions sont imbriquées.
Le retour de la fonction "contenue" devient le premier paramètre de la fonction "contenante".

mgsvinc a écrit:
Je ne comprend pas dans la fonction "clone_and_move_components" pourquoi tu met un "s" à la fin de components" alors qu'il n'y en a pas clone_component et move_component.

Le "s" indique la pluralité. clone_and_move_components agit sur un ou plusieurs composants listés dans un tableau. Tandis que clone_component et move_component agissent sur un composant à la fois.

mgsvinc a écrit:
Pourquoi met-tu "components = all" ?

components ='all' définit que si tu ne fournis pas le premier paramètre, alors il prend la valeur 'all'.
C'est une valeur par défaut. Tu peux forcer cette valeur en passant un tableau de Composants.

mgsvinc a écrit:
cela ne va t'il pas entrainer le déplacement de tous les composants au même endroit ?

Je ne pense pas car les transformations sont relatives. Vois le corps de la fonction clone_component.

mgsvinc a écrit:
[...] je ne comprend pas la fin du code, ni le if, ,ni "components.each do |component|"

if est une condition et each une itération. Je t'invite à lire ce cours-ci et ce cours-là pour comprendre.

mgsvinc a écrit:
Enfin je voudrais te demander si quand j'appelle l'une de ces fonctions je dois changer "component" par "entities[0]", par exemple "def move_component(entities[0], x_distance)" pour exécuter la fonction sur le 1er composant

Non. Il faut passer le paramètre lors de l'appel de la fonction. Modifier la définition n'est pas bon.

Code:


move_component(entities[0]) # bon, la valeur de la distance par défaut (1m) entre en jeu
move_component(entities[0], 3.m) # bon, la valeur de la distance est spécifiée par toi

def move_component(entities[0], x_distance) # pas bon


mgsvinc a écrit:Bonjour Samuel, je vais me permettre de te tutoyer, j’espère que ça ne te dérange pas.

de toute façon ici , c'est le principe , on tutoie d'entrée de jeu
c'est le contraire de la vrai vie sur les forums , quand tu vouvoies , c'est presque un manque de respect .......  je déconne mais c'est pas tout à fait faux

en tout cas je suis le fil de discussion avec grand intérêt et je vous (je parle à tous les deux ) remercie pour toutes ces infos super intéressantes

Samuel Tallet-Sabathé a écrit:Le "s" indique la pluralité. clone_and_move_components agit sur un ou plusieurs composants listés dans un tableau. Tandis que clone_component et move_component agissent sur un composant à la fois.

Samuel Tallet-Sabathé a écrit:if est une condition et each une itération. Je t'invite à lire ce cours-ci et ce cours-là pour comprendre.

Désolé, je me suis mal exprimé, quand je dis que je ne comprend pas le "s" "if" et "each", c'est que je ne comprends ce qu'il vienne faire dans le code, je connais leurs définitions d'une manière général mais pas leur utilité dans ce cas précis.
Par exemple quand je dis que ne comprends pas le "if", c'est que je ne comprends pas pourquoi tu écrit "if components == 'all' " (et pas juste le "if")

Merci pour le reste, c'est d'une grande utilité. Je vais bosser sur ça ce weekend et je posterais pour te montrer où mon code en est.

tenrev a écrit:c'est le contraire de la vrai vie sur les forums , quand tu vouvoies , c'est presque un manque de respect ....... mdr5  je déconne mais c'est pas tout à fait faux mdr1

on va éviter de froisser qui que ce soit alors

mgsvinc a écrit:
[...] je ne comprends pas pourquoi tu écrit "if components == 'all' " [...]

Code:


# ...
# @param [Array<Sketchup::ComponentInstance>, String] components Composants. Par défaut : tous.
# ...
# def clone_and_move_components(components = 'all', x_distance = 1.m)
# ...


'all' est la valeur par défaut du paramètre components. Cf. la définition ci-dessus.
if components == 'all' signifie : si tous les composants du modèle sont ciblés.
Dans le cas contraire, seuls les composants passés en paramètre sont ciblés.

Si tu préfères, tu peux supprimer les valeurs par défaut. Cela donnerait ce code :

Code:


# ...

# Clone et déplace plusieurs composants SketchUp à une distance X.
#
# @param [Array<Sketchup::ComponentInstance>] components Composants.
# @param [Length] x_distance Distance dans l'axe X.
#
# @return [void]
def clone_and_move_components(components, x_distance)

  components.each do |component|

    move_component(clone_component(component), x_distance)

  end

end


Ah ok, j'avais pas compris qu'en passant les composants en paramètres ça n'affecterait que ces derniers.

Voici où en est mon code :

Code:

def visu

model = Sketchup.active_model
entities = model.entities
selection = model.selection
definitions1 = model.definitions[0] #définition du 1er composant
definitions2 = model.definitions[1] #définition du 2éme composant
view = model.active_view

# excel call

require 'win32ole'

xl = WIN32OLE.new('Excel.Application')
xl.visible=1

wb = xl.Workbooks.Open('C:\Users\vince\Desktop\fichiersrb\dbvisuclient')

worksheet = wb.Worksheets('Feuil1')

l = worksheet.Range('a1').Value

# Méthode.cm

l = l.to_i.cm

# Clone un composant SketchUp.
#
# @param [Sketchup::ComponentInstance] component Composant original.
#
# @return [Sketchup::ComponentInstance] Un composant-clone.
# La transformation du composant-clone est relative à l'original.

def clone_component(component)

 return Sketchup.active_model.entities.add_instance(component.definition,component.transformation)

end

# Déplace un composant SketchUp à une distance X.
#
# @param [Sketchup::ComponentInstance] component Composant.
# @param [Length] x_distance Distance dans l'axe X.
#
# @return [void]

def move_component(component, x_distance)

transformation_values = Geom::Transformation.new.to_a

transformation_values[-4] = x_distance
transformation_values[-3] = 0
Sketchup.active_model.entities.transform_entities(Geom::Transformation.new(transformation_values),component)

end

# Clone et déplace plusieurs composants SketchUp à une distance X.
#
# @param [Array<Sketchup::ComponentInstance>] components Composants. Par défaut : tous.
# @param [Length] x_distance Distance dans l'axe X. Par défaut : 1m.
#
# @return [void]
def clone_and_move_components(components = 'all', x_distance = 1.m)

if components == 'all'

components = Sketchup.active_model.entities.grep(Sketchup::ComponentInstance)

end

components.each do |component|

move_component(clone_component(entities[0]), l)

end

end

end

Cependant je n'arrive toujours pas à le faire fonctionner. Je n'ai pas de messages d'erreurs et je ne sais pas vraiment d'où le problème peut venir.
Peut-etre quand j'appelle la fonction "move_component(clone_component(entities[0]), l)" je ne doit pas appeler mon composant avec "entities[0]"
Pourrait tu y jeter un coup d’œil et me dire ce que tu en penses ?

Il ne faut surtout pas imbriquer une définition de fonction dans une autre définition de fonction.

Code:

def visu ... def clone_component ... end ... end # pas bon

Tu devrais inclure les définitions des fonctions et des variables dans une classe ou un module...

Samuel Tallet-Sabathé a écrit:Il ne faut surtout pas imbriquer une définition de fonction dans une autre définition de fonction.

Code:

def visu ... def clone_component ... end ... end # pas bon

Tu devrais inclure les définitions des fonctions et des variables dans une classe ou un module...

merci interessant

mgsvinc,

J'ai donné une forme de classe à ton idée de script. J'ai pris soin de commenter le code en français.

Code:


# Import des dépendances.
require 'win32ole'

# TODO: Décrire les tenants et aboutissants de ce script.
class ExcelComponents

  # Construit un objet de type `ExcelComponents`.
  #
  # @param [String] excel_file_path Chemin vers un fichier Excel.
  #
  # @example
  #
  #  excel_components = ExcelComponents.new(
  #    'C:\\Users\\vince\\Desktop\\fichiersrb\\dbvisuclient'
  #  )
  #
  #  excel_components.move_and_clone(2)
  def initialize(excel_file_path)

    raise ArgumentError, '`excel_file_path` doit être une chaîne de caractères'\
      unless excel_file_path.is_a?(String)

    @excel_file_path = excel_file_path

    begin

      @length = length_from_excel_file

    rescue StandardError => _error

      UI.messagebox("Impossible d'obtenir la longueur depuis le fichier Excel.")

      # Attention : En cas d'erreur, une longueur par défaut est assignée (1 m).
      @length = 1.m

    end

  end

  # Obtient une longueur en centimètres depuis le fichier Excel.
  #
  # @return [Length] Une longueur convertie de cm vers inch.
  def length_from_excel_file

    # Attention : Excel doit être installé !
    excel = WIN32OLE.new('Excel.Application')

    excel.visible = true

    workbook = excel.Workbooks.Open(@excel_file_path)

    # TODO: Vérifier si l'indexation commence à partir de 0 ou 1.
    worksheet = workbook.Worksheets(1)

    length = worksheet.Range('A1').value

    excel.Quit

    length.to_i.cm

  end

  # Clone un composant SketchUp.
  #
  # @note Cette fonction est réutilisable dans d'autres scripts.
  #
  # @param [Sketchup::ComponentInstance] component Composant original.
  #
  # @return [Sketchup::ComponentInstance] Un composant-clone.
  def clone_component(component)

    Sketchup.active_model.entities.add_instance(

      component.definition,

      # La transformation du composant-clone est relative à l'original.
      component.transformation

    )

  end

  # Déplace un composant SketchUp à une distance X.
  #
  # @note Cette fonction est réutilisable dans d'autres scripts.
  #
  # @param [Sketchup::ComponentInstance] component Composant.
  # @param [Length] x_distance Distance dans l'axe X.
  #
  # @return [Boolean] `true` en cas de succès, `false` autrement.
  def move_component(component, x_distance)

    transformation_values = Geom::Transformation.new.to_a

    transformation_values[-4] = x_distance
    transformation_values[-3] = 0

    Sketchup.active_model.entities.transform_entities(

      Geom::Transformation.new(transformation_values),
      component

    )

  end

  # Déplace et clone les composants du modèle SketchUp actif
  # en tenant compte de la longueur lue dans le fichier Excel.
  #
  # @param [Numeric] how_many Combien de fois ? Par défaut : 1.
  #
  # @return [Boolean] `true` en cas de succès, sinon `false`.
  def move_and_clone(how_many = 1)

    Sketchup.active_model.start_operation('Déplacer et cloner', true)

    how_many.times do

      # Récupère tous les composants du modèle actif.
      components = Sketchup.active_model.entities.grep(
        Sketchup::ComponentInstance
      )

      components.each do |component|
        move_component(clone_component(component), @length)
      end

    end

    Sketchup.active_model.commit_operation
    # Note : Cette opération est annulable.

  end

end


Excel n'est pas installé sur mon PC. Peux-tu me dire si la lecture du fichier Excel fonctionne chez toi ?

Concernant l'opération "Déplacer et cloner", elle fonctionne bien chez moi. La preuve en image :