Études en informatique

Aller en bas

Études en informatique

Message  Bacrima le 17.08.12 11:05

Étudier l'informatique, enfin, plus précisément, faire une licence informatique à l'université de Besançon, demande de produire certain travaux.
Pour la fin du second semestre, on nous a laisser le choix entre plusieurs sujets (Site d'origine):



Instructions communes aux 4 projets

• Le travail est à réaliser en binôme.
• Le travail est à réaliser en langage Java.
• On s'attachera à structurer les données manipulées en types agrégés.
• On s'attachera à résoudre les problèmes rencontrés par la programmation de fonctions ad-hoc.
• Tous les types agrégés programmés seront documentés sous la forme d'un commentaire placé avant le type agrégé incluant la description du rôle du type et la description de ses champs.
• Toutes les fonctions programmées seront documentées sous la forme d'un descriptif placé avant la fonction et d'éventuelles lignes de commentaire inline.
• Le programme principal devra être architecturé autour d'un système de gestion de menus textuels permettant son utilisation et, pour les sujets n°1, 2 et 3, le test individuel des fonctionnalités demandées.
• Le fichier java développé devra inclure une première ligne de commentaire avec les nom et prénom des développeurs, le groupe de TP auxquels ils appartiennent et le numéro de projet choisi.
• Le fichier .java devra être accompagné d'un fichier readme.txt (ou .pdf ou .doc ou .ood) incluant:
o le mode d'emploi de l'application développée,
o pour chaque question posée, un descriptif de la technique employée pour la résoudre,
o l'indication de ce qui a été développé par chacun des 2 membres du binôme,
o toutes autres informations jugées pertinentes.
• Chaque binôme réalisera une présentation (environ 10 mn) du fonctionnement de son projet (assortie de questions de l'enseignant de TP) au cours d'une séance de TP de la semaine du 7 mai.
• Les projets sont à rendre pour le vendredi 11 mai 2012 dernier délai.
• Les deux fichiers sont à envoyer par courrier électronique à l'adresse XXXXXXX.XXXXX@univ-fcomte.fr. L'objet du mail devra contenir les noms des auteurs, leur numéro de groupe de TP et le numéro de projet choisi. Un accusé de réception sera émis à la remise du message.


Sujet n°1: Manipulations sur des ensembles de chaînes de caractères

On souhaite manipuler des ensembles de chaînes de caractères. Ces ensembles peuvent contenir 0, 1, ..., N chaînes de caractères. Ils respectent la règle commune à tous les ensembles nathématiques: Un élément ne peut apparaître 2 fois dans le même ensemble. Tout essai d'ajout à un ensemble d'une chaîne déjà présente échouera.
a) Définir un type agrégé "Ensemble" de stockage d'un ensemble de chaînes de caractères.
b) Développer une méthode de création d'un ensemble vide.
c) Développer une méthode de test si une chaîne de caractères appartient à un ensemble.
d) Développer une méthode d'ajout d'une chaîne de caractères à un ensemble.
e) Développer une méthode de retrait d'une chaîne de caractères d'un ensemble.
f) Développer une méthode de test si un ensemble est vide.
g) Développer une méthode de création d'un ensemble par union de 2 ensembles.
h) Développer une méthode de création d'un ensemble par intersection de 2 ensembles.
i) Développer une méthode de création d'un ensemble par différence entre 2 ensembles.


Sujet n°2: Affichages sur un écran "graphique"

On souhaite dessiner à l'écran en haute définition: Allumer des pixels, tracer des segments de droite, remplir des rectangles, tracer des cercles, ...
A cette fin, de manière à faciliter la gestion d'une fenêtre d'affichage en mode graphique, on utilisera les trois fichiers EcranHD.class, EcranHD$MyFrame.class et EcranHD$MyCanvas.class qui contiennent un certain nombre de méthodes permettant ce type d'affichage (voir documentation). Ces fichiers sont à télécharger et à placer dans le même répertoire que le fichier .java de l'application développée.
La méthode la plus importante est la méthode EcranHD.set(int [][] img) qui est la seule méthode d'affichage. En effet, elle dessine dans la fenêtre l'image codée par le tableau d'entiers img. La taille de ce tableau selon le premier indice est le nombre de colonnes de pixels codées dans l'image. La taille selon le second indice est le nombre de lignes de pixels. Chaque pixel est codé en couleur RVB 24bits selon la formule r+256*v+256*256*b où chacune des composantes r,v et b est un entier compris dans l'intervalle [0,255].
Le fichier TestEcranHD.java donne un exemple d'utilisation des méthodes EcranHD.*.
a) Ecrire une méthode de création d'un tableau image initialisé à la couleur de fond noir.
b) Ecrire une méthode de création d'un tableau image initialisé à une couleur arbitraire.
c) Ecrire une méthode permettant d'allumer un pixel de coordonnées (x,y) d'un tableau image avec une couleur arbitraire.
d) Ecrire une méthode permettant de tracer un segment de droite entre deux pixels de coordonnées (x1,y1) et (x2,y2) d'un tableau image avec une couleur arbitraire.
e) Ecrire une méthode permettant de remplir un rectangle de pixels d'un tableau image avec une couleur arbitraire.
f) Ecrire une méthode permettant de tracer un cercle de pixels d'un tableau image avec une couleur arbitraire.
g) Ecrire une méthode permettant de remplir un cercle de pixels d'un tableau image avec une couleur arbitraire.


Sujet n°3: Mini traitement de texte

