Urban wasteland

Sunday, March 1st, 2015

The last time I went to Brus­sels with my car (which is pretty rare all things con­sid­ered), I expect­edly ended up stuck in the traf­fic. I was right next to this and couldn’t miss the oppor­tu­nity to take my new DSLR out :)
2015-02-26 - Abandon.jpg

Simple time-lapse using ffmpeg

Sunday, January 25th, 2015

In my pre­vi­ous post, I’ve described the lit­tle tool I’ve put together to help me out trig­ger my DSLR remotely & how I’ve used it to cre­ate basic time-lapse videos.

The video qual­ity of my first attempts were pretty.. mis­er­able. Soo I HAD TO try and find a bet­ter approach. Here’s where I am at right now and the next steps on my list to fur­ther improve the result quality.

Yes­ter­day, I’ve taken two image sequences: one of my gar­den (again :p) and another one inside our liv­ing room. I’ve used a delay of 10 sec­onds for both but (some­what) dif­fer­ent set­tings for the shots.

I didn’t pre­pare much before tak­ing these image sequences; my goal was only to have some raw mate­r­ial to use as input and to run some exper­i­ments with the tools cur­rently at my disposal.

For the gar­den sequence, I’ve used a small — though not small enough — aper­ture (8) and a short expo­si­tion time (1/125s).

For the liv­ing room sequence, I’ve used a smaller aper­ture (f 11) and a longer expo­si­tion time.

Again, my goal wasn’t to have great images as input so don’t men­tion the images quality ;-)

I’ve gath­ered 384 shots for the first sequence and  165 for the sec­ond (time ran out ^^).

Here are the final videos. As you can see below, those videos are already of MUCH bet­ter qual­ity than my first attempts.

First sequence:

Sec­ond sequence (fast):

Sec­ond sequence (medium):

Sec­ond sequence (slow):

With­out fur­ther ado, let me describe how I went from the RAW input files (DNG) to the result­ing video.

First, I had to con­vert my raw files to a file for­mat that ffm­peg can work with. I’ve used XnCon­vert, but for CLI lovers, ImageMag­ick can prob­a­bly do that too.

Next, I needed to rename all files to fol­low a very sim­ple nam­ing con­ven­tion (you’ll see later why that’s use­ful). Here’s a sim­ple one-liner to do that easily:

find . -name '*.png' | awk 'BEGIN{ a=0 }{ printf "mv %s %04d.png\n", $0, a++ }' | bash

What this com­mand does is that it takes all .png files in the cur­rent (or sub) folder(s) and renames them, ensur­ing that they all con­tain 4 dig­its. For exam­ple ‘IMGP_20150124001.png’ will become ‘0001.png’ and ‘IMGP_20150124002.png’ will become ‘0002.png’.

The last step (yep, already) is to actu­ally cre­ate the video. In the exam­ple below, I cre­ate the video and directly add a sound­track to it:

ffmpeg -v info -y -f image2 -r 24 -i ./in/%4d.png -t 00:00:16 -i soundtrack.mp3 -c:a copy
\ -shortest -threads 8 -s:v 1920x1080 -vcodec libx264 -preset veryslow -qp 0 -map 0:0 -map 1:0 ./movie2.mkv

