[JDK 1.6.0] Information image

Bonjour,

Je ne connais pas JAVA, et je voudrai connaitre pour des images au format TIF, JPG, PNG

le format
le nombre de DPI,
la taille en millimétre et en pixel
la taille en octet du fichier

Merci de votre aide

Salut,

Pour connaitre la taille d'un fichier en octet, quelque soit son type, tu peux utiliser la méthode length() de la classe File.

Pour connaitre le format, on peut éventuellement passer par le type mime, mais ce système dépend de la configuration et le l’environnement, et ne pourras pas fonctionner dans certains cas. Sinon on peut utiliser ImageIO, qui va fournir une liste de reader compatible : il suffira de demander au premier reader compatible le format.

Pour connaitre les dimensions en pixels, on peut également utiliser ImageIO. Pour les DPI, idem, mais il faudra accéder aux metadata de l'image.

Pour déterminer la taille en millimètres, il suffit de faire le calcul à partir des dimensions et des DPI.

Exemples de tous les cas :

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
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
public class ImageMetaExample {
 
	public static void main(String[] args) {
 
		String filepath = "C:/Users/Joël/Pictures/suricate.png";
 
		File file = new File(filepath);
 
		System.out.printf("La taille du fichier est %d octet(s)%n", file.length());
 
		try {
			System.out.printf("La type mime du fichier est %s%n", Files.probeContentType(file.toPath()));
		} catch (IOException e) {
			System.err.println("Impossible de déterminer le type mime");
			e.printStackTrace();
		}
 
		System.out.printf("Le format du fichier est %s%n", getImageFormatFile(file));
 
		Dimension dimPx = getImagePixels(file); 
		if ( dimPx!=null ) {
			System.out.printf("Les dimensions de l'image sont %d×%d pixel(s)%n", dimPx.width, dimPx.height);
		}
		else {
			System.out.println("Impossible d'obtenir les dimensions de l'image (erreur à la lecture)");
		}
 
		Dimension dpi = getImageDotPerInches(file); 
		if ( dpi!=null ) {
			System.out.printf("Les DPI de l'image sont %d×%d pixels%n", dpi.width, dpi.height);
		}
		else {
			System.out.println("Impossible d'obtenir les DPI de l'image (erreur à la lecture)");
		}
 
		DoubleDimension dpmm = getImageDotPerMm(file);
		if ( dimPx!=null && dpmm!=null ) {
			System.out.printf("Les dimensions de l'image sont %f×%f mm%n", dimPx.width * dpmm.width, dimPx.height * dpmm.height);
		}
		else {
			System.out.println("Impossible d'obtenir les dimensions en millimètres (erreur à la lecture)");
		}
 
 
	}
 
	private static Dimension getImageDotPerInches(File file) {
		DoubleDimension pixelSize = getImagePixelSizeMillimeters(file);
		Dimension dimension = null;
		if ( pixelSize!=null ) {
			dimension = new Dimension();
			dimension.width = toDpi(pixelSize.width);
			dimension.height = toDpi(pixelSize.height);
		}
		return dimension;
	}
 
	private static DoubleDimension getImageDotPerMm(File file) {
		DoubleDimension pixelSize = getImagePixelSizeMillimeters(file); 
		if ( pixelSize!=null ) { 
			pixelSize.width = 1/pixelSize.width;
			pixelSize.height = 1/pixelSize.height;
		}
		return pixelSize;
	}
 
	private static DoubleDimension getImagePixelSizeMillimeters(File file) {
		DoubleDimension dimension = null;
		try( ImageInputStream iis = ImageIO.createImageInputStream(file) ) {
 
			for (Iterator<ImageReader> readerIterator = ImageIO.getImageReaders(iis); readerIterator.hasNext(); ) {
				ImageReader reader = readerIterator.next();
				reader.setInput(iis);
				IIOMetadata metadata = reader.getImageMetadata(0);
		        IIOMetadataNode standardTree = (IIOMetadataNode) metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
		        IIOMetadataNode dimensionNode = (IIOMetadataNode) standardTree.getElementsByTagName("Dimension").item(0);
		        double horizontalDotMM = getPixelSizeMM(dimensionNode, "HorizontalPixelSize");
		        double verticalDotMM = getPixelSizeMM(dimensionNode, "VerticalPixelSize");
		        dimension = new DoubleDimension(horizontalDotMM, verticalDotMM);
			    break;
			}
 
		} catch (IOException e) { 
			e.printStackTrace();
		}
		return dimension;
 
	}
 
