Enregistrement sans perte d'un BufferedImage

Version imprimable

Bonjour,

Pour la mise en place d'un système de cache d'images, je cherche à enregistrer des BufferedImage dans un fichier (qui sera de toute façon supprimé à la fermeture de l'application) mais sans perte.

Pour l'instant, j'enregistrais en BMP (mais même pas sûr qu'il prenne en compte les canaux Alpha), les spécifications de ImageIO.write sont un peu évasives.

Mais je me dis qu'il y a peut être une technique déjà toute fait pour ça (et qui n'utiliserait pas forcement ImageIO).

Donc si quelqu'un a une idée un peu mieux qu'un vieux bmp...

Merci

Pour l'instant, le code ressemblait à ça :

Code:

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
public class FileImageCache implements ImageCache {
	static private Logger logger = Logger.getAnonymousLogger();
 
	private Map<Object, File> files = new HashMap<Object, File>();
 
	/* (non-Javadoc)
	 * @see millie.gui.cache.ImageCache#clear()
	 */
	@Override
	public void clear() {
		for(Map.Entry<Object, File> e : files.entrySet()) {
			File f = e.getValue();
			f.delete();
		}
	}
 
	/* (non-Javadoc)
	 * @see millie.gui.cache.ImageCache#get(java.lang.Object)
	 */
	@Override
	public BufferedImage get(Object id) {
		File f = files.get(id);
		if(f==null)
			return null;
		BufferedImage im = null;
		try {
			im = ImageIO.read(f);
		}
		catch(IOException e) {
			logger.warning(e.getMessage());
			e.printStackTrace();
		}
		return im;
	}
 
	/* (non-Javadoc)
	 * @see millie.gui.cache.ImageCache#put(java.lang.Object, java.awt.image.BufferedImage)
	 */
	@Override
	public void put(Object id, BufferedImage im) {
		try {
			File f = File.createTempFile("zzz", "bmp");
			f.deleteOnExit();
			ImageIO.write(im, "bmp", f);
			files.put(id, f);
		} catch (IOException e) {
			logger.warning(e.getMessage());
			e.printStackTrace();
		}
 
	}
 
	/* (non-Javadoc)
	 * @see millie.gui.cache.ImageCache#remove(java.lang.Object)
	 */
	@Override
	public void remove(Object id) {
		File f = files.get(id);
		if(f!=null) {
			f.delete();
		}
	}
 
}

23/01/2009, 11h24
adiGuba

Salut,

Tu pourrais utiliser des ImageIcon qui sont sérialisables...
Par contre si tu veux obtenir une BufferedImage il va falloir la reconstruire.

a++
23/01/2009, 14h48
sinok

Euh juste par le plus grand des hasards, PNG ne serait-il pas un format lossless? ;)

Citation:

Envoyé par sinok

Euh juste par le plus grand des hasards, PNG ne serait-il pas un format lossless? ;)

J'étais persuadé qu'il y avait perte avec le PNG, mais en fait non.

"Les caractéristiques de PNG lui permettent d’enregistrer des photographies sans perte de données"

Bon bah voilà, couplé avec des caches avec migration entre mémoire et fichier (ou autres), ça roule bien ^^

Code:

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
 
/**
 * Cache d'images qui utilise 2 autres ImageCache.
 * Le premier est le cache qui contiendra les dernières données ajoutés/accédés. 
 *  Lorsque le premier cache attendra une certaine taille, les données les plus vieilles seront
 *  migrées vers le second cache.
 *  
 * @author humberf
 *
 */
public class MigrationImageCache implements ImageCache {
 
	private ImageCache firstCache;
	private ImageCache secondCache;
	private int firstCacheSize;
	private AccessSet accessSet = new AccessSet();
	private Object mutex = new Object();
 
	/**
         * 
         * @param firstCache cache récent
         * @param secondCache vieux cache
         * @param firstCacheSize taille du premier cache, doit supérieur ou égale à 1
         */
	public MigrationImageCache(ImageCache firstCache, ImageCache secondCache, int firstCacheSize) {
		if(firstCacheSize<1) {
			throw new IllegalArgumentException("Cache size<1");
		}
		this.firstCache = firstCache;
		this.secondCache = secondCache;
		this.firstCacheSize = firstCacheSize;
	}
 
 
	@Override
	public void clear() {
		synchronized (mutex) {
			firstCache.clear();
			secondCache.clear();
			accessSet.clear();
		}
	}
 
	class Purger extends Thread {
		public void run() {
			synchronized (mutex) {
				while(accessSet.size()>firstCacheSize) { //on supprimes les premiers éléments
					Object id = accessSet.getOlderAccessAndRemove();
					BufferedImage im = firstCache.get(id);
					firstCache.remove(id);
					secondCache.put(id, im);
				}
			}
		}
	}
 
	private void purgeFirstCache() {
		//accès lourd pour la purgation, on le fait dans un thread à part
		new Purger().start();
	}
 
	@Override
	public BufferedImage get(Object id) {
		synchronized (mutex) {
			purgeFirstCache();
 
			//si en mémoire
			BufferedImage im = firstCache.get(id);
			if(firstCache.get(id) !=null) { 
				accessSet.access(id);
				return im;
			}
			else {
				im = secondCache.get(id);
				if(im==null) {
					return null;
				}
				firstCache.put(id, im); //on le remet en cache mémoire
				accessSet.add(id);
 
				return im;
			}
		}
	}
 
	@Override
	public void put(Object id, BufferedImage im) {
		synchronized (mutex) {
			purgeFirstCache();
 
			firstCache.put(id, im);
			accessSet.add(id);
		}
	}
 
	@Override
	public void remove(Object id) {
		synchronized (mutex) {
			if(firstCache.get(id) !=null) { //en mémoire
				firstCache.remove(id);
				accessSet.remove(id);
			}
			else {
				secondCache.remove(id);
			}
		}
	}
 
}