Un texte est stocké dans un tableau de chaînes de caractères. Chacune de ces chaînes contient un seul paragraphe. Chaque paragraphe est composé de zéro, une ou plusieurs phrases (séparateur '.'). Les phrases à cheval sur plusieurs paragraphes sont interdites. Les points de suspension sont interdits. Chaque phrase est composée de plusieurs mots (séparateur ' '). Les autres caractères de ponctuation usuels (',', ';', ':', ...) sont autorisés dans les phrases. Les mots sont composés de caractères alphabétiques, de caractères numériques et de tous les caractères qui ne sont pas des caractères de ponctuation.
a) Ecrire une méthode permettant de compter le nombre de paragraphes contenus dans un tel tableau.
b) Ecrire une méthode permettant de compter le nombre de phrases contenues dans un tel tableau.
c) Ecrire une méthode permettant de compter le nombre de mots contenus dans un tel tableau.
d) Ecrire une méthode permettant de vérifier le respect des règles suivantes dans un tel tableau:
- pas de double-espace,
- pas d'espace avant les caractères de ponctuation,
- toujours un espace après les caractères de ponctuation,
- toujours un caractère de ponctuation en fin de paragraphe.
On souhaite afficher un texte en réalisant des sauts de ligne au sein des paragraphes permettant de ne pas dépasser la largeur disponible sur la page. Pour cela, on considère que tous les caractères ont la même largeur (police "Courrier" par exemple) et qu'il est donc possible de compter la largeur d'affichage au moyen d'un nombre entier n de caractères.
e) Ecrire une méthode permettant d'afficher un texte avec "alignement à gauche" sur n caractères de largeur.
f) Ecrire une méthode permettant d'afficher un texte avec "centrage" sur n caractères de largeur.
g) Ecrire une méthode permettant d'afficher un texte avec "alignement à gauche et à droite" (justification) sur n caractères de largeur. On ajoutera judicieusement des caractères espace entre les mots de manière que chaque ligne affichée se termine au nème caractères (à l'exception de la dernière ligne de chaque paragraphe).


Sujet n°4: Un jeu de bataille navale humain contre ordinateur

Le but est de développer un jeu de bataille navale opposant un humain à l'ordinateur.
1 porte-avions (5 cases adjacentes), 2 cuirassés (4 cases adjacentes), 2 destroyers (3 cases adjacentes) et 4 frégates (2 cases adjacentes) sont placés sur un damier de 15x15 cases de manière à ne se toucher ni par le bord d'une case, ni par le coin d'une case. Le joueur humain les place lui-même ou demande un placement automatique aléatoire. Les bâtiments sont placés aléatoirement par le programme simulant le joueur ordinateur.
Pour rendre le jeu plus rapide, on pourra réduire la taille du plateau. Une taille de 12x12 cellules est compatible avec le nombre de navires à placer.
a) Implanter les structures de données nécessaires à la gestion du jeu.
b) Implanter une méthode permettant au joueur humain de placer ses bâtiments.
c) Implanter une méthode permettant de placer aléatoirement les bâtiments de l'ordinateur.
Remarque: Dans la phase de lancement du jeu, cette méthode pourra être utilisée pour proposer au joueur de placer automatiquement ses bâtiments.
d) Implanter une méthode d'affichage du damier à destination du joueur humain avec indication:
- des cases vides et non antérieurement visées par l'ordinateur,
- des cases vides et déjà visées par l'ordinateur,
- des cases occupées par un de ses bâtiments mais encore intactes,
- des cases occupées par un de ses bâtiments mais touchées par un tir précédent de l'ordinateur,
- des cases déjà visées par le joueur (avec résultat de son tir).
Le processus de jeu doit permettre au joueur humain de tirer sur les cases qu'il souhaite du damier de l'ordinateur. Entre chaque tir du joueur humain, le joueur cybernétique choisit une case du damier du joueur humain et tire dessus. En début de partie, le premier joueur qui tire est choisi au sort (ou à défaut le joueur humain).
A chaque tir humain, le résultat est affiché soit par un message "Touché", soit par un message "Coulé", soit par un message "Raté".
A chaque tir de l'ordinateur, les coordonnées de la case visée sont affichées et le résultat du tir est affiché par un message et visualisé sur l'affichage de contrôle humain.
e) Implanter la méthode qui permettra au joueur humain de viser une case du damier de l'ordinateur et d'obtenir le résultat de son tir.
f) Implanter la méthode qui permettra au joueur cybernétique de choisir la position qu'il vise et d'exploiter le résultat de son tir. Il conviendrait d'implanter une stratégie de choix "efficace".
g) Implanter le processus de jeu de telle manière qu'une partie soit arrêtée lorsque tous les bâtiments humains ou tous les bâtiments de l'ordinateur sont entièrement détruits. Un affichage indique alors qui a gagné.


Avec un ami, on a choisit le sujet n°2 : Affichages sur un écran "graphique".
Si cela vous intéresse, voici le résultat de notre dur labeur :



// Bacrima, XXXXXX Xxxxxx, Groupe TP3, Sujet n°2.