Here’s a break­down of the com­mand argu­ments. All argu­ments in italic are those I didn’t use in the exam­ple above but that can come in handy depend­ing on what your goal is:

  • –v info
    • out­put infor­ma­tion mes­sages (default)
    • you can switch that to ver­bose, debug, … if you need to trou­bleshoot things
  • –y
    • over­write exist­ing files with­out asking
  • –r 24
    • fixed input frames per sec­onds to 24 (FPS)
      • note that 30fps or more is nicer for the human eye, but I didn’t have enough images to sus­tain that
    • with this, ffm­peg gen­er­ates time­stamps assum­ing con­stant fps
    • notice that the ‘-r’ argu­ment is placed BEFORE the –i (inputs)! This is manda­tory, oth­er­wise it’ll spec­ify the out­put fram­er­ate rather than the input, which is not what you want
  • –f image2
    • the input files for­mat; in this case images
  • –i …
    • spec­i­fies the input files
    • you can now see why I’ve renamed the input files first; here I used a num­ber mask ’%4d’ which will match all our cor­rectly named input files
    • notice that the images are loaded from a “in” sub-folder; I used that idiom to sep­a­rate the input and the output
  • –i soundtrack.mp3
    • in this exam­ple, I add another input, which is an audio file that will be added to the video
  • –c:a copy
    • instructs ffm­peg to copy the input audio file with­out re-encoding it
    • I can do this since the video con­tainer that I’ve cho­sen — mkv — can hold the mp3 file as is
  • –short­est
    • stop when the short­est input is fin­ished (i.e., stop when we run out of images or when the audio input file is finished
  • threads 8
    • self-explanatory :)
  • –qscale:a 0
  • –s:v 1920x1080
    • out­put video (:v) res­o­lu­tion, in this case full hd
  • –vcodec libx264
    • out­put video encod­ing: x.264
    • (since we all love x.264, right??!)
  • –t 00:00:16
    • dura­tion of the video (hh:mm:ss)
    • I had 384 input images that I wanted to dis­play at 24 fps thus 384/24 = 15.x seconds
    • since I spec­i­fied the ‘-short­est’ option, I don’t care if the total dura­tion is a bit too long
  • –b:v 2M (or more :p)
    • video (:v) bitrate. Use­ful if you must limit the file size
    • in my case I didn’t care about the out­put file size given the low num­ber of input material
  • –pre­set veryslow
    • since I didn’t care about out­put file size, I went for the high­est qual­ity possible
    • x.264 loss­less
  • –qp 0
  • –map 0:0 –map 1:0
    • map the video and audio tracks (only one –map argu­ment is needed if there is no input audio!)
  • –loop 1
    • you can use this option if you want to loop your images (i.e., when the encoder has gone through all input images, it starts over with the first image)
    • this can be use­ful if you want to loop until some­thing else is done (e.g., until the end of the audio input track if you remove the ‘-short­est’ argument)
  • ./blabla.mkv
    • self explana­tory

Note that the order of the argu­ments DOES matter!

ffm­peg is a very ver­sa­tile & pow­er­ful com­mand line util­ity, so this barely scratches the sur­face of what it can do (and I’m by no means a spe­cial­ist). If you want to know more, check out the offi­cial docs.

There you have it! Quite sim­ple heh :)

In the exam­ple above, I’ve directly added the audio track using ffm­peg, but I don’t rec­om­mend this. You’ll be much bet­ter off adding the audio track after­wards; ide­ally using a video edit­ing soft­ware such as Pin­na­cle Stu­dio, Adobe Pre­miere, Adobe After Effects and the like ;-)

With these, you’ll be able to make nice tran­si­tions, pre­cisely mix & match the audio and video, etc.

So to con­clude, this is a much bet­ter approach for gen­er­at­ing time-lapse videos than what I did at first.. but I real­ize that this is still very amateurish.

I want to fur­ther improve the out­put video qual­ity (not only encoding-wise), but to do so, I’ll need to:

  • cap­ture more input pic­tures so that I can make longer videos at a higher frame rate (ide­ally I’d like to try and gen­er­ate 60fps videos)
  • think a bit more about the rela­tion between:
    • the total num­ber of frames
    • the delay between each frame
    • the obtu­ra­tion speed
    • the aper­ture
  • post-process the input frames at least a bit to even out the expo­sure, etc
    • this should really boost the result­ing video quality
  • post-process the video once generated
    • add the audio and sync it correctly
    • add effects such as fade-in, fade-out, ease-in, ease-out
    • add an introduction
    • add a watermark
    • add cred­its ;-)
  • improve my gear (see my pre­vi­ous post for my ideas about that)
  • give LRTime­Lapse a try as it looks like a great soft­ware solu­tion with (partly) auto­mated work­flows for cre­at­ing time-lapse videos
    • it seems to be able to work directly with the RAW input files (DNG in my case)
    • it seems to be very well inte­grated with Light­room, which is already part of my pho­to­graphic toolkit
    • finally, it cre­ates the out­put video file using ffm­peg which is, as you’ve seen above, per­fectly fine ;-)

And last but not least, I’ll need to choose some­thing AWESOME to take pic­tures of ;-)

Time-lapse using Arduino as DSLR remote trigger — v1

Saturday, January 17th, 2015

I’ve been want­ing to cre­ate time-lapse ani­ma­tions for a while now.

Since I’ve finally started acquir­ing some elec­tron­ics com­po­nents (actu­ally a awful lot thereof — accord­ing to my wife :p), I am finally able to actu­ally build some things for myself.. :)

