Taille de l'image dans les données utilisateur …

[g5cedric]

Salut la french,
je cherche un moyen pour me facilité la vie avec les TiledCam…

je voudrais pouvoir contrôler les réglages de rendu directement dans les "Données Utilisateur".
j'ai chercher et il me semble que c'est impossible avec Xpresso…

On m'a donnée l'idée de passer par un ( ou des ) scripts COFFEE et PYTHON mais pour moi c'est vraiment une autre langue…

déjas, est-ce possible de contrôler la hauteur et largeur de l'image final grace à ça ?
je cherche modifier la taille de l'image final ( qui sera le résultat d'un calcule )
et le nombre d'images de ma scene ( de 0 à 9 ) pour 10 images par exemple.
voir même si c'est possible de mémoriser 2 tailles dont je me sers souvent…

Si vous avez une idée ?

[valkaari]

Il faut déjà récupérer les paramètres de rendu actif, tu peux en avoir plusieurs. En python c'est la fonction

 rdata = doc.GetActiveRenderData()

Donc la variable rdata vas récupérer l'ensemble des valeurs (vois ça comme un gros tableau avec des noms en première colonne et des valeurs en deuxième)

Pour accéder à une valeur en particulier, il faut coller son nom entre crochet derrière rdata.

 print rdata[c4d.RDATA_XRES_VIRTUAL]

C'est assez simple à récupérer, il faut juste ouvrir tes paramètres de rendu, cliquer sur un champ et le jeter dans ton code.


edit :
tu peux coller ça dans n'importe quel endroit où tu peux mettre du python, sans autre libraire à importer.
taille de l'image et image de début et de fin de rendu.

 
    rdata[c4d.RDATA_XRES_VIRTUAL]
    rdata[c4d.RDATA_YRES_VIRTUAL]
    rdata[c4d.RDATA_FRAMEFROM]
    rdata[c4d.RDATA_FRAMETO]

[g5cedric]

Merci Valkaari,
j'ai bien compris maintenant comme récupérer mes donné.

j'essai de lui assigné un "input" pour que je puisse le contrôlé par Xpresso mais rien ?
je pense que je fait pas bien …

Voici une copie d'écran:

[valkaari]

si je dis pas de connerie, il faut que ton Output1 soit relié à un noeud (genre un résultat) pour que ton noeud python soit calculé/executé.

edit :

ton code ne vas pas non plus. Il faut en python respecter une indentation. Tous ce qui vas dans la fonction main() doit avoir une tabulation.

et il faut également que tu mettes la fonction rdata = doc.GetActiveRenderData()
et en fait il faut virer les "virtual" des noms des données que tu obtiens quand tu les drag&drop.
Pour les données de temps, assure toi de créer les entrées de ton noeud python avec le type Temps.

je t'ai rajouté aussi la liste déroulante pour la mettre en "manuel"

import c4d
#Welcome to the world of Python


def main():
    global Output1
    Output1 = 1
    rdata = doc.GetActiveRenderData()
    rdata[c4d.RDATA_XRES] = Width
    rdata[c4d.RDATA_YRES] = Height
    rdata[c4d.RDATA_FRAMEFROM] = From
    rdata[c4d.RDATA_FRAMETO] = To
    rdata[c4d.RDATA_FRAMESEQUENCE] = 0

    rdata.Message(c4d.MSG_UPDATE)

[César Vonc]

Tu t'en sors, g5cedric ?

N'hésite pas à demander ce qui te bloque.

[g5cedric]

Merci beaucoup,
Je regarde tout ça lundi

[g5cedric]

alors, bon, …
a mon avis, je bloque sur des bêtises car je ne connais pas ce langage…
mes questions vont être assez idiotes
voici pour le moment :



la largeur fonctionne
le reste , pas vraiment

