Mercurial > hg > digilib-old

comparison servlet/src/digilib/image/ImageLoaderDocuImage.java @ 590:69bc69381ac4 stream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more work on stream input and more cleanup
author robcast
date Thu, 06 Jan 2011 20:42:29 +0100
parents 73e041c710d3
children 2b58d2783ef0
comparison
equal deleted inserted replaced
589:73e041c710d3 590:69bc69381ac4
27 import java.awt.image.AffineTransformOp; 27 import java.awt.image.AffineTransformOp;
28 import java.awt.image.BufferedImage; 28 import java.awt.image.BufferedImage;
29 import java.awt.image.ConvolveOp; 29 import java.awt.image.ConvolveOp;
30 import java.awt.image.Kernel; 30 import java.awt.image.Kernel;
31 import java.awt.image.RescaleOp; 31 import java.awt.image.RescaleOp;
32 import java.io.File;
33 import java.io.IOException; 32 import java.io.IOException;
34 import java.io.OutputStream; 33 import java.io.OutputStream;
35 import java.io.RandomAccessFile; 34 import java.io.RandomAccessFile;
36 import java.util.Arrays; 35 import java.util.Arrays;
37 import java.util.Iterator; 36 import java.util.Iterator;
51 import digilib.io.FileOps; 50 import digilib.io.FileOps;
52 import digilib.io.ImageInput; 51 import digilib.io.ImageInput;
53 52
54 /** Implementation of DocuImage using the ImageLoader API of Java 1.4 and Java2D. */ 53 /** Implementation of DocuImage using the ImageLoader API of Java 1.4 and Java2D. */
55 public class ImageLoaderDocuImage extends ImageInfoDocuImage { 54 public class ImageLoaderDocuImage extends ImageInfoDocuImage {
56 55
57 /** image object */ 56 /** image object */
58 protected BufferedImage img; 57 protected BufferedImage img;
59 58
60 /** interpolation type */ 59 /** interpolation type */
61 protected RenderingHints renderHint; 60 protected RenderingHints renderHint;
62 61
63 /** ImageIO image reader */ 62 /** ImageIO image reader */
64 protected ImageReader reader; 63 protected ImageReader reader;
65 64
66 /** File that was read */ 65 protected static Kernel[] convolutionKernels = {
67 protected File imgFile; 66 null,
68 67 new Kernel(1, 1, new float[] {1f}),
68 new Kernel(2, 2, new float[] {0.25f, 0.25f, 0.25f, 0.25f}),
69 new Kernel(3, 3, new float[] {1f/9f, 1f/9f, 1f/9f, 1f/9f, 1f/9f, 1f/9f, 1f/9f, 1f/9f, 1f/9f})
70 };
71
72
69 /* loadSubimage is supported. */ 73 /* loadSubimage is supported. */
70 public boolean isSubimageSupported() { 74 public boolean isSubimageSupported() {
71 return true; 75 return true;
72 } 76 }
73 77
126 } 130 }
127 logger.debug("identifying (ImageIO) " + input); 131 logger.debug("identifying (ImageIO) " + input);
128 /* 132 /*
129 * try ImageReader 133 * try ImageReader
130 */ 134 */
131 reader = getReader(input); 135 try {
136 reader = getReader(input);
137 } catch (FileOpException e) {
138 // maybe just our class doesn't know what to do
139 return null;
140 }
132 // set size 141 // set size
133 ImageSize d = new ImageSize(reader.getWidth(0), reader.getHeight(0)); 142 ImageSize d = new ImageSize(reader.getWidth(0), reader.getHeight(0));
134 input.setSize(d); 143 input.setSize(d);
135 // set mime type 144 // set mime type
136 if (input.getMimetype() == null) { 145 if (input.getMimetype() == null) {
172 if (this.input == input) { 181 if (this.input == input) {
173 // it was the same input 182 // it was the same input
174 logger.debug("reusing Reader"); 183 logger.debug("reusing Reader");
175 return reader; 184 return reader;
176 } 185 }
177 // clean up old reader 186 // clean up old reader (this shouldn't really happen)
178 logger.debug("cleaning Reader!"); 187 logger.debug("cleaning Reader!");
179 dispose(); 188 dispose();
180 } 189 }
181 this.input = input; 190 this.input = input;
182 ImageInputStream istream = null; 191 ImageInputStream istream = null;
215 /* Load an image file into the Object. */ 224 /* Load an image file into the Object. */
216 public void loadSubimage(ImageInput ii, Rectangle region, int prescale) 225 public void loadSubimage(ImageInput ii, Rectangle region, int prescale)
217 throws FileOpException { 226 throws FileOpException {
218 logger.debug("loadSubimage"); 227 logger.debug("loadSubimage");
219 try { 228 try {
220 if ((reader == null) || (imgFile != ii.getFile())) { 229 reader = getReader(ii);
221 getReader(ii);
222 }
223 // set up reader parameters 230 // set up reader parameters
224 ImageReadParam readParam = reader.getDefaultReadParam(); 231 ImageReadParam readParam = reader.getDefaultReadParam();
225 readParam.setSourceRegion(region); 232 readParam.setSourceRegion(region);
226 if (prescale > 1) { 233 if (prescale > 1) {
227 readParam.setSourceSubsampling(prescale, prescale, 0, 0); 234 readParam.setSourceSubsampling(prescale, prescale, 0, 0);
335 + scaledImg.getHeight()); 342 + scaledImg.getHeight());
336 img = scaledImg; 343 img = scaledImg;
337 } 344 }
338 345
339 public void blur(int radius) throws ImageOpException { 346 public void blur(int radius) throws ImageOpException {
340 // DEBUG
341 logger.debug("blur: " + radius); 347 logger.debug("blur: " + radius);
342 // minimum radius is 2 348 // minimum radius is 2
343 int klen = Math.max(radius, 2); 349 int klen = Math.max(radius, 2);
344 // FIXME: use constant kernels for most common sizes 350 Kernel blur = null;
345 int ksize = klen * klen; 351 if (klen < convolutionKernels.length) {
346 // kernel is constant 1/k 352 blur = convolutionKernels[klen];
347 float f = 1f / ksize; 353 } else {
348 float[] kern = new float[ksize]; 354 // calculate our own kernel
349 for (int i = 0; i < ksize; i++) { 355 int ksize = klen * klen;
350 kern[i] = f; 356 // kernel is constant 1/k
351 } 357 float f = 1f / ksize;
352 Kernel blur = new Kernel(klen, klen, kern); 358 float[] kern = new float[ksize];
359 for (int i = 0; i < ksize; ++i) {
360 kern[i] = f;
361 }
362 blur = new Kernel(klen, klen, kern);
363 }
353 // blur with convolve operation 364 // blur with convolve operation
354 ConvolveOp blurOp = new ConvolveOp(blur, ConvolveOp.EDGE_NO_OP, 365 ConvolveOp blurOp = new ConvolveOp(blur, ConvolveOp.EDGE_NO_OP,
355 renderHint); 366 renderHint);
356 BufferedImage blurredImg = null; 367 BufferedImage blurredImg = null;
357 // blur needs explicit destination image type for color *Java2D BUG* 368 // blur needs explicit destination image type for color *Java2D BUG*
413 scaleOp.filter(img, img); 424 scaleOp.filter(img, img);
414 } 425 }
415 426
416 /** 427 /**
417 * Ensures that the array f is in the right order to map the images RGB 428 * Ensures that the array f is in the right order to map the images RGB
418 * components. (not shure what happens 429 * components. (not sure what happens otherwise)
419 */ 430 */
420 public float[] rgbOrdered(float[] fa) { 431 public float[] rgbOrdered(float[] fa) {
421 /* 432 /*
422 * TODO: this is UGLY, UGLY!! 433 * TODO: this is UGLY, UGLY!!
423 */ 434 */