Many years ago, I was dealing with high blood pressure issues. My doctor suggested that I do something that allowed me to concentrate on something fairly useful, but rather trivial. I dealt with it by trying to do counted cross stitch. It’s creative, focused, and keeps your mind occupied on what you are doing, not what is bothering you. I find myself in that position again, so I broke out the hoop and needles and started again. In case you aren’t familiar with counted cross stitch, I’ll give you a gross overview of what it is. Cross stitch is a type of needlework that uses tiny ‘x’ patterns of thread that eventually make up a picture. The thread is called “floss” and the fabric that you use is called “aida”. According to Wikipedia, aida is a special fabric that has tiny squares that have small holes at regular intervals that form the squares. This facilitates the placement of the “x” patterns that make the image. There are two types of cross stitch. One has an image printed on the aida (sort of like paint by numbers), and the other uses totally blank aida that you count stitches from the pattern. The second is much harder than the first. Go to your favorite fabric store or craft section of your local mega-mart and you’ll get the idea.

Il y a plusieurs années, j'avais quelques problèmes de d'hypertension. Mon médecin m'a suggéré de trouver une activité qui m'obligerait à me concentrer sur quelque chose d'assez utile, mais plutôt simple. Je m'en suis sorti en essayant de faire du point de croix compté. C'est créatif, ciblé, et maintient votre esprit occupé sur ce que vous faites, pas sur ce qui vous dérange. Me trouvant à nouveau dans cette situation, j'ai ressorti le cerceau et les aiguilles et j'ai recommencé.

Au cas où vous ne seriez pas familier avec le point de croix compté, je vais vous donner un bref aperçu de ce que c'est. Le point de croix est un type de couture qui consiste à faire des « x » minuscules en fil pour aboutir au final à une image. Le fil s'appelle « floss » ou « soie » et le tissu que vous utilisez s'appelle « aïda ». Selon Wikipedia, l'aïda est un tissu spécial formé de petits carrés et de petits trous à intervalles réguliers. Ceci facilite le placement des motifs en « x » qui forment l'image. Il existe deux types de point de croix. L'un a une image imprimée sur la toile aïda (une sorte de peinture à numéros), et l'autre utilise une toile aïda totalement vierge et c'est vous qui comptez les points du motif. La seconde est beaucoup plus compliquée que la première. Allez dans votre magasin de tissu préféré ou à la section loisirs créatifs de votre hypermarché local et vous comprendrez.

