MANRES II [EXPLODE]

SERNAM_20170826_17-SERNAM_20170826_31.2.23h14m41s23645ms.resize.jpg

paul klee

Comment Paul Klee a pensé les liens entre musique et peinture ? En cherchant à traduire visuellement la musique sans se contenter d'une synesthésie intuitive, Paul Klee a mis en place des instruments conceptuels rigoureux : damiers, quadrillages, figures en 3D...

Violaine Anger, musicologue, Cnrs / Ecole normale supérieure.
Une conférence enregistrée en 2013.

https://www.franceculture.fr/conferences/institut-francais-de-la-mode/paul-klee-une-oeuvre-ou-musique-et-peinture-sentrelacent

zoom1bit[02]

25.png

25.png

25.png

25.png

25.png

25.png

zoom1bit[01]

100.png

20.png

800.png

b00m

HH.screencap.replay

 

encodage FFMPEG

ffmpeg -i out.avi -c:v libvpx -crf 10 -b:v 2M -threads 4 out.webm

 

HH 1 bit




Image originale :


 

HH




#!/usr/bin/python
# coding: utf-8

# haacheuur 0.24

import sys
import Image
import random
import os
import ImageDraw
import ImageFont
import ImageFilter
from time import gmtime, strftime
import time

# modifs du 30/10/2013
import ImageEnhance

#ouvertrure de l'image source et conversion en mode couleur 1bit
#im1 = Image.open(str(sys.argv[1])).convert('1')
#im1 = Image.open(str(sys.argv[1])).convert('L')
im1 = Image.open(str(sys.argv[1]))
im2 = im1.copy()

#rapport d'allongement de la nouvelle image par rapport à la largeur de l'image originale
allongement = 1

im3 = Image.new("RGBA",(im1.size[0], im1.size[1]))
im4 = Image.new("RGBA",(im1.size[0]*allongement, im1.size[1]))

Larg = im1.size[0]
Haut = im1.size[1]
import pickle

loadfile = False

class Sequence:
    def __init__(s):
        randomCoupeHauteur = []
        s.randomCopyPosi =[]
        s.proportions=[]
        s.choix=[]
        s.sizeOutput=None
        s.sizeInput=None

"""
seq = dict()
seq["randomCoupeHauteur"] = []
seq["randomCopyPosi"] = [] 
seq["proportions"] = []
seq["choix"] = []
seq["sizeOutput"]= im4.size
seq["sizeInput"] = im1.size
"""
if loadfile:
    seq=pickle.load(open("test.pickle"))

else :
    seq=Sequence()
    
