Torglut

La lumière, le réflecteur et la lentille

2012-02-27T22:12:00.000+01:00

Jouons un peu avec la réflexion et la réfraction dans Blender Cycles :
La lampe de poche, dans le principe.

Partie 3 : La lumière, le réflecteur et la lentille.

Pour les autres parties, c'est ici :

Partie 1 :: Partie 2 :: Partie 3

La parabole

Si on place à la fois la parabole et la lentille, on obtient ceci :

La tâche lumineuse est d'une belle intensité, le mur est bien éclairé.

Youpi ?

Non. Pas youpi. Car en réalité, il s'agit d'un heureux hasard : les rayons (D) réfléchis par la parabole sont parallèles entre eux avant de traverser la lentille (D2), mais ensuite ils sont réfractés par la lentille, ils se croisent sur l'axe optique, puis divergent (D3). L'heureux hasard vient du fait que le mur se trouve à la bonne distance de la lentille. S'il était plus éloigné de la lampe de poche, la tâche lumineuse serait beaucoup plus étalée et aussi beaucoup moins lumineuse.

La fumée

Pour voir le trajet des rayons lumineux, l'idéal serait d'ajouter un peu de fumée dans l'environnement. Malheureusement, je ne sais pas modéliser de la fumée avec le moteur de rendu Cycles. L'autre solution c'est d'utiliser une planche, positionnée en biais, sur le trajet de la lumière. On peut voir que les rayons se croisent en sortie de lentille, ils forment une sorte de tâche cônique et ils divergent.

La sphère

L'idée qui vient immédiatement après l'échec du réflecteur parabolique, c'est d'utiliser un réflecteur sphérique. L'idée est que les rayons émis vers la sphère seront réfléchis dans la direction exactement opposée, ils traverseront l'ampoule, et ils auront alors la bonne direction pour traverser la lentille et être parallèles entre eux en sortie de lentille.

Youpi ?

Non. Toujours pas youpi.

En tous cas pas dans la modélisation actuelle, car la lampe n'est pas transparente, elle a un matériau de type "emit". Donc les rayons réfléchis par la sphère sont stoppés par l'ampoule, ils n'atteignent pas la lentille. Sans compter que le réflecteur sphérique est plutôt moche.

Le réflecteur définitif

Là, c'est exactement le moment où j'abandonne toute recherche de forme parfaite, pour faire place à la créativité. Voici donc le splendide réflecteur pifométrique de révolution. Le but, c'est à la fois de récupérer le plus possible d'énergie émise vers la droite par l'ampoule et de récupérer des rayons quasi-parallèles entre eux sur la gauche, en sortie de la lentille.

La tâche lumineuse est un peu plus intense avec le réflecteur que sans, et cette fois-ci, l'intensité lumineuse sur le mur de gauche ne devrait pas trop dépendre de la distance entre la lampe de poche et le mur. Bon ok, la différence n'est pas non plus extraordinaire, mais disons qu'il suffit d'y croire.

Le résultat final en image :

Une petite vidéo pour illustrer la lumière, le réflecteur, et la lentille :

La lumière et la lentille

2012-02-26T11:46:00.000+01:00

Jouons un peu avec la réflexion et la réfraction dans Blender Cycles :
La lampe de poche, dans le principe.

Partie 2 : La lumière et la lentille.

La lentille

Pour récupérer l'énergie des rayons qui vont dans la direction B, on peut utiliser une lentille. Dans les milieux autorisés, on parle de l'association de 2 dioptres.

Si on place la lentille de façon à ce que son foyer soit situé au centre de l'ampoule, alors les rayons réfractés seront parallèles entre eux en sortie de la lentille. La question est de savoir comment fabriquer une telle lentille. Il existe de nombreux articles dans wikipedia qui parlent de dioptres, de réflexion, de réfraction, et qui mentionnent des personnes célèbres :

Ma parole, c'est à croire qu'ils s'y sont tous mis !

Avec quelques approximation, le plus simple sera de fabriquer une "lentille mince convergente plan-convexe (plan-sphérique)" : une surface sphérique d'un côté et une surface plane de l'autre, les deux étant proches l'une de l'autre. Il reste à savoir où se trouve le foyer d'une telle lentille.

La formule la plus simple semble être celle de la vergence :

V = (n2 -n1) / R

Avec n1 et n2 les indices des milieux, et R le rayon du dioptre.

Sur cette même page, on voit que pour une lentille mince plongée dans l'air, la vergence est :

V = (n - 1) * (1/R1 -1/R2)

Si on considère qu'un plan est une sphère de rayon infini, alors on a R2 qui est infini, et donc 1/R2 qui est nul, donc :

V = (n - 1) * (1/R1)

Pour se simplifier la vie, on va prendre n=2. Dans blender cycles, cela correspondra à un indice de réfraction du matériau égal à 2 :

V = (2 - 1) * (1/R) = 1/R

Toujours sur cette page, on voit aussi la relation entre la vergence V et la distance focale f :

V = 1/f

On obtient donc la distance focale f :

f = 1/V

Donc le foyer se trouve à la distance f suivante, R étant le rayon de la sphère :

f = R

Youpi. Merci les approximations, difficile d'espérer quelque chose de plus simple.

La modélisation

Pour modéliser la lentille, il suffit de créer un nouvel objet de type sphère, de ne conserver que certains vertex, comme si cette sphère était coupée par un plan, puis de fermer la lentille en rassemblant tous les vertex du côté plan en un seul point avec la fonction "w" :: "Merge" :: "At center" en mode édition.

Une astuce : pour faciliter le placement ultérieur de cette lentille, il faut que son foyer corresponde à l'origine de l'objet (dans blender). Ce sera le cas par défaut si on utilise une sphère et un matériau "Glass" dont l'indice de réfraction (IOR) vaut 2, car dans ce cas, f=R.

Les pertes

Une partie de la lumière est réfractée par la lentille (elle éclaire le mur) et une autre partie est réfléchie (elle n'éclaire pas le mur), mais le matériau "Glass" n'a qu'un seul paramètre, l'indice de réfraction, on ne peut donc pas régler simplement la proportion d'énergie réfléchie (perdue).

Le résultat

Le résultat en image :

La lentille produit une belle tâche lumineuse sur le mur : ça fonctionne. Youpi.

La suite au prochain numéro.

La lumière et le réflecteur

2012-02-25T11:44:00.001+01:00

Jouons un peu avec la réflexion et la réfraction dans Blender Cycles :
La lampe de poche, dans le principe.

Partie 1 : La lumière et le réflecteur.

La scène

La scène, c'est un mur, sur la gauche, que l'on cherche à éclairer avec une lampe de poche. Il y a aussi le sol et le mur du fond. La lampe de poche est constituée principalement d'une ampoule, quasi-sphérique, qui éclaire peu (emission strength : 10.0).

Cette ampoule est placée sur une tige métallique, elle-même fichée dans un socle cubique. Regardez Pluto. Tout cela est légèrement éclairé par une douce lumière d'ambiance, car si on ne garde que l'ampoule comme source lumineuse, on n'y voit rien.

Le problème de l'ampoule, c'est qu'elle n'émet pas assez de lumière pour éclairer le mur de gauche. L'énergie qu'elle émet est diffusée dans toutes les directions.

Pour schématiser, les rayons qui vont dans la direction A sont corrects, ceux qui vont dans la direction B sont presque corrects, mais pour toutes les autres directions de rayons, l'énergie lumineuse est perdue, elle n'éclaire pas le mur.

La parabole

Pour récupérer l'énergie lumineuse émise dans les directions opposées au mur (celle des rayons dont la direction est E ou D), il faut utiliser un réflecteur (un miroir) à droite de la scène. Pour que les rayons réfléchis soient parallèles à l'axe optique et qu'ils éclairent bien le mur de gauche, le réflecteur doit avoir une forme parabolique et le foyer de cette parabole doit être situé au centre de l'ampoule. En réalité, comme c'est un objet en 3 dimensions, il faudrait utiliser le terme paraboloïde de révolution. Ce principe du miroir parabolique est décrit ici.

Pour modéliser un paraboloïde de révolution dans Blender, il suffit de partir d'un objet quelconque (un plan par exemple), de supprimer tous les vertex, de dessiner la silhouette (le profil) d'une parabole, puis d'utiliser le modifier nommé "Screw", pour créer la surface de révolution.

Quelques astuces :

Une fois le modifier de type Screw appliqué, il se peut que les vertex du sommet de la parabole ne soient pas rassemblées en un seul vertex, ce qui crée des défauts dans le modèle. Pour régler ce problème, il suffit, en mode édition, de tout sélectionner (CTRL+A), puis d'utiliser le menu"w" :: "remove doubles".
Si des jointures entre les différentes facettes de la parabole deviennent sombres, c'est que plusieurs facettes adjacentes ont des directions de normales opposées. Pour régler ce problème, il suffit, en mode édition, de tout sélectionner (CTRL+A), puis de recalculer les normales (CTRL+N).
Pour faciliter le placement du réflecteur par la suite, il faut s'arranger pour que le point origine de l'objet (dans Blender) soit situé au foyer de la parabole.

Pour que cet objet se comporte comme un miroir, il faut lui affecter un matériau de type "Glossy".

Les pertes

Le réflecteur n'est pas un miroir parfait, une partie de l'énergie lumineuse n'est pas réfléchie, elle est diffusée. Pour modéliser cela, on peut combiner un matériau de type "Diffuse" au matériau "Glossy", à l'aide d'un "node" de type "Mix Shader".

Dans les pertes, il y a aussi les rayons qui vont dans la direction C. Pour récupérer l'énergie de ces rayons, il suffirait de prolonger un peu la forme de la parabole, jusqu'à ce que les rayons C viennent la toucher. Je ne le fais pas, car sinon on ne verrait plus l'ampoule dans cette scène. Mais dans le principe, l'énergie de ces rayons est plutôt facile à récupérer.

Le résultat

Le résultat en image :

On obtient un joli rond lumineux sur le mur : ça fonctionne. Youpi.

La suite au prochain numéro.

Les matériaux de base dans Blender Cycles

2012-01-06T23:11:00.000+01:00

Un nouvel aperçu des matériaux de base dans Blender Cycles.

Pas mal de choses ont changé du côté des matériaux dans Blender Cycles, par rapport aux versions précédentes. Revoici un aperçu des matériaux de base avec Blender Cycles version 2.61.

Diffuse

Paramètres :

Color.
Roughness : J'imagine que ce paramètre définit la rugosité du matériau et qu'il doit influencer la façon dont les reflets se forment. Mais la vérité m'oblige à te le dire, je ne vois pas la différence en faisant varier ce paramètre (ce n'est pas bien grave).

C'est toujours le matériau de base. Il définit une couleur uniforme.

Dans cette image, de gauche à droite, roughness varie de 0 à 1.

Diffuse

Glass

Paramètres :

Méthode : Beckmann par défaut.
Color.
Roughness : Pour influencer la rugosité du matériau (verre poli, verre dépoli).
IOR : C'est l'indice de réfraction du matériau.

C'est le matériau transparent et un peu réfléchissant, qui permet de modéliser de l'eau, des liquides, du verre, du diamant, et bien d'autres choses. Le paramètre "IOR" remplace avantageusement l'ancien paramètre "fresnel". Il est ainsi possible de définir directement l'indice de réfraction du matériau désiré. Tout est expliqué ici, mais pour faire très simple : 1.33 pour de l'eau, 1.52 pour du verre, et 2.42 pour du diamant.

Dans cette image :

De gauche à droite, l'indice IOR varie de 1 (comme de l'air) à 2 (comme du verre ou du diamant).
De haut en bas, roughness varie de 0 (verre poli, lisse) à 1 (verre dépoli, sablé).

Glass

Glossy

Paramètres :

Méthode : Beckmann par défaut.
Color.
Roughness : Pour influencer la rugosité du matériau.

C'est un matériau réfléchissant.

Dans cette image, de gauche à droite, roughness varie de 0 (miroir parfait) à 1 (très peu de reflets).

Glossy

Transluscent

Paramètres :

Color.

C'est un matériau translucide avec un seul paramètre : Color. Il faut probablement l'utiliser en combinaison avec d'autres matériaux.

Transluscent

Transparent

Paramètres :

Color.

C'est un matériau transparent avec un seul paramètre : Color. Il n'y a visiblement pas de réfraction. Il faut probablement l'utiliser en combinaison avec d'autres matériaux.

Transparent

Velvet

Paramètres :

Color.
Sigma

Ce matériau peut servir à modéliser des tissus.

Dans cette image, de gauche à droite, sigma varie de 0 à 1.

Velvet

Emission

Paramètres :

Color.
Strength : Pour faire varier l'intensité lumineuse.

Ce matériau sert à modéliser des sources lumineuses.

Dans cette image, de gauche à droite, sur la rangée du milieu, strength varie de 1 à 2.

Emission

Holdout

Ce matériau n'a aucun paramètre. Il faut certainement l'utiliser en combinaison avec d'autres matériaux. D'après les commentaires de "Kel M" sur le précédent article, ce matériau perce un trou dans une image avec zéro alpha.

Holdout

Voilà pour les matériaux de base, qu'on peut toujours combiner à l'envi pour en former d'autres, à l'aide d'opérations nommées "Mix Shader" ou "Add Shader".

Dessine-moi un blender avec Blender Cycles

2011-12-04T07:49:00.001+01:00

Modéliser un blender avec blender.

Vidéo accélérée (timelapse) pour modéliser un blender avec blender :

Le rendu avec Blender Cycles :

Créer une texture répétable facilement avec Gimp

2011-11-20T15:42:00.001+01:00

Un nouveau petit tutoriel avec The Gimp, dans la série des textures répétables (tileable).

En version courte, il s'agit de :