public class Projet2XXXXXX_XXXXX{

/*LE PROGRAMME PRINCIPAL*/

public static void main(String[]args){

// Déclaration des variables.

int[][] img = new int[1200][700]; // Tableau représentant la fenêtre.
int ChoixMenu; // Un entier qui représentera le choix de l'utilisateur dans le menu.
EcranHD.init(0,0,img.length,img[0].length,"Windows"); // Initialisation de la fenêtre.
couleur c = new couleur() ; // Création d'une couleur pour initialiser le tableau d'entier.

//Initialisation du tableau à "blanc"
c.r = 255 ;
c.g = 255 ;
c.b = 255 ;
img = tableauCouleur(img, c) ;

//Le menu

ChoixMenu=1; //Initialisation.

Ecran.afficherln("Bonjour, bienvenu sur notre application graphique. ") ;

while(ChoixMenu!=0){

ChoixMenu = saisieMenu() ; // Permet à l'utilisateur de choisir l'action.
img = ExecutionMenu(img,ChoixMenu); // Exécute l'action choisie.

}
}

/* LES STRUCTURES*/

// Création structure couleur. Ce type agrégé nous sert à passer d'une saisie de trois composantes en Rouge, Vert, Bleu, à un entier, ainsi qu'à créer des moyennes de valeurs, et autres calculs sur les composantes.
// r : permet de stocker la valeur en rouge d'une variable couleur.
// g : permet de stocker la valeur en vert d'une variable couleur.
// b : permet de stocker la valeur en bleu d'une variable couleur.
static class couleur {
int r = 0 ;
int g = 0 ;
int b = 0 ;
}

// Création structure position dans la matrice de pixels. Ce type agrégé nous sert à permettre à l'utilisateur de saisir des coordonnées pour un centre, des pixels particuliers, des extrémités de segments, des sommets de rectangle, etc.
// i : permet de stocker le numéro de la colonne d'un pixel.
// j : permet de stocker le numéro de la ligne d'un pixel.
static class positionPixel {
int i = 0 ;
int j = 0 ;
}

// Création structure cercle. Ce type agrégé permet de stocker les données utiles concernant un cercle, et ainsi pouvoir faire les calculs pour tracer disques et cercles.
// centre : permet de stocker les coordonnées du centre du cercle.
// rayon : permet de stocker la valeur du rayon du cercle à tracer.
static class cercle {
positionPixel centre = new positionPixel() ;
int rayon = 0 ;
}


/*LES SOUS-PROGRAMMES */

// Algorithme de saisie d'une couleur en RGB, avec condtion sur l'entier.
public static couleur saisirCouleur() {
couleur coul = new couleur() ;
do {
Ecran.afficherln("Quel dose de rouge? (Entre 0 et 255)") ;
coul.r = Clavier.saisirInt() ;
} while (coul.r<0 || coul.r>255) ; // Prolonge la saisie tant que la couleur sélectionnée ne se trouve pas entre 0 et 255
do {
Ecran.afficherln("Quel dose de vert? (Entre 0 et 255)") ;
coul.g = Clavier.saisirInt() ;
} while (coul.g<0 || coul.g>255) ;
do {
Ecran.afficherln("Quel dose de bleu? (Entre 0 et 255)") ;
coul.b = Clavier.saisirInt() ;
} while (coul.b<0 || coul.b>255) ;
return coul ;
}

// Algorithme de saisie d'un pixel parmi l'ensemble de l'image avec condition sur la sélection.
public static positionPixel saisirPos(int[][] img) {
positionPixel pos = new positionPixel() ;
do {
Ecran.afficherln("Quel est l'absisse du pixel ? (Entre 0 et " , img.length -1 , "). ") ;
pos.i = Clavier.saisirInt() ;
} while (pos.i<0 || pos.i>img.length-1) ; // Prolonge la saisie tant que la position n'est pas située dans le domaine de définition de la fenêtre.
do {
Ecran.afficherln("Quel l'ordonnée du pixel ? (Entre 0 et " , img[0].length - 1 , "). ") ;
pos.j = Clavier.saisirInt() ;
} while (pos.j<0 || pos.j>img[0].length-1) ;
return pos ;
}

// Calcul du maximum de deux réels.
public static double max(double x, double y){
double max = x ;
if(x<y){
max = y ;
}
return max ;
}

// Calcul du minimum de deux réels.
public static double min(double x, double y){
double min = x ;
if(x>y){
min = y ;
}
return min ;
}


// Calcul de la valeur absolue d'un réel.
public static double abso(double x){
double abso = x ;
if(x<0){
abso = -1*x ;
}
return abso ;
}

// Calcul de la distance entre deux points.
public static int distance(positionPixel pos1, positionPixel pos2) {
int dist;
dist = (pos1.i-pos2.i)*(pos1.i-pos2.i)+(pos1.j-pos2.j)*(pos1.j-pos2.j); // Formule vectorielle d'une distance dans un plan. (Au carré)
dist = (int)(Math.sqrt(dist)); // On prend la racine (séparé en deux pour plus de lisibilité.)
return dist ;
}

// Conversion d'une couleur RGB en une couleur caractérisée par un seul entier.
public static int conversionCouleur ( couleur c) {
return (c.r + c.g*256 + c.b* 256*256) ; // Mise en base 256 des couleurs.
}

// Conversion d'une couleur caractérisée par un seul entier en une couleur RGB en inversant la fonction conversionCouleur.
public static couleur conversionInverse (int coul) {
couleur c = new couleur() ;
c.b = (int)(coul/(256*256)) ;
c.g = (int)(coul/256-256*c.b) ;
c.r = coul - 256*c.g - 256*256*c.b ;
return c;
}

// Changement de la couleur de fond de l'image. Fonction remplaçant chaque entier du tableau d'entier par la couleur choisie.
// A noter que l'on pourrait se passer d'un tableau d'entier en entrée, mais cela obligerait à déclarer de nouveau un tableau d'entiers.
public static int[][] tableauCouleur(int[][] fenetre, couleur c){
int i = 0 ;
int j = 0 ;
for (i=0 ; i<fenetre.length ; i=i+1) {
for (j=0 ; j<fenetre[0].length ; j=j+1) {
fenetre[i][j] = conversionCouleur(c) ;
}
}
return fenetre ;
}

// Changement de la couleur d'un pixel, à partir d'une couleur et d'une position.
public static int[][] pixelCouleur(int[][] fenetre, couleur c, positionPixel pos){
fenetre[pos.i][pos.j] = conversionCouleur(c) ;
return fenetre ;
}

// Tracer un segment d'une couleur donné à partir de deux points et d'une couleur.
public static int[][] segmentCouleur(int[][] img, couleur c, positionPixel pos1, positionPixel pos2){
double k = 0.0 ;
int i ;
int j ;
if(max(abso(pos2.i-pos1.i) , abso(pos2.j-pos1.j)) != 0) { // On vérifie que le segment n'est pas un simple pixel.
do {
i = (int)(pos1.i+k*(pos2.i-pos1.i)) ; // On calcule l'abscisse des points du segment grâce à une position de départ et un vecteur direction.
j = (int)(pos1.j+k*(pos2.j-pos1.j)) ; // De même avec l'ordonnée.
img[i][j] = conversionCouleur(c) ;
k = k + 1/(2*(max(abso(pos2.i-pos1.i) , abso(pos2.j-pos1.j)))) ; // On calcule le pas par lequel l'on fait avancer la fonction qui calcule les positions.
} while (k <= 1) ;
}
else {
img = pixelCouleur(img, c, pos1) ; // Si ce n'est qu'un point, l'on utilise la fonction adéquate.
}
return img ;
}

// Remplir un rectangle d'une couleur donnée, à partir d'une couleur et de deux positions qui encadrent le rectangle désiré.
public static int[][] rectangleCouleur(int[][] img, couleur c, positionPixel pos1, positionPixel pos2) {
int i ;
int j ;
for (i = (int)(min(pos2.i,pos1.i)) ; i < (int)(max(pos2.i,pos1.i)) + 1 ; i = i+1) { // On parcourt de l'abscisse minimum à l'abscisse maximum.
for (j = (int)(min(pos2.j,pos1.j)) ; j < (int)(max(pos2.j,pos1.j)) + 1 ; j = j+1) { // On parcourt de l'ordonnée minimum à l'ordonnée maximum.
img[i][j] = conversionCouleur(c) ;
}
}
return img ;
}

// Tracer un cercle d'une couleur donnée.
public static int[][] cercleCouleur(int[][] img, couleur c, cercle cer) {
int i ;
int j ;
positionPixel pos = new positionPixel();
positionPixel posMin = new positionPixel();
positionPixel posMax = new positionPixel();

//Initialisation des posMin et posMax pour parcourir un carré contenant exactement le cercle (le carré minimum).

posMin.i = (int)max(0,cer.centre.i-cer.rayon);
posMin.j = (int)max(0,cer.centre.j-cer.rayon);
posMax.i = (int)min(img.length-1,cer.centre.i+cer.rayon);
posMax.j = (int)min(img[0].length-1,cer.centre.j+cer.rayon);

for (i = posMin.i ; i < posMax.i + 1 ; i = i+1) {
for (j = posMin.j ; j < posMax.j + 1 ; j = j+1) {
pos.i=i;
pos.j=j;
if(cer.rayon==distance(cer.centre,pos)){ // Test d'appartenance au cercle (points à égale distance du centre (rayon)).
img[i][j] = conversionCouleur(c) ;
}
}
}
return img;
}

// Remplir un disque d'une couleur donnée.Même que précédemment à une condition près.
public static int[][] disqueCouleur(int[][] img, couleur c, cercle cer) {
int i ;
int j ;
positionPixel pos = new positionPixel();
positionPixel posMin = new positionPixel();
positionPixel posMax = new positionPixel();

posMin.i = (int)max(0,cer.centre.i-cer.rayon);
posMin.j = (int)max(0,cer.centre.j-cer.rayon);
posMax.i = (int)min(img.length-1,cer.centre.i+cer.rayon);
posMax.j = (int)min(img[0].length-1,cer.centre.j+cer.rayon);

for (i = posMin.i ; i < posMax.i + 1 ; i = i+1) {
for (j = posMin.j ; j < posMax.j + 1 ; j = j+1) {
pos.i=i;
pos.j=j;
if(cer.rayon>=distance(cer.centre,pos)){ // Changement de la condition pour que les points à l'intérieur du cercle soit coloriés (moins éloignés, donc inférieur ou égal).
img[i][j] = conversionCouleur(c) ;
}
}
}
return img;
}


// Exécution du Menu.
// Cette fonction permet d'exécuter le choix qu'à fait l'utilisateur au moment de la saisie. Elle prend un entier et retourne l'action correspondante.
public static int[][] ExecutionMenu(int[][] img, int ChoixMenu){
couleur c = new couleur() ;
positionPixel pos1 = new positionPixel() ;
positionPixel pos2 = new positionPixel() ;
cercle cer = new cercle();

// Distinction des cas et exécution des scripts correspondant.
switch(ChoixMenu){

case 0:{
Ecran.afficher("Merci d'avoir utilisé notre application. Bonne journée.");
EcranHD.quit();
}
break;

case 1:{
img = afficherTableauNoir(img) ;
}
break;

case 2:{
img = afficherTableauCouleur(img) ;
}
break;

case 3:{
img = afficherPixelCouleur(img) ;
}
break;

case 4:{
img = afficherSegmentCouleur(img) ;
}
break;

case 5:{
img = afficherRectangleCouleur(img) ;
}
break;

case 6:{
img = afficherCercleCouleur(img) ;
}
break;

case 7:{
img = afficherDisqueCouleur(img) ;
}
break;

case 8:{
img = aleaMulti(img) ;
}
break;

case 9:{
img = effetDisco(img) ;
}
break;

case 10:{
img = flou(img) ;
}
break;

case 11:{
img = assombImg(img) ;
}
break;

case 12:{
img = eclairImg(img) ;
}
break;
case 13:{
img = filtreRouge(img) ;
}
break;
case 14:{
img = filtreVert(img) ;
}
break;
case 15:{
img = filtreBleu(img) ;
}
break;
case 16:{
img = negatif(img) ;
}
break;
default : {
Ecran.afficherln("Erreur dans la sélection du menu. ") ; // Message en cas de mauvaise saisie. On pourrait empêcher de saisir un autre entier également.
}
break;
}

return img ;
}


//Affichage des choix du menu et saisie d'un entier correspondant au choix.
public static int saisieMenu(){
int ChoixMenu;

Ecran.afficherln("0 - Quitter.");
Ecran.afficherln("1 - Créer un tableau noir.");
Ecran.afficherln("2 - Créer un tableau de couleur arbitraire.");
Ecran.afficherln("3 - Colorier arbitrairement un pixel donné.");
Ecran.afficherln("4 - Colorier arbitrairement un segment donné.");
Ecran.afficherln("5 - Colorier arbitrairement un rectangle donné.");
Ecran.afficherln("6 - Colorier arbitrairement le contour d'un cercle donné.");
Ecran.afficherln("7 - Colorier arbitrairement l'intérieur d'un cercle donné.");
Ecran.afficherln("8 - Bonus : Remplir aléatoirement la fenêtre.");
Ecran.afficherln("9 - Bonus : Effet Disco.");
Ecran.afficherln("10 - Bonus : Flou.");
Ecran.afficherln("11 - Bonus : Assombrissement.") ;
Ecran.afficherln("12 - Bonus : Eclaircissement.") ;
Ecran.afficherln("13 - Bonus : Filtre Rouge.") ;
Ecran.afficherln("14 - Bonus : Filtre Vert.") ;
Ecran.afficherln("15 - Bonus : Filtre Bleu.") ;
Ecran.afficherln("16 - Bonus : Négatif.") ;
Ecran.afficherln("Pour executer une commande, saisir son numéro puis valider :");

ChoixMenu = Clavier.saisirInt();

return ChoixMenu ;
}

// Fonction permettant l'initialisation de la variable couleur à noir, et l'exécution de la fonction tableauCouleur, qui renverra un tableau noir.
public static int[][] afficherTableauNoir(int[][] img){
couleur c = new couleur() ;

c.r = 0 ;
c.g = 0 ;
c.b = 0 ;
img = tableauCouleur(img, c) ;
EcranHD.set(img) ; // Actualisation de l'image.

return img ;
}

// Fonction permettant de saisir la couleur, et de changer le fond grâce à elle.
public static int[][] afficherTableauCouleur(int[][] img){
couleur c = new couleur() ;

c = saisirCouleur() ;
img = tableauCouleur(img, c) ;
EcranHD.set(img) ;

return img ;
}

// Fonction faisant saisir une couleur, et une position, puis change le pixel correspondant.
public static int[][] afficherPixelCouleur(int[][] img){
couleur c = new couleur() ;
positionPixel pos1 = new positionPixel() ;

c = saisirCouleur() ;
pos1 = saisirPos(img) ;
img = pixelCouleur(img, c, pos1) ;
EcranHD.set(img) ;

return img ;
}

// Fonction demandant la saisie de deux positions et d'une couleur, pour tracer le segment correspondant.
public static int[][] afficherSegmentCouleur(int[][] img){
couleur c = new couleur() ;
positionPixel pos1 = new positionPixel() ;
positionPixel pos2 = new positionPixel() ;

c = saisirCouleur() ;
pos1 = saisirPos(img) ;
pos2 = saisirPos(img) ;
img = segmentCouleur(img, c, pos1, pos2) ;
EcranHD.set(img) ;

return img ;
}

//Fonction permettant la saisie de 2 positions et d'une couleur, et remplissant ce rectangle.
public static int[][] afficherRectangleCouleur(int[][] img){
couleur c = new couleur() ;
positionPixel pos1 = new positionPixel() ;
positionPixel pos2 = new positionPixel() ;

c = saisirCouleur() ;
Ecran.afficher("Veuillez saisir les coordonnées de deux sommets opposés. ") ;
pos1 = saisirPos(img) ;
pos2 = saisirPos(img) ; ;
img = rectangleCouleur(img, c, pos1, pos2) ;
EcranHD.set(img) ;

return img ;
}

// Fonction demandant la saisie d'une couleur et d'un cercle, puis le trace.
public static int[][] afficherCercleCouleur(int[][] img){
couleur c = new couleur() ;
cercle cer = new cercle() ;

c = saisirCouleur() ;
Ecran.afficherln("Veuillez saisir les coordonnées du centre du cercle. ") ;
cer.centre = saisirPos(img);
Ecran.afficherln("Veuillez saisir le rayon du cercle. ") ;
cer.rayon = Clavier.saisirInt();
img = cercleCouleur(img, c, cer) ;
EcranHD.set(img) ;

return img ;
}

// Fonction demandant la saisie d'une couleur et d'un cercle, puis le remplit.
public static int[][] afficherDisqueCouleur(int[][] img){
couleur c = new couleur() ;
cercle cer = new cercle() ;

c = saisirCouleur() ;
Ecran.afficherln("Veuillez saisir les coordonnées du centre du disque. ") ;
cer.centre = saisirPos(img);
Ecran.afficherln("Veuillez saisir le rayon du disque. ") ;
cer.rayon = Clavier.saisirInt();
img = disqueCouleur(img, c, cer) ;
EcranHD.set(img) ;

return img ;
}

// Génération aléatoire de plusieurs événements :
public static int[][] aleaMulti(int[][] img){
int event;
int i;

// Initialisation à une couleur de fond aléatoire.
couleur c = new couleur() ;
c.r = (int)(255*Math.random()+1) ;
c.g = (int)(255*Math.random()+1) ;
c.b = (int)(255*Math.random()+1) ;
img = tableauCouleur(img, c) ;

// Saisie du nombre d'événements aléatoires désiré.
Ecran.afficherln("Veuillez saisir le nombre d'événements aléatoires que vous souhaitez voir apparaître : ") ;
event = Clavier.saisirInt() ;

// Appel le nombre fixé de fois la fonction qui génère un effet au hasard.
for(i=0;i<event+1;i=i+1){
img = alea(img) ;
}

return img;
}


// Génération aléatoire d'un événement :
public static int[][] alea(int[][] img){

couleur c = new couleur() ;
positionPixel pos1 = new positionPixel() ;
positionPixel pos2 = new positionPixel() ;
cercle cer = new cercle() ;
// Génération d'un choix aléatoire.(5 possibilités car sinon cela faisait mal aux yeux).
int choixAlea = (int)(5*Math.random());

// Initialisation de toutes les variables possibles au hasard.
c.r = (int)(255*Math.random()+1) ;
c.g = (int)(255*Math.random()+1) ;
c.b = (int)(255*Math.random()+1) ;
pos1.i = (int)(img.length*Math.random()) ;
pos1.j = (int)(img[0].length*Math.random()) ;
pos2.i = (int)(img.length*Math.random()) ;
pos2.j = (int)(img[0].length*Math.random()) ;
cer.centre.i = (int)(img.length*Math.random()) ;
cer.centre.j = (int)(img[0].length*Math.random()) ;
cer.rayon = (int)((max(img[0].length,img.length)/2)*Math.random()) ;

// Association du choix aux différentes possibilités (Pixel, segment, rectangle, cercle ou disque).
switch(choixAlea){

case 0:{
img = pixelCouleur(img, c, pos1) ;
}
break;

case 1:{
img = segmentCouleur(img, c, pos1, pos2) ;
}
break;

case 2:{
img = rectangleCouleur(img, c, pos1, pos2) ;
}
break;

case 3:{
img = cercleCouleur(img, c, cer) ;
}
break;

case 4:{
img = disqueCouleur(img, c, cer) ;
}
break;

}

EcranHD.set(img) ;
return img;
}

// Fait une moyenne sur les couleurs (couleur sous la forme d'un unique entier).
public static int[][] effetDisco(int[][] img){
int [][] img2 = new int[img.length][img[0].length];
int i;
int j;
int k;
int l;
int somme;
int div;

// Parcourt du tableau entier.
for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
somme = 0 ;
div = 0 ;
// Exécution du calcul de la moyenne.
for(k=-10;k<11;k=k+1){
for(l=-10;l<11;l=l+1){

if((i+k>0)&&(i+k<img.length)&&(j+l>0)&&(j+l<img[0].length)){ // Script pour gérer les bords du tableau.
somme = somme + img[i+k][j+l] ;
div = div + 1;
}

}
}
img2[i][j] = (int)(somme/div) ;
}
}

