[ SKETCHUP plugins ] Flightpath2

simjoubert a écrit:Jack l'a mal employé dans sa vidéo hier
Le début, c'est bon ! Fenêtre éditeur je colle le code puis exécuter
après il faut basculer en mode console et coller la commande qui appelle la fonction.

simjoubert a écrit:Patience jeune Padawan je suis dessus !

Code:

curve_to_enscape_path

Code:

    # CURVE TO ENSCAPE PATH VIDEO

    # Cette fonction permet d'extraire la position de chaque point de la courbe et la position de la cible.
    # Elle crée un fichier xml importable dans Enscape dans le module Vidéo.

    # 4 Modes de trajectoire :
          # Parcours Marche avant: La caméra est placée sur chaque points de la courbe et vise le point suivant.
          # Parcours Marche arrière : La caméra est placée sur chaque points de la courbe et vise le point précédent.
          # Traveling : La caméra vise la mire, en chaque points de la courbe.
          # Panoramique : La caméra est fixée sur la mire et vise chaque points de la courbe.
        
    # Options de délai entre 2 points de vue :
          # Délai départ, milieu et fin de trajectoire.
          # Calcul de l'incrément pour chaque point de vue, pour simuler une accéleration ou un ralenti.

    # Options heure des points de vue :
          # Heure départ, milieu et fin de trajectoire.
          # Calcul de l'incrément pour chaque point de vue.

    # Option : Transitions douces
    # Option : Caméra instable

    # Usage : Sélectionnez une courbe et un composant cible (c'est l'origine du composant qui sera la cible dans un traveling et la position de la caméra pour un panoramique)
    # Source JDD (Forum Biblio3d)
    # Author Simon Joubert
    # Version 1.0
    # Date 12/03/2022



    def curve_to_enscape_path()

        model = Sketchup.active_model
        sel = model.selection
        # On récupère la position de la cible.
        inst = sel.grep(Sketchup::ComponentInstance)[0]
        unless inst == nil
         cible = inst.transformation.origin
         mode = "Parcours marche avant|Parcours marche arrière|Traveling|Panoramique"
        else
         mode = "Parcours marche avant|Parcours marche arrière"
        end
         # On récupère la courbe
        curve = sel.grep(Sketchup::Edge)[0].curve
        edges_num = curve.edges.length
        ferme = (curve.edges[0].start.position == curve.edges[-1].end.position ? 0:1)
        cam_num = edges_num + ferme
        cam_middle = (cam_num/2).to_i
        
  
        if model.path == "" # Le modèle n'est pas enregistré.
         message  = UI.messagebox("Veuillez enregister votre modèle et recommencer.\nOpération annulée", MB_OK)
         return
        
        elsif edges_num < 1 # Il n'y a aucune scène.
         message  = UI.messagebox("La sélection ne comporte aucune courbe.\nOpération annulée", MB_OK)
         return
        
        else
  
         #Boite de dialogue
         prompts = ["Horodatage increment début","Horodatage increment milieu","Horodatage increment fin", "Heure début", "Heure milieu", "Heure fin", "Angle champ de vision en degrés ?", "Caméra instable ?", "Transition en douceur ?","Mode trajectoire"]
         defaults = [2.0,5.0,2.0,8.0,14.0,22.0, 60, "Non","Oui","Parcours marche avant"]
         list = ["","","","","","","","Oui|Non","Oui|Non",mode]
         input = UI.inputbox(prompts, defaults, list, "Trajectoire vidéo entre les scènes")
        
         if input == false # L'utilisatateur a annulé.
           return
          
         else
  
           # Paramètre chemin enregistrement fichier.
           mpath = model.path.gsub(".skp","\")
           url = File.join(mpath, "Scenes_Camera_trajectoire.xml")
        
           # Paramètres Convertion
           pi = Math::PI
           convertion_inch_meter = 0.0254
  
           # Paramètres saisies par l'utilisateur.
           timestamp_start = input[0].to_f
           timestamp_start_increment = (input[1].to_f-input[0].to_f)/cam_middle
           timestamp_middle = input[1].to_f
           timestamp_end = input[2].to_f
           timestamp_end_increment = (input[2].to_f-input[1].to_f)/(cam_num-cam_middle)
          
           hour_start = input[3].to_f
           hour_start_increment = (input[4].to_f-input[3].to_f)/cam_middle
           hour_middle = input[4].to_f
           hour_end = input[5].to_f
           hour_end_increment = (input[5].to_f-input[4].to_f)/(cam_num-cam_middle)
          
           fieldOfViewRad = (input[6]*(2*pi)/360).round(6)
           shakyCam =(input[7]=="Oui" ?1:0)
           easingInOut =(input[8]=="Oui" ?1:0)
           mode = case input[9]
             when "Parcours marche avant"
             0
             when "Parcours marche arrière"
             1
             when "Traveling"
             2
             else
             3
           end
          
           #durationSeconds = timestampSeconds * cam_num
           timestamp = 0
        
        
        
           # initialisation de la boucle.
           i = 0 #compteur
           timestamp = 0
           doc =""
  
           # boucle sur chaque scènes
           while i  <edges_num
             # Caméra et vecteur selon le mode.
             case input[9]
               when "Parcours marche avant"
                 cam = curve.edges[i].start.position
                 edge_end = curve.edges[i].end.position
                 vector = cam.vector_to(edge_end)
               when "Parcours marche arrière"
                 cam = curve.edges[i].start.position
                 edge_end = curve.edges[i].end.position
                 vector = edge_end.vector_to(cam)
               when "Traveling"
                 cam = curve.edges[i].start.position
                 vector = cam.vector_to(cible)
               else
                 cam = cible
                 edge_start = curve.edges[i].start.position
                 vector = cible.vector_to (edge_start)
               end
            
             lookat_x = (vector.x * convertion_inch_meter).round(6)
             lookat_y = (vector.z * convertion_inch_meter).round(6) # Permutation des axes Z et Y
             lookat_z = -(vector.y * convertion_inch_meter).round(6) # Permutation des axes Z et Y
          
             eye = cam # position de la caméra
             position_x = (eye.x * convertion_inch_meter).round(6)
             position_y = (eye.z * convertion_inch_meter).round(6) # Permutation des axes Z et Y
             position_z = -(eye.y * convertion_inch_meter).round(6) # Permutation des axes Z et Y
             if i < cam_middle
               hour = hour_start + ( i* hour_start_increment)
               timestamp = timestamp + (timestamp_start+ ( i * timestamp_start_increment))
             elsif i == cam_middle
               hour = hour_middle
               timestamp = timestamp + timestamp_middle
             else
               hour = hour_middle + ( (i-cam_middle)* hour_end_increment)
               timestamp = timestamp + (timestamp_middle + ( (i-cam_middle) * timestamp_end_increment))
            
             end
          
             # On ajoute à la chaîne xml les paramètres de keyframe propre à la scène.
             doc = doc + <<-XML
               <Keyframe order="#{i}" hour="#{hour}" fieldOfViewRad="#{fieldOfViewRad}" timestampSeconds="#{timestamp}">
                 <Position x="#{position_x}" y="#{position_y}" z="#{position_z}" />
                 <LookAt x="#{lookat_x}" y="#{lookat_y}" z="#{lookat_z}" />
               </Keyframe>
             XML
        
             i +=1 # On incrémente le compteur
           end # Fin de la boucle
          
           if ferme == 1 # Si la courbe, n'est pas une boucle, on gère le dernier point.
             # Caméra et vecteur selon le mode
             case input[9]
               when "Parcours marche avant"
                 cam = curve.edges[-1].end.position
                 edge_start = curve.edges[i].start.position
                 vector = edge_start.vector_to(cam)
               when "Parcours marche arrière"
                 cam = curve.edges[-1].end.position
                 edge_start = curve.edges[-1].start.position
                 vector = cam.vector_to(edge_start)
               when "Traveling"
                 cam = curve.edges[-1].end.position
                 vector = cam.vector_to(cible)
               else
                 cam = cible
                 edge_end = curve.edges[-1].end.position
                 vector = cible.vector_to (edge_end)
               end
             # cam = curve.edges[-1].end.position # On récupère la caméra de la scène n° i
             # vector = cam.vector_to(center)
             lookat_x = (vector.x * convertion_inch_meter).round(6)
             lookat_y = (vector.z * convertion_inch_meter).round(6) # Permutation des axes Z et Y
             lookat_z = -(vector.y * convertion_inch_meter).round(6) # Permutation des axes Z et Y
          
             eye = cam # position de la caméra
             position_x = (eye.x * convertion_inch_meter).round(6)
             position_y = (eye.z * convertion_inch_meter).round(6) # Permutation des axes Z et Y
             position_z = -(eye.y * convertion_inch_meter).round(6) # Permutation des axes Z et Y
            
             hour = hour_end
             timestamp = timestamp + timestamp_end
          
             # On ajoute à la chaîne xml les paramètres de keyframe propre à la scène.
             doc = doc + <<-XML
               <Keyframe order="#{i}" hour="#{hour}" fieldOfViewRad="#{fieldOfViewRad}" timestampSeconds="#{timestamp}">
                 <Position x="#{position_x}" y="#{position_y}" z="#{position_z}" />
                 <LookAt x="#{lookat_x}" y="#{lookat_y}" z="#{lookat_z}" />
               </Keyframe>
             XML
           end
          
           # Entête du fichier xml
           doc_entete = <<-XML
           <?xml version="1.0" ?>
           <VideoPath version="1" durationSeconds="#{timestamp}" easingInOut="#{easingInOut}" shakyCam="#{shakyCam}">
             <Keyframes count="#{cam_num}">
           XML
        
           # On ajoute au xml la fermeture des balises d'entête.
           doc = doc_entete + doc + <<-XML
             </Keyframes>
           </VideoPath>
           XML
        
  
  
  
           # On teste l'existance du dossier portant le même nom que le fichier du modèle.
           if File.directory?(mpath) == false
             # on crée le répertoire avec le nom du modèle s'il n'existe pas.
             FileUtils.mkdir mpath
           end
        
           # Ecriture du fichier
         File.open(url, 'w') { |file| file.write(doc) }
        
           # Message de succès
           message  = UI.messagebox("Le fichier :\n#{url}\na été généré avec succès !", MB_OK)
          
         end
        end
       end
  

JDD a écrit:je me suis permis d'apporter quelques mineures corrections (coquilles, orthographiques ou grammaticales et de ponctuations) à ton code.

Ci-après la version corrigé

simjoubert a écrit:J'ai un peu bossé cette nuit !
Encore quelques tests pour parer les premiers bugs !
Il est multilingue Anglais Français.

JDD a écrit:Il semble que la trajectoire ne soit pas masquée dans les scènes dans ton code comme réalisé par flighpath2 .
As-tu pris ce détail en compte ?

JDD a écrit:Mais perso, je préfère utiliser la version première de ton script, car ta seconde version ne génère pas les scènes dans SU

Je préfère en effet de créer des scènes dans sketchUp en premier lieu, et pouvoir visionner dans sketchUp au préalable au lancement du script ce que rend approximativement l'animation dans SketchUp et si besoin, ajuster certaines de mes scènes en conséquences et enfin lancer le script pour récupérer le xml correspondant aux scènes dans SU.