Discussion :

[Neolex]

Bonjour à tous ,
voici une image ppm :

P3
#truc.ppm
4 4
15
0 0 0 0 0 0 0 0 0 15 15 0
0 0 0 0 15 7 0 0 0 0 0 0
0 0 0 0 0 0 0 15 7 0 0 0
15 15 0 0 0 0 0 0 0 0 0 0

Il faut qu'elle soit stockée dans une liste chainée de la manière suivante :
[red][green][blue] [nombre d'occurence de la couleur]
000 3 -----> 1500 1 -----> 000 1 -----> 0157 1 -----> 000 4 -----> 0157 1 -----> 000 1 -----> 15150 1 -----> 000 3 /

une image doit comprendre une largeur et une hauteur ( 4 et 4 pour l'exemple si dessus )
la valeur max d'une couleur : 15 pour cet exemple
ainsi qu'une liste chaînée comme représentée si dessus

je vous montre donc les classes que j'ai crée , mon problème est que je n'arrive pas à lire le fichier et mettre les informations dans ma liste chaînée...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Image {
 
	private int largeur , hauteur ;
	private int valeurMax ;
	private Liste listeSegment = new Liste() ;
 
	public Image(String nomFichier) {
		FileInputStream fichier ;
		int c ;
		try{
			fichier = new FileInputStream("images/"+nomFichier) ;
			BufferedReader f = new BufferedReader(fichier);
			f.readLine();
			f.readLine();
			String s = f.readLine();
			String[] split = s.split(" ");
			this.largeur = Integer.parseInt(split[0]);
			this.hauteur = Integer.parseInt(split[1]);
			this.valeurMax = Integer.parseInt(f.readLine());			
			System.out.println("Hauteur : "+this.hauteur + "\n largeur :"+ this.largeur 
								+ "\n valeurmax : "  + this.valeurMax);
 
			fichier.close();
 
			}
		}catch(FileNotFoundException ex){
			System.out.println("Fichier n'existe pas");
		}catch(IOException exc){
			System.out.println("Erreur d'entrée sortie");
		}
	}
// setteurs et getteurs ...

Le code de la Liste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class Liste {
	Segment premier;
 
	public boolean estVide() {
		return premier == null;
	}
 
	public Segment getPremier() {
		return premier;
	}
 
	public void ajouterALaFin(int red,int green,int blue , int n) {
		if (estVide()) {
			premier = new Segment(red,green,blue,n);
		} else {
			Segment dernier = getDernierElement();
			dernier.setSuivant(new Segment(red,green,blue,n));
		}
	}
 
 
	private Segment getDernierElement() {
		Segment dernier = premier;
		while (dernier.getSuivant() != null) {
			dernier = dernier.getSuivant();
		}
		return dernier;
	}
 
	public int getLongueur() {
		int longueur = 0;
		Segment elt = getPremier();
		while (elt != null) {
			longueur++;
			elt = elt.getSuivant();
		}
		return longueur;
	}
 
	public void concatener(Liste l) {
		if (this.estVide()) {
			this.premier = l.premier;
		} else {
			Segment dernier = getDernierElement();
			dernier.setSuivant(l.getPremier());
		}
	}
 
	public void ecrireListe() {
		System.out.print("[");
		Segment elt = getPremier();
		while (elt.getSuivant() != null) {
			System.out.print("(" + elt.getRed()+","+elt.getGreen()+","+elt.getBlue()+")");
			elt = elt.getSuivant();
		}
		System.out.println("(" + elt.getRed()+","+elt.getGreen()+","+elt.getBlue()+")" + "]");
	}
 
}

ensuite le code de Segment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class Segment {
	private int red,green,blue;
	private int nombre ;
	private Segment suivant;
 
	public Segment(int red,int green,int blue , int n, Segment suivant) {
		this.red = red;
		this.green = green;
		this.blue = blue;
		this.nombre = n;
		this.suivant = suivant;
	}
 
	public Segment(int red,int green,int blue , int n) {
		this.red = red;
		this.green = green;
		this.blue = blue;
		this.nombre = n;
		this.suivant = null;
	}
 
	public int getRed() {
		return red;
	}
	public void setRed(int red) {
		this.red = red;
	}
 
	public int getGreen() {
		return green;
	}
	public void setGreen(int green) {
		this.green = green;
	}
 
	public int getBlue() {
		return blue;
	}
	public void setBlue(int blue) {
		this.blue = blue;
	}
 
	public int getNombre() {
		return nombre;
	}
 
	public void setNombre(int nombre) {
		this.nombre = nombre;
	}
 
	public Segment getSuivant() {
		return suivant;
	}
 
	public void setSuivant(Segment suivant) {
		this.suivant = suivant;
	}
}

Edit : Je me suis trompé de forum , je voulais dans le débuter de General Java

[Neolex]

j'ai édité , j'ai réussi à recuperer la largeur la hauteur et la valeur maximale mais je suis toujours bloquée pour mettre les données de l'image dans une ma liste chaînée .

[joel.drigo]

Salut,

déjà P3 indique qu'il s'agit du format ppm plain

dans le format ppm, après la valeur max pour la couleur,

on a des lignes de triplets de type (r, g, b) dont les valeurs (de r, de g, de b) sont des décimaux ascii (donc lisible directement dans une chaine de caractères et dont la valeur peut être obtenue avec un Integer.parsetInt()

dans le format ppm raw (d'entête P6) tu aurais des nombres binaires au lieu des décimaux, en big endian, sur 8 ou 16 bits (8 bits si la couleur max est < 256, 16 bits sinon)

pour moi le format le plus adapté est un tableau de triplets(une classe qui représente un triplet), à 2 dimensions, qu'on connait (on les a lues au début du fichier),

le tableau à 2 dim me semble être le stockage le plus adapté, plus adapté en tout cas qu'une liste chainée


ensuite, on lit les valeurs de cette manière en gros

on initialise x=0, y=0

on lit r, on lit g, on lit b, qu'on place dans un triplet

lit r (ou lire g, ou lire b) c'est lire des caractères jusqu'au prochain whitespace en les concaténant dans un buffer (classe StringBuilder) puis Integer.parsetInt() sur la chaine lue pour avoir la valeur entière

on place le triplet lu en (x,y),

on fait x+1, si x>largeur, alors x=0 et y=y+1,

etc... jusqu'à ce qu'on est plus rien à lire (ou qu'on ait atteint la fin de fichier, on ne sait jamais)

subtilité : chaque fois qu'un whitespace est atteint, il faut lire tout les whitespaces jusqu'a un caractère non whitespace, pour commencer à lire la valeur suivante (dans le format P3, les nombre de whitespace est minimum 1 mais sans maximum).


maintenant si le but de l'exercice est de charger les données dans une liste de de segment chainés (même si c'est un type totalement inadapté), la première question que je me pose c'est ou se trouve la notion de ligne de pixels ? (puisqu'on a des lignes de points),
bon effectivement on peut utiliser la valeur de largeur n pour sauter dans la chaîne de n en n pour avoir chaque ligne de pixels

l'algo est exactement le même que pour un tableau, sauf qu'on a même pas besoin de passer à la ligne en bout de ligne :

en gros :

tant qu'il y a quelquechose à lire
lire un triplet et l'ajouter à la liste


si au lieu de lire chaque valeur les unes après les autres tu préfères lires de lignes avec readLine et les splitter ensuite, c'est un peu près la même chose,

on peut imaginer un truc comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
void read(Liste liste, BufferedReader reader) throws IOException {
 
   String data = reader.readLine();
   if ( data!=null ) {
      readLine(liste, data);
   }
 
}
 
void read(Liste liste, String data) throws IOException {
 
     String[] split = split(data);
 
     int i=0;
     while((i=readNextSegment(liste,split,i)>=0);
 
}
 
int readNextSegment(Liste liste, String[] data, int index) throws IOException {
 
     if ( index==data.length ) {
        return -1;
     }
     else if ( index+3<=data.length ) {
          int r = read(data[index++]);
          int g = read(data[index++]);
          int b = read(data[index++]);
          addSegment(liste,  r, g, b );
     }
     else {
         throw new IOException("Il manque des données dans ce fichier (par exemple !)");
     }
 
     return index;
 
}

enfin, le code de la classe Liste et Segment, il t'es imposé ou c'est toi qui la mis au point ?

Personnellement je trouve que passer le segment suivant d'un segment dans le constructeur c'est plutôt génant, parce que ça veut dire qu'il faut toujours lire les valeurs suivantes, en gros il faudrait commencer à lire le fichier par la fin. c'est pas le plus simple...

[Neolex]

Tout d'abord merci beaucoup pour ta réponse .
Effectivement ça serait plus simple avec une genre de matrice mais je dois utiliser une liste chaînée de segments .

Pour le code de la liste et du segment c'est moi qui l'ai crée .

Je vais essayer de bien assimilé ce que tu dis et essayer d'adapter le code , je suis encore un peu perdu besoin d'une petite pause pour comprendre tout ça .

Par contre il faut ne mettre qu'un segment pour plusieurs pixel de même couleur , par exemple 5 pixel rouge se suivant sera un segment(255,0,0,5) puis on passer au pixel de couleur suivante et je ne sais pas trop comment mettre ça en oeuvre pour l'instant .

Personnellement je trouve que passer le segment suivant d'un segment dans le constructeur c'est plutôt génant, parce que ça veut dire qu'il faut toujours lire les valeurs suivantes, en gros il faudrait commencer à lire le fichier par la fin. c'est pas le plus simple...

J'ai adapté le code donné en cours , et peut être que ce n'est pas une bonne chose mais je ne comprends pas vraiment pourquoi il faudrait commencer par la fin .
Je devrais donc enlever ce constructeur et garder celui sans le segment suivant ?

edit :

la première question que je me pose c'est ou se trouve la notion de ligne de pixels ? (puisqu'on a des lignes de points),
bon effectivement on peut utiliser la valeur de largeur n pour sauter dans la chaîne de n en n pour avoir chaque ligne de pixels

Le prof à dit " Autrement dit, dans notre representation (comme dans le
fichier PPM), on ne prend pas en compte les fins de lignes "

[joel.drigo]

Ok. Je n'avais pas capté la contrainte pour les segments.

Donc en gros, on stocke pas chaque point séparément, on stocke de segment, de point contigu de même couleur.

Ca me choque pas : c'est une sorte de compression en mémoire.

Pour les fins de lignes, on peut toujours retrouver la matrice avec la largeur de l'image, donc ça me va aussi.

pour la compression, on peut faire varier le code que j'avais indiqué (tu as remarqué que je t'ai laissé des trous (notamment le branchement avec ta liste chainée et tes segments),

il suffit de détecter lorsqu'on change de couleur et de compter sinon, et on détermine ainsi la taille des segments...

donc j'ajoute encore un niveau de méthode

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
private int n, lastr, lastg, lastb; // attention ça rend statefull le code, donc plus threadsafe (il faudrait avoir un contexte pour résoudre le problème, un petit tableau d'entier par exemple)
public void addSegment(Liste liste,  int r, int g, int b ) {
    if ( n!=0 ) {
        // on a déjà commencé un segment
        if ( r!=lastr ||  g!=lastg || b!=lastb ) {
           // une couleur au moins est différente
            addNewSegment(liste, lastr, lastg, lastb, n); // le segment précédent est ajouté à la liste
        }
        else {
           n++; // un point de plus dans le segment (même couleur, même segement)
           return; // attention retour à l'appelant
        }
    }
    // premier point d'un nouveau segment
    n=1;
    lastr=r;
    lastg=g;
    lastb=b;
}
 
}

attention, il y a un truc à ne pas oublier : il faut penser au dernier segment, puisqu'on créé un segment toujours alors qu'on a lu la couleur suivante

il faut modifier ce que j'avais mis comme condition d'arrêt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
if ( index==data.length ) {
        if (n!=0) {
            addNewSegment(liste, lastr, lastg, lastb, n);
        }
        return -1;
}

j'ai tapé ça direct dans l'éditeur du forum, j'ai pas vérifié si ça compile ou ça tourne, mais en gros c'est ça l'idée

[joel.drigo]

Le prof à dit " Autrement dit, dans notre representation (comme dans le
fichier PPM), on ne prend pas en compte les fins de lignes "