for i in range(4):
    
        
    # constitution de la liste des tranches horizontales
    # genre comme si qu'on avait un 16 pistes :)
    # nombre aleatoire compris dans les limites de l'image
    def randHaut():
        return random.randint(0, im1.size[1]/8)*8
    
    if loadfile:
        randomCoupeHauteur = seq.randomCoupeHauteur
        
    else:
        randomCoupeHauteur = [0, \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        randHaut(),randHaut(),randHaut(),randHaut(), \
        im1.size[1]]
        # rangement des valeurs des plus petites au plus grandes
        randomCoupeHauteur.sort()
        seq.randomCoupeHauteur = randomCoupeHauteur
        
    # les hachures
    def Hacheur(haut, bas) :
        
        n=0
        i=0
        #!!!!!!!!!!
        while n<im4.size[0] :
            
            if loadfile:
                proportions = seq.proportions
                choix_rnd = seq.choix[i]
                randomCopyPosi = seq.randomCopyPosi[i]
            else:
                '''
                8 16 24 32 40 48 56 64 72 80 88 96 104 112 120 128 136 144 152 160 168
                '''
                #proportions = [(160,6),(120,4),(120,8),(80,16),(60,16),(20,32),(8,24),(8,16),(5,64),(3,24),(2,24),(1,256),(1,128),(1,64),(1,32),(1,16),(1,8)]
                proportions = [(160,1),(120,2),(120,3),(80,6),(64,12),(24,18),(8,24),(8,16)]
                seq.proportions = proportions
                #proportions = seq.proportions[]
                choix_rnd = random.randint(0, len(proportions)-1)
                #choix_rnd = random.randint(0, len(proportions)-1)
                seq.choix.append(choix_rnd)
                
                largeur = proportions[choix_rnd][0]
    
                
                # positionnement de la copie, aleatoirement, entre 0 et la largeur totale de l'image 
                randomCopyPosi = random.randint(0, (im1.size[0]-largeur))
                #randomCopyPosi = seq.randomCopyPosi
                seq.randomCopyPosi.append(randomCopyPosi)
            
            i+=1

            # tirage au sort

            
            #seq["choix"].append(choix_rnd)
            
            # assignation des valeurs (paires) finales choisies
            largeur = proportions[choix_rnd][0]            
            repeat = proportions[choix_rnd][1]
    

            #seq["randomCopyPosi"].append(randomCopyPosi)
            
            cx1 = randomCopyPosi
            cx2 = randomCopyPosi + largeur
            # decoupage du sample
            im3 = im2.crop((cx1,haut,cx2,bas))
            '''
            print "im3 = im2.crop : "+str(im3.size)
            '''
                
            draw = ImageDraw.Draw(im4)
                    
            loop = 0
            
            pixelSizeList = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,4,8]
            pixelSizeIndex = random.randint(0,len(pixelSizeList)-1)
            pixelSize = pixelSizeList[pixelSizeIndex]
            '''
            print " pixelSize = "+str(pixelSize)
            '''
            
            ''' COLLAGE DU SAMPLE
            '''
            while loop<repeat:    
                px1 = n
                px2 = n + largeur
                
                draw = ImageDraw.Draw(im3)
                
                ''' PIXELISATION
                '''

                im3 = im3.resize((im3.size[0]/pixelSize, im3.size[1]/pixelSize), Image.NEAREST)
                im3 = im3.resize((im3.size[0]*pixelSize, im3.size[1]*pixelSize), Image.NEAREST)
                
                '''
                print "im3.size="+str(im3.size)
                print "im4.size="+str(im4.size)
                '''
                
                #lignes colorées de 1 pix
                draw.line((im3.size[0]-1, 0, im3.size[0]-1, im3.size[1]-1), fill="rgb(255,255,255)")
                
                im4.paste(im3, (px1, haut, px2, bas))
                
                n = n + largeur
                loop = loop + 1
    
    ''' OPTIONS
    '''    
    def TrancheHorizontale() :
        # tirage au hasard de la bande copiee
        pos = random.randint(0, im1.size[1]-im1.size[1]/20)
        # copiage
        im5 = im2.crop((0,pos,im1.size[0],pos+im1.size[1]/20))
        
        # le soulignage en blanc
        draw = ImageDraw.Draw(im5)
        draw.line((0, im5.size[1]-1, im5.size[0], im5.size[1]-1), fill="black")
        draw.line((0, 1, im5.size[0], 1), fill="black")
        
        # collage    
        im4.paste(im5, (0,pos,im1.size[0],pos+im1.size[1]/20))

    # HAACHEUUR
    for j in range(len(randomCoupeHauteur)-1):
        Hacheur(randomCoupeHauteur[j], randomCoupeHauteur[j+1])
    
    ''' SAUVEGARDE
    '''
    # CTRL + S
    #chemin du script    : scriptpy = sys.argv[0]
    #chemin de l'image    : str(sys.argv[1])
    scriptpy = str(sys.argv[1])
    script = scriptpy[:-3]
    n = "%05d" % i
    im4.save(script+"."+n+"_"+strftime("%Y%m%d-%Hh%Mm%Ss", gmtime())+".png",'PNG', quality=100)
    pickle.dump(seq, open("test.pickle","w"))
    
    #print script+"."+str(i)+"_"+strftime("%Y%m%d-%Hh%Mm%Ss", gmtime())+".jpg"
    #millis = int(round(time.time() * 1000))
    #print "millis-secondes : "+str(millis)
    
 

 

 

 

HH_

Natron : compositeur vidéo

le lien :

https://natron.inria.fr/install/

haacheuur de juillet 2015

hacheuur_0.24.gare.20150723-09h20m53s.png

hacheuur_0.24.gare.20150723-09h20m57s.png


hacheuur_0.24.gare.20150723-09h21m02s.png

hacheuur_0.24.gare.20150723-09h21m08s.png

hacheuur_0.24.gare.20150723-09h21m13s.png

hacheuur_0.24.gare.20150723-09h21m18s.png

 

#!/usr/bin/python
# coding: utf-8
import sys
import Image
import random
import os
import ImageDraw
import ImageFont
import ImageFilter
from time import gmtime, strftime
# modifs du 30/10/2013
import ImageEnhance

#ouvertrure de l'image source et conversion en mode 1bit
#im1 = Image.open(str(sys.argv[1])).convert('1')
im1 = Image.open(str(sys.argv[1]))
im2 = im1.copy()
#im3 = Image.new("1", (im1.size[0], im1.size[1]))
#im4 = Image.new("1", (im1.size[0]*3, im1.size[1]))

im3 = Image.new("RGBA",(im1.size[0], im1.size[1]))
im4 = Image.new("RGBA",(im1.size[0]*1, im1.size[1]))

Larg = im1.size[0]
Haut = im1.size[1]

for i in range(10):
    
    # nombre aleatoire compris dans les limites de l'image
    def randHaut(): return random.randint(0, im1.size[1])
        
    # constitution de la liste des tranches horizontales
    # genre comme si qu'on avait un 16 pistes :)
    randomCoupeHauteur = [0, \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    randHaut(),randHaut(),randHaut(),randHaut(),randHaut(), \
    im1.size[1]]

    # rangement des valeurs des plus petites au plus grandes
    randomCoupeHauteur.sort()
    
    # DEBUG
    liste = []

    # les hachures
    def Hacheur(haut, bas) :
        n=0
        while n<im4.size[0] :
        
            # constitution d'une liste de dimensions et de repetitions
            randomListe = [(2560,1),(1280,2),(640,4),(320,8),(320,3),(160,12) \

,(160,6),(120,8),(80,24),(40,16),(20,32),(20,16),(10,32),(10,16),(5,64)]
            # repeter ce qui suit 2 ou 3 fois pour realiser non pas
            # un sample, mais carrement ue sequence


# 8>< ------------------------------------------------------------------            
            # tirage au sort
            #randomFacteur = random.randint(0, len(randomListe)*3)
            choix = 0
            
            # DEBUG    
            #print len(randomListe)*3
            
            # ponderation du tirage au sort
            randomFacteur = random.randint(0, len(randomListe)-1)
            
            # DEBUG
            #liste.append(choix)
            
            # assignation des valeurs (paires) finales choisies
            randomCopyLargFinal = randomListe[randomFacteur][0]            
            repeat = randomListe[randomFacteur][1]
    
            # positionnement de la copie, aleatoirement, entre 0 et la largeur totale de l'image
            randomCopyPosi = random.randint(0, (im1.size[0]-randomCopyLargFinal))

            cx1 = randomCopyPosi
            cx2 = randomCopyPosi + randomCopyLargFinal
            # decoupage du sample
            im3 = im2.crop((cx1,haut,cx2,bas))
# 8>< ------------------------------------------------------------------
                
            draw = ImageDraw.Draw(im4)        
            loop = 0
            
            #collage, n fois, du sample
            while loop<repeat:    
                px1 = n
                px2 = n + randomCopyLargFinal
                
                draw = ImageDraw.Draw(im3)
                
                im4.paste(im3, (px1, haut, px2, bas))
                
                n = n + randomCopyLargFinal
                loop = loop + 1

    # les tranches horizontales intactes soulignees de blanc                 
    def TrancheHorizontale() :
        # tirage au hasard de la bande copiee
        pos = random.randint(0, im1.size[1]-im1.size[1]/20)
        # copiage
        im5 = im2.crop((0,pos,im1.size[0],pos+im1.size[1]/20))
        
        # le soulignage en blanc
        draw = ImageDraw.Draw(im5)
        draw.line((0, im5.size[1]-1, im5.size[0], im5.size[1]-1), fill="black")
        draw.line((0, 1, im5.size[0], 1), fill="black")
        
        # collage    
        im4.paste(im5, (0,pos,im1.size[0],pos+im1.size[1]/20))

    # HAACHEUUR
    for i in range(len(randomCoupeHauteur)-1):
        Hacheur(randomCoupeHauteur[i], randomCoupeHauteur[i+1])
   
            
    
    # CTRL + S
    scriptpy = sys.argv[0]
    script = scriptpy[:-3]
    im4.save(script+"."+strftime("%Y%m%d-%Hh%Mm%Ss", gmtime())+".png")
   

la franqui

IMG_4255_laFranqui.JPG

berssaptera.remix

une version en cours de développement de haacheuur,
avec comme source berssaptera (photographie numérique, décembre 2014)

Image originale :

IMG_3722.opti.jpg

Image produite par Haacheuur.py :

berssaptera.remix.png

 

Si l'on zoome sur la partie ici soulignée en bleu ciel :

berssaptera.remix.zoom860.png

 

Cela donne nous cette image, vue à taille réelle (100%) :

 

berssaptera.remix.sample.png

pylones

pylone.jpg

je sais pas...

Localisation de la prise de vue :
https://www.google.fr/maps/place/......737.5%22E/@43.18708,2.660411,644m/data=!3m2!1e3!4b1!4m2!3m1!1s0x0:0x0

screenshots puredata/Gem

Un feedback OpenGL/GLSL, se trouvant dans l'aide de puredata/Gem :
Gem/examples/10.glsl/07.framebuffer_and_shader.pd
Présentement, en mode gluant :

Capture du 2015-04-09 19:18:33.png

Capture du 2015-04-09 19:18:38.png

Capture du 2015-04-09 19:18:40.png

screenshots puredata/Gem

L'interface de controle (puredata) à gauche, la sortie OpenGL (Gem) à droite. Des similarité entre ces 2 surfaces, en effet la sortie OpenGL (à droite) est texturée avec  des bouts d'images venant de la partie gauche.
Comment se passe la capture écran pour l'avoir dans puredata/gem :
- la capture est effectué avec FFMPEG

Avec quelque chose comme :

ffmpeg -f x11grab -r 25 -s 256x256 -follow_mouse centered -show_region 1 -i :0.0+0,0 -vcodec rawvideo -pix_fmt yuv420p -threads 0 -f v4l2 /dev/video1


- puis renvoyée (pipe) dans un device /dev/video$ grace à VLOOPBACK
- pour au final être récupérée dans puredata/Gem en utilisant l'objet [pix_video]).

Capture du 2015-03-03 22:49:32.png

Capture du 2015-03-05 17:16:49.png

Capture du 2015-03-05 17:18:47.png

Capture du 2015-03-05 17:19:51.png

Capture du 2015-03-05 17:20:07.png

Capture du 2015-03-05 17:20:14.png

Capture du 2015-03-05 17:24:20.png

Ce qu'il y a d'amusant donc dans ce patch est qu'il recopie en permanence le bureau (donc les interfaces de contrôle qui servent à piloter le bazar) pour en faire une image exploitable dans un contexte openGL.

screencast : 1 de 2015

Un screencast, en 2015, ça casse pas trois pattes à un canard.

le logiciel qui enregistre l'écran c'est ffmpeg :

 ffmpeg -f x11grab -r 25 -s 1600x900 -i :0.0+0,0 -vcodec libx264 -threads 0 video.mkv
 ffmpeg -i screencast_2015.mkv -vcodec vp8 -crf 22 -threads 0 screencast_2015.webm

commandes que j'ai adapté depuis ceci :

http://wiki.oz9aec.net/index.php/High_quality_screen_capture_with_Ffmpeg

 

SlowmoVideo

un truc qui ralenti l'image sans dégrader les sujets en mouvement (en repèrant les pixels qui bougent)

http://slowmovideo.granjow.net/download.php

AIDE A LA CREATION

Aide individuelle à la création 2015 / Drac Midi-Pyrénées / TOULOUSE
La Direction régionale des affaires culturelles (Drac) Midi-Pyrénées attribue
des aides individuelles pour des projets prévus sur le territoire national dans
les domaines suivants : peinture, estampe, sculpture, installation, photographie… 
Ces aides concernent la phase de conception du projet et
non sa diffusion (exposition ou édition) et permettent aux artistes de mener
aussi bien une étude qu’une recherche artistique n’aboutissant pas
nécessairement à la réalisation concrète d’une oeuvre. Le montant de
l’allocation attribuée est calculé selon la nature du projet présenté et les
dépenses nécessaires à sa réalisation. 
La demande ne peut dépasser 7500 euros.
Date limite de dépôt du dossier complet 
++++++++++++++++++++++++++++++
31.03.2015, le cachet de la poste faisant foi.
+++++++++++++++++++++++++++++++++++
Contacts :
Madame Marie-Béatrice Angelé
Conseiller pour les arts plastiques
Tél. : 05 67 73 20 19
julie.loustau(arobase)culture.gouv.fr
Le dossier doit être adressé à :
Monsieur le directeur régional des affaires culturelles
Service des arts plastiques
Drac Midi-Pyrénées
32 rue de la Dalbade
BP 811
31080 TOULOUSE cedex 06
Apposer la mention
NE PAS OUVRIR
sur l’enveloppe
ainsi que vos coordonnées.
INFORMATIONS et FORMULAIRE :
http://www.culturecommunication.gouv.fr/.../AIC%20descriptif_2015.pdf.

haacheuur blanc

le programme Haacheuur 0.24 travaillant avec une image blanche
(cliquez sur les images pour les agrandir à taille réelle) :

 hacheuur_0.24._2014.11.24_12h38m38s.png hacheuur_0.24._2014.11.24_15h41m33s.gif hacheuur_0.24._2014.11.24_15h41m37s.gif hacheuur_0.24._2014.11.24_15h41m40s.gif hacheuur_0.24._2014.11.24_15h42m56s.gif hacheuur_0.24._2014.11.24_15h43m06s.gif

- page 1 de 2

Cumulonimbus.fr - 2015 - license cc by-nc-sa 3.0 fr
Dernière mise à jour : 2017-09-20 14:09:07