Découper un morceau potable dans la photo d'origine.
Appliquer le filtre Gimp "Filters :: Light and Shadow :: Low frequency even".
Couper la photo en 4 avec la fonction Gimp "Layer :: Transform :: Offset :: Offset by x/2, y/2".
Aténuer manuellement les jonctions entre les 4 parties de l'image avec l'outil "Clone Tool" en choisissant "Circle Fuzzy" en tant que "Brush".

En version moins courte :

Etape 0 : Installation du script/plugin "Low Frequency Even".

En me baladant sur l'Interweb, j'ai découvert le pugin Gimp "Low Frequency Even" créé par "Miran". Ce plugin lisse les lents changements de couleurs et de luminosité sur l'image, en réalisant une moyenne sur les basses fréquences.

Pour l'installer, il suffit de télécharger le fichier "Low_Frequency_Even_2.x.scm" et de le déposer dans le répertoire "scripts" de Gimp. Sur une Ubuntu GNU/Linux, ça donne à peu près ça pour l'installation du plugin :


cd ~/.gimp-2.6/scripts/

wget http://registry.gimp.org/files/Low_Frequency_Even_2.x.scm

Pour vérifier le nom des répertoires dans lesquels il faut placer les scripts et pugins Gimp, il suffit de cliquer sur "Edit :: Preferences", puis d'aller dans "Folders :: Scripts".

Il faut probablement relancer Gimp pour qu'il trouve ce script/plugin.

Etape 1 : La photo.

Idéalement, il faut une belle photo, presque déjà répétable, faite avec un appareil de pro, sans trop de déformation.

Si, comme moi, tu ne disposes que d'une photo prise à la dégoutée, avec ton téléphone portable, et que tu ne peux pas t'empêcher de prendre le bout de ton pieds en photographiant le sol, et bien ce n'est pas très grave, ça va marcher quand même.

Pour redresser la photo, tu peux utiliser le logiciel Hugin, ou alors tu peux être plus feignant et te contenter de ne garder que la partie centrale de la photo, qui est moins sujette aux déformations, aux distortions, et aux effets vignette.

Tu sélectionnes un rectangle au centre en utilisant l'outil Gimp nommé "Rectangle Select Tool". Puis tu ne gardes que ce rectangle en utilisant le menu Gimp "Image :: Crop to selection".

Etape 2 : Utilisation du script/plugin "Low Frequency Even".

L'énorme avantage du script "Low Frequency Even" est qu'il va lisser les grosses différences de couleurs et de luminosité sur l'ensemble de l'image. Mais du coup, l'image résultante aura un peu moins de couleurs. Il faut donc jouer avec les 2 paramètres du script "Brightness detail filter pass radius" et "Colors detail filter pass radius". Plus le chiffre est élevé, moins le script aura d'effet, et vice versa.

Etape 3 : Offset.

La suite est identique à la méthode manuelle déjà présentée. Tu utilises le menu "Layer :: Transform :: Offset". Tu cliques sur le bouton du milieu : "Offset by x/2, y/2", pour que Gimp remplisse les valeurs X et Y, puis tu cliques sur le bouton "Offset".

Ensuite, tu utilises l'outil "Clone Tool", en choisissant des zones à copier avec "CTRL + clic", puis en recopiant ces zones sur les jointures pour les rendre invisibles. Tu choisis plusieurs zones source successivement, pour que l'on ne voit pas trop de répétition. Tu choisis un outil "Brush" dont les bords sont en dégradés, tel que "Circle Fuzzy", pour ne pas créer de nouvelles jointures.

Pour donner une idée de l'effet du script "Low Frequency Even", voici 2 images, l'une avec le script, l'autre sans. Dans les 2 cas, je n'ai pas encore utilisé l'outil "Clone tool", donc on voit les 4 zones de l'image. Mais on voit aussi que ça sera plus facile de lisser les jointures sur l'image qui a déjà subi l'effet du script/plugin "Low Frequency Even", car ces jointures sont déjà moins visibles.

Avec LFE

Sans LFE

Et voilà, tu obtiens une nouvelle texture répétable et de saison : le tapis de feuilles mortes. La feuille d'automne, emportée par le vent, en rondes monotones, tombe en tourbillonnant.

Un exemple de rendu de cette texture, avec Blender Cycles : Un banc public, sur un tapis de feuilles d'automne.

Dessine-moi un verre de grenadine avec Blender Cycles

2011-11-05T00:54:00.002+01:00

Un nouveau tutoriel vidéo avec Blender Cycles pour modéliser un verre de grenadine.

Avec Cycles, chacun crée son récipient en verre avec du liquide dedans, même CG Cookie.
Alors pourquoi pas moi ?
Pourquoi pas toi ?

Dans ce tutoriel, tu vas utiliser :

Le moteur de rendu Cycles de Blender (ouais !).
"SHIFT + Z" pour redimensionner uniquement sur les axes X et Y, mais pas sur l'axe Z.
"F" pour créer des faces.
Le modificateur de type "mirror", pour n'avoir à modéliser qu'un quart de ton verre.
Des "Edge Loops" en pagaille.
La fonction "Edge Slide".
"P" pour séparer un objet et en créer un nouveau à partir de ta sélection ("Separate by selection").
L'édition proportionnelle ("Proportional Editing") pour bouger des vertex adjacents à ta sélection.
La fonctione "UV unwrap" pour plaquer une texture répétable sur le sol.
Quelques matériaux Blender Cycles.
Un effet "Depth Of Field" (profondeur de champ) avec les menus "Focus" et "Aperture Size".

Dans ce tutorial, je n'ai pas utilisé ma carte graphique (CUDA) pour le rendu, car j'ai encore quelques soucis pour trouver la bonne version de Blender+Cycles sur le site de Graphicall. Certaines versions fonctionnent avec CUDA, mais posent problème lors de l'utilisation de textures (genre "ça plante" ou bien "ça va être tout noir"). D'autres versions me permettent d'utiliser des textures et la fonction "UV unwrap", mais ne fonctionnent pas avec CUDA. Ces petits soucis ne sont probablement que passagers, car Blender évolue vite. Très vite.

Le tutoriel en vidéo, partie 1, pour créer le verre :

Le tutoriel en vidéo, partie 2, pour créer la grenadine :

Le tutoriel en vidéo, partie 3, pour créer le sol, deux murs, et une source lumineuse :

Le tutoriel en vidéo, partie 4, pour définir la texture du sol :

Le tutoriel en vidéo, partie 5, pour définir la texture de la grenadine, et définir un point focal :

Pour les matériaux Blender Cycles, c'est un peu moins simpliste que la dernière fois, mais ce n'est pas non plus la mer à boire.

Pour le plateau, il s'agit d'un joyeux mélange entre une texture "Diffuse" et un tout petit peu de "Glossy", avec un effet "Bump Map" (relief) apporté par les éléments "RGB to BW" et "Multiply", connectés à l'entrée "Displacement".

Pour la grenadine, il s'agit d'un mélange entre un élément de type "Glass" avec un indice de réfraction plus faible, comme de l'eau, et un élément "Transluscent" pour ajouter un effet translucide, de façon à ce que le liquide soit moins transparent. Du coup, le rendu met "un certain temps" à converger.

Et voilà le verre de grenadine sur un plateau en planchettes d'eucalyptus :

Redessine-moi une orange

2011-10-31T00:48:00.000+01:00

Un nouveau tutoriel en images pour dessiner une orange avec Blender et Cycles.

Etape 0 : Modéliser une orange.

Pour modéliser une orange, il suffit de suivre ce tutoriel en vidéo, en 4 parties. Je ne vais pas le refaire, ça ne rimerait à rien. On va juste s'attarder un peu sur les matériaux du moteur de rendu "Blender Cycles", car ils sont différents de ceux du moteur de rendu interne "Blender Render". L'objectif sera ici de traduire les matériaux de "Blender Render" en matériaux "Blender Cycles".

Etape 1 : La couleur "diffuse".

La première chose à faire, pour dessiner une orange, c'est de choisir une couleur orange. C'est trivial, mais ça va mieux en le disant. Dans une fenêtre "Node Editor", on choisit donc un matériaux de type "Diffuse BSDF", on choisit une belle couleur orange, et on connecte cet élément à l'entrée "Surface" de l'élément "Material Output".

Voici notre orange. La bonne nouvelle c'est qu'elle est orange. La mauvaise nouvelle, c'est qu'elle est complètement uniforme.

Etape 2 : Les variations de couleurs.