Also a while back, I started playing with creating a program that would take an image and convert it into a cross stitch pattern. One thing lead to another, and I had to shelve the program for other things. I’ve now dusted off the idea and started anew. We will spend the next few articles dealing with this project. It will take a while, since some things are fairly complex and have many parts to them. Here is the “game plan”: • Create a database for the pixel colors to floss colors. • Create a GUI using Tkinter for the application. • Flesh out the application to do the manipulation of the image files. • Create a PDF file that will be the ultimate pattern for the project. What you will learn • Revisitation of database and XML manipulation. • Revisitation of Tkinter GUI programming. If you missed the previous articles on this, please refer to FCM issues 51 thru 54. • Image manipulation using PIL (http://pillow.readthedocs.org/en/latest/). • PDF creation using pyFPDF (https://code.google.com/p/pyfpdf).

J'ai également commencé à m'amuser il y a quelque temps avec la création d'un programme qui prendrait une image pour la convertir en un modèle de point de croix. Une chose en entraînant une autre, j'ai dû laisser le programme de côté pour faire d'autres choses. J'ai maintenant déterré l'idée et commencé à nouveau.

Nous allons traiter ce projet durant les prochains articles. Il faudra néanmoins du temps, car certaines choses sont assez complexes et comprennent de nombreuses parties. Voici le « plan de jeu » : • Créer une base de données pour convertir les couleurs de pixels en couleurs de fils. • Créer une interface graphique avec Tkinter pour l'application. • Étoffer l'application pour faire la manipulation des images. • Créer un fichier PDF qui sera le modèle ultime pour le projet.

Ce que vous apprendrez : • révision sur la manipulation de base de données et XML ; • révision sur la programmation d'interfaces avec Tkinter. Si vous avez raté les précédents articles à ce sujet, merci de vous référer aux numéros 51 à 54 ; • manipulation d'images avec PIL (http://pillow.readthedocs.org/en/latest/) ; • création de PDF à l'aide de pyFPDF (https://code.google.com/p/pyfpdf).

Getting Started The first thing in our list of tasks is to create the database that will hold the DMC(™) floss colors and reference them to the closest approximation to the RGB (Red, Green, Blue) values that are used in images on the computer. At the same time, the database will hold the hex value and the HSV (Hue, Saturation, Value) representations for each floss color. It seems that HSV is the easiest way to find the “closest” representation of a color that will match the floss colors. Of course, the human eye is the ultimate decision maker. If you are not familiar with HSV color representations, there is a rather complex writeup on Wikipedia at http://en.wikipedia.org/wiki/HSL_and_HSV. It might help, but it might make things less clear. The first thing we need is an XML file that has the DMC floss colors with a RGB conversion. The best one I found is at http://sourceforge.net/p/kxstitch/feature-requests/9/. The file you want is dmc.xml. Download it and put it in a folder that you will use to hold the Python code.

Pour commencer

La première chose dans notre liste de tâches est de créer la base de données qui contiendra les couleurs de fils DMC (™) et de les rapprocher le mieux possible des valeurs RVB (Rouge, Vert, Bleu) utilisées pour les images sur ordinateur. La base de données contiendra également la valeur hexadécimale et la représentation HSV (Teinte, Saturation, Lumière) pour chaque couleur de fil. Il semble que le HSV soit la façon la plus simple de trouver la « plus proche » représentation d'une couleur de fil. Bien sûr, l'œil humain est le décideur ultime. Si vous n'êtes pas familier avec les représentations de couleurs HSV, il y a un article assez complexe sur Wikipedia : http://fr.wikipedia.org/wiki/Teinte_saturation_lumi%C3%A8re. Il pourrait aider, mais il pourrait rendre les choses moins claires.

La première chose dont nous avons besoin est un fichier XML qui contient les couleurs de fils DMC avec une conversion RVB. Le meilleur que j'ai trouvé est ici : http://sourceforge.net/p/kxstitch/feature-requests/9/. Le fichier que vous cherchez est dmc.xml. Téléchargez-le et mettez-le dans le dossier que vous utiliserez pour stocker le code Python.

Now we will be using apsw (below) to do our database manipulation, which you should already have and ElementTree to do the XML parsing (which is included in Python version 2.7+). As always, we start with our imports. In this program, we have only the two. We also set the name of the table. The next portion should be familiar if you have been reading the articles for a while. We create a function that will read the XML file, and parse it for us. We then can use the information to load the database. A snippet of the XML file is shown top right. We are looking for the <floss> tag for each line of information. To do this, we use the .findall(‘floss’) command. Once we have the information line, we break each tag (name, description, etc.) into separate variables to place into the database. When it comes to the <color> tag, we use the .floss.findall(‘color’) command to get each value of Red, Green and Blue.

Maintenant, nous allons utiliser apsw (ci-dessous), que vous devriez déjà avoir, pour manipuler la base de données et ElementTree pour faire l'analyse XML (inclus depuis Python version 2.7).

Comme toujours, nous commençons par nos importations. Dans ce programme, nous n'en avons que deux. Nous réglons également le nom de la table.

La partie suivante devrait vous être familière si vous avez lu les articles depuis un certain temps. Nous créons une fonction pour lire le fichier XML et l'analyser. Nous pouvons ensuite utiliser ces informations pour remplir la base de données. Un extrait du fichier XML est affiché en haut à droite.

Nous recherchons la balise <floss> pour chaque ligne d'information. Pour ce faire, nous utilisons la commande .findall('floss'). Une fois que nous avons la ligne d'information, nous découpons chaque balise (nom, description, etc.) en variables distinctes pour les placer dans la base de données. Quand nous arrivons à la balise <color>, nous utilisons la commande .floss.findall('color') pour obtenir chaque valeur de Rouge, Vert et Bleu.

We start by telling the function that we will be using the global variables connection and cursor. We then set the filename of the XML file, parse the XML file, and get started. We also use a counter variable to show that something is happening while the parsing and database inserts are going on. Now that we have all our data, we need to create the SQL insert statement and execute it. Notice the “\” after the word VALUES in the SQL statement. That is a line-continuation character to make it easier for printing here in the magazine. We will be creating the database and table in a few moments. SQL = “INSERT INTO DMC (DMC,Description,Red,Green,Blue) VALUES \ ('%s','%s',%s,%s,%s)” % (name,desc,red,green,blue) cursor.execute(SQL)

Nous commençons par indiquer à la fonction que nous allons utiliser les variables globales connexion et curseur. Nous indiquons ensuite le nom du fichier XML, analysons le fichier XML, et démarrons. Nous utilisons également une variable compteur pour montrer que quelque chose se passe durant les analyses et insertions en base de données.

Maintenant que nous avons toutes nos données, nous devons créer l'instruction d'insertion SQL et l'exécuter. Notez le « \ » après le mot VALUES dans l'instruction SQL. C'est un caractère de continuation de ligne pour faciliter l'impression ici dans le magazine. Nous allons créer la base de données et une table dans quelques instants.

  SQL = "INSERT INTO DMC (DMC,Description,Rouge,Vert,Bleu) VALUES \

  	      ('%s','%s',%s,%s,%s)" % (nom,desc,rouge,vert,bleu)
 

curseur.execute(SQL)

Now, we print to the terminal window that something is going on: print “Working record {0}”.format(cntr) cntr += 1 Now we create and/or open the database in the OpenDB routine (bottom right). If you’ve been with us when we have done database work before, you will notice that we are using two cursors this time. The cursor variable is used for the “normal” inserts, and later on in the select statement for the update to set the hex and HSV values. We have to use two cursors, since if you modify a cursor in the middle of a logic statement, you lose everything with the new command. By using ‘ucursor’, we can use that for the update statements. Other than that, it is our normal OpenDB routine.

Maintenant, nous affichons dans la fenêtre de terminal que quelque chose se passe :

     print “Enregistrement en cours : {0}”.format(compteur)

   compteur += 1

Maintenant, nous créons et/ou ouvrons la base de données dans la routine OuvrirBase (en bas à droite). Si vous étiez avec nous quand nous avons travaillé avec les bases de données, vous avez remarqué que nous utilisons deux curseurs cette fois. La variable curseur est utilisé pour les insertions « normales », et plus tard dans l'instruction select pour la mise à jour afin de régler les valeurs hex et HSV. Nous devons utiliser deux curseurs, car si vous modifiez un curseur au milieu d'une instruction logique, vous perdez tout avec une nouvelle commande. Nous pouvons utiliser « ucursor » pour les déclarations de mise à jour. À part cela, il s'agit de notre routine OpenDB habituelle.

Now that the database is created and/or opened, we can set up our table (top right). Notice that the SQL statement below uses the triple quote to allow for the line to break neatly for viewing. The EmptyTables routine (middle right) is there just to make sure that if we want to or need to run the application more than once, we start with a clean and empty table if it exists. IF we were to stop here, we would have a reasonable working database with the DMC color, color name and the RGB values associated with each. However, as I alluded to before, it is easier to pick the closest floss color by using the HSV data. We next create the hex value from the RGB values (middle left).

Maintenant que la base de données est créée et/ou ouverte, nous pouvons mettre en place notre table (en haut à droite). Notez que l'instruction SQL ci-dessous utilise les guillemets triples pour permettre un saut de ligne pour la lisibilité.

La routine ViderTables (au milieu à droite) est là juste pour s'assurer que si nous voulons ou devons exécuter l'application plus d'une fois, nous commençons avec une table vide et propre si elle existe.

Si nous devions nous arrêter ici, nous aurions une base de données de travail raisonnable avec les couleurs DMC, leur nom et les valeurs RVB associées à chacune. Cependant, comme je l'ai mentionné précédemment, il est plus facile de choisir la couleur de fil la plus proche en utilisant les données HSV.

Nous créons donc ensuite la valeur hexadécimale pour les valeurs RVB (au milieu à gauche).

The next function creates the HSV values from the RGB values. I found the algorithm on the internet. You can research it there. Finally, we create the UpdateDB function (next page, top left). We use the SELECT * FROM DMC command and use the “standard” cursor variable to hold the data. We then step through the returned data, and read the RGB values, and pass them to the rgb2hex function as a tuple and to the rgb2hsv function as three separate values. Once we get the return values, we use the update SQL command to match the proper record by using the primary key (pkID). As I stated before, we have to use a separate cursor for the update statement. The last thing we do is call each of the functions in order to create the database, and, at the end, we print “Finished” so the user knows everything is done. OpenDB() MakeTables() EmptyTables() # Just to be safe ReadXML() UpdateDB() print “Finished”

La fonction suivante crée les valeurs HSV à partir des valeurs RVB. J'ai trouvé l'algorithme sur internet. Vous pouvez le chercher aussi.

Enfin, nous créons la fonction MAJBase (page suivante, en haut à gauche). Nous utilisons la commande SELECT * FROM DMC et la variable de curseur « standard » pour contenir les données. Nous parcourons ensuite les données récupérées, lisons les valeurs RVB et les transmettons à la fonction rgb2hex comme un tuple et à la fonction rgb2hsv comme trois valeurs distinctes. Une fois que nous avons obtenu les valeurs de retour, nous utilisons la commande SQL update pour trouver l’enregistrement approprié en utilisant la clé primaire (pkID). Comme je l'ai déjà dit, nous devons utiliser un curseur distinct pour l'instruction de mise à jour.

La dernière chose à faire est d'appeler chacune des fonctions afin de créer la base de données et, à la fin, nous affichons « Fin » pour informer l'utilisateur que tout est fait.

OuvrirBase() CreerTables() ViderTables() # Juste pour etre sur LireXML() MAJBase() print “Fin”

I named this program “MakeDB”. The database should be created in the same folder where the code and XML file are located. As always, the full code can be found at http://pastebin.com/Zegqw3pi. Next time, we will work on the GUI. We use Tkinter for the GUI, so, in the meantime, you might want to refresh your memory by looking at FCM issues 51 thru 54 where I take you through Tkinter. Until next time, have a good month.

J'ai nommé ce programme « MakeDB ». La base de données devrait être créée dans le dossier où se trouve le code et le fichier XML. Comme toujours, le code complet peut être trouvé sur http://pastebin.com/P7gZgNTm (http://pastebin.com/Zegqw3pi pour le code en anglais).

La prochaine fois, nous travaillerons sur l'interface graphique en utilisant Tkinter, donc, en attendant, vous pouvez vous rafraîchir la mémoire en regardant les FCM nos 51 à 54 où je vous expliquais Tkinter.

Passez un bon mois. À la prochaine fois.

# makedb.py # DMC.xml vers SQLite database # Pour Full Circle Magazine numero 85

import apsw from xml.etree import ElementTree as ET nomtable = “DMC”

inchangé

def LireXML():

  global connexion
  global curseur
  nomfic = 'dmc.xml'
  arbre = ET.parse(nomfic)
  racine = arbre.getroot()
  compteur = 0
  for fil in racine.findall('floss'):
      nom = fil.find('name').text
      desc = fil.find('description').text
      for couleur in fil.findall('color'):
          rouge = couleur.find('red').text
          vert = couleur.find('green').text
          bleu = couleur.find('blue').text

def OuvrirBase():

  global connexion
  global curseur
  global ucurseur
  global nombase
  connexion = apsw.Connection("fils.db3")
  curseur = connexion.cursor()
  ucurseur = connexion.cursor()

def CreerTables():

  sql = '''CREATE TABLE IF NOT EXISTS DMC
           (pkID INTEGER PRIMARY KEY, DMC INTEGER,
           Description TEXT, Rouge INTEGER, Vert INTEGER, Bleu INTEGER,
           HEX TEXT,H INTEGER,S INTEGER,V INTEGER)'''
  curseur.execute(sql)

def rgb2hex(rgb):

  return '%02x%02x%02x' % rgb

def ViderTables():

  sql="DELETE FROM %s" % nomtable
  curseur.execute(sql)

inchangé