img = img2 ;

EcranHD.set(img) ;
return img ;
}

// Moyenne sur les composantes RGB d'une couleur.
public static int[][] flou(int[][] img){
int [][] img2 = new int[img.length][img[0].length];
int i;
int j;
int k;
int l;
couleur c = new couleur() ;
int div ;

// Parcourt de l'ensemble des pixels.
for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.r = 0 ;
c.b = 0 ;
c.g = 0 ;
div = 0 ;
// Exécution de la moyenne.
for(k=-2;k<3;k=k+1){
for(l=-2;l<3;l=l+1){

if((i+k>0)&&(i+k<img.length)&&(j+l>0)&&(j+l<img[0].length)){ // Afin de gérer les bords.
c.r = c.r + conversionInverse(img[i+k][j+l]).r ; //Afin de faire la moyenne sur les couleur, l'on transforme l'entier de base en 3 autres entiers.
c.g = c.g + conversionInverse(img[i+k][j+l]).g ;
c.b = c.b + conversionInverse(img[i+k][j+l]).b ;
div = div + 1;
}

}
}
c.r = (int)(c.r/div) ;
c.g = (int)(c.g/div) ;
c.b = (int)(c.b/div) ;
img2[i][j] = conversionCouleur(c) ;
}
}

img = img2 ;