	private static int toDpi(double sizeInMM) {
		return sizeInMM<0?-1:(int)Math.round(25.4f / sizeInMM);
	}
 
	private static double getPixelSizeMM(IIOMetadataNode dimensionNode, String name) {
		NodeList nodeList = dimensionNode.getElementsByTagName(name);
        IIOMetadataNode node =  nodeList.getLength() > 0 ? (IIOMetadataNode) nodeList.item(0) : null;
        if ( node!=null ) {
        	return Double.parseDouble(node.getAttribute("value"));
        }
        else {
        	return -1;
        }
	} 
 
	private static String getImageFormatFile(File file) {
		String format = "inconnu";
		try( ImageInputStream iis = ImageIO.createImageInputStream(file) ) {
 
			for (Iterator<ImageReader> readerIterator = ImageIO.getImageReaders(iis); readerIterator.hasNext(); ) {
			    format = readerIterator.next().getFormatName();
			    break;
			}
 
		} catch (IOException e) { 
			e.printStackTrace();
		}
		return format;
 
	}
 
	private static Dimension getImagePixels(File file) {
		Dimension dimension = null;
		try( ImageInputStream iis = ImageIO.createImageInputStream(file) ) {
 
			for (Iterator<ImageReader> readerIterator = ImageIO.getImageReaders(iis); readerIterator.hasNext(); ) {
				ImageReader reader = readerIterator.next();
				reader.setInput(iis);
				dimension = new Dimension(reader.getWidth(reader.getMinIndex()), reader.getHeight(reader.getMinIndex()));
			    break;
			}
 
		} catch (IOException e) { 
			e.printStackTrace();
		}
		return dimension;
 
	}
 
	private static class DoubleDimension extends Dimension2D {
 
		public double width;
		public double height;
 
		public DoubleDimension() {
		}
 
		public DoubleDimension(double width, double height) {
			this.width=width;
			this.height=height;
		}
 
		@Override
		public double getWidth() {
			return width;
		}
 
		@Override
		public double getHeight() {
			return height;
		}
 
		public void setWidth(double width) {
			this.width = width;
		}
 
		public void setHeight(double height) {
			this.height = height;
		}
 
		@Override
		public void setSize(double width, double height) {
			this.width=width;
			this.height=height;
		}
 
		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append('[');
			sb.append(width);
			sb.append(", ");
			sb.append(height);
			sb.append(']');
			return sb.toString();
		}
 
	}
 
}

Avec trace d'exécution :

La taille du fichier est 56493 octet(s)
La type mime du fichier est image/png
Le format du fichier est png
Les dimensions de l'image sont 150×150 pixel(s)
Les DPI de l'image sont 96×96 pixels
Les dimensions de l'image sont 566,850000×566,850000 mm

Tu peux avoir intérêt à regrouper les méthodes qui manipulent les readers ImageIO pour ne pas avoir à relire le flux plusieurs fois, si tu fais appel systématiquement à ces méthodes de manière groupée.

Attention, Java ne gère pas nativement tous les formats de fichier image. Mais pour le png, jpg et tif, c'est bon.

EDIT : désolé, je n'avais pas fait attention au tag jdk 1.6

Le même exemple en 1.6 (même en 1.5), sauf la partie mime type (il faudrait passer par une MimeTypeMap) :

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
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
 
public class ImageMetaExample {
 
