working on it ...

Filters

Explore Public Snippets

Sort by

Found 1,512 snippets

    public by snip2code  743  3  4  0

    First Snippet: How to play with Snip2Code

    This is the first example of a snippet: - the title represents in few words which is the exact issue the snippet resolves; it can be something like the name of a method; - the description (this field) is an optional field where you can add interesting information regarding the snippet; something like the comment on the head of a method; - the c
    /* place here the actual content of your snippet. 
       It should be code or pseudo-code. 
       The less dependencies from external stuff, the better! */

    public by lauhin  5381  3  7  1

    Count chars in a String in Java

    Count chars in Strings or letters in words in Java using the Spring framework
    import org.springframework.util.StringUtils;
    
    int occurance = StringUtils.countOccurrencesOf("012405802569015014", "0"); //returns 5
    int occurance = StringUtils.countOccurrencesOf("hello world", "l"); //returns 3

    public by lauhin  4624  11  5  0

    Java date to String

    this code converts a java date to a String
    //this code converts a java date to a string
    DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
    String reportDate = df.format(today);

    public by lauhin  4911  1  5  0

    Interator to stream in Java 8

    makes a java 8 stream from an iterator
    //this method converts a iterator to a stream. This can only be used in Java 8
    public static <T> Stream<T> iteratorToStream(final Iterator<T> iterator, final boolean parallell) {
      Iterable<T> iterable = () -> iterator;
      return StreamSupport.stream(iterable.spliterator(), parallell);
    }
    
    //here I show you how to use this method. You need this try arround it so Java will close the stream automatically after using it.
    try (Stream<???> stream = Utils.<???>iteratorToStream(anIterator, true)) {
      
    }

    public by Fabax  2412  1  4  0

    Processing : mask pgraphic

    Processing : mask pgraphic: mask1.pde
    PGraphics s, m;
    void setup(){
      size(220,220);
    
      // Create a cookie cutter.
      // White areas are kept. Black areas are not.
      m = createGraphics( width, height, P2D );
      m.beginDraw();
      m.background(0);
      m.fill(255);
      m.stroke(255);
      m.ellipse(100, 100, 60, 60);
      m.endDraw();
      
      // Create a pattern.
      s = createGraphics( width, height, P2D );
      s.beginDraw();
      s.smooth();
      s.translate(s.width/2, s.height/2);
      s.rotate( radians(35) );
      s.background(0,0,255);
      s.noStroke();
      s.fill( 0,255,0);
      for( int i = -300; i < 300; i+=10 ){
        s.rect( i, -300, 5, 600);
      }
      // This line uses the cookie cutter.
      s.mask( m.get() );
      s.endDraw();  
    }
    
    void draw(){
      background(128,0,0);
      image( s.get(), 0, 0);
    }
    
    

    public by Fabax  3050  0  4  0

    Processing : Class Wii

    Processing : Class Wii: wii.pde
    /* Wii Processing class
     * (cc) 2009 Douglas Edric Stanley
     * l'Atelier Hypermédia
     * l'École supérieure d'art d'Aix-en-Provence
     * http://www.ecole-art-aix.fr/
     * 
     * Pour utiliser cette classe il faut :
     * 
     + Osculator : http://www.osculator.net/
     + Open Sound Control for Processing (OscP5) : http://www.sojamo.de/libraries/oscP5/
     *
     * La classe Wii permet de se connecter à Osculator via OSC et répartir les
     * valeurs du Wiimote, du Nunchuck et du Classic Controller (tous les deux
     * reliés au Wiimote) et enfin du Balance Board (Planche WiiFit) -- le tout
     * dans sous une forme plus simple à manier dans Processing.
     *
     * Il y a un fichier de configuration d'Osculator inclus dans le dossier du sketch
     * qui fait le gros du boulot pour configurer Osculator pour parler à Processing. Il faut
     * juste "relier" Osculator et votre Wiimote/BalanceBoard (ouvrez le tiroir dans Osculator
     * pour voir la liste de tous les appareils)
     *
     * On peut avoir jusqu'à 4 instances de n'importe quelle combinasion Wiimote/BalanceBoard.
     * Il faut qu'Osculator soit démarré et emêt en OSC sur le port 9000 (configurable)
     * avant de pouvoir recevoir les valeurs.
     * 
     * Il suffit de copier ce fichier "wii.pde" dans le dossier de votre sketch et de
     * re-ouvrir votre sketch (ou Processing, peu importe) pour voir apparaître l'onglet Wii :
     
     ~/Documents/
     /Processing/
     /NomDuSketch/
     /data/
     /NomDuSketch.pde
     /Wii.pde
     /wii.oscd
     
     * Au début de votre sketch il faut déclarer l'objet qui contiendra les valeurs :
     
     Wii wii = new Wii();
     
     * Si vous voulez recevoir sur un autre port, mettez un int entre les parenthèses :
     
     Wii wii = new Wii(666666);
     
     * Si vous voulez voir/tester toutes les possibilités, demander à wii de tout déssiner :
     
     void draw() {
     background(255);
     wii.draw(); 
     }
     
     * L'objet wii sera ensuite le seul 'accès' nécessaire pour avoir les valeurs
     * du Wiimote/BalanceBoard. Par exemple, pour avoir la valeur de l'accéleromètre
     * il suffit de le demander comme ceci:
     
     background( wii.wiimote.accel.pitch * 255 );
     
     * Notez que les valeurs arriveront toujours entre 0.0 et 1.0. Si on veut 0-255, il
     * suffit de les multiplier par 255. Si on veut jusqu'à la taille du Sketch, il suffit
     * de multiplier par 'width' ou par 'height' (ex: wii.accel.roll * width).
     * 
     * Si on a plusieurs Wiimotes attachés, il faut indiquer lequel on veut :
     
     // cette image bougera une image et l'agrandira suivant
     float x = wii.wiimote[3].accel.pitch * width;
     float y = wii.wiimote[3].accel.roll * width;
     float largeur = wii.wiimote[3].accel.accel * monImage.width;
     float hauteur = wii.wiimote[3].accel.accel * monImage.height;
     
     * Pour faire vibrer un Wiimote, il faut lui demander de vibrer (0.0 = éteint / 1.0 allumé) :
     
     wii.wiimotes[n].vibrate(1.0);
     
     * Pour changer les lumières LED, on envoie la commande led(numéro_du_masquage) :
     
     wii.wiimotes[n].led(15);
     
     * Voici quelques examples de valeurs de masquage:
     
     0 = 0000
     1 = 0001
     2 = 0010
     3 = 0011
     4 = 0100
     8 = 1000
     15= 1111
     
     * Il y a aussi une commande pour allumer comme un indicateur de niveau (0.0 - 1.0)
     
     wii.wiimotes[n].level(valeur);
     
     * L'objet wii classifiera ensuite les valeurs suivant l'arborescence suivante :
     
     wii
     
     * (balance board)
     
     wii.balanceBoard                    *raccourci vers le premier balanceBoards[n] qui arrive
     wii.balanceBoards[n]                *jusqu'à 4 wiimotes/balanceBoards (0/4, 1/3, 2/2, 3/1, 4/0)
     wii.balanceBoards[n].values[n]      *il y en a 4
     wii.balanceBoards[n].someone        *boolean (true/false) pour dire s'il y a quelqu'un dessus ou pas
     wii.balanceBoards[n].top_left       *raccourci vers .values[0]
     wii.balanceBoards[n].top_right      *raccourci vers .values[1]
     wii.balanceBoards[n].bottom_right   *raccourci vers .values[2]
     wii.balanceBoards[n].bottom_left    *raccourci vers .values[3]
     wii.balanceBoards[n].sum            *la somme des 4 valeurs (x 100 pour avoir les Kg)
     
     * (wiimote)
     
     wii.wiimote                         *raccourci vers le premier wiimotes[n] qui arrive
     wii.wiimotes[n]                     *jusqu'à 4 wiimotes/balanceBoards (0/4, 1/3, 2/2, 3/1, 4/0)
     wii.wiimotes[n].accel
     wii.wiimotes[n].accel.pitch
     wii.wiimotes[n].accel.roll
     wii.wiimotes[n].accel.yaw
     wii.wiimotes[n].accel.accel         *l'ampleur des trois précédentes valeurs
     
     wii.wiimotes[n].button
     wii.wiimotes[n].button.a
     wii.wiimotes[n].button.b
     wii.wiimotes[n].button.one
     wii.wiimotes[n].button.two
     wii.wiimotes[n].button.left
     wii.wiimotes[n].button.right
     wii.wiimotes[n].button.up
     wii.wiimotes[n].button.down
     wii.wiimotes[n].button.minus
     wii.wiimotes[n].button.home
     wii.wiimotes[n].button.plus
     
     wii.wiimotes[n].ir
     wii.wiimotes[n].ir.x
     wii.wiimotes[n].ir.y
     wii.wiimotes[n].ir.xys[n]             *x, y, rayon : jusqu'à 4 points
     wii.wiimotes[n].ir.xys[n].x
     wii.wiimotes[n].ir.xys[n].y
     wii.wiimotes[n].ir.xys[n].r           *la taille
     
     * (nunchuk)
     
     wii.wiimotes[n].nunchuk.accel
     wii.wiimotes[n].nunchuk.accel.pitch
     wii.wiimotes[n].nunchuk.accel.roll
     wii.wiimotes[n].nunchuk.accel.yaw
     wii.wiimotes[n].nunchuk.accel.accel         *l'ampleur des trois précédentes valeurs
     
     wii.wiimotes[n].nunchuk.joystick
     wii.wiimotes[n].nunchuk.joystick.x
     wii.wiimotes[n].nunchuk.joystick.y
     
     wii.wiimotes[n].nunchuk.button
     wii.wiimotes[n].nunchuk.button.c
     wii.wiimotes[n].nunchuk.button.z
     
     * (classic controller)
     
     wii.wiimotes[n].classic.right
     wii.wiimotes[n].classic.right.x
     wii.wiimotes[n].classic.right.y
     
     wii.wiimotes[n].classic.left
     wii.wiimotes[n].classic.left.x
     wii.wiimotes[n].classic.left.y
     
     wii.wiimotes[n].classic.button
     wii.wiimotes[n].classic.button.a
     wii.wiimotes[n].classic.button.b
     wii.wiimotes[n].classic.button.x
     wii.wiimotes[n].classic.button.y
     wii.wiimotes[n].classic.button.left
     wii.wiimotes[n].classic.button.right
     wii.wiimotes[n].classic.button.up
     wii.wiimotes[n].classic.button.down
     wii.wiimotes[n].classic.button.l          * cette valeur est analogique 0.0 -> 1.0
     wii.wiimotes[n].classic.button.zl
     wii.wiimotes[n].classic.button.r          * cette valeur est analogique 0.0 -> 1.0
     wii.wiimotes[n].classic.button.zr
     wii.wiimotes[n].classic.button.home
     wii.wiimotes[n].classic.button.minus
     wii.wiimotes[n].classic.button.plus
     
     * Liste des TO-DO (pas encore implementé) :
     * 
     + un indicateur de mouvement sur la planche (avec un seuil) -- c'est pratique pour faire du son
     + des « call-backs » pour appeler une fonction dès les changements d'état (bouton / mouvement)
     * 
     */
    
    
    import oscP5.*;
    import netP5.*;
    
    //////////////////////////////////////////////////////////////////
    
    class Wii {
    
      // connection à Open Sound Control
      OscP5 osc;
      NetAddress osculator;
      // police pour le mode DEBUG
      PFont debug_font;
    
      // les wiimotes
      Wiimote[] wiimotes = new Wiimote[4];
      // le pointeur vers le premier wiimote à s'annoncer
      Wiimote wiimote = new Wiimote();
      // l'index du wiimote par défaut
      int default_wiimote_index = -1;
    
      // les balance boards
      Balance[] balanceBoards = new Balance[4];
      // le pointeur vers le premier board à s'annoncer
      Balance balanceBoard = new Balance();
      // l'index board par défaut
      int default_board_index = -1;
    
    
      Wii() {
        // par défaut, écouter sur le port 9000 (celui par défaut d'Osculator)
        this(9000);
      } 
    
      Wii(int port) {
        osc= new OscP5 (this, 9000);
        osculator = new NetAddress("127.0.0.1",8000);
        debug_font = createFont("Monospaced", 10);
      }
    
      void draw() {
    
        color c = color(0);
    
        textFont(debug_font);
    
        for(int i=0; i<4; i++) {
    
          switch(i) {
            case(0): 
            c = color(255,0,0); 
            break;
            case(1): 
            c = color(0,127,0); 
            break;
            case(2): 
            c = color(0,0,255); 
            break;
            case(3): 
            c = color(255,0,255); 
            break;
          }
    
          fill(c);
          stroke(c);
    
          if (balanceBoards[i] != null) balanceBoards[i].draw(i,c);
          if (wiimotes[i] != null) wiimotes[i].draw(i,c);
    
        }
    
      }
    
      void oscEvent(OscMessage message) {
    
        // saucisonner l'identifiant du message
        String[] pattern = split(message.addrPattern(), "/");
        String typetag = message.typetag();
    
        // si pas assez, on s'en fout du reste
        if (pattern.length < 4) return;
    
        // lequel des controlleurs ?
        int index = (pattern[2].equals("1")) ? 0 : 
        (pattern[2].equals("2")) ? 1 : 
        (pattern[2].equals("3")) ? 2 : 
        (pattern[2].equals("4")) ? 3 : -1;
    
        // si on n'a pas eu de controlleur correcte
        if (-1 == index) return;
    
        // vérifier que les array des balance board et wiimotes sont remplis correctement
        // (pour ne pas avoir de null-pointer)
        if (pattern[3].equals("balance")) checkBoardArray(index);
        else if (pattern[3].equals("accel")) checkWiimoteArray(index);
        else if (pattern[3].equals("button")) checkWiimoteArray(index);
        else if (pattern[3].equals("ir")) checkWiimoteArray(index);
        else if (pattern[3].equals("nunchuk")) checkWiimoteArray(index);
        else if (pattern[3].equals("classic")) checkWiimoteArray(index);
    
        // passer les évenements à leurs propriétaires
        if (pattern[3].equals("accel")  ) {
          if (balanceBoards[index] != null) balanceBoards[index].deactivate();
          wiimotes[index].message(pattern,typetag,message);
        }
    
        if (pattern[3].equals("button") ) {
          if (balanceBoards[index] != null) balanceBoards[index].deactivate();
          wiimotes[index].message(pattern,typetag,message);
        }
    
        if (pattern[3].equals("ir")) {
          if (balanceBoards[index] != null) balanceBoards[index].deactivate();
          wiimotes[index].message(pattern,typetag,message);
        }
    
        if (pattern[3].equals("balance")) {
          if (wiimotes[index] != null && wiimotes[index].active) wiimotes[index].deactivate();
          balanceBoards[index].message(pattern,typetag,message);
        }
    
        if (pattern[3].equals("nunchuk")) {
          if (balanceBoards[index] != null) balanceBoards[index].deactivate();
          if (wiimotes[index] != null) wiimotes[index].classic.active = false;
          wiimotes[index].nunchuk.message(pattern,typetag,message);
        }
    
        if (pattern[3].equals("classic")) {
          if (balanceBoards[index] != null) balanceBoards[index].deactivate();
          if (wiimotes[index] != null) wiimotes[index].nunchuk.active = false;
          wiimotes[index].classic.message(pattern,typetag,message);
        }
    
    
      }
    
      void checkBoardArray(int index) {
    
        // si on n'a pas encore attribué ce balance board
        if (null == balanceBoards[index]) balanceBoards[index] = new Balance();
    
        // si on n'a pas encore attribué le pointeur par défaut
        if (-1 == default_board_index) {
          balanceBoard = balanceBoards[index]; 
          default_board_index = index;
        }
    
      }
    
      void checkWiimoteArray(int index) {  
    
        // si on n'a pas encore attribué ce balance board
        if (null == wiimotes[index]) wiimotes[index] = new Wiimote(index);
    
        // si on n'a pas encore attribué le pointeur par défaut
        if (-1 == default_wiimote_index) {
          wiimote = wiimotes[index]; 
          default_wiimote_index = index;
        }
    
      }
    
      //////////////////////////////////////////////////////////////////////////////////
    
    
      class Wiimote {
    
        boolean active = false;
        boolean vibration = false;
        int object_index = 0;
        Accel accel = new Accel();
        Button button = new Button();
        IR ir = new IR();
        Nunchuk nunchuk = new Nunchuk();
        Classic classic = new Classic();
    
        Wiimote() {
        }
    
        Wiimote(int index) {
          object_index = index;
        }
    
        void deactivate() {
          active = false;
          classic.active = false;
          nunchuk.active = false; 
          // ir has to potentially turn off all the raw points (max. 4)
          ir.deactivate(); 
        }
    
        void vibrate(float value) {
    
          value = min(1.0,max(0.0,value));
    
          // mémoriser si on vibre ou pas
          if (value >= 0.5) vibration = true;
          else vibration = false;
    
          String header = "/vibrate/" + object_index;
          OscMessage message = new OscMessage(header);
          message.add(value);
          osc.send(message, osculator);
    
        }
    
        void led(int light_mask) {
    
          light_mask = min(15,max(0,light_mask));
    
          String header = "/led/" + object_index;
          OscMessage message = new OscMessage(header);
          message.add((float)light_mask);
          osc.send(message, osculator);
    
        }
    
        void level(float level_value) {
    
          level_value = min(1.0,max(0.0,level_value));
    
          String header = "/light/" + object_index;
          OscMessage message = new OscMessage(header);
          message.add(level_value);
          osc.send(message, osculator);
    
        }
    
        void message(String[] pattern, String typetag, OscMessage message) {
    
          active = true;
    
          if (pattern[3].equals("accel")) accel.message(pattern,typetag,message);
          else if (pattern[3].equals("button")) button.message(pattern,typetag,message);
          else if (pattern[3].equals("ir")) ir.message(pattern,typetag,message);
    
        }
    
        void draw(int index, color c) {
    
          if (!active) return;
    
          float x_step = width/4;
          float x_half_step = x_step/2;
    
          float x = (index*x_step)+x_half_step;
    
          // dessiner l'accéleration du wiimote
          accel.draw(index, x, 20, c);
    
          // dessiner les boutons
          drawButtons(x, (height/2)-85, c);
    
          // draw the infrared points
          ir.draw(x, (height/2)+90, c);
    
          // si le nunchuk est actif, dessinder l'accéleration du nunchuk
          if (nunchuk.active) {
            // dessiner l'accélerateur du nunchuk
            nunchuk.accel.draw(index, x, height-75, c);
            // dessiner les joysticks
            nunchuk.joystick.draw(x, (height/2)+40, c);
          }
    
          // draw the two joysticks
          if (classic.active) {
            classic.left.draw(x-30, (height/2)+40, c);
            classic.right.draw(x+30, (height/2)+40, c);
          }
    
        }
    
        void drawButtons(float x, float y, color c) {
    
          // draw buttons    
          pushMatrix();
    
          translate(int(x), int(y));
    
          stroke(c);
    
          // wiimote
    
          pushMatrix();
    
          translate(20,-20);
    
          // image of a wiimote
          fill(c,0);
          rect(-11,0,21,50);
    
          // arrows
    
          fill(c, button.left*255);
          rect(-8,8,5,5);
    
          fill(c, button.right*255);
          rect(+2,8,5,5);
    
          fill(c, button.up*255);
          rect(-3,3,5,5);
    
          fill(c, button.down*255);
          rect(-3,13,5,5);
    
          // triggers
    
          fill(c, button.a*255);
          rect(-3,21,5,5);
    
          fill(c, button.b*255);
          rect(5,21,5,5);
    
          // reset
    
          fill(c, button.minus*255);
          rect(-8,30,5,5);
    
          fill(c, button.home*255);
          rect(-3,30,5,5);
    
          fill(c, button.plus*255);
          rect(+2,30,5,5);
    
          // selection
    
          fill(c, button.one*255);
          rect(-3,38,5,5);
    
          fill(c, button.two*255);
          rect(-3,43,5,5);
    
          popMatrix();
    
          // nunchuk
    
          pushMatrix();
    
          translate(-20,-20);
    
          fill(c,0);
          triangle(-10,0,10,0,0,50);
    
          fill(c, nunchuk.button.c*255);
          rect(-3,3,5,5);
    
          fill(c, nunchuk.button.z*255);
          rect(-3,8,5,5);
    
          fill(c,0);
          ellipse(0,20,7,7);
    
          popMatrix();
    
          // classic controller
    
          pushMatrix();
    
          translate(0,50);
    
          // draw the joystick frame
          fill(c,0);
          rect(-30,0,60,30);
    
          // joystick holders
          fill(c,0);
          ellipse(-10,25,7,7);
          ellipse(+10,25,7,7);
    
          fill(c, classic.button.y*255);
          rect(9,13,5,5);
    
          fill(c, classic.button.x*255);
          rect(16,8,5,5);
    
          fill(c, classic.button.b*255);
          rect(16,18,5,5);
    
          fill(c, classic.button.a*255);
          rect(23,13,5,5);
    
          fill(c, classic.button.left*255);
          rect(-28,13,5,5);
    
          fill(c, classic.button.right*255);
          rect(-18,13,5,5);
    
          fill(c, classic.button.up*255);
          rect(-23,8,5,5);
    
          fill(c, classic.button.down*255);
          rect(-23,18,5,5);
    
          // left and right buttons
    
          fill(c, classic.button.l*255);
          rect(-30,0,20,5);
    
          fill(c, classic.button.zl*255);
          rect(-10,0,5,5);
    
          fill(c, classic.button.zr*255);
          rect(5,0,5,5);
    
          fill(c, classic.button.r*255);
          rect(10,0,20,5);
    
          // show the right and left analog values
          fill(c);
          float h = 15*classic.analog.l;
          rect(-30,0,h,5);
          h = 15*classic.analog.r;
          rect(30-h,0,h,5);
    
          // reset buttons
    
          fill(c, classic.button.minus*255);
          rect(-9,10,5,5);
    
          fill(c, classic.button.home*255);
          rect(-4,10,5,5);
    
          fill(c, classic.button.plus*255);
          rect(1,10,5,5);
    
          popMatrix(); // end controller matrix
    
            popMatrix();
    
        }
    
        ///////////////////////////////////////
    
        class Accel { 
    
          float pitch, roll, yaw, accel;
    
          void message(String[] pattern, String typetag, OscMessage message) {
    
            if (!message.typetag().equals("ffff")) return;
    
            pitch = message.get(0).floatValue();
            roll  = message.get(1).floatValue();
            yaw   = message.get(2).floatValue();
            accel = message.get(3).floatValue(); 
    
          }
    
          void draw(int index, float x, float y, color c) {
    
            noStroke();
            fill(c);
    
            float w = 20 + (40 * accel);
            float h = w * 1.5;
    
            pushMatrix();
    
            translate((int)x,(int)y,0.0);
    
            String value_string;
            value_string = "no." + nf(index,0);
            text(value_string, -textWidth(value_string)/2, 30);
            value_string = "pitch:" + nf(pitch,1,5);
            text(value_string, -textWidth(value_string)/2, 40);
            value_string = " roll:" + nf(roll,1,5);
            text(value_string, -textWidth(value_string)/2, 50);
            value_string = "  yaw:" + nf(yaw,1,5);
            text(value_string, -textWidth(value_string)/2, 60);
            value_string = "accel:" + nf(accel,1,5);
            text(value_string, -textWidth(value_string)/2, 70);
    
            rotateZ(PI);
            rotateX(pitch*PI);
            rotateY(roll*PI+PI/2);
            rotateZ(yaw*PI+PI/2);
    
            rect(-w/2,-h/2,w,h);
    
            popMatrix();
    
          } 
    
        }
    
        ///////////////////////////////////////
    
        class Joystick { 
    
          float x = 0.5;
          float y = 0.5; 
    
          Joystick() {
    
          }
    
          void message(String[] pattern, String typetag, OscMessage message) {
            //
            if ( !typetag.equals("ff") ) return;
            //
            x = message.get(0).floatValue();
            y = message.get(1).floatValue();
          }
    
          void draw(float pos_x, float pos_y, color c) {
    
            pushMatrix();
    
            translate(pos_x,pos_y);
    
            fill(c,0);
            stroke(c,255);
            ellipse(0,0,50,50);
    
            ellipse( (x*50)-25, 25-(y*50), 15, 15 );
    
            popMatrix();
    
          }
    
        }
    
        ///////////////////////////////////////
    
        class Button { 
    
          boolean changed;
          float a, b, c, z, x, y, l, r, zl, zr, left, down, up, right, one, two, plus, minus, home; 
    
          void message(String[] pattern, String typetag, OscMessage message) {
    
            if (!typetag.equals("f")) return;
    
            String name = pattern[pattern.length-1];
    
            if (name.equals("1")) one = message.get(0).floatValue();
            if (name.equals("2")) two = message.get(0).floatValue();
            if (name.equals("A")) a = message.get(0).floatValue();
            if (name.equals("B")) b = message.get(0).floatValue();
            if (name.equals("Down")) down = message.get(0).floatValue();
            if (name.equals("Home")) home = message.get(0).floatValue();
            if (name.equals("Left")) left = message.get(0).floatValue();
            if (name.equals("Minus")) minus = message.get(0).floatValue();
            if (name.equals("Plus")) plus = message.get(0).floatValue();
            if (name.equals("Right")) right = message.get(0).floatValue();
            if (name.equals("Up")) up = message.get(0).floatValue();
            if (name.equals("L")) l = message.get(0).floatValue();
            if (name.equals("R")) r = message.get(0).floatValue();
            if (name.equals("X")) x = message.get(0).floatValue();
            if (name.equals("Y")) y = message.get(0).floatValue();
            if (name.equals("C")) c = message.get(0).floatValue();
            if (name.equals("Z")) z = message.get(0).floatValue();
            if (name.equals("ZL")) zl = message.get(0).floatValue();
            if (name.equals("ZR")) zr = message.get(0).floatValue();
    
            changed = true;
    
          }
    
        }
    
        ///////////////////////////////////////
    
        class IR { 
    
          boolean active;
          float x,y;
          IRRaw[] raws = new IRRaw[4];
    
          IR() {
            for(int i=0; i<raws.length; i++) raws[i] = new IRRaw();
          }
    
          void deactivate() {
            active = false;
            for(int i=0; i<raws.length; i++) raws[i] = new IRRaw();
          }
    
          void message(String[] pattern, String typetag, OscMessage message) {
    
            active = true;
    
            // if this is a simple infrared
            if (typetag.equals("ff") && 4==pattern.length) {
              x = message.get(0).floatValue();
              y = message.get(1).floatValue();
            } 
            else if (typetag.equals("fff") && 6==pattern.length && pattern[4].equals("xys")) {
    
              // get the index of this point
              int index = (pattern[5].equals("1")) ? 0 : 
              (pattern[5].equals("2")) ? 1 : 
              (pattern[5].equals("3")) ? 2 : 
              (pattern[5].equals("4")) ? 3 : -1;
    
              // error
              if (-1 == index) return;
    
              raws[index].x = message.get(0).floatValue();
              raws[index].y = message.get(1).floatValue();
              raws[index].r = message.get(2).floatValue();
              raws[index].active = true;
    
            }
    
          }
    
          void draw(float pos_x, float pos_y, color c) {
    
            if (!active) return;
    
            //println("draw ir");
    
            pushMatrix();
    
            translate(pos_x, pos_y);
    
            // draw the view rectangle
            fill(c,0);
            stroke(c);
            rect(-30,0,60,40);
    
            // draw the dot
            pushMatrix();
            translate(-30,0);
            ellipse(x*60,40-(y*40),7,7);
            popMatrix();
    
            // draw the four dots
            for(int i=0; i<4; i++) {
              // ignore if not active
              if (!raws[i].active) continue;
              // chercher le rayon
              float radius = 1 + (raws[i].r * 15);
              // draw
              pushMatrix();
              translate(-30,0);
              ellipse(raws[i].x*60,40-(raws[i].y*40),7,7);
              popMatrix();
            }
    
            popMatrix();
    
          }
    
        }
    
        ///////////////////////////////////////
    
        class IRRaw {
          boolean active = false;
          float x,y,r; 
        }
    
        ///////////////////////////////////////
    
        class Nunchuk { 
    
          boolean active = false;
          Joystick joystick = new Joystick(); 
          Accel accel = new Accel(); 
          Button button = new Button(); 
    
          void message(String[] pattern, String typetag, OscMessage message) {
    
            active = true;
    
            if ( typetag.equals("ffff") && pattern.length == 6 && pattern[4].equals("accel") && pattern[5].equals("pry") ) {
    
              accel.message(pattern,typetag,message);
    
            } 
            else if (pattern[4].equals("button") ) {
    
              button.message(pattern,typetag,message);
    
            } 
            else if (pattern[4].equals("joy") ) {
    
              joystick.message(pattern,typetag,message);
    
            }
    
          }
    
        }
    
        ///////////////////////////////////////
    
        class Classic { 
    
          boolean active;
          Joystick left = new Joystick();
          Joystick right = new Joystick(); 
          Button button = new Button();
          Analog analog = new Analog();
    
          class Analog { 
            float l, r; 
          }
    
          void message(String[] pattern, String typetag, OscMessage message) {
    
            active = true;
    
            if (pattern[4].equals("button") ) {
    
              // weird bug
              float value = message.get(0).floatValue();
              if (value > 0.0 && value < 1.0) {
                if (pattern[5].equals("L")) analog.l = message.get(0).floatValue();
                else if (pattern[5].equals("R")) analog.r = message.get(0).floatValue();
                return;
              }
    
              button.message(pattern,typetag,message);
    
            } 
            else if (pattern[4].equals("analog") && typetag.equals("f")) {
    
              if (pattern[5].equals("L")) analog.l = message.get(0).floatValue();
              else if (pattern[5].equals("R")) analog.r = message.get(0).floatValue();
    
            } 
            else if (pattern[4].equals("joyl") && typetag.equals("ff")) {
    
              left.x = message.get(0).floatValue();
              left.y = message.get(1).floatValue();
    
            } 
            else if (pattern[4].equals("joyr") && typetag.equals("ff")) {
    
              right.x = message.get(0).floatValue();
              right.y = message.get(1).floatValue();
    
            }
    
          }
    
        }
    
        ///////////////////////////////////////
    
      } // fin de la classe Wiimote
    
    
        ///////////////////////////////////////////////////////////////////////////
    
    
      class Balance {
    
        boolean active = false;
        // est-ce que quelqu'un est sur la planche
        boolean someone = false;
        // les cinq états réunis dans une liste de valeurs
        float[] values = new float[5];
        // ces listes avec des noms lisibles
        float bottom_left, bottom_right, top_left, top_right;
        // la somme
        float sum = 0.0;
        // centre de gravité
        Center center = new Center();
        // ciblage
        Target target = new Target();
    
        Balance() {
    
        }
    
        void deactivate() {
          active = false;
          target = new Target(); 
          center = new Center();
        }
    
        void draw(int index, color c) {
    
          if (!active) return;
    
          String value_string;
    
          float x_step = width/4;
          float x_half_step = x_step/2;
    
          float x = int((index*x_step)+x_half_step);
    
          pushMatrix();
    
          translate(x,44,0);
    
          // l'index de la planche
          value_string = "no." + nf(index,0);
          text(value_string, int(-textWidth(value_string)/2), +6);
          value_string = "bottom_left :" + nf(values[0],1,5);
          text(value_string, int(-textWidth(value_string)/2), +16);
          value_string = "bottom_right:" + nf(values[2],1,5);
          text(value_string, int(-textWidth(value_string)/2), +26);
          value_string = "top_left    :" + nf(values[3],1,5);
          text(value_string, int(-textWidth(value_string)/2), +36);
          value_string = "top_right   :" + nf(values[4],1,5);
          text(value_string, int(-textWidth(value_string)/2), +46);
    
          popMatrix();
    
          pushMatrix();
    
          translate(x,(height/2)-85);
    
          // le rectangle de la planche
          if (someone) noFill();
          else fill(c);
          rect(-50,0,100,50);
    
          // la somme
          float y = (sum * 50);
          line(-50,y,50,y);
    
          value_string = "somme:" + nf(sum,1,5) + " / " + nf( int(sum*100), 0) + "kg";
          text(value_string, int(-textWidth(value_string)/2), +66);
    
          if (someone) {
            ellipse(-50, +50, values[0]*50, values[0]*50);
            ellipse(+50, +50, values[1]*50, values[1]*50);
            ellipse(-50, +0,  values[2]*50, values[2]*50);
            ellipse(+50, +0,  values[3]*50, values[3]*50);
          }
    
          // draw the center
          if (center.x > 0.0 && center.y > 0.0) {
            pushMatrix();
            translate((int)(center.x*100)-50, (int)(center.y*50),0);
            line(-4,0,5,0);
            line(0,-4,0,5);
            popMatrix();
          }
    
          // do we draw the target?
          if (target.active) {
            pushMatrix();
            // move to target position
            translate((int)(target.x*100)-50, (int)(target.y*50),0);
            // are we near the target?
            if (center.near) {
              // draw rectangle
              fill(c);
              rect(-4,-4,8,8);
            } 
            else {
              // otherwise, draw target
              stroke(c);
              line(-4,-4,-1,-4);
              line(-4,-4,-4,-1);
              line( 4,-4, 2,-4);
              line( 4,-4, 4,-1);
              line(-4, 4,-4, 2);
              line(-4, 4,-1, 4);
              line( 4, 4, 4, 2);
              line( 2, 4, 5, 4);
            }
            popMatrix();
          }
    
          popMatrix();
    
        } // fin du draw()
    
        void message(String[] pattern, String typetag, OscMessage message) {
    
          active = true;
    
          if( pattern.length != 4 ) return;
          if (!typetag.equals("fffff")) return;
    
          setValues(message);
        }
    
        void setValues(OscMessage message) {
    
          // regarder la somme pour voir si quelqu'un est sur la planche
          if (message.get(4).floatValue() < 0.1) {
            // personne
            someone = false;
            // turn of centering
            center = new Center();
            // pas la peine de continuer
            return;
          }
    
          // chercher la somme
          sum = values[4] = message.get(4).floatValue();
    
          // il y a quelqu'un
          someone = true;
    
          // remplir les valeurs
          for(int i=0; i<4; i++) {
            values[i] = message.get(i).floatValue() / sum;
          }
    
          // mémoriser les nouvelles valeurs
          bottom_left = values[0];
          bottom_right = values[1];
          top_left = values[2];
          top_right = values[3];
    
          // figure out the center
          center.x = 1.0 - (((top_left+bottom_left) - (top_right+bottom_right) + 1) / 2);
          center.y = 1.0 - (((top_left+top_right) - (bottom_left+bottom_right) + 1) / 2);
          if (target.active) center.near = target.near(center.x, center.y);
    
        }
    
        // indiquer si quelquun est sur la planche
        boolean someone() {
          return someone; 
        }
    
        class Target { 
    
          boolean active;
          float x = -1.0, y = -1.0; 
          float tolerance = 0.05;
    
          void deactivate() {
            x = -1.0;
            y = -1.0;
            active = false;
          }
    
          void setXY(float new_x, float new_y) {
            x = new_x;
            y = new_y;
            active = true;
          }
    
          void setTolerance(float new_tolerance) {
            tolerance = new_tolerance;
          }
    
          boolean near(float new_x, float new_y) {
            // if we're not even targeting within bounds return false
            if (x < 0 || y < 0) return false;
            // 
            if (new_x < 0 || new_y < 0) return false;
            // if we're inactive return false
            if (!active) return false;
            // figure out the distances
            float diff = dist(x, y, new_x, new_y);
            // if the distance is greater than the tolerance, we're not close enough
            if (diff > tolerance) return false;
            // if all that is untrue, then we're near -- return true
            return true;
          }
    
        } // fin de la classe Target
    
        class Center {
    
          boolean near = false;
          float x = -1.0;
          float y = -1.0;
    
        }
    
      } // fin de la classe Balance
    
    } // fin de la classe Wii
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    external by n1ckfg  16  0  1  0

    Represent a float in two bytes instead of four

    Represent a float in two bytes instead of four: FloatShortConversion.pde
    short places = 1000;
    float foo = -11.14175;
    short bar = (short) (foo * places);
    float foo2 = (float) bar / (float) places;
    println(foo + " " + foo2);
    
    

    external by Marc  30  0  1  0

    VEGAS Processing - system.transitions.Tween

    VEGAS Processing - system.transitions.Tween: VEGAS Processing - system.transitions.Tween.pde
    import core.easings.Linear;
    import core.easings.*;
    import system.transitions.*;
    
    Console finish = new Console("finish" ) ;
    Console change = new Console("change" ) ;
    Console start  = new Console("start"  ) ;
    
    Rectangle rect ;
    Tween tween ;
    
    void setup() 
    {
        size(480,450);
        frameRate(60);
        background(0);
        
        rect = new Rectangle( 10 , 10 , 10 , 10 ) ;
        
        tween = new Tween( rect , Elastic.easeOut, 60 ) ;
        
        tween.setFPS( 60 )
             .setDuration( 60 ) ;
             
        tween.setUseSeconds( true ).setDuration( 1 );
        
        tween.finishIt().connect( finish ,"receive" ) ;
        //tween.changeIt().connect( change ,"receive" ) ;
        tween.startIt().connect( start  ,"receive" ) ;  
    
        tween.from( "x" , 10 ).to( "x" , 460 ).easing( "x" , Sine.easeOut )
             .from( "y" , 10 ).to( "y" , 430 ).easing( "y" , Bounce.easeOut ) ;
        tween.run() ;
    }
    
    void draw() 
    {    
        background(25);
        rect.render() ;
        
    }
    void mousePressed() 
    {
        if( tween.running() )
        {
           tween.stop() ; 
        }
        
        tween.from( "alpha" , 0 ).to( "alpha" , 0.6 ).easing( "x" , Linear.ease )
             .from( "x" , rect.x ).to( "x" , mouseX - rect.width * .5 ).easing( "x" , Back.easeOut )
             .from( "y" , rect.y ).to( "y" , mouseY - rect.height * .5 ).easing( "y" , Expo.easeOut ) ;
        tween.run() ;
    }
    
    public class Rectangle
    {
        public Rectangle( float x , float y , float width , float height )
        {
            this.x = x ;
            this.y = y ;
            this.width = width ;
            this.height = height ;
        }
    
        private float _alpha = 1 ;
        
        public float x = 0 ;
        public float y = 0 ;
    
        public float width = 0 ;
        public float height = 0 ;
        
        public Float getAlpha()
        {
             return _alpha ;
        }
        
        public Rectangle setAlpha( Float value )
        {
             _alpha = Math.max( Math.min( value, 1 ), 0 ) ;
             return this ;
        }
        
        
        public void render()
        {
            fill(140,255,100,_alpha*100);
            rect( x, y, width, height);
        }    
         
        public String toString()
        {
            return "[Rectangle x:" + x + " y:" + y + " width:" + width + " height:" + height + "]" ;
        }
    }
    
    public class Console
    {
        String name ;
    
        public Console( String name )
        {
            this.name = name ;
        }
    
        public void receive( Object object )
        {
            Tween tween = (Tween) object ;
            println( this + " rect:" + rect + " tween:" + tween + " time:" + tween.time() + " duration" + tween.duration() ); ;
        }
    
        public String toString()
        {
            return "[Console " + name + "]" ;
        }
    }
    
    

    external by Github  31  0  1  0

    Circle is generated of random dots

    Circle is generated of random dots: dot_circle.pde
    PVector location;
    PVector velocity;
    float rad;
    int h = 0;
    
    void setup() {
      size(900,900);
      
      //HSB color mode is a simple way to go through the entire
      //color scheme just by changing one variable.
      colorMode(HSB, 360, 100, 100);
      
      background(0,0,12);
      smooth();
    }
    
    void draw() {
      // looped circular movement
      println(frameCount);
      rad = radians(frameCount);
      
      // size of the circle, >350 – bigger, <350 – smaller.
      float x = width/2 + (350* cos(rad));
      float y = height/2 + (350 * sin(rad));
    
      location = new PVector(x, y);
      
      // velocity also determines the width of the ring.
      velocity = new PVector(random(-50, 200), random(-50, 20));
      location.add (velocity);
      
      stroke(h, 90, 90);
      fill(h, 90, 90);
      // size of the balls.
      ellipse(location.x, location.y, 10, 10);
      
      // when x reaches it max (completeting a full circle)
      // the color changes.
      if (x > 799.94) {
        h = h + 10;
      }
      // color reset
      if ( h > 360) {
        h = 0;
      }
    }
    
    

    external by Nicola Ariutti  29  0  1  0

    A Processing sketch to turn a decimal number to its binary rapresentation.

    A Processing sketch to turn a decimal number to its binary rapresentation.: int_to_binary.pde
    /*
    * A Processing sketch to turn a decimal number to its
    * binary rapresentation. Pay attention: here 
    * we are printing least significant bits for first.
    */
    
    int b = 9;
    int c = 0;
    
    print("#");
    for(int i=0;i<8; i++)
    {
      c = (1<<i);
      c = b & c;
      c = (c>>i);
      //print(c + " ");
      print(c==1);
    }
    println();
    
    
    • Public Snippets
    • Channels Snippets