I’ve put together a sim­ple cir­cuit allow­ing me to trig­ger my DSLR cam­era every X units of time. For now the delay between shut­ters is hard­coded but I might add a poten­tiome­ter later on in order to be able to mod­ify it with­out hav­ing to repro­gram it. I could save the delay in the EEPROM so that I don’t have to re-enter it each time I start it up.

Since I didn’t want to touch my DSLR at all, I’ve decided to build a remote trig­ger lever­ag­ing the infrared (IR) sen­sors present on my Pen­tax K20D.

As this is a sim­ple pro­to­type, I’ve just used an Arduino Uno (5v) with a small bread­board. In the future, this project might be a good can­di­date for my first PCB.. but we’ll see about that later :p

Cur­rent features

  • Trig­ger my DSLR remotely every X (hard­coded delay) through infrared
  • Light up an LED before trig­ger­ing the DSRL (just for fun)


  • 1 Arduino (e.g., Arduino Uno)
  • 1 high out­put IR LED (I bought this one, but see the issues list..)
  • 1 green LED
  • 1 27 ohm resis­tor (or more, or less depend­ing on your test results :p)
  • 1 560 ohm resistor
  • 1 bread­board
  • jumper wires


As you can see, the cir­cuit is veeeeery easy to pull together. The IR led is basi­cally just like any other led.. with the dis­tinc­tion that you can’t directly see its output ;-)

Source code:

// Remote DSLR Trigger

// Libraries
#include <multiCameraIrControl.h> // Camera IR control

// Circuit-specifics
const int SENDING_LED_PIN = 13;

// IR Control
Pentax K20D(9); // IR Led on PIN 9

void setup(){   
  pinMode(SENDING_LED_PIN, OUTPUT); // LED = output

void loop(){
      digitalWrite(SENDING_LED_PIN, HIGH);
      digitalWrite(SENDING_LED_PIN, LOW);
  delay(60000); // 1 min delay between shots

As you can see, the code is also very straight­for­ward thanks to Sebastien Setz’s Arduino IR con­trol library

The library takes care of the mod­u­la­tion nec­es­sary so that the DSLR gets the mes­sage clearly.. ;-)

Basi­cally, it does the fol­low­ing for Pentax:

Note that the library sup­ports other DSLRs such as Canon, Nikon, etc as well as other func­tions depend­ing on the models.


  • One thing that sucks with my cur­rent build is the IR dis­tance. It doesn’t work far­ther than 40-50cm, which, I guess, is due to the IR LED that I’m using. It might not be as pow­er­ful as it should (though I ordered a ‘high-output’ IR LED). Some or the library users men­tioned remov­ing the resis­tor did help. Oth­ers have used an NPN tran­sis­tor. Although I’ve tried the NPN tran­sis­tor, it didn’t help (at all)..

Ideas for a future version:

The project sources includ­ing the schemat­ics are avail­able on GitHub

Let’s go take some pic­tures now.. :)

Update #1:

Okay, I’ve made my two first tries.. Not great but hey, you always need to start some­where right?

I’ve used AviDe­mux to cre­ate the video but the orig­i­nal was too fast. I didn’t want to bother now find­ing a clean solu­tion so I hacked my way through by invok­ing ffm­peg to help me out slow it down:

ffmpeg -i input.mkv -filter:v "setpts=2.0*PTS" output.mkv

This isn’t great because it low­ers the video qual­ity but I’ll make bet­ter videos when I get bet­ter pic­tures that are worth the hassle =)

Here are the result­ing videos:

Update #2 (2015–01-25):

I’ve spent a bit of time find­ing out how to gen­er­ate higher qual­ity time-lapse videos. Check out the next post for details :)

Démarrer une voiture dont la batterie est trop faible (pas HS)

Sunday, January 4th, 2015

Encore un post à deux balles qui me servira de rap­pel pour plus tard… :)

Pour les éventuels mécanos qui liraient ce post: n’hésitez pas à me sig­naler si je raconte des âner­ies étant donné que je suis loin de m’y connaître… =)

Quand la bat­terie d’une voiture est trop faible pour démar­rer le moteur, il faut lui filer un petit coup de pouce.

Pour ça le mieux est d’avoir des cables à dis­po­si­tion (avec les pinces crocodileuhhh):