EcranHD.set(img) ;
return img ;
}

// Fonctions permettant d'assombrir l'image en rapprochant les valeurs de 0.
public static int[][] assombImg(int[][] img){
int i;
int j;
couleur c = new couleur() ;
double taux ;
do {
Ecran.afficherln("Veuillez saisir le taux d'assombrissement (Pourcentage compris entre 0 (aucun changement) et 1 (noir)). ") ;
taux = Clavier.saisirDouble() ;
} while (taux<0 || taux>1) ; // Condition sur la valeur de taux.

for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.r = (int)(conversionInverse(img[i][j]).r*(1-taux)) ; // 1-taux est le pourcentage de lumière restant. Si l'on assombrit de 100% = 1, on multiplie par 0.
c.b = (int)(conversionInverse(img[i][j]).b*(1-taux)) ;
c.g = (int)(conversionInverse(img[i][j]).g*(1-taux)) ;
img[i][j] = conversionCouleur(c) ;
}

}

EcranHD.set(img) ;
return img ;
}

// Fonction permettant d'éclaircir une image, en rapprochant les valeurs de 255.
public static int[][] eclairImg(int[][] img){
int i;
int j;
couleur c = new couleur() ;
double taux ;
do {
Ecran.afficherln("Veuillez saisir le taux d'éclaircissement (Pourcentage compris entre 0 (aucun changement) et 1 (blanc)). ") ;
taux = Clavier.saisirDouble() ;
} while (taux<0 || taux>1) ; // Condition sur la valeur du taux.

for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.r = (int)(conversionInverse(img[i][j]).r+(255-conversionInverse(img[i][j]).r)*(1-taux)) ; // Calcul donnant toujours un nombre entre x et 255.
c.b = (int)(conversionInverse(img[i][j]).b+(255-conversionInverse(img[i][j]).b)*(1-taux)) ; // On ajoute au nombre de base x, un nombre compris entre 0 et 255-x.
c.g = (int)(conversionInverse(img[i][j]).g+(255-conversionInverse(img[i][j]).g)*(1-taux)) ; // Et on prend un pourcentage de ce nombre. Cela éclaricit l'image de ce pourcentage.
img[i][j] = conversionCouleur(c) ;
}

}