	public static void main(String[] args) {
 
		String filepath = "C:/Users/Joël/Pictures/suricate.png";
 
		File file = new File(filepath);
 
		System.out.printf("La taille du fichier est %d octet(s)%n", file.length());
 
 
		System.out.printf("Le format du fichier est %s%n", getImageFormatFile(file));
 
		Dimension dimPx = getImagePixels(file); 
		if ( dimPx!=null ) {
			System.out.printf("Les dimensions de l'image sont %d×%d pixel(s)%n", dimPx.width, dimPx.height);
		}
		else {
			System.out.println("Impossible d'obtenir les dimensions de l'image (erreur à la lecture)");
		}
 
		Dimension dpi = getImageDotPerInches(file); 
		if ( dpi!=null ) {
			System.out.printf("Les DPI de l'image sont %d×%d pixels%n", dpi.width, dpi.height);
		}
		else {
			System.out.println("Impossible d'obtenir les DPI de l'image (erreur à la lecture)");
		}
 
		DoubleDimension dpmm = getImageDotPerMm(file);
		if ( dimPx!=null && dpmm!=null ) {
			System.out.printf("Les dimensions de l'image sont %f×%f mm%n", dimPx.width * dpmm.width, dimPx.height * dpmm.height);
		}
		else {
			System.out.println("Impossible d'obtenir les dimensions en millimètres (erreur à la lecture)");
		}
 
 
	}
 
	private static Dimension getImageDotPerInches(File file) {
		DoubleDimension pixelSize = getImagePixelSizeMillimeters(file);
		Dimension dimension = null;
		if ( pixelSize!=null ) {
			dimension = new Dimension();
			dimension.width = toDpi(pixelSize.width);
			dimension.height = toDpi(pixelSize.height);
		}
		return dimension;
	}
 
	private static DoubleDimension getImageDotPerMm(File file) {
		DoubleDimension pixelSize = getImagePixelSizeMillimeters(file); 
		if ( pixelSize!=null ) { 
			pixelSize.width = 1/pixelSize.width;
			pixelSize.height = 1/pixelSize.height;
		}
		return pixelSize;
	}
 