L’idée est de se servir d’une bat­terie de sec­ours (soit une autre voiture, soit un chargeur etc. On va par­tir de la sup­po­si­tion qu’on va démar­rer avec l’aide d’une autre voiture dont la bat­terie fonc­tionne bien et est chargée.

Pour brancher les cables il faut suivre l’ordre suiv­ant (important):

  • brancher le cable rouge (+) sur la borne (+) de la bat­terie de la voiture en panne
  • branche le cable rouge (+) sur la borne (+) de la bat­terie de secours
  • brancher le cable noir (-) sur la borne (-) de la bat­terie de sec­ours (ou sur le chas­sis — il y a des endroits prévus pour en général)
  • brancher le cable noir (-) sur la borne (-) de la bat­terie de la voiture en panne (ou sur le chas­sis — il y a des endroits prévus pour en général)

Une fois que les cables sont branchés, on peut allumer le moteur de la voiture de sec­ours et atten­dre quelques min­utes. Si on débranche le cable noir (-) de la voiture en panne, on entend nor­male­ment un change­ment de régime du moteur de la voiture de sec­ours. Quand c’est bien branché, ça ralen­tit un peu le moteur de la voiture de sec­ours (en tout cas j’ai con­staté ça sur la mienne, je ne suis pas mécano :p).

Après quelques min­utes on peut essayer d’allumer le moteur de la voiture en panne. Si ça ne démarre pas, elle doit au moins avoir l’air un peu plus près de démarrer..

Si elle ne démarre tou­jours pas après 15–20 min­utes, la bat­terie est peut être HS..

Si la voiture en panne démarre, alors sa bat­terie est tou­jours en vie et va être rechargée petit à petit par le moteur qui tourne. Pour aider un peu on peut alors allumer le chauffage, la radio, etc.

A ce moment on peut débrancher les cables (il faut suivre l’ordre inverse pour débrancher).

Le mieux est de laisser la voiture (presque plus) en panne pour que sa bat­terie se recharge un maximum..

Extracting audio from a video using ffmpeg.. and cutting a part of a video

Friday, January 2nd, 2015

This post will mainly serve as a reminder for the next time I ever need this. The goal is absolutely NOT to cre­ate a detailed guide.. ;-)

To extract the audio track out of a video:

ffmpeg -i input.mp4 -c:a copy -vn -sn output.m4a


To cut a part of a video (no re-encoding):

ffmpeg -i VID_20140214_171208.mp4 -vcodec copy -ss 00:10:00 -t 00:00:08 result.mp4

The com­mand above cuts from 10:00 and takes 8 sec­onds of video.

Gaufrettes sucrées

Tuesday, December 23rd, 2014

Parce que des fêtes sans sucre ce ne sont pas de vraies fêtes, voici une recette très sim­ple à réaliser qui ravira vos papilles gustatives!

Merci à ma cou­sine pour la recette de départ, que je me suis per­mis de hacker un peu :)

Les ingré­di­ents:

  • 8 oeufs
  • 320g de sucre (pas plus sinon ça peut tuer les diabétiques ^^)
  • 500g de beurre fondu
  • 300-500g de sucre perlé (selon vos goûts :p)
  • 2 sachets de sucre vanillé
  • 1 càs de miel
  • 11g de lev­ure en poudre
  • 5g de sel
  • 1ml d’arôme de vanille
  • 350-400g de farine


  • mélangez tous les ingré­di­ents sauf la farine
  • inté­grez la farine au mélange petit à petit en évitant les grumeaux
  • lais­sez la pâte reposer quelques heures au frigo
  • faites cuire 2–3 min­utes au four à gaufres (de préférence un petit pour pou­voir faire des galettes assez fines)


Arduino — Décideur électronique

Tuesday, December 23rd, 2014

Dans la vie, il y a les indé­cis.. et les autres.

Quand on fait par­tie des indé­cis, on éprouve régulière­ment des dif­fi­cultés à faire des choix, quelque soit leur impor­tance. Une mar­que de sucre ou une autre? Par­tir main­tenant ou dans cinq min­utes? Aller à gauche ou à droite? Les indé­cis souf­frent sou­vent en silence…

Heureuse­ment, vous pou­vez les aider! Offrez leur un décideur électronique.