mmm, c'est pas tout à fait vrai, pas tout à fait faux

d'ailleurs y'a une petite subtilité que j'ai pas pris en compte dans mon code

avec un p6 (raw ppm), si je me trompe pas, on a une ligne de data par ligne de raster, donc on prend bien en compte les fin de ligne

avec un p3 (plain ppm), il y a la limite des 70 car par lignes qui fait qu'effectivement une ligne de data n'est pas forcément une ligne de raster

c'est d'ailleurs cette histoire de limite de 70 caractères que mon code ignore totalement :

on peut imaginer qu'un code de couleur commence sur une ligne et continue sur la suivante

c'est pour ça qu'a mon avis il serait plus judicieux de lire le fichier caractères par caractères, comme le format garanti qu'il y a toujours au moins un whitespace avant et au moins un whitespace après une valeur, on peut détecter facilement les différentes valeurs de couleur

on peut procéder par exemple avec un tableau de char : on sait le dimensionner puisqu'on a la couleur max (si taille c'est le nombre de digit max pour représenter le nombre max de couleur )

genre, rapidement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
public int readNextValue(Reader reader) {
while(true) {
char c = readNextChar(reader);
if ( c==0 ) return -1; // fin de fichier atteinte
if ( Character.isWhiteSpace() ) {
     if ( nbread>0 ) {
     // nouvelle valeur de r, de g, ou de b
     int valeur Integer.parsetInt(new String(chararray, 0, nbread));
     nbread=0;
     return valeur;
     }
}
else {
     chararray[nbread]=c;
     nbread++;
}
}
 
public char readNextChar(Reader reader) {
    int c = reader.read();
    if ( c<0 ) return 0; // le fichier ne contient vraisemblablement pas de caractère 0 donc on peut utiliser ce caractère pour fin de fichier (on pourrait utiliser EOF (26))
   else return (char)c;
}

[joel.drigo]

J'ai adapté le code donné en cours , et peut être que ce n'est pas une bonne chose mais je ne comprends pas vraiment pourquoi il faudrait commencer par la fin .
Je devrais donc enlever ce constructeur et garder celui sans le segment suivant ?

pour instancier un segment il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

segment=new Segment(red,green,blue , n, suivant)

donc pour créer un segment, il faut connaitre :
- red
- green
- blue
- n
et suivant

donc pour créer un segment, il faut connaitre le segment suivant.

si tu lis dans l'ordre,
il faut lire les datas du premier segment et les garder dans un petit coin,
puis lire les datas du second segment, et les garder dans un petit coin, parce qu'on peut pas créer de segment, on n'a pas encore lu le segment suivant, soit le 3ème segment, et ainsi de suite...

on peut résoudre ça par un code récursif, mais si ton fichier est maousse, ça va prendre un max de mémoire et peut être même dépasser la taille max de la pile

alors que si on lit par la fin, quand on veut créer un segment, on a toujours déjà lu le segment suivant avant, donc on peut le créer immédiatement

sinon, voici un petit exemple de liste chainée vite fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
/**
 * @author jdrigo
 */
public class LinkList<D> implements Iterable<D> {
 
	private Link first;
	private Link last;
	private int size;
 
	/**
         * 
         */
	public LinkList() {
	}
 
	public boolean isEmpty() {
		return first==null;
	}
 
	public LinkList<D> insert(D data) {
		Link link = new Link(data);
		if ( first==null ) {
			first=link;
			last=first;
		}
		else {
			link.next=first;
			first=link;
		}
		size++;
		return this;
	}
 
	public LinkList<D> add(D data) {
		Link link = new Link(data);
		if ( first==null ) {
			first=link;
			last=link;
		}
		else {
			last.next=link;
			last=link;
		}
		size++;
		return this;
	}
 
	public D last() {
		if ( isEmpty() ) {
			throw new IllegalStateException("Empty list");
		}
		else {
			return last.getData();
		}
	}
 
	public D first() {
		if ( isEmpty() ) {
			throw new IllegalStateException("Empty list");
		}
		else {
			return first.getData();
		}
	}
 
	public D removeFirst() {
		if ( isEmpty() ) {
			throw new IllegalStateException("Empty list");
		}
		else {
			Link link;
			if ( last==first ) {
				link = last;
				first=last=null;
			}
			else {
				link = first;
				first = first.next;
			}
			D data = link.getData();
			link.reset();
			size--;
			return data;
		}
	}
 
	public D removeLast() {
		if ( isEmpty() ) {
			throw new IllegalStateException("Empty list");
		}
		else {
			Link link;
			if ( last==first ) {
				link = last;
				first=last=null;
			}
			else {
				link = last;
				last = first;
				while( last.next!=link ) {
					last = last.next;
				}
				last.next=null;
			}
			D data = last.getData();
			link.reset();
			size--;
			return data;
		}
	}
 
	public void clear() {
		if ( !isEmpty() ) {
			Link link = first;
			do {
				link.reset();
				link=link.next;
			} while( link!=null );
			first=last=null;
		}
	}
 
	public int getSize() {
		return size;
	}
 
	public Object[] toArray() {
		Object[] array = new Object[size];
		int index=0;
		Link link=first;
		while(link!=null) {
			array[index++]=link.getData();
			link=link.next;
		}
		return array;
	}
 
	public D[] toArray(D[] array) {
		if ( array.length<size ) {
			array = (D[]) Array.newInstance(array.getClass().getComponentType(), size);
		}
		int index=0;
		Link link=first;
		while(link!=null) {
			array[index++]=link.getData();
			link=link.next;
		}
		while (index<array.length) {
			array[index++]=null;
		}
		return array;
	}
 
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append('[');
		boolean first=true;
		for(D data : this ) {
			if ( first ) first=false; else sb.append(", ");
			sb.append(data);
		}
		sb.append(']');
		return sb.toString();
	}
 
	public Iterator<D> iterator() {
		return new Iterator<D>() {
 
			private Link next = first;
			private Link read;
 
			public D next() {
				if ( next==null ) {
					throw new NoSuchElementException();
				}
				if ( next.reset ) {
					throw new ConcurrentModificationException();
				}
				D data = next.getData();
				read = next;
				next = next.next;
				return data;
			}
			public boolean hasNext() {
				if ( next==null ) {
					return false;
				}
				if ( next.reset ) {
					throw new ConcurrentModificationException();
				}
				return next!=null;
			}
			public void remove() {
				if ( read!=null ) {
					if ( read==first ) {
						if( first==last ) {
							last=null;
						}
						first=read.next;
					}
					else {
						Link pref=first;
						while( pref.next!=read ) {
							pref=pref.next;
						}
						pref.next=read.next;
					}
					size--;
					read.reset();
					read=null;
				}
				else {
					throw new IllegalStateException();
				}
			}
		};
	}
 
	private class Link {
 
		D data;
		Link next;
		boolean reset;
 
		public Link(D data) {
			this.data=data;
		}
 
		void reset() {
			data=null;
			next=null;
			reset=true;
		}
 
		public D getData() {
			return data;
		}
 
	}
 
	public static void main(String[] args) {
 
		LinkList<String> list = new LinkList<String>();
		println(list);
		list.add("1");
		println(list);
		list.add("2").add("3").add("4");
		println(list);
		list.insert("A").insert("B").insert("C");
		println(list);
		System.out.println("Remove first: " + list.removeFirst());
		println(list);
		System.out.println("Remove last: " + list.removeLast());
		println(list);
		System.out.println("First: " + list.first());
		System.out.println("Last: " + list.last());
		System.out.println(Arrays.toString(list.toArray()));
		System.out.println(Arrays.toString(list.toArray(new String[3])));
		System.out.println(Arrays.toString(list.toArray(new String[10])));
		for(Iterator<String> iter = list.iterator(); iter.hasNext(); ) {
			String c = iter.next();
			if ( "1".equals(c) ) {
				iter.remove();
			}
		}
		println(list);
	}
 
	private static void println(LinkList<String> list) {
		System.out.println(list.getSize()+": " + list);
	}
 
}

