ScreenCapturer

9 octobre 2012 | graphisme, programmation | 1 commentaire

Incroyable ! Voici une librairie pour Processing capable de faire des captures vidéo de l’écran et beaucoup plus. Informations : http://www.onformative.com/lab/screencapturer/

reset, html5, processing 2 beta, 6 ans

4 septembre 2012 | programmation | 0 commentaire


Voilà 6 ans que ce blog (que j’utilise plutôt comme un carnet de liens) existe, merci à vous et à WordPress !
Pour fêter ça, quelques liens à ajouter à votre/ce bookmark :)

Un article comparant reset de Meyer, Yahoo et le normalize des CSS.
http://blog.sixzero.me/2012/02/25/reset-vs-normalize/ avec les démonstrations : Normalize css, Eric Meyer’s reset css, Yahoo reset css.

Une alternative à la méthode du reset avec un mini framework très choux http://www.knacss.com/.

Un validateur HTML5 avec quelques fonctions pratiques.

Et pour finir, une bonne nouvelle Processing 2 est sorti hier en version beta (revisions.txt).

rideau

20 juin 2012 | graphisme, programmation | 0 commentaire

Une installation assez efficace sous Processing.

accordeur avec processing

27 avril 2012 | programmation, tutorials | 0 commentaire


Avec la librairie Minim de Processing, il est possible d’analyser le son en temps réel. Voici quelques lignes de code pour obtenir la fréquence « la plus présente » dans votre source sonore.
La méthode d’initialisation n’est pas simple à retenir, avec minim.getLineIn on peut régler le « input », le buffer et la qualité (un gros buffer donnera un résultat précis mais des performances moindres).

Pour résumer, ce script prend un échantillon du son et balaie toutes les fréquences de 0 à 20000 Hz pour mémoriser le pic. On pourrait réduire le spectre analysé ou tester que les fréquences « justes » avec getFreq pour un usage autre.

Les musiciens pourront se reporter à cette page pour avoir les fréquences des notes (avec le La3 à 440 hz).

Vous pouvez tester avec des fichiers mp3 via google ou ici.

import ddf.minim.*;
import ddf.minim.analysis.*;

Minim minim;
AudioInput in;
FFT fft;
float highestAmp=0;
int frequency;
float amplitude;

void setup(){
        size(512, 200);
        background(0);
        
        // initialize Minim and catching the output
        minim = new Minim(this);
        in = minim.getLineIn(Minim.MONO, 4096*8, 44100); // better result with *8
        fft = new FFT(in.left.size(), 44100);
}


void draw() {
      highestAmp=0;
      amplitude=0;
      frequency = 0;
      fft.forward(in.left);

      //searching from 0Hz to 20000Hz. getting the band, and from the band the frequency
     for(int i = 0; i < 20000; i++) {
            amplitude = fft.getFreq(i);
            if (amplitude > highestAmp){
                highestAmp = amplitude;
                frequency = i;
            }
          }
          //write the frequency on the screen
          fill(255);
          background(0);
          text(frequency,200,100);
}

base du code via processing Forum.

processing 2.05a + webcam

8 avril 2012 | programmation, tutorials | 0 commentaire

Une nouvelle version de Processing 2 est disponible en version Alpha depuis quelques jours (ici).

La capture vidéo (webcam) a changé depuis la v2, voici la nouvelle méthode (avec start()) :

import processing.video.*;
Capture video;

void setup() {
  size(320, 240);
  video = new Capture(this, 320, 240);
  video.start();
  background(0);
}

void draw() {
  if (video.available()) {
    video.read();
    image(video,0,0);
  }
}

L’ancienne méthode pour processing 1.5x est disponible ici.

spirale

1 février 2012 | graphisme, programmation | 0 commentaire

Voici une portion de code processing (v1.5 et/ou v2) que l’on retrouve dans ma carte de vœux 2012, une étape nécessaire avant l’assemblage de « mes briques de code ».
Deux notions de maths sont utiles, le calcul de distances entre deux points et l’équation paramétrique d’un cercle mais pas besoin de comprendre rigoureusement pour s’amuser avec ces formules :)

float x, y; //position du point
float a; // une sorte de rayon
int tx, ty; // target du point

void setup() {
  size(640, 360);
  background(250);
  smooth();
  frameRate(500);
  x=400;
  y=200;
  tx=320;
  ty=180;

  strokeWeight(2);
  a=sqrt(sq(x-tx)+sq(y-ty)); // distance entre deux points (pythagore)
}

void draw() 
{
  fill(0, 10); //effet trace (motion trail)
  noStroke();
  rect(0, 0, 640, 360);
  stroke(255);
  point(x, y);

  // calcul de la position
  float angle=radians(frameCount*4); // à chaque image on bouge de 4°
  if (a>1) {
    x=cos(angle)*a+tx; // équation d'un cercle de rayon a et centre tx
    y=sin(angle)*a+ty; // 
    a=a-0.05; // réduction du rayon
  } else {
    x=tx;
    y=ty;
  }
}

2012

31 janvier 2012 | graphisme | 0 commentaire

À la dernière minute, je vous souhaite une chouette année 2012 !
Une année pleine de pixels et de réel !
http://jenseign.com/2012/

processing

4 janvier 2012 | programmation | 0 commentaire

On peut faire pas mal d’opérations sur les Array dans Processing mais pour supprimer un élément, j’ai rien vu, de plus subset compte de 1 à n les éléments de la liste (=array) !
Voici une function _remove pour les listes de chiffres, à adapter selon vos besoins.

int[] s= { 1, 2, 3, 4};

int[] _remove(int[] s, int r) {
  return concat(subset(s, 0, r), subset(s, r+1, s.length-r-1));
}

void setup() {
  println("s="+join(nf(s, 0), ", "));
  s=_remove(s, 1); //on compte comme dans l'array à partir de 0
  println("s="+join(nf(s, 0), ", "));
}

Comme la manipulation sur les tableaux en 2D n’est pas simple (enfin il faut juste mettre un type devant), voici la version 2D

int[][] _remove(int[][] s,int r){
 return (int[][]) concat((int[][]) subset(s,0,r),(int[][]) subset(s,r+1,s.length-r-1));
}