Depuis la version 8 de nuke the foundry nous propose une nouveauté qui est le node de BlinkScript.
Le node de BlinkScript a comme fonction de "processer" les pixels d'une image, c'est a dire permettre d'appliquer des calculs et des algorithmes sur chaque pixel d'une image a l'aide d'un langage de programmation. Avant l'existence du BlinkScript ce genre de calcul au niveau du pixel était possible, sans passer par le NDK, avec l'utilisation de la fonction sample() en python mais c'était extrêmement couteux en performance. Parcourir une image pixel par pixel en pyhon peut prendre plusieurs dizaines de seconds voir minutes selon l'utilisation des valeurs du pixel et de la taille de l'image. Grâce au BlinkScript les performances sont bien meilleurs.
Nous allons rapidement voir comment le BlinkScript fonctionne, il possède un éditeur de texte qui lui permet de recevoir le code qui lui fournit les instructions a exécuter. Une fois ce code rentré nous allons demande au BlinkScript de le convertir et de le compiler en cliquant sur le bouton Recompile ainsi il devient utilisable par nuke. Le langage utilisé pour "coder" des BlinkScript est un langage dit "kernel" avec une syntaxe proche de celle du C++ il sera converti dans un langage adapté a l’exécution de ces instructions soit sur le CPU soit sur le GPU (SMID ou OpenCL). Une fois converti et compile le BlinkScript devient aussi performant, voir plus qu'un node classique code en C++ avec le NDK. Le système de Blink a été aussi intégré aux NDK pour pouvoir développer des nodes C++ et profiter de cette nouvelle technologie CPU / GPU.
Le réel avantage du BlinkScript est donc sa performance mais il possède quelques mauvais points. Il est bon de les savoir pour comprendre les limites de ce node et ne pas perde de temps a essayer de programmer des choses que le BlinkScript ne pourra pas faire.
Le BlinkScript travail que sur le pixel, il est impossible de travailler sur un autre contexte. Par exemple ce n'est pas possible de paramétrer la taille d'une image, de changer de frame, de changer les connections du BlinkScript ... Il n'agit que sur le pixel.
Le BlinkScript peut posséder des Knobs mais leurs valeurs peuvent être attribué qu'a la première exécution du BlinkScript. Au final nous pouvons qu'initialiser les valeurs des Knobs. Il est impossible de changer une valeur d'un knob en cour de processing (calcule de l'image) par contre elles peuvent être lues. Si la valeur d'un knob est changé "manuellement" le processing sera relancé automatiquement avec cette nouvelle valeur.
Le BlinkScript étant assez nouveau la gestion des erreurs de syntaxe ou de compilation sont souvent flous et nous aide pas beaucoup pour trouver d’où vient notre erreur. Il faut se préparer a passer du temps a debugger notre BlinkScript. Une bonne connaissance en C++ peut être un avantage pour corriger et éviter ce genre d'erreurs.
Le BlinkScript ne travail que sur les channels R, G, B, et A ce qui nous oblige très souvent a faire précéder le BlinkScript d'un Shuffle pour rediriger les Channels souhaité vers RGBA.
Nous pouvons en déduire que le BlinkScript est a utiliser principalement dans un gizmo entouré d'une panoplie de nodes pour le préparer et agir sur d'autre contexte que celui du pixel.
Une fois satisfait du code de votre BlinkScript il est possible de le publier, c'est a dire que nuke va préparer le node a une utilisation en production. Nuke va grouper notre BlinkScript et linker ses knobs sur l'interface du group. Nous avons le choix de crypter le code source pour éviter tout plagia si notre souhait est de garder secret nos supers algorithmes, l’éditeur de texte disparaitra. Si nous décidons de ne pas crypter, le code source sera accessible dans l’éditeur de texte du BlinkScript.
Voila nous avons fait un rapide tour d'horizon de ce nouveaux node. Son fonctionnement, ses avantages et ses désavantages nous paraissent plus clair. Nous sommes prés a nous lancer dans le développement d'un BlinkScript. Dans les prochains articles nous allons voir comment utiliser les différentes fonctions du BlinkScript a travers plusieurs exemples.
Suite du tuto : http://unblogdecolin.blogspot.fr/2014/11/nuke-tuto-blink-script-suite.html
A++
C.
Since version 8 of nuke the foundry proposes a novelty that is the node of BlinkScript.
The node of BlinkScript as function to process the pixels of an image, that is possible to apply calculations and algorithms on each pixel of an image using a programming language. Before its existence such of calculation at the pixel level was possible, without going through the NDK, with the use of the sample() function in python but it was extremely costly in performance. Browsing image pixel a pixel with pyhon may take severals tens of seconds depending using of pixel values and the image size. Thanks to BlinkScript performance is much better.
Quickly we'll see how the BlinkScript works, it has a text editor that allows it to receive the code which provides instructions to execute. Once the code has been entered we will ask the BlinkScript to convert and compile it by clicking the button Recompile, so it becomes usable by nuke. The language used to "encode" the BlinkScript is a sort of language called "kernel" with a syntax similar to the C++ then it will be converted into a suitable language to the execution of these instructions either on the CPU or on the GPU (MISA or OpenCL ). Once converted and compiled BlinkScript also becomes effective, like a classic node code in C ++ with the NDK. Blink system has also been integrated into the NDK to develop nodes in C ++ and enjoy this new CPU / GPU technology.
The real advantage is BlinkScript's performance but it has some bad points. It is good to know to understand the limits of this node and not wast our time trying to manage things that BlinkScript can not do.
The BlinkScript work on the pixel, it is impossible to work on a different context. For example it is not possible to set the size of an image, change frame, change the connections BlinkScript ... It works only on the pixel.
The BlinkScript may possess Knobs but their values can only be assigned has the first run of the BlinkScript. Finally, we can just initializes the values of the Knobs. It is impossible to change a value of a knob during processing, in contrast they can be read. If the value of a knob is changed "manually" the processing will be restarted automatically with this new value.
The BlinkScript being fairly new that's why error handling syntax or compilation are often vague and not much help us to find where our error is. We must prepare to spend our time to debug BlinkScript. A good knowledge of C ++ can be a benefit to correct and prevent such errors.
The BlinkScript work on the channels R, G, B, A and so we have very often precede the BlinkScript a Shuffle to redirect to the desired RGBA Channels.
We can deduce that the BlinkScript is to use primarily in a gizmo surrounded by an array of nodes to prepare and act on context other than the pixel.
Once satisfied with the code of your BlinkScript it is possible to publish it, that nuke will prepare the node has a production use. Nuke will group our BlinkScript and link knobs to its interface group. We have the choice to encrypt the source code to avoid plagiarism if our desire is to keep our secret algorithms, the text editor will disappear. If we decide not to encrypt the source code will be available in the text editor BlinkScript.
Here we did a quick tour of this new node. Its operation, its advantages and disadvantages we seem clearer. We are ready to get into the development of a BlinkScript. In future articles we will see how to use the various functions of BlinkScript through several examples.
The next tuto : http://unblogdecolin.blogspot.fr/2014/11/nuke-tuto-blink-script-suite.html
A++
C.
Aucun commentaire:
Enregistrer un commentaire