avec ta classe Segment tu aurais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

LinkList<Segment> segments = new LinkList<Segment>();

[Neolex]

merci pour toute ces réponses , mais j'avoue que là je suis un peu perdu , je vais donc m'y remettre demain à tête reposée et je poserais d'autre questions si necessaire ...

Merci pour ton aide !

[Neolex]

Je suis completement perdu ....

Je dois donc commencer par modifier ma classe Liste et Segment ?
Je devrais enlever la valeur suivant de Segment et ajouter un segment dernier à ma liste ?

j'essaye de prendre les problèmes 1 par 1 ... je suis completement dépassé

[joel.drigo]

désolé si j'ai ajouté de la confusion

c'est une bonne approche d'aborder un problème étape par étape.

si on considère uniquement la partie structure de données (comment tu vas stocker des données en mémoire pour les manipuler), il y a effectivement 2 élements :

- des segments de couleur, qui stocke les 3 composantes rouge, vert, bleu et le nombre de points successifs de même couleur dans le fichier
- une liste chainée de segments

à partir de la tu dois voir en tout évidence comment déclarer ces 2 types.

tu peux bien sur dans une autre solution de structure avoir uniquement un seul type segment, tel que les segments soit liés entre eux. mais il me semble plus logique de faire qu'un nouveau segment s'ajoute à la suite d'un segment précédent, plutôt qu'un segment se lie à son suivant.

