Voir la version complète : Récupérer la hauteur d'un objet
Re Salut, :odile:
je veux récupérer la taille d'un objet.
J'utilise donc la fonction GetScale(), mais celle ci renvoi le facteur d'echelle. Comment avoir la valeur numérique?
Merci :oops:
Edit:
j'ai aussi essayé avec le container PRIM_POLY_HEIGHT mais ca me renvoi "nil" :coup:
Pour un objet polygone il faut la calculer en faisant la comparaison de tous les points de ton polygone pour obtenir les valeurs minimales et maximales x y z, ainsi tu obtient un vecteur max et un vecteur min
le vecteur taille = vecteur max - vecteur min .
Si non pour une primitive tu accède a ses dimensions par son container et n’oubli pas de multiplier par échelle si elle est différente de 1.
Ouah :o
Y a pas plus simple? Je saurais jamais faire un truc pareil :oops:
Vu que c'est un coffee dans un xpresso je vais essayé de passer par l'xpresso.
Merci quand meme Majoul
Ouah :o
Y a pas plus simple? Je saurais jamais faire un truc pareil :oops:
Tout dépend de ce que tu désire faire.
Ben juste avoir la valeur Y d'un objet.
Sachant qu'il y a des objets poly et des objets extrusions.
En fait je veux positionner automatiquement un objet au sommet d'un autre.
Majoul à tout bien résumé:
- Soit ton objet est polygonal et tu évalues sa "bounding-box" en calculant la distance entre les points extrêmes de l'objet, pour chaque axe.
-Soit ton objet est paramétrable (primitive, spline dans extrusion...) et dans ce cas là il faut prélever les dimensions dans les containers puis calculer les dimensions totales de l'objet.
En Xpresso tu as le noeud "Boite" qui évalue la bounding-box d'un objet, mais uniquement de type polygonal.
ok merci je vais travailler là dessus :poucehaut:
Bon voila ce que j'ai bidouillé. :?
En fait je scan tous les points de l'objet et je garde la valeur la plus haute et la plus basse. Par déduction on obtien la hauteur de l'objet.
//hauteur du pilier
// récupération du tableau des points du pilier et du nombre total de points
var pt_pilier=pilier->GetPoints();
var tot_pt_pilier=pilier->GetPointCount();
//déclaration des variables pour le point le plus haut et le plus bas
//par defaut on lui donne la valeur du premier point
var pilier_Y_max=pt_pilier[0].y;
var pilier_Y_min=pt_pilier[0].y;
//boucle scannant chaque point et cérifiant sa valeur
//on récupère la position du point le plus haut et le plus bas
var i;
for(i=0;i<tot_pt_pilier;i++)
{ if(pilier_Y_max<pt_pilier[i].y)
{ pilier_Y_max=pt_pilier[i].y;
}
if(pilier_Y_min>pt_pilier[i].y)
{ pilier_Y_min=pt_pilier[i].y;
}
}
//calcul de la différence pour obtenir la hauteur du pilier
var haut_pilier=pilier_Y_max-pilier_Y_min;
Le seul défaut que je pourrais y voir c'est si tous les points sont a une valeur negative en Y. :|
Mais dans ce que je veux faire ca ne devrait pas etre le cas.
Qu'en pensez vouz :roll:
C'est exactement le bon principe il te suffit juste à la fin d'ajouter la fonction abs() (valeur absolue) pour que le calcul de la différence donne toujours une valeur positive (distance entre ces 2 points):
var haut_pilier=abs(pilier_Y_max-pilier_Y_min);
Merci de cette précision. :poucehaut:
Pas besoin de la valeur absolue, il s’est tromper sur le max et min, c’est inversé
for(i=0;i<tot_pt_pilier;i++)
{ if(pilier_Y_max>pt_pilier[i].y)
{ pilier_Y_max=pt_pilier[i].y;
}
if(pilier_Y_min<pt_pilier[i].y)
{ pilier_Y_min=pt_pilier[i].y;
}
}
J'avais juste survolé le bout de code et je n'ai même pas fait gaffe à ça, heureusement on a un Majoul qui veille au grain pour me récupérer ! :wink:
Pour la valeur absolue, c'est surtout une sécurité, pour éviter que la suite du code ne se mette en vrac si le calcul n'est pas bon avant et qu'on en ressort avec une distance négative pouvant planter la suite du code qui baserait ses calculs sur une distance forcément positive... :roll:
Ben quand je l'avais fait comme ca au debut et ca m'inversé le résultat.
Le max avait la plus petite valeur et le min la plus grande :o
Alors j'ai inversé.
Mais y doit y avoir une coui... quelque part car c'est vrai que c'est pas logique. Je pense que y a un rapport avec la valeur attribuer aux variables au départ.
Je potasse ca. :mrgreen:
En général ce genre de calcul j’en fait une fonction qui me renvoi la taille de l’enveloppe, et chaque fois que j’en ais besoin je fais un copier coller dans le script et je l’utilise comme une simple fonction au besoin. Cela évite les erreurs et fait gagner du temps.
Padawa je te conseille de prendre cette méthode cela t’évite a faire la même chose à chaque nouvelle expression. Pour la valeur négative je l’ai pisté parce que je suis passé par ce genre d’erreurs.
En fait je pense avoir trouvé.
Il suffit de comparer les points entre eux et non avec les variables.
Ca donne ca
for(i=1;i<tot_pt_pilier;i++)
{ if(pt_pilier[i].y>pt_pilier[i-1].y)
{ pilier_Y_max=pt_pilier[i].y;
}
if(pt_pilier[i].y<pt_pilier[i-1].y)
{ pilier_Y_min=pt_pilier[i].y;
}
}
Et la ca marche :bounce:
Pour ce qui est du calcul de l'enveloppe Majoul, je pense que tu doit avoir raison, mais j'en suis totalement incapable. Je suppose qu'il faut toucher au matrice et autre fonction mathématique et la dedans j'y pige rien.
Soyons clair, tout ce qui va toucher a l'implémentation mathématique c'est pas pour moi.
Je suis un "scripteur" et on voit que c'est ce qui manque a C4D :wink:
Merci qquand meme :odile:
Pour ce qui est du calcul de l'enveloppe Majoul, je pense que tu doit avoir raison, mais j'en suis totalement incapable. Je suppose qu'il faut toucher au matrice et autre fonction mathématique et la dedans j'y pige rien.
ce n'est ni plus ni moins de ce que tu vient de faire, voici un exemple:
// si ta fonction est à la suite du main() tu la déclare ici
donner_dim_boite(obj) ;
//************************************************** ********
// main
//************************************************** ********
main(doc, op)
{
// on verifi avant que l'objet est un polygon ou une spline
if(instanceof(op, PolygonObject) || instanceof(op, SplineObject))
{
// ici tu l'utilise comme une simple fonction
var dim = donner_dim_boite(op) ;
// pour la hauteur
var hauteur = dim.y ;
println(dim.y) ;
}
}
//************************************************** ********
// La Fonction
//************************************************** ********
donner_dim_boite(obj)
{
var nb = obj->GetPointCount() ; if(nb<2) return vector(0.0) ;
var arr = obj->GetPoints() ;
var i , max = arr[0] , min = arr[0] ;
for (i=1 ; i<nb ; i++)
{
if(arr[i].x>max.x) max.x = arr[i].x ;
if(arr[i].y>max.y) max.y = arr[i].y ;
if(arr[i].z>max.z) max.z = arr[i].z ;
if(arr[i].x<min.x) min.x = arr[i].x ;
if(arr[i].y<min.y) min.y = arr[i].y ;
if(arr[i].z<min.z) min.z = arr[i].z ;
}
return max-min ;
}
Tiens c'est marrant Majoul, tu mets la boucle principale main(...) en début de code et tes routines après ?...
En générale, comme en C++, par convention la boucle principale est à la fin du listing, et les fonctions avant. Mais ça ne change rien au fonctionnement du code bien entendu ! :wink:
C'est juste une petite remarque bête, en passant, rien de plus... :oops: :wink:
Tu as raison, mais c’est surtout par commodité que je le fais
Ah ben mince alors :shock:
Je pensais pas etre aussi prés de la solution.
Merci, car j'allais me taper 2 fonctions de plus pour x et z.
Et la je vois, et c'est logique, que l'on cré automatiquement des vecteurs et donc qu'on peut les soustraires.
C'est vrai que c'est mieu aussi de mettre ca dans une fonction.
Merci :poucehaut:
En rajoutant 3 ligne de code à cette fonction tu peut faire l'équivalent du plugin AXIS CENTER :wink:
Powered by vBulletin® Version 4.2.1 Copyright © 2024 vBulletin Solutions, Inc. Tous droits réservés