Image Magick - Faire un tableau d'image

Image Magick

Faire un tableau d'image

Image Magick est une suite d'outils de traitement d'images formidable.

Cette suite est accessible ici : http://www.imagemagick.org

Afin de créer des tableaux de photos, j'ai fait un petit script python que voici:

import os

def strFor(strObj):
    return strObj.replace('[','').replace(']','').replace('\'','').replace(',','')

l = os.listdir()
r = []
counter=0
for x in l:
    if '.JPG' in x:
        r.append(x)
        if len(r) == 10:
            counter = counter + 1
            print('convert -label "%%f" '  + strFor(str(r)) + ' -frame 10x5+3+0 miff:- | montage - -tile 5x2 -frame 5 -geometry "512x512+5+5>" thumb{}.png'.format(counter))
            r = []

if len(r)>0:
    counter = counter + 1
    print('convert -label "%%f" '  + strFor(str(r)) + ' -frame 10x5+3+0 miff:- | montage - -tile 5x2 -frame 5 -geometry "512x512+5+5>" thumb{}.png'.format(counter))

Ce script permet de créer un second script (ici un batch windows) qui va permettre d'exécuter les commandes convert et montage de la suite Image Magick pour créer des tableaux de 5x2 images.

Les commandes convert et montage doivent être dans le PATH.

Pour faire une conversion de png vers jpg: mogrify -format jpg *.png
ATTENTION: mogrify remplace le fichier original.

Émuler un port de communication RS232 sur Linux et le lier à TCP/IP

Article intéressant pour comprendre les ports série sous linux : http://pficheux.free.fr/articles/lmf/serial/

1 - Solution à essayer avec Socat :

socat -d -d PTY,ignoreeof,echo=0,raw,link=f1 PTY,ignoreeof,echo=0,raw,link=f2 &

options :

-d -d : affiche les messages fatal, erreur, warning et notice

PTY : ouvre un pseudo terminal (pty)

ignoreeof : ne ferme pas le 'tunnel' si eof est rencontré

echo=0 : ???