Avec "Blender Render", on aurait utilisé une texture de type "clouds", pour mélanger 2 variations différentes de couleur orange. On peut réaliser quelque chose de similaire avec Cycles, en utilisant un élément de type "Mix Shader", pour mélanger 2 couleurs de type "Diffuse", et en utilisant un élément "Clouds Texture" comme facteur de modification (c'est l'entrée "fac" de l'élément "Mix Shader").

Voici notre orange. La couleur est moins uniforme. Par contre, on dirait toujours que l'orange est en mousse.

Etape 3 : La couleur translucide.

Avec "Blender Render", on aurait utilisé un effet "SSS" (SubSurface Scattering). On peut obtenir un effet similaire avec Cycles en utilisant un élément de type "Transluscent BSDF" que l'on combine aux éléments précédents.

Voici notre orange. C'est mieux, mais il manque un peu de reflets.

Etape 4 : Les reflets.

Avec "Blender Render", on aurait utilisé le paramètre "Specular". On peut obtenir un effet similaire avec Cycles en utilisant un élément de type "Glossy BSDF" que l'on combine aux éléments précédents.

Voici notre orange. Il ne lui manque qu'un peu de relief.

Etape 5 : Le relief de surface.

Avec "Blender Render", on aurait utilisé une texture pour influencer le paramètre "Normal", afin de générer un effet de type "Bump Map" (placage de relief). On peut obtenir un effet similaire avec Cycles, en utilisant l'entrée "Displacement" de l'élément "Material Output". Pour une orange, on peut utiliser une texture procédurale de type "Voronoi Texture". Mais il faut l'inverser, de façon à ce que 0 devienne 1, et que 1 devienne 0, pour transformer le blanc en noir et vice versa. On utilise donc un élément "Math :: Subtract", pour réaliser l'opération "1 - voronoi". Ensuite, pour modifier l'influence de cette texture, on utilise un autre élément "Math :: Multiply". On peut ainsi ajuster la valeur de sortie, par exemple : "(1-voronoi) * 0.8".

Et voilà notre orange terminée avec "Blender Cycles".

Il ne reste plus qu'à ajouter quelques planches d'eucalyptus pour faire un socle. Et puis bien entendu, on peut jouer autant qu'on veut avec la valeur de chacun des paramètres pour affiner le matériau final.

De retour en Corse

2011-10-30T12:03:00.003+01:00

De nouvelles vidéos de la Corse en 3D anaglyphe avec Blender.

Pour l'image du haut, c'est Blender Cycles, pour les vidéos, c'est Blender Internal.

Un petit récapitulatif :

Les données proviennent de l'IGN : c'est le Modèle Numérique de Terrain (MNT) issu de la BD ALTI.
Pour les importer dans Blender, il s'agit d'utiliser le script "asc2obj.pl" en suivant les tutos ici, là, et encore là.
Pour réaliser un rendu anaglyphe, il suffit de suivre le tuto de David Ward, sur le site Blender Cookie.

Et voilà une vidéo de 3 minutes de la Corse en 3D anaglyphe :

Et encore une autre vidéo similaire :

Tuto dominos avec Blender

2011-10-10T21:21:00.000+02:00

Un nouveau tutoriel pour modéliser et faire tomber des dominos avec Blender.

Dans ce tutoriel, tu vas utiliser :

Blender Game Engine (BGE)
Le menu "physics"
Le type "Rigid Body"
Le bouton "Game :: Record Animation"

Un exemple de rendu :

Le tutoriel :

Dessine-moi un désert

2011-10-02T17:20:00.000+02:00

Maintenant que tu disposes de ta jolie texture de désert répétable, tu peux t'en servir pour modéliser un désert immense. Voici donc un petit tutoriel en images pour modéliser ce désert, dans Blender.

La scène

Tu utilises un plan, agrandi 100 fois. Tu lui appliques un matériau dont la couleur "Diffuse" est un "blanc-jaune-clair", et dont la valeur "Specular" est très basse, disons "0.01".

Sur ce plan "desert", tu vas appliquer 2 textures presque identiques, l'une pour influencer le paramètre "normal", et l'autre pour influencer le paramètre "color". La première sera nommée "bump_desert", et la seconde "color_desert". Toutes les deux seront de type "Image or Movie" et utiliseront ta texture de désert.

Pour que la texture soit aux bonnes dimensions, tu modifies les valeurs X, Y, et éventuellement Z, dans le menu "Mapping". Pour cet exemple, X=Y=Z=20. Tu dois veiller à utiliser les mêmes valeurs de "Mapping" pour les 2 textures. Tu coches aussi la case "Premultiply" dans le menu "Image" des 2 textures, bien que je ne sache pas dire exactement à quoi cela correspond.

La texture "bump_desert" va donner un effet de relief au sol. Pour cette texture, dans le menu "Influence", tu décoches "Color", tu coches "Normal", et tu renseignes une valeur d'environ "-0.02" pour ce paramètre "Normal". C'est avec une valeur négative pour ce paramètre que les zones sombres de ta texture seront en creux, et les zones claires en relief. C'est un peu contre-intuitif de devoir renseigner une valeur négative pour obtenir ce comportement, mais c'est comme ça dans Blender pour ce paramètre. Tu coches la case "RGB to Intensity" pour que Blender transforme la luminosité de la texture en valeurs. Tu choisis aussi "Best Quality" pour le paramètre "Bump Mapping Method". Tu peux aussi augmenter le contraste sur la texture, pour donner un relief plus prononcé, en renseignant "2.0" pour le paramètre "Contrast" du menu "Colors".

La texture "color_desert" va influencer la couleur, comme son nom l'indique. Donc tu ne coches que le paramètre "Color" dans le menu "Influence" et tu renseignes la valeur "1.0". Tu choisis la valeur "Multiply" pour le paramètre "Blend".

Tu utilises une lumière de type "Sun", et tu places cette lumière presque au zénith. Il va faire chaud. Tu renseignes aussi "2.0" (ou un peu plus) pour la valeur "Energy" de ce soleil.

Si tu lances un rendu à ce stade, tu devrais obtenir à peu près cette image. Le désert est correct, mais il manque un ciel.

Le ciel, le soleil, et Suzanne

Pour le ciel et le soleil, tu sélectionnes le soleil, et dans l'onglet "Object Data", tu ouvres le menu "Sky and Atmosphere". Tu coches la case "Sky". Pour le paramètre "Sun and Sky Presets", tu choisis "Desert". Pour "Horizon: Brightness", tu renseignes la valeur "8.0", et pour "Sun: Brightness", tu renseignes la valeur "2.0".

Tu ajoutes un objet sur le sol. Au hasard, ce sera Suzanne. Pour voir quelques couleurs dans l'ombre des objets, tu coches la case "Ambient Occlusion" dans l'onglet "World", et tu renseignes une valeur faible, par exemple "0.1".

Un rendu devrait donner à peu près cette image.

Du relief

Le problème principal est que le sol est complètement plat, ce qui n'est guère étonnant, dans la mesure où il est modélisé par un plan. Pour donner du relief, tu vas utiliser un "Displace Modifier" sur ce plan.

Tu commences par ajouter une nouvelle texture pour le désert. Tu la nommes "displace_desert", et tu décoches cette texture dans la liste, de façon à ce qu'elle n'intervienne pas dans le rendu. Elle servira uniquement de paramètre pour le "Modifier". Tu choisis "Clouds" comme type de texture, "Improved Perlin" pour le paramètre "Basis", et tu augmentes à "2.0" la valeur du paramètre "Contrast". Comme pour tout le reste, tu peux jouer avec les valeurs pour trouver quelque chose qui te plaise.

Tu ajoutes un modifier de type "Displace" dans l'onglet "Modifiers". Pour le paramètre "Texture" de ce "Modifier", tu choisis la texture "displace_desert" que tu viens de créer. Tu renseignes la valeur "0.03" pour le paramètre "Strength".

Pour que ce modificateur puisse avoir un effet, il faut que l'objet desert (le plan) dispose de plus de vertices. Pour cela, tu subdivises le plan plusieurs fois, en passant en mode édition ("tab"), en utilisant la touche "w", en choisissant "Subdivide", et éventuellement en augmentant le nombre de subdivisions ("Number of cuts"). Tu cliques aussi sur le bouton "Shading: Smooth", pour arrondir les angles sur le sol, car à présent il y a plusieurs facettes. Tu déplaces le sol sur l'axe Y pour avoir une plus grande profondeur de champ.

Au sujet de la profondeur de champ, tu sélectionnes la caméra, et dans l'onglet "Object Data", tu renseignes une grande valeur (disons "400") pour le paramètre "Clipping: End" du menu "Lens". Cela permet de voir tout le désert, sans qu'il soit tronqué au fonds de l'image.

Tu renseignes aussi le paramètre "Depth of Field" avec le nom de ton objet central, "Monkey". C'est ce qui permettra d'avoir un effet "Profondeur de Champ".

Un rendu devrait donner une image similaire à celle-ci.

Composition

Tu ouvres une fenêtre de type "Node Editor" et tu choisis "Compositing Nodes". Tu coches les cases "Use Nodes", et "Backdrop". Tu ajoutes ("Shift+A") un node de type "Output :: Viewer", un node de type "Filter :: Defocus", et un node de type "Group :: vignette".

Dans le node "Defocus" : tu renseignes la valeur "10.0" (par exemple) pour le paramètre "fStop", tu décoches "Preview", et tu coches Use Z-Buffer".

Dans le node "vignette", tu renseignes la valeur "0.3".

Et voilà, le résultat devrait ressembler à cette image :

Si tu veux aller plus loin, il y a un toturial le site BlenderGuru, pour donner un effet de distortion due à la chaleur (heat distortion).

Faire une texture répétable avec The Gimp

2011-10-01T20:46:00.000+02:00

Un petit tutoriel avec The Gimp, dans la série des textures, avec la méthode automatique et la méthode manuelle. Cette fois-ci, le sujet c'est le désert.

La photo

Pour faire une texture de désert, il faut commencer par faire une photo de désert. Celle-ci a été prise à Ibiza, parce que ... Ya de belles balades à faire dans le coin. Et de belles photos aussi.

Tu commences par sélectionner une partie centrale de la photo, avec l'outil "Rectangle Select Tool", de façon à te débarrasser des bordures qui sont généralement déformées lors de la prise de vue. Et puis, si tu as pris la photo n'importe comment, il se peut aussi que tu voies ton pieds, ou ta tong, ce qui n'aiderait pas pour la suite. Bref, tu commences par découper un morceau "potable" de la photo, et tu utilises ensuite le menu "Image :: Crop To Selection" de Gimp.

La méthode automatique

Tu utilises le menu "Filters :: Map :: Texturize". Tu peux laisser les valeurs par défaut dans le menu "Texturize Plug-in for GIMP", mais tu dois cocher la case "Tileable" (Répétable). Tu cliques sur "OK".

Et là, c'est le bon moment pour aller boire un café, car cela va prendre un certain temps. Le bandeau indique "Texturizing image...".

Et voilà, la texture est crée, elle est répétable. Elle est aussi 4 fois plus grande que l'image initiale.

Résultat avec la méthode automatique

La méthode manuelle

A partir de l'image initiale du morceau "potable" de la photo, tu utilises le menu "Layer :: Transform :: Offset". Tu cliques sur le bouton du milieu : "Offset by x/2, y/2", pour que Gimp remplisse les valeurs X et Y, puis tu cliques sur le bouton "Offset".

Tu obtiens une image avec 4 zones bien identifiables, et ton boulot va être de faire en sorte que la jointure entre ces 4 zones ne soit plus visible.

La première chose à faire est de rendre "plus claires" les parties 1 et 4, afin que leur luminosité générale soit à peu près la même que celle des parties 2 et 3. Ceci peut être fait en utilisant l'outil "Dodge / Burn Tool". Par exemple en utilisant la méthode "Dodge" sur les endroits les plus sombres des zones 1 et 4, pour les éclaircir, sans trop perdre de détail.

Ensuite, tu utilises l'outil "Clone Tool", en choisissant des zones à copier avec "CTRL + clic", puis en recopiant ces zones sur les jointures qui se trouvent juste entre les zones 1, 2, 3, et 4, pour rendre ces jointures invisibles. Tu choisis plusieurs zones source successivement, pour que l'on ne voit pas trop de répétition : tu prends une zone source, tu clones un peu cette zone sur une jointure, puis tu prends une autre zone source, et tu continues, et ainsi de suite. Tu choisis un outil "Brush" dont les bords sont en dégradés, pour ne pas créer de nouvelles jointures.

Enfin, tu peux refaire l'opération "Layer :: Transform :: Offset", avec "Offset by x/2, y/2", pour vérifier si ton image est bien répétable, c'est à dire si tu ne vois plus de jointures entre les zones 1, 2, 3 et 4. Sinon, il faut corriger.

Et voilà c'est fini, tu as une texture répétable, et avec un peu de chance, elle est plus jolie que la texture obtenue par la méthode automatique.

La recette des pâtes fraîches

2011-09-24T23:49:00.000+02:00

La recette facile des pâtes fraîches aux oeufs frais.

Les ingrédients :

La recette de base est d'environ 100 g de farine de blé pour 1 oeuf. Ou 125 g pour 1 oeuf, comme on veut.

Idéalement, il se dit qu'il faut de la farine de blé dur (ou bien faut-il dire de la farine de semoule de blé dur ?).

Il se dit même, sur wikipedia, que la réglementation française stipule que :
"L'appellation 'pâtes fraîches aux oeufs frais' suppose la réunion de trois conditions : un taux d'humidité supérieur à 12%, une semoule de blé dur de qualité supérieure classée, et un minimum de 140 grammes d’oeufs par kilogramme de semoule".

Mais en réalité, ça fonctionne très bien avec n'importe quelle farine.

Il ne faut pas de sel (contrairement à ce qu'on peut lire ici ou là). Ceci dit, c'est toujours étonnant ces recettes où on te dit "ce qu'il ne faut pas". Il ne faut pas non plus de choucroute.

La recette :

Mélange les oeufs et la farine.

Pétris le mélange : s'il est trop sec, ajoute un peu d'eau, s'il est trop mou, ajoute un peu de farine. Un bon mélange ne doit pas coller aux doigts.

Place la pâte (le mélange) sur une table légèrement farinée. Au besoin, découpe-là en petits morceaux à l'aide d'un couteau.

Laisse reposer ... disons 15 minutes.

La machine à pâtes :

Règle la machine à pâtes en position la plus large (position 7 sur la mienne). Passe le morceau de pâte 5 à 6 fois entre les 2 rouleaux, en tournant la poignée.

Au besoin, saupoudre un peu de farine sur le morceau de pâte.

Règle ensuite la machine en position 6, pour diminuer un peu l'écratement des rouleaux, et passe la pâte une seule fois dans cette position.

Recommence la même opération, une seule fois, avec les rouleaux en position 5, et ainsi de suite jusqu'à obtenir l'épaisseur désirée. Disons qu'on s'arrête à la position 3, car après c'est trop fin.

A l'aide d'un couteau, coupe la pâte en morceaux d'environ 25 cm de long. Passe la pâte dans les rouleaux de découpe en tournant la poignée lentement.

Si les rouleaux ne coupent pas, c'est que la pâte est trop molle. Il te faut alors ajouter un peu de farine et repasser par les premiers rouleaux.

Si la pâte ne passe pas, c'est qu'elle est trop sèche. Il te faut alors ajouter un peu d'eau et repasser par les premiers rouleaux.

Ne nettoie jamais la machine avec de l'eau, mais avec un chiffon doux et sec.

Matériaux Blender Cycles

2011-09-15T12:12:00.000+02:00

Un aperçu des matériaux de base dans Blender Cycles.

Les matériaux de base dans Cycles sont différents de ceux que l'on trouve dans Blender.

Diffuse
C'est le matériau de base, avec un unique paramètre : la couleur.

Diffuse

Glass
C'est le matériau transparent, avec 3 paramètres : Color, Roughness, et Fresnel. Sur ce rendu, de gauche à droite, Roughness augmente de presque 0.0 à 0.250, et de haut en bas, Fresnel augmente de 0.3 à 1.0. On peut y voir du verre poli, du verre dépoli, et peut-être même des liquides. Fresnel peut s'apparenter à l'indice de réfraction mais les valeurs sont différentes d'une vraie valeur IOR.

Glass

Glossy
C'est un matériaux un peu réfléchissant, avec 4 paramètres : la méthode (Beckmann par défaut), Color, Roughness, et Fresnel. Sur ce rendu, de gauche à droite, Roughness augmente de presque 0.0 à 0.250, et de haut en bas, Fresnel augmente de presque 0.0 à 1.0.

Glossy

Transluscent
C'est un matériau translucide avec un seul paramètre : Color. Il faut probablement l'utiliser en combinaison avec d'autres matériaux.

Transluscent

Transparent
C'est un matériau transparent avec un seul paramètre : Color. Il n'y a visiblement pas de réfraction, l'objet n'est pas réaliste. Il faut probablement l'utiliser en combinaison avec d'autres matériaux.

Transparent

Velvet
Ce matériau est défini par 3 paramètres : Color, Sigma, et Fresnel. Sur ce rendu, de gauche à droite, Sigma augmente de 0.6 à 1.0, et de haut en bas, Fresnel augmente de 0.6 à 1.0.

Velvet

Emission
Ce matériau émet de la lumière. Il est défini par 2 paramètres : Color et Strength. C'est avec ce matériau qu'on peut créer des lampes dans Cycles. Avec un plan on peut créer une sorte de "area light". Sur ce rendu, les 4 objets lumineux au centre sont de type emission, alors que les 4 autres objets lumineux dans les coins sont composés de 2 matériaux, l'un de type Diffuse, et l'autre de type Emission, combinés entre eux par une opération appelée "Mix Closure".

Emission

Holdout
Ce matériau n'a aucun paramètre. Il s'agit visiblement d'une sorte de "trou noir". Il faut certainement l'utiliser en combinaison avec d'autres matériaux.

Holdout

Combinaisons
Voilà pour les matériaux de base. Ils peuvent ensuite être combinés entre eux à l'aide d'opérations de type "Mix"ou "Add", pour donner des myriades d'autres variations. Il faut aussi garder à l'esprit que Cycles n'est pas stabilisé, et que tout cela peut changer du jour au lendemain.

Pour en savoir plus sur les différents paramètres, il y a des explications ici : http://www.blendercycles.com/tutorials/cycles.

Dessine-moi des objets en verre avec Blender et Cycles

2011-09-11T15:05:00.001+02:00

Cycles permet lui aussi d'utiliser des matériaux transparents réalistes et d'obtenir de jolis effets de lumière.

Cycles est un moteur de lancer de rayons plus réaliste que le moteur de rendu interne de Blender ("Blender Render"), un peu à la manière de Luxrender. Cycles est en développement et n'est pas encore très stable, mais un de ses avantages est qu'il sera directement intégré à Blender, à la différence de Luxrender. L'autre énorme avantage pour moi est qu'il peut facilement utiliser les processeurs de la carte graphique pour accélerer la phase de rendu. D'après ce qu'on peut lire ici, les cartes graphiques NVidia sont directement supportées, et le support pour les cartes ATI est en cours avec OpenCL. Il se trouve que par un heureux hasard qui n'en est pas un, je dispose d'une carte NVidia avec le support de CUDA, et qu'elle est directement et facilement utilisable avec Blender et Cycles.


lspci -v -q


(...)
02:00.0 VGA compatible controller: nVidia Corporation G92 [GeForce GTS 250] (rev a2) (prog-if 00 [VGA controller])
 (...)
 Memory at fa000000 (32-bit, non-prefetchable) [size=16M]
 Memory at e0000000 (64-bit, prefetchable) [size=256M]
 Memory at f8000000 (64-bit, non-prefetchable) [size=32M]
 (...)
 Kernel driver in use: nvidia
 Kernel modules: nvidia-current, nouveau, nvidiafb
(...)

Cycles n'utilise pas aussi exactement les propriétés physiques des matériaux que Luxrender. Par exemple, pour définir l'indice de réfraction (IOR) d'un objet transparent ou semi transparent, Luxrender utilise directement la valeur IOR réelle du matériau (eau, air, verre, verre avec 52 pourcent de plomb, etc), alors qu'avec Cycles, on obtient un effet similaire en faisant varier un paramètre nommé "fresnel", dont la valeur varie entre 0 et 1, et qui ne représente pas réellement cet indice d'IOR.

La manière simple d'utiliser Cycles est de récupérer une version précompilée de Blender et Cycles que l'on peut trouver sur le site http://graphicall.org/. Par exemple pour une architecture GNU/Linux 32 bits, il suffit de télécharger une des versions précompilées qui se trouve ici.

Voici ce que ça donne pour installer tout ça, avec les versions actuelles de Blender et Cycles. Pour cet exemple, j'utilise une version compilée par Fish.

0. Installer Blender et Cycles :

Pour une partie de ce qui suit, il faut être root.


sudo -i
cd /tmp
wget http://graphicall.org/47/download

Le fichier téléchargé est nommé "download", il peut être décompressé avec l'outil "7z" qui vient avec le paquet "p7zip-full". L'extraction de cette archive produit un répertoire nommé "blender25_cycles".


7z x download
chown --recursive root:root blender25_cycles
chmod --recursive go+rx blender25_cycles
mv blender25_cycles/ /usr/local/bin/blender259cycles/

Avec cette version précompilée de Blender+Cycles, il faut aussi installer le package "libsamplerate0" pour régler une dépendance.


aptitude install libsamplerate0
exit

1. Activer Cycles dans Blender :

On lance Blender avec :


/usr/local/bin/blender259cycles/blender

Dans l'interface de Blender, on active Cycles en allant dans le menu "File::User Preferences", puis en choisissant "Add-Ons", puis "Render", puis en cochant la petite case pour activer l'addon nommé "Cycles Render Engine". Normalement, avec cette version précompilée, cette case est déjà cochée par défaut.

Toujours dans l'interface de Blender, dans le bouton qui se trouve tout en haut, il faut ensuite changer la valeur "Blender Render" par "Cycles". Normalement, avec cette version précompilée, c'est déjà le moteur "Cycles" qui est actif par défaut.

Toujours dans l'interface de Blender, dans le menu de droite ("Properties"), dans l'onglet "Render", on peut renseigner le paramètre "Device" avec la valeur "GPU", puis renseigner le paramètre "GPU Type" avec la valeur qui correspond à la carte graphique dont on dispose, dans mon cas, il s'agit de la valeur "CUDA". L'autre solution est de n'utiliser que la valeur "CPU" pour le paramètre "Device", mais c'est vraiment dommage.

Il faut aussi renseigner le paramètre "Passes", qui indique le nombre de passes que le moteur Cycles doit effectuer avant de considérer le rendu comme terminé. Par défaut, ce nombre de passes est à 10, ce qui va bien pour faire des rendus rapides, mais est clairement insuffisant pour faire des rendus définitifs. Empiriquement, et à la louche pifométrique, il faut spécifier une valeur entre 500 et 5000 pour le paramètre "Passes: Render" pour avoir un résultat correct, et pour éviter les effets de pixélisation dans les zones de pénombre.

Et voilà, il ne reste plus qu'à modéliser une jolie scène, généralement avec des objets en verre un peu partout (car ça rend bien avec Cycles), à appuyer sur F12 pour lancer le rendu, et aller vaquer à d'autres occupations. Plusieurs minutes plus tard on obtient un joli rendu, dans Blender. Cycles s'arrête tout seul après avoir effectué le nombre de passes qu'on lui a spécifié.

Dessine-moi des objets en verre avec Blender et Luxrender

2011-09-02T01:34:00.000+02:00

Luxrender permet d'utiliser des matériaux transparents réalistes et d'obtenir de jolis effets de lumière.

Luxrender est un moteur de lancer de rayons réaliste, basé sur les propriétés physiques réelles des matériaux et sur la façon dont les rayons lumineux interagissent avec eux (réflexion, réfraction, etc.). En gros, contrairement au moteur de lancer de rayons interne à Blender, avec lequel on triche souvent un peu pour donner l'illusion d'une scène réaliste (en ajoutant des sources de lumière, par exemple), avec Luxrender on ne triche pas.

Le gros avantage est que le rendu est réaliste. Un gros inconvénient est que le rendu est extrêmement lent (ou plutôt que le rendu avec le moteur de lancer de rayons interne de Blender est extrêmement rapide, ce qui revient au même). Un autre inconvénient est que le rendu avec Luxrender peut donner un aspect granuleux ou pixélisé sur les zones qui se trouvent dans la pénombre. La solution est de le laisser tourner encore plus longtemps. Pour donner un ordre d'idée pifométrique, sur quelques scènes, s'il faut environ 1 heure pour faire un rendu avec le moteur interne de Blender, il faudra environ 24 heures pour faire un rendu de la même scène avec Luxrender, à la louche.

Luxrender est distribué sous license GNU GPL, tout comme Blender.

Luxrender est en développement. Une version stable est disponible ici. Il s'agit de la version 0.8 (aujourd'hui).

On peut interfacer Luxrender avec Blender, ou le contraire, en suivant par exemple le guide qui se trouve ici.

Voici ce que ça donne pour installer tout ça, avec les versions actuelles de Blender, Luxrender, LuxBlend, et Pylux, sur ma machine de démo (Debian GNU/Linux 6.0.2, 32 bits).

0. Installer Blender :

On commence par installer la version de Blender distribuée par Debian, pour régler d'éventuelles dépendances de paquets :



sudo aptitude install blender

Pour une partie de ce qui suit, il faut être root.



sudo -i

On opte pour la version stable actuelle : Blender 2.59, téléchargée sur le site officiel, en version précompilée.



cd /tmp/

wget http://download.blender.org/release/Blender2.59/blender-2.59-linux-glibc27-i686.tar.bz2

cd /usr/local/bin/

tar jxvf /tmp/blender-2.59-linux-glibc27-i686.tar.bz2

chown --recursive root:root blender-2.59-linux-glibc27-i686

chmod --recursive go+rx blender-2.59-linux-glibc27-i686

1. Installer Luxrender :

On opte pour une version de développement (weekly testing build), soyons fous. Toujours en version précompilée (ne soyons pas trop fous quand même).



cd /tmp/

wget http://www.vladmiller.info/lux/lux-gcc452-i686-sse2-110719-lux-v09dev-110718-ceffe9cfbc2d-opencl.tar.bz2

cd /usr/local/bin/

tar jxvf /tmp/lux-gcc452-i686-sse2-110719-lux-v09dev-110718-ceffe9cfbc2d-opencl.tar.bz2

chown --recursive root:root gcc452-i686-sse2-110719-lux-v09dev-110718-ceffe9cfbc2d-opencl

chmod --recursive go+rx gcc452-i686-sse2-110719-lux-v09dev-110718-ceffe9cfbc2d-opencl

2. Installer LuxBlend (LuxBlend25) :

LuxBlend est un addon pour Blender qui permet d'activer Luxrender lors du rendu, à la place du moteur de rendu par défaut de Blender. Les liens vers les versions de Luxrender et LuxBlend se trouvent sur la page "Weekly Testing Builds" du forum de Luxrender : http://www.luxrender.net/forum/viewforum.php?f=30 . Comme il s'agit de versions de développement, ... Si ça plante ... Bin ... Faut pas s'étonner outre mesure (et choisir une autre version plus stable).



cd /tmp/

wget http://src.luxrender.net/luxblend25/archive/25a6b616dbfe.tar.bz2

tar jxvf /tmp/25a6b616dbfe.tar.bz2

chown --recursive root:root luxblend25-25a6b616dbfe

chmod --recursive go+rx luxblend25-25a6b616dbfe

cp --recursive /tmp/luxblend25-25a6b616dbfe/src/luxrender/ /usr/local/bin/blender-2.59-linux-glibc27-i686/2.59/scripts/addons/

3. Installer Pylux :

Pylux permet de mieux intégrer Luxrender dans l'interface Blender. Il est livré avec Luxrender en tant que "pylux.so".



cp /usr/local/bin/gcc452-i686-sse2-110719-lux-v09dev-110718-ceffe9cfbc2d-opencl/pylux.so /usr/local/bin/blender-2.59-linux-glibc27-i686/2.59/scripts/addons/luxrender/.

4. Activer LuxBlend (LuxBlend25) dans Blender :

On n'a plus besoin des droits root à présent, et il est sans doute préférable de lancer tout ça en tant qu'utilisateur standard non privilégié (appellons le "torglut").



exit

On lance Blender avec :



/usr/local/bin/blender-2.59-linux-glibc27-i686/blender

Dans l'interface de Blender, on active Luxrender en allant dans le menu "File::User Preferences", puis en choisissant "Add-Ons", puis "Render", puis en cochant la petite case pour activer l'addon nommé "LuxRender". Cela peut prendre quelques secondes.

Toujours dans l'interface Blender, dans le bouton qui se trouve tout en haut, il faut ensuite changer la valeur "Blender Render" par "LuxRender".

5. Indiquer le chemin vers Luxrender dans LuxBlend (c'est à dire dans Blender) :

Toujours dans l'interface de Blender, dans le menu de droite ("Properties"), dans l'onglet "Render", il faut renseigner le paramètre "Path to LuxRender Installation" avec la valeur "/usr/local/bin/gcc452-i686-sse2-110719-lux-v09dev-110718-ceffe9cfbc2d-opencl/".

Il faut aussi renseigner les paramètres suivants, dans Blender :

"Sampler (traditional CPU)" pour "Renderer". Les autres valeurs font envie (GPU), mais je ne parviens pas à les faire fonctionner sur ma machine.
"External" pour "Rendering Mode".
"LuxRender GUI" pour "External type".
Cocher "Embed File Data".
Cocher "Run Renderer".

Et voilà, il ne reste plus qu'à modéliser une jolie scène, généralement avec des objets en verre un peu partout (car ça rend bien avec luxrender), à appuyer sur "F12" pour lancer le rendu, et aller vaquer à d'autres occupations. Plusieurs heures plus tard, il faudra encore attendre quelques heures. Luxrender ne s'arrête pas tout seul, il s'arrête de lancer des rayons lorqu'on l'arrête avec le bouton stop, le rendu est alors considéré comme fini, et il est visible dans Blender.

Dessine-moi un chateau

2011-09-01T09:46:00.000+02:00

Modéliser un château fort devient un jeu d'enfant avec l'addon masonry de Blender.

Jonathan Williamson a fait un très bon mini-tutorial pour apprendre à utiliser cet addon "masonry" dans Blender, ça se passe comme d'habitude sur le site Blender Cookie.

Certains addons sont directement inclus dans Blender, et distribués avec. Ils sont étiquetés "Release". Pour les autres, qui sont étiquetés "Contrib" ou "External", il suffit d'aller les chercher dans la partie "Extensions" du wiki de Blender, c'est ici.

L'addon "masonry" est donc un script écrit en python, sous license GPL, dont les auteurs sont Jambay, Paul Spooner, Dudecon, Ziggy, qui permet d'avoir un nouveau sous-menu dans la catégorie "Add::Mesh". Il permet de créer facilement des murs de briques ou de moellons prêts à l'emploi, avec toutes sortes de variations, telles que des ouvertures (fenêtres), des escaliers, des créneaux, des voûtes, des chemins de ronde et des parapets, des meurtrières, et sans doute d'autres variations que j'oublie.

Pour installer l'addon, il suffit de le télécharger, puis de le déposer dans le répertoire "scripts/addons" de Blender. Pour moi, il s'agit de l'emplacement suivant : "/usr/local/bin/blender25_cycles/2.59/scripts/addons/add_mesh_masonry.py".

Il faut ensuite indiquer à Blender qu'on veut utiliser cet addon en allant cocher la bonne case dans le menu "File::User Preferences" puis dans "Add-Ons::Add Mesh::Masonry".

Pour faire d'autres variations, il est possible d'utiliser des "Modifiers", comme indiqué dans le tutorial de Belnder Cookie :

Le modifier "Bevel" pour arrondir les angles des moellons.
Le modifier "Array" pour multiplier le nombre de murs. Les murs générés par l'addon s'emboîtent parfaitement entre eux.
Le modifier "Simple Deform" pour faire des murs circulaires, en choisissant le mode "Bend" dans les propriétés de ce modifier.

Pour le rendu de cette image, j'ai utilisé le moteur de rendu "Cycles" qui est en cours d'intégration dans Blender. Le plus simple pour disposer d'une version de Blender qui inclue Cycles est d'aller chercher une version précompilée sur le site http://www.graphicall.org/. Visiblement, ça aide aussi de disposer d'une carte graphique NVidia sous Linux.

Et voilà, il ne reste plus qu'à modéliser un château médiéval connu. Ou sinon le Gouffre de Helm, ou Minas Morgul, ou Minas Tirith.

Des tutos P2V faciles chez JoPa

2011-08-31T12:00:00.003+02:00

Il y a du nouveau sur le site de l'ami JoPa !

Si tu veux faire du Pi-Tou-Vi les yeux fermés et une main dans le dos, rien de tel que les tutos de JoPa, pour jouer avec Mondo Rescue (GPL) et Proxmox VE (GPLv2) : C'est par ici et par là, avec les explications, et les screencast qui vont bien, et c'est en français.

Et puis il y a aussi tout un tas d'autres bidouilles, howto, trucs, astuces, découvertes, tests, autour de GNU/Linux et des Logiciels Libres : http://www.jopa.fr.

Blender : Et pourtant elle tourne

2011-08-24T00:15:00.001+02:00

Un petit bonus, maintenant que tu as modélisé ton joli puzzle, tu peux appliquer une vidéo à la place de l'image en texture.

Pour réaliser l'animation de la terre qui tourne, j'ai suivi le tutorial "http://www.blenderguru.com/create-a-realistic-earth/" du site BlenderGuru.

J'ai ensuite appliqué la vidéo produite, en tant que texture, sans avoir à redimensionner, ni à changer l'aspect, car la vidéo est carrée (600x600, de mémoire, à 2kPI près), comme le puzzle initial.

La vidéo du puzzle de la Terre qui tourne (rendu final) :

Le tutoriel pour créer cette vidéo :

Blender : éparpillé par petits bouts façon puzzle

2011-08-23T21:55:00.003+02:00

Un nouveau tutorial / tutoriel avec Blender, et aussi un peu avec The Gimp, pour modéliser un puzzle.

Dans ce tutorial, il est question de :

Filtre "Filters::Render::Pattern::Jigsaw" de Gimp
Alt+F pour demander à Blender de générer des faces automatiquement
Modificateur de type Subdivision Surface / SubSurf
Modificateur de type Solidify
Modificateur de type Edge Split
Plusieurs matériaux différents sur le même objet
Plusieurs textures
Appliquer une image en tant que texture
UV Mapping
Effet Vignette

La vidéo tutorial Blender, partie 1 :

La vidéo tutorial Blender, partie 2 :

La vidéo tutorial Blender, partie 3 :

La vidéo tutorial Blender, partie 4 :

Un exemple de rendu Blender 3D en image :

Une petite citation qui va bien avec le sujet : "Aux quatre coins de Paris qu'on va le retrouver, éparpillé par petits bouts façon puzzle".

Bonus : L'effet vignette réutilisable dans Blender

2011-08-12T11:29:00.001+02:00

Maintenant que tu as créé ton splendide effet vignette dans Blender, tu vas pouvoir le réutiliser dans d'autres rendus, sans avoir à le recréer.

Il suffit, dans le "Node Editor", de sélectionner les différents éléments de l'effet vignette, en maintenant la touche SHIFT enfoncée, comme pour toute sélection multiple, puis de créer un groupe d'éléments, en appuyant sur "CTRL+G".

Blender crée alors un nouveau groupe, nommé par défaut "NodeGroup", qui se comporte comme un élément du Node Editor, et qui dispose de 2 entrées de type "image", et d'une sortie, elle-aussi de type "image".

Tu peux alors voir l'intérieur de ce nouveau groupe, en le sélectionnant, puis en appuyant sur "TAB", un peu comme si tu passais en "mode édition".

Tu peux alors renommer ce groupe : "vignette" sera plus parlant que "NodeGroup". Tu peux aussi supprimer l'une des 2 entrées de type "image", en appuyant sur la petite croix sur la gauche, et en connectant l'autre entrée "image" aux 2 éléments (le "Lens Distortion" et le "Multiply"). C'est pratique, car finallement, l'effet vignette n'aura alors plus qu'une seule entrée "image". Et là où Blender devient carrément génial, c'est que tu peux aussi connecter l'entrée "Fac (Factor)" de l'élément "Multiply" vers la gauche, pour créer une nouvelle entrée dans ce groupe "vignette", tu n'auras alors plus besoin de repasser en mode édition pour modifier cette valeur "Factor".

En appuyant à nouveau sur la touche "TAB", tu sors du mode édition, et tu vois ton nouvel élément "vignette", avec son unique entrée "image" et sa nouvelle entrée "Fac".

Il ne te reste plus qu'à sauvegarder ton projet Blender tout à fait normalement, par exemple en tant que "vignette.blend".

Pour réutiliser l'effet vignette dans un autre rendu, il te suffit d'importer une partie de ce fichier "vignette.blend", avec le menu "File::Append", puis de naviguer vers le fichier "vignette.blend", puis de naviguer dans ce fichier ".blend", vers "NodeTree/vignette" (ou le nom que tu as choisi pour ton élément), car Blender ouvre les fichier ".blend" un peu comme s'il s'agissait d'archives.

L'effet vignette est alors disponible comme un nouvel élément de type groupe, en appuyant sur "SHIFT+A" :

Et voilà :

L'effet vignette dans Blender

2011-08-10T22:38:00.005+02:00

Voici comment ajouter un effet vignette à tes images dans Blender.

Si tu visionnes certains tutos Blender, tu verras parfois l'auteur ajouter tout un tas d'effets à l'image finale, à l'aide du mode "Node Editor" de Blender (ou "Compositing", ou "Post-Processing", comme ils disent). Certains effets sont compliqués à réaliser, d'autres sont simples. L'effet vignette fait partie des simples. A ce sujet, parmi les personnes qui visiblement parlent le Blender couramment, il y a Andrew Price, dont le site http://www.blenderguru.com/ contient une foultitude de tutoriaux très bien faits. Et visiblement, Andrew Price utilise régulièrement un effet vignette pour ses rendus finaux.

Voici donc, pas-à-pas, comment faire cet effet vignette.

Pour la version courte : il faut ajouter les éléments suivants, dans le "Node Editor" de Blender :

"Distort::Lens Distortion", avec le paramètre "Distort" à 1.0
"Convertor::Math", avec le type "Greater Than", et le 2ème paramètre "Value" à 0.0
"Filter::Blur", avec le type "Fast Gaussian", l'option "Relative" cochée, et les paramètres "X" et "Y" à 20%
"Color::Mix", avec le type "Multiply", et une valeur entre 0.0 et 1.0 pour le paramètre "Fac (Factor)", c'est l'ajustement de ce paramètre qui permettra de donner plus ou moins de force à l'effet vignette.

Voilà, c'est fini.

Pour la version longue, voici la même chose en images, avec les différentes étapes :

Passer en mode "Node Editor" :

Cocher la case "Compositing: Compositing Nodes" dans "Node tree type", de façon à utiliser le "Node Editor" pour modifier les images.
Cocher la case "Use Nodes" (bin oui).
Cocher la case "Backdrop", de façon à avoir, en image de fonds, l'image que que l'on veut prévisualiser, à l'aide d'éléments nommés "Output::Viewer" :

Ajouter (avec "Shift+A", comme dans l'éditeur de Blender) un élément de type "Output::Viewer", et le connecter, pour voir ce que ça donne. Pour connecter 2 éléments dans le "Node Editor", il suffit de glisser d'un élément à l'autre en maintenant le bouton gauche de la souris enfonçé, comme si on dessinait les connexions. C'est très intuitif. Pour casser une connexion, il suffit de laisser la touche "Ctrl" enfonçée, et de dessiner un trait avec le bouton gauche de la souris, comme si on utilisait un cutter, pour couper les connexions. Pour le moment ça ne donne que l'image initiale, car on n'a encore rien fait :

Ajouter un élément de type "Distort::Lens Distortion", avec un paramètre "Distort" à 1.0, c'est ce qui permet de définir une zone ovale en fonction de la taille de l'image initiale. On ne se servira pas de la déformation, mais uniquement de l'effet de bord que représente cette forme ovale :

Ajouter un élément de type "Convertor::Math", de type "Greater Than", avec la valeur 0.0 pour le 2ème paramètre "Value". Ainsi, tout ce qui n'est pas complètement noir dans l'image d'entrée deviendra blanc, et seuls les pixels complètement noirs resteront noirs. C'est ce qui donne la forme ovale blanche sur fonds noir.

Ajouter un élément de type "Filter::Blur", de type "Fast Gaussian", pour faire un dégradé (floutage) sur la forme ovale. Il faut cocher "Relative" pour pouvoir définir des pourcentages pour les paramètres "X" et "Y". Donner la valeur 20% à ces paramètres. On a obtenu l'effet vignette seul, qu'il faudra ensuite combiner avec l'image initiale :

Ajouter un élément de type "Color::Mix", de type "Multiply", et ajuster le paramètre "Fac (Factor)" à sa guise, entre 0.0 et 1.0. Par exemple avec la valeur 0.5. Injecter les 2 images en entrée de cet élément : l'image initiale ("Render Layer"), et l'image de sortie de la vignette seule (sortie du filtre "Blur"). Le type "Multiply" permet de n'avoir que du noir pour les zones noires de la forme ovale, d'avoir l'image initiale pour les zones blanches de la forme ovale, et d'avoir un dégradé pour les zones grises de la forme ovale :

Et voici le résultat final en images (Avant/Après) :

Avant, sans effet vignette

Après, avec effet vignette

Bon, bien entendu, l'effet vignette ne va pas rendre extraordinairement jolie une image qui à la base n'était pas terrible, c'est juste pour l'exemple, mais parfois, ça peut aider à concentrer le regard vers le centre de l'image.

Dessine-moi les calanques de Cassis

2011-07-30T12:09:00.001+02:00

Il est possible de modéliser des reliefs assez précis dans Blender, en utilisant une carte qui contient des courbes de niveaux.

Le tutorial pour modéliser la Pointe de la Cacau, qui se trouve dans les calanques de Cassis, entre la calanque de Port Miou et la calanque de Port Pin :

Un exemple de rendu en vidéo :

Un exemple de rendu en image :

Créer une texture de type mur de briques avec Hugin et Gimp

2011-06-04T00:38:00.004+02:00

Sur Internet, il existe des tas de textures, de très bonne qualité, dans le genre "murs de briques", et certaines sont utilisables sans trop de contraintes de type "droits d'auteurs". Mais il se peut que tu souhaites créer ta propre texture, par exemple parce-que tu as trouvé le mur de briques le plus beau du monde, ou bien parce-que tu veux une texture de ton mur de briques, celui que tu as façonné de tes mains. Voici comment créer une texture de type "mur de briques", à partir d'une photo, avec Hugin et The Gimp.

Ces deux logiciels sont probablement disponibles pour ta distribution GNU/Linux préférée. Avec Ubuntu, par exemple, il suffit de taper "sudo aptitude install hugin gimp".

Il faut commencer par prendre une photo "à peu près correcte" d'un mur de briques :

On voit que la photo est déformée au niveau des coins, les briques ne sont plus horizontales, elles semblent arrondies.

Le logiciel Hugin peut servir à tout un tas de choses, mais ici il uniquement va servir à "redresser" la photo, pour que les lignes horizontales soient à peu près horizontales, et pour que les lignes verticales soient à peu près verticales.

Pour cela, dans l'interface Hugin, tu cliques sur le bouton "Load images..." de l'onglet "Assistant", et tu sélectionnes ta photo initiale.

Ensuite, dans l'onglet "Control Points", Hugin affiche deux fois la photo initiale. Tu crées ici des points de contrôle, pour aider Hugin à trouver des "lignes", dans l'image, qui devraient être horizontales, ou bien qui devraient être verticales. Par exemple, pour les deux points de contrôle numérotés "0", tu cliques, dans l'image de gauche, juste au dessus d'une brique qui se trouve en haut et à gauche, puis tu cliques, dans l'image de droite, juste au dessus d'une brique qui se trouve au centre, sur la même rangée de briques. Hugin détecte alors que tu signales une ligne entre ces deux points numérotés "0", et que tu souhaites que cette ligne soit parfaitement horizontale dans l'image finale (puisqu'elle est presque horizontale). Tu confirmes en appuyant sur le bouton "Add", une fois les deux points de contrôle bien placés. Tu recommences en ajoutant plusieurs couples de points de contrôle, tantôt pour définir des lignes qui devraient être horizontales, tantôt pour définir des lignes qui devraient être verticales. Dans cet exemple, j'ai défini 11 couples de points de contrôle. Plus tu définis de points, meilleur sera le résultat. Tu coches aussi les cases "auto fine-tune", "auto add", et "auto estimate".

Ensuite, dans l'onglet "Optimizer", tu choisis "Positions, View and Barrel (y,p,r,v,b)", et tu cliques sur le bouton "Optimize now!".

Ensuite, dans l'onglet "Stitcher", tu choisis la projection "Rectilinear", tu cliques sur les boutons "Calculate Field of View", "Calculate Optimal Size", et "Fit Crop to Images". Enfin, tu cliques sur le bouton "Stitch Now...".

Hugin crée alors une image corrigée, dans laquelle les briques paraissent plus horizontales. Par défaut, le format de fichier de sortie est "tiff".

Tu ouvres cette photo corrigée dans Gimp, et tu l'enregistres dans le format de fichier de ton choix, par exemple "png". L'objectif est à présent de générer une texture de type "mur de briques", qui soit "répétable"/"superposable" ("tileable", comme ils disent). Pour cela, tu définis une sorte de carré, avec l'outil "Rectangle Select Tool", en essayant de choisir un morceau de photo qui soit déjà presque "répétable", à vue d'oeil. C'est l'étape la plus difficile, car si cette sélection n'est pas déjà "presque répétable", alors la suite va donner des résultats "tout moyens". Mais bon, pas de panique, tu pourras toujours revenir en arrière, pour sélectionner un meilleur morceau de l'image, et recommencer à partir d'ici.

Une fois ton morceau d'image sélectionné, tu utilises le menu suivant de Gimp : "Image :: Crop to Selection".

Enfin, il suffit d'appliquer le filtre magique de Gimp, en utilisant le menu suivant : "Filters :: Map :: Make Seamless". Si le résultat est moisi, c'est que tu as mal choisi ta zone d'image, lors de l'étape précédente, il faut donc repartir de cette étape. Voici, ci-dessous, ce que cela devrait donner. C'est à peu près la même image, mais légèrement modifiée par le filtre magique de Gimp, pour qu'elle soit réellement répétable.

Cette texture est ensuite utilisable dans Blender, pour faire des murs immenses.

Un exemple de rendu, dans Blender, avec la texture ci-dessus :

Dessine-moi la Corse en 3D anaglyphe

2011-05-30T22:03:00.007+02:00

La Corse en relief anaglyphe avec Blender : Chausse tes lunettes 3D !

Après avoir suivi un nouveau tutorial proposé sur le site Blender Cookie, et en reprenant le Modèle Numérique de Terrain de la Corse, toujours à partir des données de l'IGN, j'ai généré une vue de la Corse en 3D anaglyphe.

Pour profiter pleinement de l'image, il faut chausser des lunettes 3D, genre en carton, avec un filtre de couleur rouge pour l'oeil gauche, et un filtre de couleur cyan (bleu-vert) pour l'oeil droit.

Il existe des tas de sites sur l'Internet qui vendent ce genre de lunettes, de plus ou moins bonne qualité.

Il fut un temps où on en trouvait aussi, parfois, dans des revues scientifiques que j'étudiais assidûment, telles que Picsou Magazine, ou Pif Gadget.

Sur ce coup, comme il m'en fallait "tout de suite à n'importe quel prix", je suis allé acheter un film en Blu-Ray Disc, qui parle apparemment de zombies, fantômes, et autres morts-vivants, et qui contient une version "Relief" dudit film, compatible avec tous les téléviseurs du marché, ainsi que ... roulements de tambours ... Quatre paires de lunettes en carton fournies !

Youpi.

Je ne vais pas refaire le tutorial, le mieux est de suivre celui de Blender Cookie. Le principe est de créer 2 scènes dans Blender (Scene.L et Scene.R, par exemple), d'affecter une caméra pour chaque oeil (camera.L et camera.R, par exemple), de séparer les caméras d'une certaine distance sur leur axe X local, puis d'appliquer un filtre, avec le "Node Editor" de Blender, comme dans l'image ci-dessous.

La vidéo 3D Anaglyphe du survol de la Corse :

Dessine-moi la Corse

2011-05-25T23:17:00.005+02:00

Importer un modèle de la Corse avec un pas de 250 mètres dans Blender.

Comme il existe des MNT avec une résolution (un "pas") de 250 mètres, ce serait dommage de ne pas en profiter.

Avec le même script, et les mêmes données de l'IGN, il est possible de définir une zone plus petite pour importer un objet de meilleure résolution, mais sans exagérer sur le nombre de vertex et de polygones. Il suffit de définir la colonne de début, la ligne de début, la colonne de fin, et la ligne de fin, pour ne garder qu'une partie des données.Cela produit un objet (mesh) d'environ 260 000 vertex et à peu près autant de polygones.

La commande :


./asc2obj.pl MNT250_L93_FRANCE.ASC 4265 3545 4615 4285 > corse.obj

La vidéo :

Dessine-moi la France

2011-05-25T22:36:00.006+02:00

Comment obtenir un mesh de la France dans Blender ?

Tout d'abord, voici une vidéo, créée avec Blender, dans laquelle on survole la France, on peut voir les Alpes, puis le Massif Central, puis les Pyrénées, et enfin la France entière, avec la Corse :

Pour importer un mesh de la France dans Blender, il me fallait avant tout une référence du relief de la France. Chez les professionnels de la profession, cela s'appelle un Modèle Numérique de Terrain (MNT) : http://fr.wikipedia.org/wiki/Modèle_numérique_de_terrain.

Pour trouver ce genre de chose en France, le réflexe, c'est d'aller voir l'Institut Géographique National (IGN) : http://www.ign.fr/. En cherchant sur le site web de l'IGN, je suis effectivement tombé sur la "BD ALTI", et sur les phrases suivantes :

"Référentiel du relief sur la France, la BD ALTI (R) est une gamme complète de modèles numériques de terrain qui décrivent la forme du terrain à différentes échelles (du 1 : 25 000 au 1 : 1 000 000). La BD ALTI (R) au pas de 250m, 500m, 1 000m est gratuite pour un usage non commercial."

Bingo. C'est exactement ce qu'il me fallait. Youpi.

Donc à partir de la page suivante de l'IGN, on peut récupérer la "BD ALTI", selon différentes résolutions (différents "pas"), et sous différents formats :
http://professionnels.ign.fr/ficheProduitCMS.do?idDoc=5323461

J'ai récupéré 3 archives zip contenant ce MNT, en format ASC (en ASCII, très simples à lire), selon 3 "pas" : 250 mètres, 500 mètres, et 1000 mètres :

France_1000_ASC_L93.zip (2.1 MB)
France_500_ASC_L93.zip (4.4 MB)
France_250_ASC_L93.zip (13 MB)

J'ai tenté de faire un "addon" pour Blender, en python, à partir de tutoriels, pour ajouter un menu, dans le genre "Shift+A :: Add :: Mesh :: France", et en convertissant les fichiers ASC en instructions python pour générer des "vertices" et des "faces". Mais cet essai n'a pas abouti : "Not enough memory, tout ça".

J'ai ensuite tenté de convertir ces fichiers ASC en fichiers de vertex (vertices), sans définir les polygones ("faces"), puis d'utiliser un addon Blender nommé "Import-Export: Raw mesh format (.raw)". Cet addon est décrit ici : http://wiki.blender.org/index.php/Extensions:2.5/Py/Scripts/Import-Export/Raw_Mesh_IO. Mais cet essai n'a pas abouti non plus : "Not enough memory, tout ça".

En regardant de plus près les différents formats de description d'objets (Mesh) que Blender sait importer ( http://www.blender.org/download/python-scripts/import-export/ ), je suis tombé sur cet addon : "Wavefront OBJ Importer/Exporter", qui est présent et actif par défaut sous Blender. D'après Wikipédia, le format "Wavefront .obj file" semble tout simple : http://en.wikipedia.org/wiki/Wavefront_.obj_file. Il suffit d'écrire "v x y z" pour définir un vertex de coordonnées (x, y, z). Et il suffit d'écrire "f a b c d" pour définir un polygone formé par les vertices numérotés (a, b, c, d).

Re-Bingo. Re-Youpi.

J'ai écrit un script perl pour lire les fichiers "*.ASC" du modèle numérique de terrain de l'IGN, et produire des fichiers "*.obj" au format Wavefront. Pour l'utiliser, il suffit de télécharger un des fichiers de l'IGN (gratuit pour un usage non commercial), d'extraire un fichier "ASC" (dézipper l'archive), de rendre le script perl exécutable ("chmod 755 asc2obl.pl"), puis de le lancer avec une commande telle que :


./asc2obj.pl MNT1000_L93_FRANCE.ASC > france.obj

J'ai pu ensuite importer les fichiers ".obj" représentant la France, en utilisant le menu "File :: Import :: Wavefront (.obj)" de Blender.

Quelques remarques tout de même :

Je ne peux pas importer les fichiers les plus précis (en tous cas pas sur ma machine), mais uniquement le fichier avec un pas de 1000 mètres, toujours pareil : "Not enough memory, tout ça".
Une fois le Mesh importé, l'interface de Blender rame sérieusement, à cause des 1.2 millions de vertices et des 1.2 millions de polygones. Et comme le dit le vieux sage des montagnes : "Quand tu as 1.2 millions de polygones sur un objet, tu ne cliques pas sur subsurf".
Bizarrement, les axes Y et Z sont intervertis, je pensais voir la France en vue de dessus, et je la vois en vue de face. Ce n'est pas un problème avec Blender, il suffit de sélectionner l'objet et de le tourner : "r x -90".
Comme les axes Y et Z sont intervertis, il faut aussi les intervertir lorsqu'on applique une image en tant que texture, dans le menu "Texture :: Image Mapping".
Pour que le rendu fasse un peu plus naturel, il faut cliquer sur "smooth", sinon, les reliefs sont moches.
Pour faire plus joli, j'ai un peu triché : j'ai accentué 3 fois la hauteur des montagnes. Là encore, avec Blender, c'est très simple : "s z 3". Ce n'est plus très réaliste, mais c'est plus sympa.

Pour la texture, j'ai utilisé une image qui se trouve elle aussi dans l'archive zip distribuée par l'IGN, dans un ".doc".

Et voilà. A partir de là, on peut imaginer plein de trucs, par exemple appliquer une texture de terrain plus réaliste, ou appliquer une texture de carte routière, ou faire tomber de la pluie avec le simulateur de fluides de Blender, et peut-être voir l'eau emprunter le lit des fleuves, ou bien utiliser un fluide plus visqueux, et simuler des écoulements de lave depuis des volcans. La limite, c'est l'imagination ! Hum ... Mouais ... Disons ... La limite, c'est l'imagination, et la RAM.

Quelques chiffres :

MNT1000_L93_FRANCE : fichier ASC de 4.7 MB, fichier obj de 61.5 MB, 1.2 millions de vertex (vertices), presque autant de polygones (faces).
MNT500_L93_FRANCE : fichier ASC de 18.7 MB, fichier obj de 258.7 MB, probablement 4.8 millions de vertex (vertices), presque autant de polygones (faces).
MNT250_L93_FRANCE : fichier ASC de 74.6 MB, fichier obj de 1.1 GB, probablement 19.2 millions de vertex (vertices), presque autant de polygones (faces).

Voici le script perl "asc2obj.pl" pour convertir les fichiers .ASC en fichiers .obj :


#!/usr/bin/perl -w
# torglut GPL 2011 (this perl script)
# You must first get data from http://www.ign.fr/
# Please read http://professionnels.ign.fr/ficheProduitCMS.do?idDoc=5323461
# for data, and its license, terms of use, etc.
#
# Usage of this script :
# ./asc2obj.pl <filename.asc> [colmin] [rowmin] [colmax] [rowmax] > <filename.obj>
# ./asc2obj.pl MNT1000_L93_FRANCE.ASC > france.obj
# ./asc2obj.pl MNT250_L93_FRANCE.ASC 4265 3545 4615 4285 > corse.obj
# Then you can import france.obj in Blender, using the wavefront importer

use strict;

my %c; # configuration

sub cr() {
    my $id = shift();
    my ($col, $row) = (0, 0);
    $col = 1 + (($id - 1) % $c{'ncols'});
    $row = 1 + (($id - 1) / $c{'ncols'});
    return(($col, $row));
}

sub parse_asc() {
    my $filename = shift() or die("error : input filename missing");
    my $colmin = shift() || 1;
    my $rowmin = shift() || 1;
    my $colmax = shift() || 9999;
    my $rowmax = shift() || 9999;
    my $fh;
    my ($x, $y, $z, $step, $factor);
    my ($a, $b, $c, $d);
    my $f = ''; # list of faces
    my $id = 0;
    my $realid = 0;
    my ($col, $row);

    open($fh, "<$filename") or die("error : cannot open file $filename");
    while (my $line = <$fh>) {
        $line =~ s/\n$//;
        $line =~ s/\r$//;
        if ($line =~ m/^\s*(\w+)\s+(\-?[\d\.]+)$/g) {
            $c{lc($1)} = $2; # get configuration from ASC file header
            if (defined($c{'ncols'})) {
                if ($colmax == 9999) { $colmax = $c{'ncols'}; }
                $c{'realcols'} = 1 + $colmax - $colmin;
                $step = 20.0 / $c{'ncols'};
                if (defined($c{'cellsize'})) {
                    $factor = 20.0 / ($c{'ncols'} * $c{'cellsize'});
                    if (defined($c{'nrows'})) {
                        if ($rowmax == 9999) { $rowmax = $c{'nrows'}; }
                        $y = ($factor * $c{'nrows'} * $c{'cellsize'}) / 2;
                    }
                }
            }
        } else {
            $line =~ s/$c{'nodata_value'}/0/g;
            $x = -10.0 - $step;
            while ($line =~ s/^\s*(-?\d+)//g) {
                $id += 1;
                $x += $step;
                ($col, $row) = &cr($id);
                next if (($col < $colmin) || ($col > $colmax) || ($row < $rowmin) || ($row > $rowmax));
                $realid += 1;
                $z = $factor * $1;
                printf("v %.3f %.3f %.3f\n", $x, $y, $z);
                if (($realid > $c{'realcols'}) && (($realid - 1) % ($c{'realcols'}))) {
                    $a = $realid;
                    $b = $realid - $c{'realcols'};
                    $c = $b - 1;
                    $d = $a - 1;
                    $f .= "f $a $b $c $d\n";
                }
            }
        }
        $y -= $step;
    }
    close($fh);
    print($f);
}

# main
&parse_asc(shift(), shift(), shift(), shift(), shift());

Dessine-moi un verre de jus d'orange

2011-05-13T21:40:00.009+02:00

Une nouvelle vidéo tutorial avec Blender.

Le rendu final en image :

Un autre exemple de rendu en image :

La vidéo, partie 1 :

La vidéo, partie 2 :

La vidéo, partie 3 :

Dessine-moi une orange

2011-04-30T11:07:00.009+02:00

J'ai regardé une foultitude de vidéos "tutorial" pour apprendre à utiliser le logiciel de lancer de rayons : Blender 3D.

En résumé, dans les perles, il y a :

Les vidéos hébergées sur le site de Blender.
Les vidéos pas-à-pas "Blender Video Tutorials" (Neal Hirsig).
Les fabuleuses vidéos du site Blender Cookie, même si malheureusement, certaines sont payantes. Elles sont faites par des gens qui visiblement parlent le "Blender" couramment : Jonathan Williamson, David Ward, et d'autres.
Les vidéos youtube de David Ward.
Le film Sintel.
Le film Big Buck Bunny.

Pour débuter, voici 4 vidéos pas-à-pas, tout de mon cru, pour modéliser une orange.

Le rendu final en image (ok, avec 3 oranges) :

Vidéo partie 1 :

Vidéo partie 2 :

Vidéo partie 3 :

Vidéo partie 4 :

L'ordinateur de Mademoiselle Pêche sera-t-il allumé demain ?

2010-06-24T00:01:00.001+02:00

Voilà encore une grande question pour l'humanité, et une occasion de jouer à nouveau avec gnuplot. D'après le graphe présentant une semaine générique, et en admettant qu'on soit lundi, la réponse est "plutôt oui, aux alentours de midi".

Pour fabriquer ce graphe, il faut quelques données.

L'idéal serait d'avoir un un fichier "days.txt" qui, sur chaque ligne, contiendrait "D/HH P", où D serait le jour de la semaine, HH serait l'heure, ou plutôt, la tranche horaire entre HH et HH+1, et P serait le pourcentage de chances que l'ordinateur de Mademoiselle Pêche soit allumé au jour D et à l'heure HH. Malheureusement, d'après la documentation gnuplot, il n'est pas possible de paramétrer la directive "set timefmt" pour lui demander de lire une donnée de type "jour de la semaine". On peut par contre afficher une donnée de ce type, en utilisant "%a" dans les paramètres de la directive "set format x". Donc il va falloir tricher pour faire lire les données à gnuplot, et lui indiquer de quel "jour de la semaine" on parle. Par exemple, on peut fixer l'année. Disons (presque au hasard) qu'on fixe l'année à 1970. La directive "set timefmt" accèpte "%j" en paramètre, pour indiquer le "jour de l'année" (de 1 à 365). Donc si on parle de "1970/1", on désigne le jour 1 de l'année 1970. La commande suivante indique qu'il s'agissait d'un jeudi :


perl -e 'print(scalar(localtime(0)) . "\n");'
Thu Jan  1 01:00:00 1970

Et avec la commande suivante, en ajoutant 4 jours, on constate que le jour 5 (1+4) de l'année 1970 était un lundi :


perl -e 'print(scalar(localtime(4 * 24 * 3600)) . "\n");'
Mon Jan  5 01:00:00 1970

Donc on peut donner en entrée à gnuplot des lignes du type "1970/D+4 P", avec D représentant le "jour de la semaine", et variant de 1 pour lundi, à 7 pour dimanche : de 1970/5 à 1970/11.

Pour le pourcentage de chances que l'ordinateur de Mademoiselle Pêche soit allumé, c'est un peu moins trivial : je ne suis pas voyant. On va considérer que l'histoire se répète (ou que Mademoiselle Pêche a ses petites habitudes), et que si, par le passé, l'ordinateur était généralement allumé le mardi entre 11H et 12H, alors il le sera, à la même heure, mardi prochain. Pour le passé, c'est plus simple. On peut par exemple regarder le contenu des fichiers syslog, et se dire que s'il y a une ligne de log datée du jour D et de l'heure HH, alors c'est que l'ordinateur était allumé. Mademoiselle Pêche fait partie de ces gens étonnants qui éteignent régulièrement leur ordinateur.

Plus on a de données, mieux c'est, donc on peut configurer l'ordinateur de Mademoiselle Pêche pour stocker une grande période de logs. Mademoiselle Pêche est sous Ubuntu/GNU/Linux, donc on peut modifier, pour cela, la valeur du paramètre "rotate" dans le fichier "/etc/logrotate.d/rsyslog" :


# /etc/logrotate.d/rsyslog
# (...)
/var/log/syslog
{
    rotate 60
    daily
    # (...)
}
# (...)

Oui mais parfois, Mademoiselle Pêche laisse l'ordinateur allumé, mais aucun log n'est produit, donc la lecture des fichiers syslog n'est pas forcément très fiable. On peut forcer rsyslog (ou autre syslog-ng) à écrire au moins un log toutes les n secondes. Pour rsyslog, il s'agit des paramètres "$ModLoad immark", et, optionnellement, "$MarkMessagePeriod" dans le fichier "/etc/rsyslog.conf".

Après quelques semaines, on peut demander à un script perl de lire ces fichiers syslog, et de produire un fichier indiquant, pour chaque jour de la semaine, et chaque heure, si l'ordinateur était allumé (valeur 100%), ou non (valeur 0%), ou parfois (autre valeur).

Le script "onoff_days.pl" :


#!/usr/bin/perl -w

# torglut
# GPL

use strict;

use Time::Local;

my $line;
my $stamp;
my $next_stamp;
my %stamp_hash;
my @stamp_array;
my %v;  # database
my $step = 3600;    # one hour

my %mon2num    = qw(
 jan 00 feb 01 mar 02 apr 03 may 04 jun 05
 jul 06 aug 07 sep 08 oct 09 nov 10 dec 11
);

# get current year
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();

&init();    # empty %v database

while ($line = <stdin>) {
    $stamp_hash{int(&stampfromline($line) / $step)} = 1;
}

delete($stamp_hash{0});    # delete failed stamps
@stamp_array = sort {$a <=> $b} (keys(%stamp_hash));    # sort stamps

$stamp       = shift(@stamp_array);    # first stamp
&add_value($stamp, 100);    # computer is ON

while ($next_stamp = shift(@stamp_array)) {
    while (++$stamp < $next_stamp) { &add_value($stamp, 0); }    # OFF
    &add_value($stamp, 100);                                        # ON
}

&print_stats();

sub stampfromline {
    my $line = shift();
    if ($line =~ m/^(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+/) {
        return(&timelocal($5, $4, $3, $2, $mon2num{lc($1)}, $year));
    } else {
        return(0);
    }
}

sub add_value {
    my $date  = shift();
    my $value = shift();
    ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime($date * $step);
    # if $wday == 0 then it means Sunday :
    if ($wday == 0) { $wday = 7; }
    $v{$wday}{$hour}{number} += 1;
    $v{$wday}{$hour}{value}  += $value;
}

sub init {
    for (my $d = 1; $d < 8; $d++) {
        for (my $h = 0; $h < 24; $h++) {
            $v{$d}{$h}{number} = 0;
            $v{$d}{$h}{value}  = 0;
        }
    }
}

sub print_stats {
    for (my $d = 1; $d < 8; $d++) {
        for (my $h = 0; $h < 24; $h++) {
            my $p = 0;
            if ($v{$d}{$h}{number} != 0) {
                $p = int($v{$d}{$h}{value} / $v{$d}{$h}{number});
            }
            my $h_str = sprintf("%02d", $h);
            my $dd = $d + 4;    # Day 4 of year 1970 was Sunday
            print('1970/' . $dd . '/' . $h_str . ' ' . $p . "\n");
        }
    }
}

La commande à lancer pour produire le fichier "days.txt" :


zcat syslog.*.gz | onoff_days.pl > days.txt

Le fichier de commandes gnuplot "plot_days.gp" :


set output "computer_days.png"
set terminal png size 800,600
set xdata time
set timefmt "%Y/%j/%H"
set format x "%a %H"
set yrange [0:100]
set grid
set key left box
plot "days.txt" using 1:2 with lines title " On"

La commande pour demander à gnuplot de tracer la courbe sur une semaine :


gnuplot plot_days.gp

Et voilà, on peut répondre à la question initiale. Sauf qu'à y regarder de près, c'est plutôt moche comme graphe (je n'ai peut-être pas assez de données pour arrondir la courbe).

Voici donc un autre script perl, un autre fichier de commandes gnuplot, et une autre courbe, non pas sur une semaine, mais sur une journée, cette fois-ci :

Fichier "onoff_hours.pl" :


#!/usr/bin/perl -w

# torglut
# GPL

use strict;

use Time::Local;

my $line;
my $stamp;
my $next_stamp;
my %stamp_hash;
my @stamp_array;
my %v;            # database
my $step = 3600;    # one hour

my %mon2num    = qw(
 jan 00 feb 01 mar 02 apr 03 may 04 jun 05
 jul 06 aug 07 sep 08 oct 09 nov 10 dec 11
);

# get current year
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();

&init();    # empty %v database

while ($line = ) {
    $stamp_hash{int(&stampfromline($line) / $step)} = 1;
}

delete($stamp_hash{0});        # delete failed stamps
@stamp_array = sort {$a <=> $b} (keys(%stamp_hash));    # sort stamps

$stamp    = shift(@stamp_array);    # first stamp
&add_value($stamp, 100);    # computer is ON

while ($next_stamp = shift(@stamp_array)) {
    while (++$stamp < $next_stamp) { &add_value($stamp, 0); }    # OFF
    &add_value($stamp, 100);                    # ON
}

&print_stats();

sub stampfromline {
    my $line = shift();
    if ($line =~ m/^(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+/) {
        return(&timelocal($5, $4, $3, $2, $mon2num{lc($1)}, $year));
    } else {
        return(0);
    }
}

sub add_value {
    my $date  = shift();
    my $value = shift();
    ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime($date * $step);
    $v{$hour}{number}    += 1;
    $v{$hour}{value}    += $value;
}

sub init {
    for (my $h = 0; $h < 24; $h++) {
        $v{$h}{number}    = 0;
        $v{$h}{value}    = 0;
    }
}

sub print_stats {
    for (my $h = 0; $h < 24; $h++) {
        my $p = 0;
        if ($v{$h}{number} != 0) {
            $p = int($v{$h}{value} / $v{$h}{number});
        }
        my $h_str = sprintf("%02d", $h);
        print($h_str . ' ' . $p . "\n");
    }
}

Fichier "plot_hours.gp" :


set output "computer_hours.png"
set terminal png size 800,600
set xdata time
set timefmt "%H"
set format x "%H"
set yrange [0:100]
set grid
set key left box
plot "hours.txt" using 1:2 smooth csplines with lines title " On"

Commandes :


zcat syslog.*.gz | onoff_hours.pl > hours.txt
gnuplot plot_hours.gp

La courbe générée est plus sympa.

Et on voit, par exemple, qu'il serait judicieux de lancer une sauvegarde distante aux alentours de 11H du matin, car l'ordinateur a des chances d'être allumé dans cette tranche horaire :


rsync -av --exclude='*/Trash/*' --exclude='.thumbnails/*' --exclude='*Cache/*' --exclude='*cache/*' -e "ssh -l peche -p 2626" peche@peche.example.org:/home/peche/ /home/torglut/peche/.

Assistance utilisateur pour Mademoiselle Rose

2010-06-16T21:13:00.003+02:00

Il arrive parfois que je doive apporter une sorte d'assistance utilisateur pour l'ordinateur de Mademoiselle Rose. Pas dans le genre je me connecte en ssh pour faire une mise à jour, ou installer un nouveau logiciel, ou configurer un bidule, mais plutôt dans le genre montrer où se trouve le menu machin dans GNOME, ou bien comment on enregistre un document OpenOffice, ou encore comment on joue à Gnome-Mines. Donc il me faut interagir avec son bureau. Et le souci c'est que je ne me souviens jamais de la ligne de commande pour lancer VNC sur son ordinateur, depuis le mien, dans un tunnel ssh.

Voici donc la ligne de commande :


ssh -t -L localhost:5900:localhost:5900 -p 2626 rose@rose.example.org 'x11vnc -localhost'

Les options :

-t Force pseudo-tty allocation.

A vrai dire, cette option provient du "man x11vnc", et je ne comprends pas vraiment à quoi elle sert. Par contre, je m'aperçois que cette page de manuel contient la fameuse ligne de commande ci-dessus, dont je ne me souviens jamais.

-L [bind_address:]port:host:hostport
This works by allocating a socket to listen to port on the local side, optionally bound to the specified bind_address. Whenever a connection is made to this port, the connection is forwarded over the secure channel, and a connection is made to host port hostport from the remote machine.
(...)
The bind_address of “localhost” indicates that the listening port be bound for local use only.

Donc ssh (le client) écoutera sur le port 5900 de l'interface 127.0.0.1 de ma machine (je n'ai pas envie qu'il écoute sur toutes les interfaces, c'est l'objet du premier "localhost:5900"), et il redirigera les connexions faites sur ce port, vers le port 5900 de l'interface 127.0.0.1 de la machine distante (celle de Mademoiselle Rose, c'est l'objet du second "localhost:5900"). On peut indiquer d'autres ports que 5900, mais il n'y a pas d'intérêt pour cet exemple.

-p port

Port to connect to on the remote host.

Euh, bon. Là, c'est à dire que j'avais mis un chouilla de "sécurité par l'obscurité" sur la machine de Mademoiselle Rose. Son démon sshd écoute donc sur le port 2626, qui, si je ne me suis pas trop planté, devrait être le seul port de sa machine qui puisse être joint depuis Internet. C'est pas la gloire, mais c'est comme ça. En temps normal, on peut supprimer ce paramètre "-p 2626".

rose@rose.example.org

Ici, j'indique à ssh de se connecter sur la machine de Mademoiselle Rose et sur son compte. La connexion sur le compte personnel de Mademoiselle Rose permet ensuite à x11vnc de pouvoir se connecter à son serveur X. Pour le nom de machine, j'ai configuré un compte d'enregistrement DNS dynamique sur sa "box" Internet. On peut utiliser les services de dyndns, par exemple. Pour protéger les innocents, les noms de comptes, les noms de machines, et les ports ont été changés dans cet exemple. A ce sujet, le domaine example.org existe vraiment. Sa fonction est définie ici.

'x11vnc -localhost'

D'après le "man x11vnc" :
As a special case, the option "-localhost" implies "-listen localhost".
(...)
-localhost : Basically the same as "-allow 127.0.0.1".

C'est la commande qui sera exécutée sur la machine de Mademoiselle Rose, une fois la connexion ssh établie. Le programme x11vnc est ainsi lancé à la demande (il faut pour cela que la commande existe sur sa machine). Il écoutera uniquement sur l'interface 127.0.0.1 (la ceinture), et il n'acceptera de connexion que depuis l'adresse 127.0.0.1 (et les bretelles). Je ne configure pas de mot de passe pour se connecter au serveur x11vnc. Le seul mot de passe demandé sera celui du compte rose sur la machine de Mademoiselle Rose, ça suffit bien.

Ensuite, il ne me reste plus qu'à lancer un client VNC (un viewer) sur mon ordinateur, en lui demandant de se connecter au pseudo-serveur VNC qui écoute sur le port 5900 de l'interface 127.0.0.1 de ma machine. La page de manuel de x11vnc propose d'utiliser la commande suivante :


vncviewer -encodings 'copyrect tight zrle hextile' localhost:0

Pour le coup, mon vncviewer (xtightvncviewer) fonctionne, mais il m'indique ne pas connaître l'option 'zrle', ce qui n'est pas bien grave.

Une autre solution est d'utiliser le client VNC installé par défaut sous Ubuntu (qui se nomme "vinagre"). Il se trouve dans le menu "Applications">"Internet">"Remote Desktop Viewer". Il faut lui demander une connexion vers l'hôte "localhost:5900".


vinagre localhost

Une bien belle courbe

2010-02-15T22:30:00.003+01:00

Suite de l'article gnuplot.

Il se trouve que quelques paquets traversent le routeur NetGear, par configuration. Certains d'entre eux finissent sur le firewall netfilter/iptables de ma machine.

Ils sont tracés, avec des commandes telles que :


(...)
IPT=/sbin/iptables
(...) 
$IPT -N logdrop
$IPT -A logdrop -j LOG --log-prefix "fwlogdrop "
$IPT -A logdrop -j DROP
(...)
$IPT -A INPUT -m conntrack --ctstate NEW -j logdrop
(...)

Bref, revoici le script "log2gp.pl", modifié pour prendre en compte aussi ces paquets :


#!/usr/bin/perl -w

use strict;

my @file = <STDIN>;
my %d;
my %mon2num = qw(
 jan 01 feb 02 mar 03 apr 04 may 05 jun 06
 jul 07 aug 08 sep 09 oct 10 nov 11 dec 12
);
my $month;
my $day;

while (my $l = shift(@file)) {
        chomp($l);
        if ($l =~ m/^(\w+)\s+(\d+).*Packet - Source:.* Destination:.* - \[Any\(ALL\) rule match\]/) {
                &add_log($1, $2);
        } elsif ($l =~ m/^(\w+)\s+(\d+).* kernel: .*IN=.*OUT=.*SRC=.*DST=.*/) {
                &add_log($1, $2);
        }
}

sub add_log {
        my $month = shift();
        my $day   = shift();
        $month = $mon2num{lc(substr($month, 0, 3))};
        $day = sprintf("%02d", $day);
        if (!defined($d{"$month/$day"})) { $d{"$month/$day"} = 0.0; }
        $d{"$month/$day"} += 1.0;
}

foreach my $k (sort(keys(%d))) {
        print("$k $d{$k}\n");
}

La commande pour générer la courbe est toujours la même :


zcat /var/log/syslog.*.gz | ./log2gp.pl > fw.dat
gnuplot plot.conf

Samsung YP-R1-JCB et Linux

2010-02-07T17:16:00.000+01:00

Si tu souhaites acheter un balladeur musical "compatible" avec GNU/Linux, une option est d'en trouver un qui veuille bien se comporter comme une clef USB (USB mass storage) une fois branché à l'ordinateur. Voici ma contribution à ton choix : le balladeur Samsung YP-R1-JCB peut se comporter comme cela. Du coup, pas de problème lorsqu'on le connecte à un système GNU/Linux.

Pour qu'il se comporte comme un périphérique de type "USB mass storage", il suffit, sur le balladeur, d'aller se promener dans le menu suivant :

"Settings" -> "Paramètres" -> "Système" -> "Connexion PC"
puis de choisir le mode "MSC" (qui n'est visiblement pas le mode par défaut).

Une fois connecté en USB (un câcle USB-Samsung-bidule est heureusement livré avec) , tu peux voir quelque chose comme ça dans syslog :

usb 1-4: new high speed USB device using ehci_hcd and address 6
usb 1-4: configuration #1 chosen from 1 choice
scsi7 : SCSI emulation for USB Mass Storage devices
usb-storage: device found at 6
usb-storage: waiting for device to settle before scanning
usb-storage: device scan complete
scsi 7:0:0:0: Direct-Access Samsung YP-R1 0322 PQ: 0 ANSI: 2
sd 7:0:0:0: Attached scsi generic sg6 type 0
sd 7:0:0:0: [sdf] 31434752 512-byte logical blocks: (16.0 GB/14.9 GiB)
sd 7:0:0:0: [sdf] Write Protect is off
sd 7:0:0:0: [sdf] Mode Sense: 0f 00 00 00
sd 7:0:0:0: [sdf] Assuming drive cache: write through
sd 7:0:0:0: [sdf] Assuming drive cache: write through
sdf:
sd 7:0:0:0: [sdf] Assuming drive cache: write through
sd 7:0:0:0: [sdf] Attached SCSI removable disk

Le balladeur peut alors être monté comme une clef USB, en VFAT. Sur Ubuntu, il est monté automatiquement, et "mount -v" indique quelque chose comme :

/dev/sdf on /media/R1 type vfat
(rw,nosuid,nodev,uhelper=devkit,uid=1000,gid=1000,
shortname=mixed,dmask=0077,utf8=1,flush)

Sinon, il reste à savoir s'il est bien, par rapport à d'autres, et là je ne sais pas t'aider, car je ne dispose que de ce balladeur. En tous cas, il sait lire a peu près tous les formats audio (mp3, ogg, ...), et à peu près tous les formats vidéo (avi, divx, ...), il dispose du bluetooth, et d'une sortie vidéo (mais le câble vidéo n'est pas livré avec, et je n'ai pas testé). Il existe un tas de sites qui présentent avantages et inconvénients de chaque balladeur, mais souvent, la facilité d'utilisation avec un GNU/Linux est laissée de côté. Tout ceci est probablement valable pour le Samsung YP-R1-JCP, puisque visiblement "B" signifie "Black" et "P" signifie "Pink" dans ce nom.

Note :

image : site de samsung

gnuplot : premiers pas

2010-02-07T13:03:00.031+01:00

Le logiciel gnuplot permet de tracer de jolies courbes, graphes, et autres histogrammes.

Pour mes premiers pas, il me faut quelques données. Coup de chance, le fichier "/var/log/syslog" et ses amis "syslog.*.gz" sont remplis de tonnes de données dont je ne fais malheureusement pas grand chose, comme par exemple les logs transmis par mon routeur NetGear.

Celui-ci produit des logs pour les paquets qu'il bloque :


Feb  7 11:41:45 TCP Packet - Source:192.168.103.66,6000 Destination:192.168.153.215,1879 - [Any(ALL) rule match]

Il envoie ces logs sur le démon "rsyslogd" de ma machine (visiblement, c'est "rsyslogd" et non pas "syslog-ng", par défaut, avec Ubuntu). Question pour plus tard : "UDPServerRun" ou bien "InputUDPServerRun" ?


# /etc/rsyslog.conf
# (...)
$ModLoad imudp
$UDPServerRun 514
# (...)

Le démon place ces logs (et d'autres) dans différents fichiers, dont "/var/log/syslog" :


# /etc/rsyslog.d/50-default.conf
# (...)
*.*;auth,authpriv.none          -/var/log/syslog
# (...)

Par la suite, "logrotate" compresse chaque journée de logs (pour un usage ultérieur, comme on dit) :


# /etc/logrotate.d/rsyslog
# (...)
/var/log/syslog
{
 rotate 183
 daily
 missingok
 notifempty
 delaycompress
 compress
 postrotate
 reload rsyslog >/dev/null 2>&1 || true
 endscript
}
# (...)

Voici donc des tonnes de logs, dans les fichiers "/var/log/syslog.*.gz". Pour revenir à gnuplot, il faudrait un fichier de données utilisable, par exemple un fichier texte, contenant sur chaque ligne, une date, suivie du nombre de paquets bloqués à cette date. Ceci peut être fait à l'aide d'un script perl, en prenant en entrée les fichiers de log, et en comptant simplement le nombre de paquets bloqués pour chaque jour. Fichier "log2gp.pl" :


#!/usr/bin/perl -w

use strict;

my @file = <STDIN>;
my %d;
my %mon2num = qw(
 jan 01 feb 02 mar 03 apr 04 may 05 jun 06
 jul 07 aug 08 sep 09 oct 10 nov 11 dec 12
);
my $month;
my $day;

while (my $l = shift(@file)) {
    next if $l !~ m/ - \[Any\(ALL\) rule match\]/;
    chomp($l);
    if ($l =~ m/^(\w+)\s+(\d+)/) {
        $month = $mon2num{lc(substr($1, 0, 3))};
        $day = sprintf("%02d", $2);
    }
    if (!defined($d{"$month/$day"})) { $d{"$month/$day"} = 0.0; }
    $d{"$month/$day"} += 1.0;
}

foreach my $k (sort(keys(%d))) {
    print("$k $d{$k}\n");
}

Ainsi, la commande suivante permet de générer un fichier "fw.dat" qui servira de données d'entrée pour gnuplot :


zcat /var/log/syslog.*.gz | ./log2gp.pl > fw.dat

Voici donc nos données, dans le fichier "fw.dat" :


01/09 267
01/10 176
(...)

On peut enfin dire à gnuplot de tracer une jolie courbe à partir de ces données, avec un fichier de commandes gnuplot. Le fichier "plot.conf" ci-dessous est utilisé pour générer cette courbe :


set output "fw.png"
set terminal png size 800,600
set xdata time
set timefmt "%m/%d"
set format x "%d %b"
set yrange [0:]
set grid
set xlabel "Day"
set ylabel "Number"
set title "Firewall"
set key left box
plot "fw.dat" using 1:2 smooth csplines with lines title "blocked packets"

Pour générer l'image "fw.png", il suffit alors de lancer :


zcat /var/log/syslog.*.gz | ./log2gp.pl > fw.dat
gnuplot plot.conf

Et voilà ! Une jolie courbe qui présente le nombre de paquets bloqués sur le firewall, par jour, en provenance des Super Vilains de l'Internet. Et après ? Après rien. C'est une jolie courbe, et pis c'est tout ;-)

Financiers faciles

2010-02-06T11:43:00.014+01:00

Ingrédients :

4 blancs d'oeufs
140 g de sucre glace
120 g de poudre d'amandes [sauf que ton paquet fait 125 g, c'est ballot]
45 g de farine
170 g de beurre + 20 g pour les moules [pour tes moules en silicone, ce n'est peut-être pas nécessaire]
sel [pas certain sur ce coup]

Recette :

Chauffe le beurre dans une casserole jusqu'à ce qu'il prenne une couleur noisette.
Laisse le refroidir, sans toutefois le laisser figer.
Prends un saladier et mélange le sucre et la poudre d'amandes, puis la farine.
Ajoute les blancs d'oeufs (non battus), et enfin le beurre.
Homogénéise bien la pâte.
Met la pâte au réfrigérateur pour la figer pendant une heure.
Cette pâte peut être préparée à l'avance et même être congelée dans des sacs en plastique.
Préchauffe le four à 200° (thermostat 6). [ma recette est incohérente sur ce point : thermostat 6 devrait être équivalent à 180°, disons que c'est par là quoi, disons 200° et puis c'est tout]
Remplis des moules à financiers avec l'appareil [terme savant pour désigner la pâte].
Enfourne les financiers 20 minutes environ [je dirais plutôt 17 minutes].
Sors les financiers du four, démoules les aussitôt, et laisse les refroidir sur une grille.

Moules à financiers :

Malheureusement, on n'en trouve pas partout. Père Noël m'a apporté les miens, en silicone, de marque "mastrad".

Que faire des jaunes d'oeufs ?

Fais de la crème anglaise avec les jaunes d'oeufs, ça le fait carrément avec les financiers ;-)

Borne d'arcade, la suite

2010-01-08T22:53:00.003+01:00

Le site a été mis à jour, avec la fameuse page "software.html" que tu attendais tant : cours y vite, cours y vite.

La fabuleuse recette des financiers à la noisette

2010-01-08T22:41:00.004+01:00

La recette des financiers à la noisette est très facile :
Il te suffit de remplacer la poudre d'amandes ... par de la poudre de noisettes.

Une prochaine fois, je t'expliquerai la recette des financiers à la noix.

Construire une borne d'arcade en 6 mois

2009-08-16T23:46:00.003+02:00

Construire une borne d'arcade en 6 mois : le site.

3615 tavie

2009-06-13T11:05:00.007+02:00

Et voilà, moi aussi je crée un blog.
Je peux y raconter ma vie passionnante.

Notes :
Image : wikipedia