Céquoidonc? Un décideur élec­tron­ique, c’est un petit gad­get qui va sauver la vie de vos proches indé­cis. C’est un appareil très sim­ple à utiliser: l’utilisateur appuie sur un bou­ton, l’appareil prend une déci­sion et une LED s’allume selon la déci­sion prise: vert = OUI; rouge = NON.

En bref, l’indécis peut utiliser un décideur élec­tron­ique pour faire des choix à sa place! Le tout étant qu’il ne remette pas en cause la déci­sion du décideur électronique… =)

La ques­tion qui vous taraude c’est évidem­ment “com­ment est-ce que je peux en con­stru­ire un?!”. Pas de panique, ça vient ;-)

D’abord il va fal­loir faire quelques achats (achetez soit un kit dans ce gout là, soit les pièces séparé­ment sur un site spé­cial­isé ou sur eBay):

  • 1 Arduino (e.g., Arduino Uno)
  • 1 LED rouge
  • 1 LED verte
  • 2 résis­tances de 560 ohm
  • 1 résis­tance de 10.000 ohm
  • 1 bou­ton pous­soir (push button)
  • 1 plaque d’essai (breadboard)
  • des cables de pon­tage (jumper wires)

Je pars de la sup­po­si­tion que vous dis­posez d’un Arduno UNO et que vous savez com­ment le pro­gram­mer. Notez que le mon­tage peut être adapté sur n’importe quel mod­èle.. Je sup­pose aussi que vous savez com­ment utiliser une plaque d’essai; si pas, allez faire un tour par là.

Voici le schéma de montage:

Schéma de montage

Schéma de montage

Le cir­cuit est découpé en plusieurs parties:

  • le bou­ton pous­soir qui per­met de déter­miner quand l’utilisateur a besoin d’une décision
  • la LED verte (= oui)
  • la LED rouge (= non)

Le principe est le suiv­ant: à chaque tour de boucle (l’Arduino exé­cute une boucle infinie dès qu’il a démarré), on véri­fie l’état du bou­ton pous­soir (via une lec­ture de la valeur du pin 2). Si le bou­ton est pressé, alors on prend une déci­sion en générant un nom­bre (pseudo) aléa­toire (0 ou 1). Si c’est 0, alors on ali­mente le pin 3 qui est relié à la LED verte; si c’est 1 alors on ali­mente le pin 4 qui est relié à la LED rouge.

Entre la source de courant et les LED (pins 3 et 4), une résis­tance de 560 ohm est placée afin de lim­iter le courant fourni à la LED.

Le code à charger sur l’Arduino:

// Electronic decider
const int buttonPin = 2;
const int yesPin = 3;
const int noPin = 4;

int buttonState = 0;
int randomNumber = 0;