raw : à priori, passe les infos input/output sans traitement (pas de mode canonique => pas d'attente de line feed [LF] pour envoyer/recevoir les caractères)

link=f1 : nomme le lien f1

La solution 1 fonctionne en faisant :

- la commande

- puis deux terminaux

- dans l'un : cat f2

- dans l'autre cat «<fichier> > f1

Utilisation de minicom

Une fois installé, minicom est simple d'utilisation. Il faut le lancer avec -s afin d'obtenir un écran de configuration qui permette de configurer le port série à utiliser et beaucoup d'autres options.

En démarrant minicom dans deux terminaux indépendant et sur les /dev/pts/12 et 14 (selon liens proposés sous f1 et f2), nous pouvons communiquer en liaison série entre les deux minicom.

Essai de lier une interface TCP/IP à un port série

socat -d -d PTY,ignoreeof,echo=0,raw,link=f1 TCP-LISTEN:22021,ignoreeof

Cela fonctionne ensuite en utilisant minicom d'un côté :

minicom -p /dev/pts/12

et netcat de l'autre :

netcat 127.0.0.1 22021

Essai de lier une interface TCP/IP à un device système (/dev/urandom)

socat -d -d /dev/urandom TCP-LISTEN:22021,ignoreeof

et netcat de l'autre :

netcat 127.0.0.1 22021

Essai pour lier une RS (ex /dev/ttyS0) existante à un port TCP/IP:

socat -d -d /dev/ttyS0 TCP-LISTEN:22021,ignoreeof

attention: il faut au préalable configurer la liaison série par exemple avec stty

Des exemples intéressants :

A cette adresse des exemples intéressants d'usage de socat :

http://stuff.mit.edu/afs/sipb/machine/penguin-lust/src/socat-1.7.1.2/EXAMPLES

Python, Tkinter et thread

Voici un petit programme d'exemple pour mise en oeuvre de Python 3.4, Tkinter et un thread.

import tkinter as tk
import threading
import time

class Application(tk.Frame):
    def __init__(self, master=None):
        tk.Frame.__init__(self, master)
        self.grid()
        self.createWidgets()

    def createWidgets(self):
        self.quitButton = tk.Button(self, text='Quit',
            command=self.wait_and_quit)
        self.quitButton.grid()
        self.text = tk.Text(self)

        self.text.grid()
        self.text.config(state=tk.DISABLED)

        self.threadEvent= threading.Event()
        self.threadObj = ThreadedTask(self.threadEvent,self)
        self.threadObj.start()

    def wait_and_quit(self):
        # A l'arret, on pose l'event et on attend la fin du thread avant de quitter
        self.threadEvent.set()
        self.threadObj.join()
        quit()

    def addLine(self,txt):
        # Methode permettant d'afficher une chaine de texte sur une nouvelle

        # ligne du widget text
        self.text.config(state=tk.NORMAL)
        self.text.insert(tk.END, txt+"\n")
        self.text.config(state=tk.DISABLED)

class ThreadedTask(threading.Thread):
    def __init__(self, quitEvent, applicationObj):
        threading.Thread.__init__(self)
        self.quitEvent = quitEvent
        self.appliObj=applicationObj

    def run(self):
        while self.quitEvent.wait(1.0) == False:
            self.appliObj.addLine("New line")
            time.sleep(2)  # Attente de 2 seconde

if __name__=='__main__':
    app = Application()
    app.master.title('Thread Test')
    app.addLine("Ligne essai 1")
    app.addLine("Ca semble fonctionner ?")
    app.mainloop()

Socat quel outil formidable.. avec un tunnel ssh

Socat est vraiment un outil formidable qui permet, dans un registre augmenté à ncat, de faire des "bidouilles" en communication réseau bien sympas.

Personnellement je l'utilise pour monter un réseau virtuel sur SSH (un VPN en somme).

Imaginons deux PC sur l'Internet:

•  PC1 d'adresse IPv4 86.22.32.30
• PC2 d'adresse IPv4 88.32.24.52

Sur le PC2 fonctionne un serveur SSH sur le port 8269 (le port normalisé étant 22, le port utilisé ici est donc une configuration "personnelle").

La 1ère étape est donc d'établir le pont SSH, donc depuis le PC1 nous faisons:

ssh -p 8269 userX@88.32.24.52 -L 5702:localhost:5702

userX est le login d'un compte utilisateur connu sur le PC2. C'est utilisateur est autorisé à ce connecté via SSH au PC2.

Afin de créer notre réseau virtuel (via socat), nous avons besoin de permettre une inter-connexion entre deux instances de socat; l'une fonctionnant sur le PC2 comme serveur, l'autre sur le PC1 comme client, qui établira la connexion.

Pour cela, il nous faut utiliser la redirection de port (port forwarding) offerte par SSH afin que le port d'écoute du serveur socat sur le PC2 soit redirigé sur le PC1. Ceci est l'objet des paramètres " -L 5702:localhost:5702", ainsi le port 5702 local au PC2 est redirigé sur le port équivalent du PC1 (donc 5702).

Nous démarrons, sur le PC2 le serveur socat qui va accepter la connexion du client PC1 et qui va créer un tunnel (sous réseau).

sudo socat TCP4-LISTEN:5702 TUN:193.168.0.1/24,up &

Les paramètres TUN:193.168.0.1/24,up vont permettre de créer une interface réseau d'adresse IPv4 193.168.0.1 et de masque 24 (255.255.255.0).

Côté PC1 (le client socat), nous démarrons la commande suivante:

 sudo socat TCP:127.0.0.1:5702 TUN:193.168.0.2/24,up &

Nous remarquons que la connexion se fait au PC local (127.0.0.1 = PC1) sur le port 5702 qui est le port "forwardé" du serveur PC2 au client PC1.

De même que pour le serveur, il y a création d'une interface réseau IPv4, mais cette fois-ci d'adresse 193.168.0.2/24.

Si tout s'est bien passé, vous pouvez désormais faire un ping entre les deux machines sur le même réseau virtuel 193.168.0.0/24

Sur les deux PC, le ping 193.168.0.1 et le ping 193.168.0.2 doivent fonctionner.

Docker, LCX, Cgroups, Github, ACID, base de données, CSP, concurrence et intégration continue...

Et voilà, je me balade sur le net en partant d'un sujet et je me retrouve sur un autre sujet qui m'intéresse tout autant... :-(

Je suis toujours indiscipliné et perdu à vouloir tout connaître, tout comprendre et tout savoir.

Ce soir, en partant de recherche à propos de Docker, je passe par une présentation sympa de celui-ci mais sans vraiment l'exploiter car je saute de suite vers des termes que je ne maîtrise pas : les LCX et les Cgroups.

Bref... Je n'ai encore pas  ce soir regardé Docker. :-(

D'autant que sur la page de docker, je vois qu'ils demandent à être "forkés" sur github. Donc je m'intéresse à GitHub qui est un espèce de sourceforge utilisant Git et basé sur le fork. Et de fil en aiguille je tombe sur l'article intéressant du blog de Frédéric de Villamil.

Depuis son blog je m'intéresse alors au langage Go et à son aspect concurrentiel.
Et mon voyage se poursuit alors vers les paradigmes ACID des bases de données et de la gestion des transactions et de contrôle de la concurrence via STM  puis des  l'algèbre des processus en CSP.

cré-diou...
Il faut que je creuse tout cela... mais quand.

Ah, j'oubliais... dans mon dédale je suis passé aussi sur les systèmes d'intégration continue à la Jenkins, TinderBox et buildbot.
Gil

Aujourd'hui, un peu de jardin.

Alors, après avoir repeint une partie de la balancelle et tondu, voici qq photos des activités jardin.

Alors, au 1er plan, la zone bêchée où était placée la p'tite maison des enfants.

Nos jolies fleurs  au pied du cerisier.

Un "truc" que j'ai planté

Et un autre "truc" que j'ai déplacé car il crevait derrière un "truc" plus envahissant.

Des outils....

• filecheckmd5.exe : outil basé sur le MD5, cet outil est utilisé par le projet SIT. L'outil est aujourd'hui obsolète ainsi que la méthode de CRC (MD5)
• ExactFile-Setup.exe : nouvel outil permettant d'autres algorithmes de CRC comme le SHA256, ...
• Création de setup (installateur de programme):
  • Inno Setup : http://www.jrsoftware.org/isinfo.php
  • Install Creator Pro 2.0
• Outils d'analyse des processus Windows (mémoire, ...):
  • ProcessExplorer
  • ProcessMonitor
  • Perfmon.exe - Performance Monitor
  • RAMMap
  • VMMAp
  • Voir les outils Sysinternals: http://technet.microsoft.com/nb-no/sysinternals/bb842062
• Outils pour compter les lignes de code: cloc, ohcount, sloccount
• File manager: xfe