	private static DoubleDimension getImagePixelSizeMillimeters(File file) {
		DoubleDimension dimension = null;
		ImageInputStream iis = null;
		try{
 
			iis = ImageIO.createImageInputStream(file);
 
			for (Iterator<ImageReader> readerIterator = ImageIO.getImageReaders(iis); readerIterator.hasNext(); ) {
				ImageReader reader = readerIterator.next();
				reader.setInput(iis);
				IIOMetadata metadata = reader.getImageMetadata(0);
		        IIOMetadataNode standardTree = (IIOMetadataNode) metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
		        IIOMetadataNode dimensionNode = (IIOMetadataNode) standardTree.getElementsByTagName("Dimension").item(0);
		        double horizontalDotMM = getPixelSizeMM(dimensionNode, "HorizontalPixelSize");
		        double verticalDotMM = getPixelSizeMM(dimensionNode, "VerticalPixelSize");
		        dimension = new DoubleDimension(horizontalDotMM, verticalDotMM);
			    break;
			}
 
		} catch (IOException e) { 
			e.printStackTrace();
		} finally {
			if ( iis!=null ) {
				try {
					iis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		return dimension;
 
	}
 
	private static int toDpi(double sizeInMM) {
		return sizeInMM<0?-1:(int)Math.round(25.4f / sizeInMM);
	}
 
	private static double getPixelSizeMM(IIOMetadataNode dimensionNode, String name) {
		NodeList nodeList = dimensionNode.getElementsByTagName(name);
        IIOMetadataNode node =  nodeList.getLength() > 0 ? (IIOMetadataNode) nodeList.item(0) : null;
        if ( node!=null ) {
        	return Double.parseDouble(node.getAttribute("value"));
        }
        else {
        	return -1;
        }
	} 
 
	private static String getImageFormatFile(File file) {
		String format = "inconnu";
		ImageInputStream iis = null;
		try{
 
			iis = ImageIO.createImageInputStream(file);
 
			for (Iterator<ImageReader> readerIterator = ImageIO.getImageReaders(iis); readerIterator.hasNext(); ) {
			    format = readerIterator.next().getFormatName();
			    break;
			}
 
		} catch (IOException e) { 
			e.printStackTrace();
		}
		return format;
 
	}
 
	private static Dimension getImagePixels(File file) {
		Dimension dimension = null;
		ImageInputStream iis = null;
		try{
 
			iis = ImageIO.createImageInputStream(file);
 
			for (Iterator<ImageReader> readerIterator = ImageIO.getImageReaders(iis); readerIterator.hasNext(); ) {
				ImageReader reader = readerIterator.next();
				reader.setInput(iis);
				dimension = new Dimension(reader.getWidth(reader.getMinIndex()), reader.getHeight(reader.getMinIndex()));
			    break;
			}
 
		} catch (IOException e) { 
			e.printStackTrace();
		} finally {
			if ( iis!=null ) {
				try {
					iis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		return dimension;
 
	}
 
	private static class DoubleDimension extends Dimension2D {
 
		public double width;
		public double height;
 
		public DoubleDimension() {
		}
 
		public DoubleDimension(double width, double height) {
			this.width=width;
			this.height=height;
		}
 
		@Override
		public double getWidth() {
			return width;
		}
 
		@Override
		public double getHeight() {
			return height;
		}
 
		public void setWidth(double width) {
			this.width = width;
		}
 
		public void setHeight(double height) {
			this.height = height;
		}
 
		@Override
		public void setSize(double width, double height) {
			this.width=width;
			this.height=height;
		}
 
		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append('[');
			sb.append(width);
			sb.append(", ");
			sb.append(height);
			sb.append(']');
			return sb.toString();
		}
 
	}
 
}

Merci de votre réponse,

J'ai recopié tel que votre exemple, lorsque je compile j'ai 55 erreurs, il doit manquer des entêtes, en ajoutant
import java.io.*; j'ai réduit le nombre d'erreur
Quelques erreurs rencontrées :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
ImageMetaExample.java:43: cannot find symbol
symbol  : class Dimension
location: class ImageMetaExample
	private static Dimension getImageDotPerInches(File file) {
	               ^
ImageMetaExample.java:162: cannot find symbol
symbol  : class Dimension2D
location: class ImageMetaExample
	private static class DoubleDimension extends Dimension2D {
	                                             ^
ImageMetaExample.java:102: cannot find symbol
symbol  : class IIOMetadataNode
location: class ImageMetaExample
	private static double getPixelSizeMM(IIOMetadataNode dimensionNode, String name) {
	                                     ^

Merci pour l'aide

J'ai pas mis les imports en effet, pour réduire la taille (ça se gère automatiquement au copier-coller dans les IDE).

La classe Dimension, c'est java.awt.Dimension (un seul choix dans le JDK). Dimension2D, c'est java.awt.geom le package (en java 1.6, il ne devrait y en avoir qu'une). IIOMetaData et le reste de ImageIO, c'est javax.imageio.metadata, ou javax.imageio.

comme je vous l'ai indiqué, je ne connais rien en java, et je n'ai pas d'IDE d'installer,

dans quel lib puis je trouver les imports j'ai plusieurs erreurs
Code:

1 2 3 4 5 6 7 8 ImageMetaExample.java:5: cannot find symbol symbol : class geom location: package java.awt import java.awt.geom; ^ ImageMetaExample.java:7: package javax does not exist import javax.imageio; ^
mais je n'ai pas eu d'erreurs pour

Code:

import java.awt.Dimension;

merci

C'est parce qu'il faut mettre le nom des classe en entier, ou mettre .*, à la fin, pour indiquer qu'on veut importer toutes les classes d'un package (java.awt.geom, c'est un package). Ce serait, à mon avis, plus simple pour toi de débuter en utilisant un IDE (bien sûr, ça masque un certain nombre de choses qu'il est utile de connaitre par la suite, mais tu auras bien l'occasion de les aborder plus tard).

En tout cas, voilà la liste de tous les imports (pour la version Java 6) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 import java.awt.Dimension; import java.awt.geom.Dimension2D; import java.io.File; import java.io.IOException; import java.util.Iterator; import javax.imageio.ImageIO; import javax.imageio.ImageReader; import javax.imageio.metadata.IIOMetadata; import javax.imageio.metadata.IIOMetadataFormatImpl; import javax.imageio.metadata.IIOMetadataNode; import javax.imageio.stream.ImageInputStream; import org.w3c.dom.NodeList;

Merci beaucoup
les formats : bmp, png, giff et jpg fonctionnent
le format tiff ne fonctionne pas avec le code
savez vous comment savoir si un format tiff est détuilé ?

Il te faut récupérer JAI (Java Advanced Imaging) sur le site archives de Java. Le jar jai_codec.jar devrait suffire. Il te faut l'inclure dans le classpath (à l'exécution comme à la compilation) avec l'option -cp.

Encore une fois merci