void setup(){
  randomSeed(analogRead(0)); // try and get a "random" seed (read an unconnected pin)
  pinMode(yesPin, OUTPUT); // LED = output
  pinMode(noPin, OUTPUT);
  pinMode(buttonPin, INPUT); // button = input

void loop(){
  buttonState = digitalRead(buttonPin); // if current is applied, then the button is being pushed)
  if(buttonState == HIGH){
    randomNumber = random(2); // either 0 or 1
    if(randomNumber == 0){
      digitalWrite(yesPin, HIGH); // power the green LED
      delay(1000); // let it up for a second
      digitalWrite(noPin, HIGH); // power the red LED
     delay(1000); // let it up for a second
  // ensure that both LEDs are off
  digitalWrite(yesPin, LOW);
  digitalWrite(noPin, LOW);
  delay(50); // delay for stability

The project sources are avail­able on GitHub

Liens utiles:

Recette libre du jour: Gratin de céleris

Friday, April 11th, 2014

A pro­pos

His­toire de changer un peu le ton du blog, voilà une recette que j’ai con­cotée hier soir. Comme toute autre chose, la cui­sine peut elle aussi suivre le mou­ve­ment du libre et gratuit :)

Je suis loin d’être un grand cuisto, mais je prends plaisir de temps en temps à appli­quer l’approche Do It Your­self (DYI) en cuisine.

Aujourd’hui, je vais vous présen­ter une recette de gratin de céleris sous license GPLv3, donc si vous décidez de la mod­i­fier vous devrez partager votre recette en retour ^^.

Ingré­di­ents pour 4 per­son­nes (ou 2 goin­fres, ou 2 per­son­nes pour 2 jours, ou.…)

Je vous ras­sure tout de suite, ce plat n’a stricte­ment RIEN de light! =)

  • 1 bon gros céleri
  • 4 grosses pommes de terre
  • 1 oignon
  • 400gr de haché porc/boeuf
  • 2 cubes de bouil­lon de volaille
  • du beurre
  • de l’eau
  • 25cl de crème fraiche
  • 20-30cl de lait
  • 50gr de gruyere
  • 50gr de parmesan
  • 2 càs de farine
  • sel
  • poivre
  • mus­cade

Pré­pa­ra­tion des pommes de terre et du céleri

On com­mence par éplucher/nettoyer les pommes de terre et les couper en morceaux (larges). Ensuite on les met à l’eau (salée). On fait atten­tion à ne pas laisser les pommes de terre trop longtemps (le but n’est pas d’en faire de la purée après ^^).

On net­toie le céleri et on le coupe en petits dés. Une fois découpé, hop à l’eau! Con­traire­ment aux pommes de terre, on peut laisser le céleri un peu plus longtemps dans l’eau pour le ramolir un peu (pas trop non plus).

Une fois cuit on égoutte et on laisse de côté.

Pré­pa­ra­tion du haché

Pen­dant que le reste cuit, on va hacher un oignon et le faire revenir dans une poêle avec du beurre. Ensuite, ajouter le haché, saler, poivrer et cuire en mélangeant fréquemment.

Une fois cuit on laisse ça de côté également.

Pré­pa­ra­tion de la sauce

Pour la sauce, on va com­mencer par faire fon­dre un peu de beurre à feu doux et y ajouter pro­gres­sive­ment  la farine. A côté de ça, on fait fon­dre un ou deux cubes de bouil­lon de volaille dans de l’eau (égale­ment à feu doux). On peut met­tre un peu plus d’eau que de coû­tume, ça fera plus de sauce au final :)

Une fois le(s) cube(s) de bouil­lon fondu(s), on y ajoute le mélange farine/beurre, une pincée de muscade.

Une fois le tout bien mélangé, on va y ajouter pro­gres­sive­ment le gruyère en le faisant fon­dre, tou­jours à feu doux. On peut à présent ajouter la crème fraiche et con­tin­uer de mélanger le tout.

A présent, on va saler et poivrer le tout selon nos goûts respectifs :)

Si le mélange est trop peu liq­uide, on y ajoute pro­gres­sive­ment du lait en mélangeant bien. La sauce ne doit néan­moins pas devenir trop liquide.

Pré­pa­ra­tion du plat

Pen­dant qu’on pré­pare le plat, on va préchauf­fer le four à 170–180°.

On va à présent beur­rer un (grand) plat à gratin et y étaler une couche de pommes de ter­res coupées en tranches (~0.842cm d’épaisseur cha­cune). On y ajoute une bonne dose de cubes de céleri puis une dose de haché pour ter­miner par une couche de sauce.

On recom­mence l’opération jusqu’à tout avoir mis dans le plat en prenant soin de ter­miner par une couche de sauce cou­vrant toute la surface.

Finale­ment, on va recou­vrir l’ensemble avec le parme­san, voire une petite noix de beurre pour les plus gourmands.


Une fois que le plat est prêt, il ne reste plus qu’à l’enfourner pour 25 min­utes, suiv­ies de 5–10 min­utes en posi­tion grill afin de bien faire dorer le parmesan.

Le résul­tat

Si tout se passe bien, ça devrait ressem­bler à ça:

Bon appétit! :)

Diablo 3 Stats Calculator v2 (EN)

Friday, March 21st, 2014


A few months after the release of Dia­blo 3, being a pas­sion­ate player & pro­gram­mer, I’ve devel­oped an online stats cal­cu­la­tor. With the release of patch 2.0 & the Paragon 2.0 sys­tem, I’ve decided to update it.

It will shortly come really handy with the release of the Reaper of Souls exten­sion (i.e., next week heh!)

Here’s the kind of infor­ma­tion that the tool will pro­vide you with:



Where is it?

The tool is avail­able online at the fol­low­ing address: http://dsebastien.net/d3FarmingXP/


How does it work?

In order for the tool to be able to cal­cu­late sta­tis­tics for you, you need to pro­vide it with infor­ma­tion about the XP that you gain. To do so, there’s a lit­tle form to fill-in for each “Run”.