EcranHD.set(img) ;
return img ;
}

// Création d'un filtre augmentant le rouge, et diminuant les autes composantes.
public static int[][] filtreRouge(int[][] img){
int i;
int j;
couleur c = new couleur() ;

for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.r = (int)(conversionInverse(img[i][j]).r+(255-conversionInverse(img[i][j]).r)*0.2) ; // Eclaircissement en rouge.
c.b = (int)(conversionInverse(img[i][j]).b*0.9) ; // Assombrissement en bleu et en vert.
c.g = (int)(conversionInverse(img[i][j]).g*0.9) ;
img[i][j] = conversionCouleur(c) ;
}

}

EcranHD.set(img) ;
return img ;
}

// Filtre augmentant le taux de vert, et diminuant le taux de bleu et de rouge. (Même procédé que ci-dessus.)
public static int[][] filtreVert(int[][] img){
int i;
int j;
couleur c = new couleur() ;

for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.g = (int)(conversionInverse(img[i][j]).g+(255-conversionInverse(img[i][j]).g)*0.2) ;
c.b = (int)(conversionInverse(img[i][j]).b*0.9) ;
c.r = (int)(conversionInverse(img[i][j]).r*0.9) ;
img[i][j] = conversionCouleur(c) ;
}

}

EcranHD.set(img) ;
return img ;
}

// Filtre augmentant le taux de bleu, et diminuant le taux de vert et de rouge. (Même procédé que ci-dessus.)
public static int[][] filtreBleu(int[][] img){
int i;
int j;
couleur c = new couleur() ;

for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.b = (int)(conversionInverse(img[i][j]).b+(255-conversionInverse(img[i][j]).b)*0.2) ;
c.g = (int)(conversionInverse(img[i][j]).g*0.9) ;
c.r = (int)(conversionInverse(img[i][j]).r*0.9) ;
img[i][j] = conversionCouleur(c) ;
}

}

EcranHD.set(img) ;
return img ;
}

