[ SKETCHUP LIVE COMPONENT ] Importer une liste de points dans son graphe via un input texte

Code:


# Extract outerloop points position of a face in a selected Component Instance to a string
# x,y,z values are roundes to 1 decimal
# string use different separator for points and values

# How to use
# 1- Draw à face
# 2- Create a Component of the face
# 3- Define the origin of the component it will be the equal at the origin of the graphe
# 4- paste this code in the Ruby Console
# 5- Copy the string result
# 6- Past it in the Live component dialog, in the string input

def stringOuterloop(separatorPoint=";",separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  face = inst.definition.entities.grep(Sketchup::Face)[0]
  vertices = face.outer_loop.vertices
  points = vertices.map{|v| v.position}
  points_mm = points.map{|p| "#{p.x.to_mm.round(1)}#{separatorValue}#{p.y.to_mm.round(1)}#{separatorValue}#{p.z.to_mm.round(1)}"}
  points_string = points_mm.join("#{separatorPoint}")
  return points_string
  
end

def stringCurve(separatorPoint=";",separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  curve = inst.definition.entities.grep(Sketchup::Edge)[0].curve
  vertices = curve.vertices
  points = vertices.map{|v| v.position}
  points_mm = points.map{|p| "#{p.x.to_mm.round(1)}#{separatorValue}#{p.y.to_mm.round(1)}#{separatorValue}#{p.z.to_mm.round(1)}"}
  points_string = points_mm.join("#{separatorPoint}")
  return points_string
  
end

string = stringCurve()
puts string


Code:

string = stringOuterloop()
puts string

Code:

string = stringCurve()
puts string

Code:

def stringCurve(curves, separatorPoint=";",separatorValue=",")
  size = curves.size
  UI.messagebox("#{ size } curves are found! Only the first will be used." , MB_OK) unless size == 1
  curve = curves[0]
  vertices = curve.vertices
  points = vertices.map{|v| v.position}
  points_mm = points.map{|p| "#{p.x.to_mm.round(1)}#{separatorValue}#{p.y.to_mm.round(1)}#{separatorValue}#{p.z.to_mm.round(1)}"}
  points_string = points_mm.join("#{separatorPoint}")
  return points_string
 
end

def stringOuterloop(faces, separatorPoint=";",separatorValue=",")
  size = faces.size
  UI.messagebox("#{ size } faces are found! Only the first will be used." , MB_OK) unless size == 1
  face = faces[0]
  vertices = face.outer_loop.vertices
  points = vertices.map{|v| v.position}
  points_mm = points.map{|p| "#{p.x.to_mm.round(1)}#{separatorValue}#{p.y.to_mm.round(1)}#{separatorValue}#{p.z.to_mm.round(1)}"}
  points_string = points_mm.join("#{separatorPoint}")
  return points_string
 
end




def getpoints()
  model = Sketchup.active_model
  sel = model.selection
  inst = sel.grep(Sketchup::ComponentInstance)[0]
 
  #test si la selection est vide
  error = 'No component selected'
  UI.messagebox(error , MB_OK) unless inst
  return error unless inst
 
  list = []

  ents = inst.definition.entities
  faces = ents.grep(Sketchup::Face)
  list.append("Outerloop first face in component") if faces.size > 0
 
  edges = ents.grep(Sketchup::Edge)
  curves = []
 
  edges.each do |e|
    curve = e.curve
    curves << curve if curve
  end
  curves = curves.uniq
  puts curves
  list.append("Curve in component") if curves.size > 0
 
  if list == []
    error = "No curve or face in the selected component"
    UI.messagebox(error , MB_OK)
    return error
  end
 
  prompts = ["What type of element do you want to extract the points from?"]
  defaults = [list[0]]
  list_c = [list.join("|")]
  input = UI.inputbox(prompts, defaults, list_c, "Select the source of point")
  puts input
 
  case input[0]
  when "Outerloop first face in component"
    string = stringOuterloop(faces)
  when "Curve in component"
    string = stringCurve(curves)
  end
 
  #string = "No points" if string ==""
  UI.messagebox(string , MB_OK)
  return string
end
points = getpoints()
puts points

Code:

##########################################
#       STRINGOUTERLOOP
#
#  Auteur Joubert Simon
#  version 0.2
#  2024/09/24
##########################################


#FR
# Extraction des coordonnées des points de contour d'une face ou d'une courbe contenue dans un composant et retourne le résultat sous forme de texte
# x,y,z les valeurs sont arrondies à une décimale
# la chaine de texte utilise le point-virgule pour séparer les point, et la virgule pour séparer les coordonnées.

#Comment l'utiliser
#1- Tracer une face ou une courbe (Une seule)
#2- Souder toutes les arrêtes de la courbe si vous travailler sur une courbe angle droit inclus
#3- créez un composant de la courbe ou de la face, définissez l'axe du composant il correspondra aux axes du graph Live Component
#4- Sélectionnez le composant
#5- utiliser la fonction suivante :
  # pour les points d'une face  -> stringOuterloop()
  # pour les points d'une courbe -> stringCurve()
#6- écrire la fonction désirée dans la console après avoir exécuter une fois tout ce code pour que les fonctions soient chargées
#7- copier le résultat sans les guillemets
#8- coller le résultat dans le champ de saisie du live component.
#9- paramétrer le reste des options de votre live component.

#10- Sélectionnez le live component et le composant
#11- Ecrire la fonction suivante dans la console -> applyTransform()
#12- le live component à remplacer le composant et le composant est masqué

# GB
# Extract outerloop points position of a face in a selected Component Instance to a string
# x,y,z values are roundes to 1 decimal
# string use different separator for points and values

# How to use
# 1- Draw à face
# 2- Create a Component of the face
# 3- Define the origin of the component it will be the equal at the origin of the graphe
# 4- paste this code in the Ruby Console
# 5- Enter the desire result commande in the Ruby console

  # Select the component before
    # For Outerloop points => stringOuterloop()
    # For Curve points => stringCurve()
    
# 6- Copy the string result
# 7- Past it in the Live component dialog, in the string input

#8- Parameter the live component

#9- Replace the component by the live
    
  # Select the component and the live component before
    # For Translation transformation => stringTransformTranslation()
    # For Rotation transformation => stringTransformRotation()
    # For Scale transformation => stringTransformScale()
    # For All transformations => stringTransform()
    
#################################################################

#You can use this graph to extract to convert the string into curve or face
# https://creator.trimble.com/graph?asset=whp:8013e391-bbc2-4053-acae-afa92c476f23



def stringOuterloop(separatorPoint=";",separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  face = inst.definition.entities.grep(Sketchup::Face)[0]
  points = face.outer_loop.vertices.map{|v|v.position}
  points_mm = points.map do |pt|
    pt.to_a.map{|val|val.to_mm.round(1)}.join(separatorValue)
  end
  points_string = points_mm.join(separatorPoint)
  return points_string
  
end

def stringCurve(separatorPoint=";",separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  curve = inst.definition.entities.grep(Sketchup::Edge)[0].curve
  points = curve.vertices.map{|v|v.position}
  points_mm = points.map do |pt|
    pt.to_a.map{|val|val.to_mm.round(1)}.join(separatorValue)
  end
  points_string = points_mm.join(separatorPoint)
  return points_string
  
end

def stringTransformTranslation(separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  tr = inst.transformation
  origin = tr.origin
  origin_mm = origin.to_a.map{|val|val.to_mm.round(1)}.join(separatorValue)
  return origin_mm
  
end

def stringTransformRotation(separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  tr = inst.transformation
  rotx = tr.rotx
  roty = tr.roty
  rotz= tr.rotz
  rotation = "#{rotx}#{separatorValue}#{roty}#{separatorValue}#{rotz}"
  return rotation
  
end

def stringTransformScale(separatorValue=",")
  
  inst = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)[0]
  tr = inst.transformation
  xscale = tr.xscale
  yscale = tr.yscale
  zscale = tr.zscale
  scale = "#{xscale}#{separatorValue}#{yscale}#{separatorValue}#{zscale}"
  return scale
  
end

def stringTransform(separatorPoint=";")
  translation = stringTransformTranslation()
  rotation = stringTransformRotation()
  scale = stringTransformScale()
  transformation = "#{translation}#{separatorPoint}#{rotation}#{separatorPoint}#{scale}"
  return transformation
end


def applyTransform()
  insts = Sketchup.active_model.selection.grep(Sketchup::ComponentInstance)
  lc = insts.filter{|inst| inst.definition.live_component?}[0]
  dc = insts.filter{|inst| not inst.definition.live_component?}[0]
  tr = lc.transformation.invert!
  tr2 = dc.transformation
  lc.transform! tr
  lc.transform! tr2
  dc.hidden = true
end




simjoubert a écrit:Pour tester en ligne il vous faut un compte Trimble créator !
Test en ligne

simjoubert a écrit:Il subsiste un petit bug lors de courbe rentrante
Il faut que je peaufine un peu avec un test de la tengente