je ne sais pas à quoi sert le Output1 relier au résultat ( qui ne m'affiche pas 1 )
pourquoi c'est jaune ? cela me fait penser qu'il faudrait recharger le script ( le recalculer ) mais visiblement c'est pas ça …

rdata[c4d.RDATA_FRAMESEQUENCE] = 0 , c'est pour le réglage "images" , 0 c'est lui demander de ce mètre en "manuellement" ?

j'aimerais aussi ne pas avoir de virgules, y a t'il une fonction pour cela ?

faut'il que je fabrique un bouton "recharger" ou "recalculer" pour être sur qu'il agisse bien ? si oui, bien, j'ai aucune idée comment faire …

j'ai bien respecter réel ou temps pour les données d'entrer et sortie …

merci pour votre aide
cedric

[valkaari]

height et pas heigth (le nom de ton port)

sinon oui pour les autres questions. Pour une liste déroulante en général (mais c'est pas tout le temps le cas) le premier élément a l'ID 0. Puis 1, 2, 3 etc...

Tu peux aussi ouvrir la console dans le menu script->console. Elle affiche les messages d'erreur et te permet donc d'en savoir un peu plus sur ce qui ne vas pas.

[g5cedric]

Bon cela avance bien, mon seul problème est de passer mes nombre de carreau ( qui son réel ) en temps…

je vous donne mon fichier si vous voyer des problème, mise a part ça , si vous voyer des suggestion …

[g5cedric]

bon, je cherche encore mon problème, mais je viens de voir qu'il me faudrait changer aussi le menu "réglages du projet"…

import c4d
#Welcome to the world of Python


def main():
    global Output1
    Output1 = 1
    rdata = doc.GetActiveRenderData()
    rdata[c4d.RDATA_XRES] = Width
    rdata[c4d.RDATA_YRES] = Height
    rdata[c4d.RDATA_FRAMEFROM] = From
    rdata[c4d.RDATA_FRAMETO] = To
    rdata[c4d.RDATA_FRAMESEQUENCE] = 0
    rdata[c4d.RDATA_FRAMERATE] = Frame
    rdata = doc.GetActiveBaseDocument()
    rdata[c4d.DOCUMENT_FPS] = FPS
    rdata[c4d.DOCUMENT_MAXTIME] = MaxTime
    rdata[c4d.DOCUMENT_LOOPMAXTIME] = LoopMaxTime
    rdata.Message(c4d.MSG_UPDATE)

j'ai rajouter un peu de code pour mes besoins …
je sais pas si "rdata = doc.GetActiveBaseDocument()" est le bon code pour modifier de la même manière les infos du projet ?

[oli_d]

Oui cela fonctionne, mais il y a plus simple la variable doc dans le python c4d te donne automatiquement le document actif ( ou plus exactement le document dans lequel se trouve le code)

Mais attention quand tu écris rdata = doc.GetActiveBaseDocument() tu écrases ta variable rdata et quand tu envoies le message de mise à jour à la fin tu l'envoies sur le doc pas sur ton renderdata

import c4d

def main():     
    global Output1     
    Output1 = 1     
    rdata = doc.GetActiveRenderData()     
    rdata[c4d.RDATA_XRES] = Width     
    rdata[c4d.RDATA_YRES] = Height     
    rdata[c4d.RDATA_FRAMEFROM] = From     
    rdata[c4d.RDATA_FRAMETO] = To     
    rdata[c4d.RDATA_FRAMESEQUENCE] = 0     
    rdata[c4d.RDATA_FRAMERATE] = Frame

    rdata.Message(c4d.MSG_UPDATE)
   
    doc[c4d.DOCUMENT_FPS] = FPS    
    doc[c4d.DOCUMENT_MAXTIME] = MaxTime     
    doc[c4d.DOCUMENT_LOOPMAXTIME] = LoopMaxTime     
    doc.Message(c4d.MSG_UPDATE)

[g5cedric]

Merci Oli_d.
je regarde cela, mais pour le moment je suis toujours embêter avec mes conversion entre réel et temps …
Je cherche, je fouille, je teste
merci tout de même

[oli_d]

Je ne sais pas si j'ai tout compris, mais je t'ai fait un exemple avec tag python (pièce jointe)

J'ai simplifié le problème en mettant 3 données utilisateur (sur le tag python) : la largeur et la hauteur de l'image finale et la subdivision.
Si la subdivision est à 2 cela fera un tuilage de 2x2 c'est à dire 4 images, à 3 ->3x3 ->9 images, à 4->16 ...

Attention si la largeur ou la hauteur n'est pas un multiple de la valeur de subdivision cela arrondi automatiquement à la valeur inférieur multiple.

le code du tag (qui fait un peu peur avec les commentaires):

import c4d

def main():
    
    #on récupère les données utilisateur (par glissé déposé)
    #op est simplement l'objet lui-même donc dans ce cas là 
    #le tag python
    larg = op[c4d.ID_USERDATA,1]
    haut = op[c4d.ID_USERDATA,2]
    subd = op[c4d.ID_USERDATA,3]
    
    #si la largeur ou la hauteur ne sont pas un multiple de subd
    #on renvoie la valeur arrondie à la donnée utilisateur correspondante
    op[c4d.ID_USERDATA,1] = larg-(larg % subd)
    op[c4d.ID_USERDATA,2] = haut-(haut % subd)
    
    #on dimensionne la hauteur et la largeur 
    #dans les données de rendu
    rdata = doc.GetActiveRenderData()
    rdata[c4d.RDATA_XRES] = larg/subd
    rdata[c4d.RDATA_YRES] = haut/subd
    
    #récupération de la frame active (je sais c'est pas simple !)
    frame = doc.GetTime().GetFrame(doc.GetFps())
    
    #on calcule le point de départ en haut à gauche
    dprt = -(subd-1)/2.0
    #bon là il faut faire un dessin et comprendre  le modulo %
    #le modulo donne le reste d'une division qui dans mon cas me donne 
    #la position de la case en x
    x = dprt+ (frame % subd)
    #la division me donne la position en y
    y = dprt+ (frame / subd)
    
    #on récupère l'objet camera 
    #op représentant le Tag python la méthode GetObject() donne l'objet 
    #sur lequel est posé le tag
    camera = op.GetObject()
    
    #et on assigne les valeurs x et y aux décalages
    #seulement si le no de la frame est plus petit que le nombre d'images 
    if frame< subd*subd:
        camera[c4d.CAMERAOBJECT_FILM_OFFSET_X]=x
        camera[c4d.CAMERAOBJECT_FILM_OFFSET_Y]=y 

sans les commentaires ça à l'air beaucoup plus digeste

import c4d

def main():
    
    larg = op[c4d.ID_USERDATA,1]
    haut = op[c4d.ID_USERDATA,2]
    subd = op[c4d.ID_USERDATA,3]

    op[c4d.ID_USERDATA,1] = larg-(larg % subd)
    op[c4d.ID_USERDATA,2] = haut-(haut % subd)

    rdata = doc.GetActiveRenderData()
    rdata[c4d.RDATA_XRES] = larg/subd
    rdata[c4d.RDATA_YRES] = haut/subd

    frame = doc.GetTime().GetFrame(doc.GetFps())
    
    dprt = -(subd-1)/2.0
    x = dprt+ (frame % subd)
    y = dprt+ (frame / subd)
    
    camera = op.GetObject()

    if frame< subd*subd:
        camera[c4d.CAMERAOBJECT_FILM_OFFSET_X]=x
        camera[c4d.CAMERAOBJECT_FILM_OFFSET_Y]=y 

Je ne sais pas si c'est vraiment dans cette direction que tu cherches à aller mais ça fera toujours un exemple ...

[edit : ] pour le voir fonctionner avance image par image dans la timeline ...
on pourrait améliorer en réglant automatiquement la frame de fin dans les données du rendu

[g5cedric]

Salut Oli_d
Merci pour ton code , c'est vrai que je me sens un peu fébrile en le lisant …
tu as réussi à refaire la "tiledcamera" grâce à quelques code , chapeau bas!
Je pensais pas que cela deviendrai autant compliquer

ton premier code me parait plus à ma porter et convient bien à mon projet.
le but d'utilisé la tiledcam de c4d et lorsque l'on donne la taille et le nombre de carreaux (tuiles) ( dans des donnée utilisateur), le code fait les tache tout seul : remplace la hauteur et largeur du rendu, place la dernière frame à developer (2x2 = 4 donc de 0 à 3 frame ) à la fois dans les réglages de rendu et dans les infos du projet ( pour la fenêtre ).

je pense que j'ai juste un problème en Xpresso pour :
une valeur tronquer pour le temps ( 1 fois sur 3 il passe a X,01 ).
mon plus gros problème, c'est de passer d'une valeur réel le nombre de carreaux ( "carreaux par axis" x "carreaux par axis" ) et de le transformé en time-1
genre : (3x3)-1 = 8 en réel mais en time, c'est plus pareil … j'ai l'impression qu'il prend en compte 1 frame = 24, mais pas toujours :/
effectivement, je peu peut-être utiliser un bou de ton dernier code pour faire le calcule en Python ?
je fait quelques test et je poste ma cam pour vous montrer ou j'en suis

merci pour votre aide à tous

[g5cedric]

Bon, bonne nouvelle, tout fonctionne MAIS …
je vous donne ma cam, car là, je suis complètement perdu …
tout mon code fonctionne (merci à vous ) mais le changement de taille ( image horizontal ou vertical ) et cela ne marche plus… snif
je me demande si il ne faudrais pas que je fabrique 2 cam, une pour les image horizontal et une autre pour les images vertical ?
voici une image :

Si vous avez une idée pourquoi ?

[g5cedric]

bon, je pense avoir trouver …
c'est le "format de film" …
j'espere qu'une petite division fera l'affaire

[g5cedric]

Bon, je vous annonce que tout à l'air de fonctionner

si quelques personnes pourrais tester et me dire ce qu'ils en pense ?

dans le zip, un fichier à placer dans library/browser et un dossier à placer dans Library/scripts

vous trouverez la cam dans votre bibliothèque ainsi que dans les scripts, vous pouvez aussi faire un bouton

[Aurety]

Merci g5cedric ! Je teste ça ce soir