// Fonction inversant la tendance des couleurs. C'est à dire qu'une composante proche de 255 sera proche de 0, et vis versa, inversant totalement l'équilibre des couleurs.
public static int[][] negatif(int[][] img){
int i;
int j;
couleur c = new couleur() ;

for(i=0;i<img.length;i=i+1){
for(j=0;j<img[0].length;j=j+1){
c.b = 255-conversionInverse(img[i][j]).b ; // On soustrait à 255 la valeur de base, pour inverser la tendance.
c.g = 255-conversionInverse(img[i][j]).g ;
c.r = 255-conversionInverse(img[i][j]).r ;
img[i][j] = conversionCouleur(c) ;
}

}

EcranHD.set(img) ;
return img ;
}

}


Pour finir, une chose intéressante :
L’effet disco appliqué plusieurs fois après un remplissage aléatoire donne ceci :


L’effet disco fait à chaque itération et pour chaque pixel la moyenne de la valeur de chacun des 440 pixels qui l'entoure (dans un carré de 21 sur 21 pixels).
En sachant que par la suite, la couleur apparait comme ceci :
Soit X la valeur d'un pixel.
Le pixel est codé en couleur RVB 24bits selon la formule X = r+256*v+256*256*b où chacune des composantes r,v et b est un entier compris dans l'intervalle [0,255].

_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Klev le 19.08.12 23:16

MAAAAAAAAATHS !

BenBox a implosé.

(Et sans lire en plus.)

Sinon, bravo, j'ai quasi rien lu, mais tu fais ce que je veux faire, donc j'admire.

_____________________
Dans la Nébuleuse, tout devient possible. Les rires se joignent aux larmes, l'émotion à l'instant, le temps à l'espace ; tous les fils noués en une toile de maître, surface interactive, simple résultante de l'activité des individus…

Klev
Admin

Emploi/Loisirs : Administrateur en torpeur.

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Bacrima le 22.08.12 13:28

Admirer est un bien grand mot, dit plutôt envier, je n'ai rien d'admirable.
Lis au moins la fin, avec la jolie image ! (Et avec un peu de courage, tu peux lire le début qui explique les sujets, c'est intéressant, je te fais grâce du programme). Smile

_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Klev le 22.08.12 14:39

Je sais choisir qui admirer, mais dire envier pourrait inclure une jalousie que je n'ai pas envie de ressentir a l'égard de mes amis.

J'admire ton amour des mathématiques, et je vous envie a toi et a Yoendel d'avoir accroché a eux dès vos premières rencontres.

« Pourquoi moi je ne les ai pas aimées ? », je me demande. Et il arrive que ça me torture. Pour ces raisons, je préfère employer le terme « admirer », afin de ne pas me sentir coupable de la jalousie qui me ronge dans mes moments de faiblesses.

Donc, je t'admire d'avoir réussi a atterrir la où j'aurais pu aller si j'avais pensé autrement quand j'ai vu ces ignobles chiffres et leur logique implacable défiler devant mes yeux naïfs dans ma jeunesse. <3

EDIT :
Ecran.afficherln("Bonjour, bienvenue sur notre application graphique. ") ;

_____________________
Dans la Nébuleuse, tout devient possible. Les rires se joignent aux larmes, l'émotion à l'instant, le temps à l'espace ; tous les fils noués en une toile de maître, surface interactive, simple résultante de l'activité des individus…

Klev
Admin

Emploi/Loisirs : Administrateur en torpeur.

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Bacrima le 23.08.12 0:38

L'orthographe restera mon pire cauchemar ! Avec la grammaire et la conjugaison ...
Je ne me suis pas accroché a eux dès nos premières rencontres.
« Pourquoi moi je ne les ai pas aimées ? », je me demande. Et il arrive que ça me torture. :mrgreen:

Les math m'ont fais rêver ... et elle continue de le faire via l'informatique ! :drunken:


Tu l'as donc lu, merci... je ne sais pas quoi dire de plus, mais cela me fais plus plaisir que tu ne peux le penser.

_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Klev le 23.08.12 0:42

Je l'ai lu assez rapidement… Et j'ai décelé ça. J'ai ensuite cherché si il y en avait d'autres un peu hâtivement.

Pourquoi ce plaisir ? Smile

_____________________
Dans la Nébuleuse, tout devient possible. Les rires se joignent aux larmes, l'émotion à l'instant, le temps à l'espace ; tous les fils noués en une toile de maître, surface interactive, simple résultante de l'activité des individus…

Klev
Admin

Emploi/Loisirs : Administrateur en torpeur.

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Bacrima le 23.08.12 0:46

Et bien, tu n'aime pas les maths et pourtant tu te force à écouter quand moi et Yo en parlons par exemple, ça m'émeut.
C'est tout.

_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Klev le 23.08.12 0:56

Oh, j'aime les maths, aujourd'hui. J'ai brisé ma Xénophobie depuis longtemps… Ça parasitait ma vie.

ET JE NE ME FORCE PAS A ÉCOUTER.

Si jamais je ne pige rien, je décroche et part dans mes pensées. Mais je garde une oreille pour reprendre le fil dès que c'est moins technique… Je l'aurais fait savoir clairement si ça me gonflait… Je veux être sincère avec mes amis.

Et j'ai une patience relativement importante Smile Il n'y a jamais eu de souci, vous êtes marrants quand vous partez loin, en plus. :mrgreen:

_____________________
Dans la Nébuleuse, tout devient possible. Les rires se joignent aux larmes, l'émotion à l'instant, le temps à l'espace ; tous les fils noués en une toile de maître, surface interactive, simple résultante de l'activité des individus…

Klev
Admin

Emploi/Loisirs : Administrateur en torpeur.

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Bacrima le 23.08.12 0:59

Tu veux dire quand on parle d'algorithme de rétro-propagation du gradient de l'erreur dans un perceptron multi-couche rebouclé sur lui-même ? Twisted Evil

_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Klev le 23.08.12 1:18

Oui, celui la est très drôle. :mrgreen:

_____________________
Dans la Nébuleuse, tout devient possible. Les rires se joignent aux larmes, l'émotion à l'instant, le temps à l'espace ; tous les fils noués en une toile de maître, surface interactive, simple résultante de l'activité des individus…

Klev
Admin

Emploi/Loisirs : Administrateur en torpeur.

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Yoendel le 27.08.12 22:35

que de délires...
Very Happy Sad

_____________________
"On ne voit bien qu'avec le cœur: l'essentiel est invisible pour les yeux." le renard, A de St Exupéry.
"Qu'est-ce que signifie «apprivoiser»? dit le Petit prince.
-C'est une chose trop oubliée, dit le renard. Ca signifie «créer des liens...»"
http://www3.sympatico.ca/gaston.ringuelet/lepetitprince/chapitre21.html
"eux veulent me forcer à parler pour ne rien dire, alors je ne dis rien pour parler."
"Il ne faut pas mettre les gens dans des petites cases ; c'est un signe de confusion mentale, mon chou !" les Chants de la Mallorée
"Point de monde sans hasard... point de hasard sans monde... la boucle est bouclée" Alexandra.
"et si notre monde avait 3 coordonnées temporelles pour une spatiale ?"
avatar
Yoendel

Humeur : variable... dérivable... et même C-infinie

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Bacrima le 13.09.12 18:50

Après avoir fais tourner l'effet disco pendant 3 heures sur une image aléatoire, voici le résultat :
Intéressant, on peut voir des formes stables apparaître (les cercles et les croix).


_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Dark Geo le 13.09.12 23:42

Très sympathique. D'autant plus que j'étudie le java (le cour du site du zero).

Le petit défault $$ c'est que j'ai rien pigé à ton Fo..u (devine le reste) programme. Le cour ne doit pas être assez complet pour ça. D'où les limites de ....Hum....l'auto-didactie ? L'auto didactique ?
Ça se dit ça ?

Sinon en tant que mathématicien je te demanderai de prouver que c'est bien la répétition de l'algorithme/programme qui créer des formes fixes/répétitives. Dans le cas contraire cela ne serait qu'une sorte de Hasard hasardeux et mal chanceux. La formulation est peu être pas très claire mais c'est le mieux que je puisse faire pour exprimer ma pensée en l'état actuel.... 23h41 et réveillé à 6h00 ....
Cordialement ;-) @+