donc si tu veux gérer ta liste chainée avec qu'une seule classe Segment, tu peux faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Segment {
     private int r, g, b, n;
 
     private Segment suivant;
 
     public Segment(int r, int g, int b, int n) {
         this.r=r;
         this.g=g;
         this.b=b;
         this.n=n;
     }
 
    public void addSuivant(Segement segment) {
         this.suivant=segment;
    }
 
}

mais si tu utilises 2 classes, une classe Segment et une classe Liste, déjà tu n'a pas besoin de prévoir de lier tes Segments entre eux, puisque Liste est fait pour ça, et le fait de séparer les 2 concepts a l'avantage de séparer les problèmes à gérer chacun de son coté :

- d'un coté la problématique de stocker une couleur et un nombre de point
- de l'autre de stocker des éléments sous forme de liste chainée, en l'occurence dans ton cas ces éléments étant des Segments, mais ça pourrait etre n'importe quoi d'autre (dans mon exemple, dans la méthode main, je teste ma classe en faisant une liste chainée de String, mais on peut chainer n'importe quoi avec ma classe, comme des String, mais aussi des Segments de couleurs, ou des Integer, ou des JFrame si ça te chante...

comme par exemple, avec l'exemple de classe LinkList que j'ai mis dans le post d'avant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Segment {
     private int r, g, b, n;
 
     public Segment(int r, int g, int b, int n) {
         this.r=r;
         this.g=g;
         this.b=b;
         this.n=n;
     }
 
     public String toString() {
        return n + " point" + (n<=1?"":"s") + " de couleur " + r +","+g+","+b;
     }
 
     public static void main(String[] args) {
 
           LinkList<Segment> segments = new LinkList<Segment>();
           segments.add(new Segment(255,0,0,10);
           segments.add(new Segment(0,255,0,42);
           segments.add(new Segment(0,0,255,3);
 
           System.out.println(segments);
 
     }
 
}

qui affichera :

[10 points de couleur 255,0,0, 42 points de couleur 0,255,0, 3 points de couleur 0,0,255]

[Neolex]

Bon je crois avoir compris , je retire donc "suivant" de segment , et créer la liste des segments à partir de la LinkList que tu m'a donné bien que pour l'instant j'ai un peu de mal à comprendre comment elle fonctionne , avec les "Link" etc ...

je me penche maintenant sur la lecture du fichier... je relis tes messages , essaye de travailler ça et je reviens donner des nouvelles .

Merci beaucoup de prendre du temps pour m'aider !

[joel.drigo]

ma classe class LinkList est très similaire à ta classe Liste :

- j'ai juste ajouté une référence sur le dernier élément pour accélérer certains traitement, mais on peut s'en passer comme dans ta version (on pourrait également ajouter une référence previous dans Link pour accélérer encore (ce qui éviterait d'avoir à parcourir toute la liste pour supprimer un élément à la fin par exemple)
- je stocke la taille que je calcule au fur et à mesure des ajouts et des suppressions, pour accélérer également (on est pas obligé de parcourir toute la liste pour connaitre sa taille)
- ensuite la classe Link permet juste d'isoler la classe de liste chaînée des éléments chaînés : ta classe Liste ne permet de chaîner que des Segments, la mienne permet juste de chainer n'importe quoi
- bon elle est en anglais alors que la tienne est en français. je ne sais pas ce qu'on te conseille à ce sujet en cours, mais bien que je suis plutôt pro français (je parle plus souvent de bogue que de bug, ou d'antémémoire que de cache, et je préfère résoudre que solutionner ), il faut bien avouer que l'anglais permet des noms de classes, de méthodes ou de variables plus élégants, que dans le monde où l'on vit et travaille de nos jours, on est en contact avec très souvent avec des développeurs (ou utilisateurs) internationaux (pour ma part, avec des indiens, des espagnols, des anglais, des suédois etc.) et qu'il est nécessaire que le code soit compréhensible par tous, que la quasi totalité des API java sont en anglais, et donc avoir quelques méthodes en français fait un peu bizarre.

ma classe est loin d'etre complète, on pourrait implémenter d'autres méthodes, en particulier toutes celles de l'interface java.util.List

[Neolex]

merci beaucoup je comprends mieux la classe LinkList maintenant .
par contre j'ai encore une question , à propos de ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
void read(Liste liste, BufferedReader reader) throws IOException {
 
   String data = reader.readLine();
   if ( data!=null ) {
      readLine(liste, data);
   }
 
}
 
void read(Liste liste, String data) throws IOException {
 
     String[] split = split(data);
 
     int i=0;
     while((i=readNextSegment(liste,split,i)>=0);
 
}
 
int readNextSegment(Liste liste, String[] data, int index) throws IOException {
 
     if ( index==data.length ) {
        return -1;
     }
     else if ( index+3<=data.length ) {
          int r = read(data[index++]);
          int g = read(data[index++]);
          int b = read(data[index++]);
          addSegment(liste,  r, g, b );
     }
     else {
         throw new IOException("Il manque des données dans ce fichier (par exemple !)");
     }
 
     return index;
 
}

la deuxieme methode read , ne s'appelerais pas readline plutôt ?

[joel.drigo]

oui tu as raison, c'est une erreur de frappe de ma part

dans la méthode readNextSegment l'appel read(String[]) c'est bien read, mais je n'ai pas mis le code cette méthode : je te laisse compléter. la méthode split(string) aussi (je donne quelque clés dans un autre post)

au sujet de LinkList, je l'ai mise en exemple. maintenant que tu as compris le principe, écris ta propre classe (modifie par exemple ta classe Liste). si tu utilises directement ma classe, ça va se voir, surtout qu'il y a plein de méthodes qui ne servent pas dans ton exercice.

[Neolex]

j'ai essayé de re ecrire une classe Liste en m'aidant de la tienne ,mais finalement j'ai juste remis la classe segment et Liste comme elles etaient au debut ...

j'ai vraiment du mal avec les listes chainées ...

Edit: voilà ma classe List et Segment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
public class List {
 
	private Segment first ;
	private int size ; 
 
	public boolean isEmpty(){
		return first == null ;
	}
 
	public Segment getFirst() {
		return first;
		}
 
	public void addFirst(int r,int g,int b,int n){
		Segment oldFist = first;
		first = new Segment(r, g, b, n ,oldFist);
		size++;
	}
 
	public void addLast(int red,int green,int blue,int n){
		Segment segment = new Segment(red, green, blue, n);
 
		if(isEmpty()){
			first = segment;  
		}
		else{
			Segment last = getLastElement();
			last.setSuivant(segment);
		}
		size++;
	}
 
	public Segment getLastElement(){
		Segment last = first ;
		while(last.getSuivant() != null){
			last = last.getSuivant();
		}
		return last;
	}
 
	public int getSize() {
		return size;
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class Segment {
	private int red,green,blue;
	private int nbOccurence ;
 
	Segment suivant;
 
	public Segment(int red,int green,int blue,int n, Segment suivant) {
		this.red = red;
		this.green = green;
		this.blue = blue;
		this.nbOccurence = n;
 
		this.suivant=suivant;
	}
 
	public Segment(int red,int green,int blue , int n) {
		this.red = red;
		this.green = green;
		this.blue = blue;
		this.nbOccurence = n;
	}
 
	public int getRed() {
		return red;
	}
	public void setRed(int red) {
		this.red = red;
	}
 
	public int getGreen() {
		return green;
	}
	public void setGreen(int green) {
		this.green = green;
	}
 
	public int getBlue() {
		return blue;
	}
	public void setBlue(int blue) {
		this.blue = blue;
	}
 
	public int getNombre() {
		return nbOccurence;
	}
 
	public void setNombre(int nombre) {
		this.nbOccurence = nombre;
	}
	public int getNbOccurence() {
		return nbOccurence;
	}
	public void setNbOccurence(int nbOccurence) {
		this.nbOccurence = nbOccurence;
	}
 
	public Segment getSuivant() {
		return suivant;
	}
 
	public void setSuivant(Segment suivant) {
		this.suivant = suivant;
	}
 
}

[joel.drigo]

Salut,

pour repartir de tes classes, supprime simplement le constructeur de Segment avec l'argument Segment suivant : il ne sert à rien dans ton cas, et si tu voulais t'en servir, ce serait trop compliqué (comme je l'ai dit il faudrait lire les suivants avant les précedents).

ensuite, comme je trouve dommage que tu comprennes pas, mais sans vouloir forcément d'obliger à prendre du temps et te prendre la tête, je vais tenter de t'expliquer rapidement et plus simplement que je peux la différence entre tes classes et les miennes.

tu as fait une classe Liste et une classe Segment

ta liste permet de manipuler les liens entre un segment et son suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public void ajouterALaFin(int red,int green,int blue , int n)

c'est ce que fait cette méthode : quand tu ajoutes un segment, sauf la première fois ou c'est la liste elle même qui a un lien sur le premier segment (par l'intermédiare de la variable premier), dans les autres cas, tu ajoutes bien ton nouveau segment au dernier que tu avais dans ta liste.

dans mes classes, j'ai simplement ajouter un niveau qui éviterait juste que Liste et Segment soit liés (Tu ne peux pas utiliiser Liste autrement que pour chainer des Segments)

la différence c'est qu'en gros ta classe Segment :

- a des données de segment de couleur (r,g,b,n)
- a une donnée de lien (segment suivant)

dans LinkList, la classe Link est en quelquesort l'équivalent de ta classe Segment, sauf qu'elle ne stocke pas directement r,g,b,n elle stocke une instance d'objet représentant des données, plus un lien exactement comme ta classe segment

ensuite quand je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new LinkList<Segment>()

j'indique que les données que je vais stocker dans mes Link, seront représenté s par la classe Segment.

en gros ma classe Link :
- a une référence de machin
- a une donnée de lien (machin suivant)

Imagine que tu utilises un tableau de int pour représenter tes segments,
tu ferais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new LinkList<int[]>()

sans rien avoir à changer dans la classe LinkList.

ici machin est un tableau de int

en ce qui concerne les listes chaînées elle mêmes plus généralement, c'est relativement simple : ton énoncé explique simplement que c'est une structure qui peut se représenter comme çà

O---->[]---->[]---->[]

O est ta racine de départ, ta classe Liste, qui peut être vide (donc aucun lien sur aucun segment
[] est un segment qui peut avoir un lien sur un segment suivant (ou pas si c'est le dernier de la chaîne)

----> représentent un lien sur Segment, soit en java, une référence

Une liste chaînée telle que celle là est adaptée au besoin suivant :

- on a souvent besoin d'ajouter des éléments au début de la liste

et c'est bien dans ce cas qu'elle est très efficace, puisqu'il suffit de dire que
nouveau.suivant=premier et que premier=nouveau quand on insère nouveau. très rapide à exécuter.
si ta liste était une ArrayList, donc stocker sous forme de tableau, il faudrait éventuellement agrandir le tableau, puis déplacer tous les éléments vers la fin d'un cran, ce qui peut être particulièrement long suivant la taille de ta liste

par contre pour ajouter à la fin de Liste, il faut toujours parcourir toute la liste pour chercher le dernier, donc parcourir les liens suivant de segment en segment en partant du premier, jusqu'à ce qu'on est plus de suivant, pour pouvoir ajouter le nouveau comme suivant du dernier, le nouveau devenant ainsi dernier. si tu as 10000 éléments dans ta liste tu image le temps que ça peut prendre. c'est pour cette raison que dans ma classe LinkList j'ai une reférence sur last : j'ai les même performance sur un ajout à la fin que pour un ajout au début
la ArrayList s'avère très rapide tant qu'il y a de la place dans le tableau, d'autant plus qu'elle gère un tableau plus grand que nécessaire avec un indicateur de dernière donnée utile, mais elle prendra un peu de temps à chaque fois que la taille du tableau devient insuffisante pour stocker un élément supplémentaire, et dans ce cas, sera obligé de récréer un nouveau tableau plus grand et de recopier l'ancien tableau dedans, ce qui prend nécessairement du temps.

[Neolex]

Oh la la , merci beaucoup de prendre tant de temps pour moi qui galere completement , mais ton dernier message à répondu vraiment à toute mes questions , je comprends beaucoup mieux !!

Je devrais donc créer une réference sur last dans ma liste aussi puisque j'aurais beaucoup de segments à ajouter à la fin quand je lirais l'image ppm non ?

[joel.drigo]

dans le cas absolu, oui.

je dis ça, parce que ça dépend de plein de chose

- de la taille des images que tu vas charger
- du nombre d'images que tu vas charger
- du but final de ton code :
- s'il s'agit d'un exercice isolé, ce n'est pas indispensable, mais c'est un plus de mettre en place une référence sur le dernier : tu ne verras probablement une différence dans le temps de chargement que sur des gros fichiers, à moins que ta machine soit vraiment hyper lente
- s'il s'agit d'un programme industriel ou tu ne peux pas prévoir le nombre d'images chargées et à quelle fréquence, la différence pourra être remarquable
à l'usage

a noter, par ailleurs, qu'on voit tout de suite la concrétisation de l'un des principes de base en informatique : souvent, plus on veut de performances, plus ça prend de mémoire

ici on ajoute juste une référence sur le dernier, donc peu de consommation de mémoire supplémentaire, pour un gain conséquent sur des gros fichiers.

[Neolex]

d'accord , pour mon exercice je dois ensuite créer des methodes qui modifie l'image et l'enregistre après .

Je vais essayer d'ajouter donc une reference sur last et essayer de comprendre comment changer la méthode addLast etc

Merci


edit : je n'arrive pas alors je ferais ça une fois le reste fini pour optimiser mon programme ...

[Neolex]

j'ai presque réussi à sauvegarder l'image dans ma liste chainée , il manque seulement le dernier segment que je n'arrive pas à ajouter .

voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
			// Debut Lecture pixels
			s = f.readLine();
			while(s != null){
				split = s.trim().split("\\s+");
				int i = 0;
				while(i+2<=split.length){
					  r = Integer.parseInt(split[i]);
					  g = Integer.parseInt(split[i+1]);
					  b =Integer.parseInt(split[i+2]);
					n = addSegment(segments, r, g, b, n);
					i += 3 ;
				}
				s = f.readLine();
			}
 
		// fonction addSegment :
 
		public int addSegment(List liste,  int r, int g, int b , int n ) {
		    System.out.println("debut addSegment");
			if ( n!=0 ) {
		    	System.out.println("si n!=0 :");
		        // on a déjà commencé un segment
		        if ( r!=lastr ||  g!=lastg || b!=lastb ) {
		           // une couleur au moins est différente
		           liste.addLast(lastr, lastg, lastb, n); // le segment précédent est ajouté à la liste
 
		        }
		        else {
		           n++; // un point de plus dans le segment (même couleur, même segement)
		           return n; // attention retour à l'appelant
		        }
		    }
			System.out.println("premier point d'un nouveau segment");
		    // premier point d'un nouveau segment
		    n=1;
		    lastr=r;
		    lastg=g;
		    lastb=b;
		    return n;
		}