A run can be a sin­gle game (i.e., I join a game, go berserk and kill every­thing in sight then leave the game) or it can be a series of games. Per­son­ally I usu­ally encode mul­ti­ple games at once, as it gives me a more real­is­tic view over the XP that I gen­er­ate per hour for a par­tic­u­lar run (e.g., CoTA).

You need to pro­vide the fol­low­ing information:

In the pic­ture above, here’s the infor­ma­tion that I’ve provided:

  • My paragon level before start­ing the run
  • My paragon level after start­ing the run (in this case I didn’t gain a level dur­ing the run)
  • The XP that I had at the begin­ning of the run (real value / 1000 for simplicity)
  • The XP that I had at the end of the run (real value / 1000 for simplicity
  • The dura­tion of the run (in minutes)

Basi­cally, noth­ing com­pli­cated. Once you click on ‘Save’, the run is added to the list and all the sta­tis­tics are cal­cu­lated again.

In order to make it eas­ier to track the time spent, there’s a lit­tle stop­watch below the form. You click the ‘Start/Pause’ but­ton once at the begin­ning and once at the end then press ‘Copy’ to get the amount of min­utes added to the form.

About the XP at the beginning/at the end, the value to insert is the real value (what you see on screen) divided by 1000. The goal is to sim­plify the encod­ing (I couldn’t care less typ­ing all that garbage XP details). To make it clearer, here are a few examples:

  • If I see 1.000.000 XP on screen, then I encode ‘1000’
  • If I see 429.000.000 then I encode ‘‘429000’
  • If I see 1.249.527.223 then I encode ‘1249527’

Happy grind­ing and don’t feel too depress­ing while look­ing at the time needed to get to Paragon 1000 ;-)

Diablo 3 Stats Calculator v2

Thursday, March 20th, 2014


Quelques mois après la sor­tie de Dia­blo 3, étant à la fois un joueur assez pas­sionné et infor­mati­cien, j’ai développé un petit cal­cu­la­teur de sta­tis­tiques en ligne. Avec la sor­tie du patch 2.0 et du sys­tème Paragon 2.0, j’ai décidé de le met­tre à jour.

Ca tombe à pic puisque l’extension Reaper of Souls sort dans moins d’une semaine!

Voici le genre d’informations que l’outil pourra vous donner:



Où qu’il est?

L’outil est disponible en ligne à l’adresse suiv­ante: http://dsebastien.net/d3FarmingXP/


Com­ment ça marche?

Pour per­me­t­tre à l’outil de cal­culer les sta­tis­tiques, il faut lui fournir de l’information sur l’XP que vous gag­nez. Pour ce faire, il y a un for­mu­laire à rem­plir pour chaque “Run”.

Un run peut être soit une par­tie unique (i.e., je ren­tre dans le jeu, je tue tout ce qui bouge, je sors et j’arrête) ou une suite de par­ties. Per­son­nelle­ment j’encode en général des suites de par­ties en une fois afin d’avoir une vue plus réal­iste de mon taux d’XP par heure (puisqu’il prend alors en compte le temps entre par­ties, …). Il m’arrive d’encoder une par­tie bien spé­ci­fique quand je veux une idée pré­cise de l’XP générée dans cette par­tie particulière.

Les infor­ma­tions à fournir sont les suivantes:

Dans l’image ci-dessus, voilà ce que j’ai entré comme informations:

  • Mon niveau paragon avant de com­mencer le run
  • Mon niveau paragon une fois le run ter­miné (dans ce cas-ci je n’ai pas passé de niveau pen­dant le run
  • L’XP que j’avais au début du run
  • L’XP que j’avais en fin de run
  • La durée du run (en minutes)

En gros, rien de bien méchant. Une fois qu’on clique sur “Enreg­istrer”, le run est ajouté à la liste et les sta­tis­tiques sont recalculées.

Pour le temps, il y a un petit chrono en dessous du for­mu­laire que vous pou­vez utiliser pour compter à votre place :)

Con­cer­nant l’XP en début/fin de run, la valeur à entrer est la valeur réelle / 1000. Le but est sim­ple­ment de faciliter l’encodage. Quelques exemples:

  • j’ai 1.000.000 d’XP au début du run, alors j’entre ‘1000’
  • j’ai 429.000.000 d’XP au début du run, alors j’entre ‘429000’


Bon farm­ing et ne déprimez pas trop en regar­dant le temps néces­saire pour arriver Paragon 1000 ;-)