_____________________


Spoiler:

   La paix n'est que mensonge.
   Il n'y a que la passion.
   Par ma passion, j'obtiens la puissance.
   Par ma puissance, j'obtiens le pouvoir.
   Par mon pouvoir, j'obtiens la victoire.
   Par mes victoires, mes chaînes se brisent.
   La Force me libérera.
   Il n'y a pas de paix, il y a la colère.
   Il n'y a pas de peur, il y a la puissance.
   Il n'y a pas de mort, il y a l'immortalité.
   Il n'y a pas de faiblesse, il y a le Côté Obscur.
   Je suis le cœur de l'Obscurité.
   Je ne connais pas la peur, mais je l'instille à mes ennemis.
   Je suis le destructeur des mondes.
   Je connais le pouvoir du Côté Obscur.
   Je suis le feu de la haine.
   Tout l'univers se prosterne devant moi.
   Je m'engage dans les ténèbres où j'ai trouvé la vraie vie
   Dans la mort de la lumière.
avatar
Dark Geo

Humeur : Variable
Localisation : Sur terre pas loin probablement sous la lune
Emploi/Loisirs : Je manque de temps pour les citer.

Feuille de personnage
Nom, classe et niveau: Geofraynils, sorcier sith
PA:
26/26  (26/26)
PV:
30/30  (30/30)

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Klev le 14.09.12 13:02

Geofraynils a écrit:Le petit défault $$ c'est que j'ai rien pigé à ton Fo..u (devine le reste) programme. Le cour ne doit pas être assez complet pour ça. D'où les limites de ....Hum....l'auto-didactie ? L'auto didactique ?
Ça se dit ça ?

A partir du moment où il y a eu cours ou tutoriel, je ne pense pas que l'on puisse encore parler d'autodidacte. :mrgreen:

Surtout qu'il doit bien avoir des fous pour avoir appris a coder sans jamais avoir eu d'aide. ^^

_____________________
Dans la Nébuleuse, tout devient possible. Les rires se joignent aux larmes, l'émotion à l'instant, le temps à l'espace ; tous les fils noués en une toile de maître, surface interactive, simple résultante de l'activité des individus…

Klev
Admin

Emploi/Loisirs : Administrateur en torpeur.

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Bacrima le 14.09.12 13:48

Je ne peut pas encore l'expliquer mathématiquement.
Mais après plusieurs test j'ai pu faire quelques constatations :

_Il se forme à chaque fois des "vagues" (ces gros trucs bleu sur le violet ou vert sur le rouge là ... Smile )
Une vague a un front (coupure net avec la couleur de fond).
Elle se déplace en direction de ce front.
Les vagues disparaissent peu à peu.
Elles sont nombreuses au départ et s’annihilent en des points spécifiques (sur ou hors de l'écran) elles peuvent s'annihiler si leur front forme un cercle intérieur.
Si leur front forme un cercle extérieur, elles s'agrandissent en formant un cercle qui finit par sortir de l'écran, mais aucune nouvelle vague n'apparait sous forme de cercle au centre de l'ancienne.

_Et en arrière plan, au bout d'un certain moment, apparait des motifs (ou circulaires ou en croix) et ils ont tendance à se normaliser (ils deviennent de la même taille et s'alignent).

Il est logique de penser à trois cas d'évolution de ce système :
_Chaotique
_Cyclique (des motifs cycliques apparaissent)
_Unique (tout l'écran devient d'une seule couleur)

_____________________
"Ouvrez-moi une bucolique à perte de vue, le ventre à tout le monde si vous l'aviez vu quand on n'y aurait qu'une petite partie de la société mécanisée."
avatar
Bacrima

Humeur : Une pointe de joie et un soupçon d'amusement
Localisation : Dans ma chambre, rarement ailleur ...
Emploi/Loisirs : Japanimer, ça se dit ?

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Études en informatique

Message  Contenu sponsorisé


Contenu sponsorisé


Revenir en haut Aller en bas

Revenir en haut

- Sujets similaires

 
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum