Apache Spark et Scala : parcourir un fichier image

Bonjour à tous,

Je dispose d’un fichier binaire, une image au format JPEG ou bien PNG. Je souhaiterais effectuer un parcours distribué de cette image (ie. : chaque noeud de mon cluster lit un groupe de pixel(s) et, par exemple, enregistre le/les RGB dans une collection Scala).

Spark fournit la fonction SparkContext::binaryFiles mais je ne sais pas comment, par la suite, lui faire "comprendre" qu’il s’agit d’une image pour pouvoir la parcourir pixel par pixel, récupérer les RGB adéquats, etc.

Quelqu’un a-t-il déjà fait cela ?

Je sais pas si je dois répondre à la question ou remettre en question la question.

Pour faire "comprendre" à ton programme qu’il s’agit d’un PNG (par exemple), il faut que tu décodes le binaire en suivant la spécification du format PNG. Il existe des bibliothèques logicielles permettant de faire ça : tu leur donnes un PNG et elles l’"interprètent". C’est à dire qu’à partir d’un binaire, elles créent notamment un tableau de pixels.

Oui oui, je sais bien, je suis en Master 2. Mais pour faire cela de façon distribuée avec Spark ? Un foreach sur la deuxième composante du couple du RDD retourné par le binaryFiles serait à écrire ? Et dedans je placerais l’appel à une fonction d’une API ? (autant prendre l’API Java avec le bufferedimage)

Oui oui, je sais bien, je suis en Master 2.

Jamais entendu ce terme, je ne sais pas ce que c’est un "Master 2". :|

Ça dépend du but à atteindre. Soit ce que tu distribues est le tableau de pixels et chaque noeud fait une partie du boulot sur les pixels qu’elle reçoit, soit ce que tu distribues est le binaire et chaque noeud décode puis traite une partie.

Pardon, c’est deuxième année de master, en France !

La toute première entrée est bien le fichier image. Du coup j’aimerais distribuer la conversion "RGB binaire d’un pixel ====> RGB integer d’un pixel". Puis distribuer l’utilisation de ces RGB integers.

Pour ce faire, j’ai pensé à :

1. Utiliser `spark_context.binaryfiles("mon fichier image.jpg/png")

2. Et après je ne sais pas trop quoi faire… J’aimerais que chaque noeud convertisse son propre groupe de RGB binaires en RGB integers

3. Puis utiliser ces RGB integers

Donc tu veux distribuer un RDD de pixels RGB binaires.

Il faudrait donc charger le fichier, le décoder pour pouvoir créer ton RDD de pixels, puis tu map sur ce RDD la conversion et l’utilisation des pixels.

Oui, mais justement : la phase de décodage ne peut pas être distribuée ?

Tout ne peut pas être fait en parallèle dans le décodage PNG. Tu peux faire 2-3 trucs en parallèle mais de loin pas tout.

Commence par implémenter un décodeur PNG, tu verras assez rapidement ce qui est parallélisable. DEFLATE est parallélisable il me semble, donc cette partie est jouable si tu l’implémentes proprement. Ensuite je suppose que le calcul des valeurs de chaque pixel étant par canal tu peux traiter les trois canaux (RGB) en parallèle sur 3 noeuds.

N’est-il pas possible d’utiliser de manière distribuée directement l’API Java (BufferedReader) ?

Dans quel but ?

Je sais pas si c’est clair pour toi mais un PNG c’est pas un fichier texte où chaque ligne peut être traitée séparément.

Pour récupérer le RGB d’un pixel appartenant à un groupe de pixels traité par tel ou tel noeud

En fait effectivement, je pensais qu’un fichier image pouvait être découpé par groupes de pixels. On donnerait chacun de ces groupe à un noeud du cluster (= on distribue l’image sur le cluster). Puis chacun de ces noeuds feraient appel à BufferedImage::getRGB(), puis feraient des traitements dessus.

Pour l’instant, ce que je fais c’est que le driver met en place une collection Scala contenant le RGB de chaque pixel, et distribue cette collection Scala sur cluster pour qu’ils fassent les traitements dessus. MAIS DU COUP, le fait de récupérer les RGB n’est PAS distribué : c’est le driver qui s’occupe de faire ça pour toute l’image, et je trouve ça dommage

D’aaccord, merci !