← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/tuxguitar/oneiric

« back to all changes in this revision

Viewing changes to src/org/herac/tuxguitar/gui/util/ImageUtils.java

  • Committer: Bazaar Package Importer
  • Author(s): Philippe Coval
  • Date: 2008-06-19 00:30:30 UTC
  • mto: (5.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20080619003030-h719szrhsngou7c6
Tags: upstream-1.0
Import upstream version 1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/herac/tuxguitar/gui/util/ImageUtils.java
1
 
package org.herac.tuxguitar.gui.util;
2
 
 
3
 
import java.awt.image.BufferedImage;
4
 
import java.awt.image.ColorModel;
5
 
import java.awt.image.DirectColorModel;
6
 
import java.awt.image.IndexColorModel;
7
 
import java.awt.image.WritableRaster;
8
 
import java.io.ByteArrayOutputStream;
9
 
import java.io.OutputStream;
10
 
 
11
 
import org.eclipse.swt.graphics.ImageData;
12
 
import org.eclipse.swt.graphics.ImageLoader;
13
 
import org.eclipse.swt.graphics.PaletteData;
14
 
import org.eclipse.swt.graphics.RGB;
15
 
 
16
 
import com.lowagie.text.BadElementException;
17
 
import com.lowagie.text.Image;
18
 
 
19
 
public class ImageUtils {
20
 
        /**
21
 
         * Escribe el ImageData en el outputStream
22
 
         * @param data
23
 
         * @param outputStream
24
 
         * @param format
25
 
         */
26
 
        public static void writeImage(ImageData data,OutputStream outputStream,int format){
27
 
                ImageLoader loader = new ImageLoader();                                         
28
 
                loader.data = new ImageData[]{data};
29
 
                loader.save(outputStream,format);                       
30
 
        }
31
 
        
32
 
        /**
33
 
         * Convierte un ImageData en un array de bytes
34
 
         * @param data
35
 
         * @param format
36
 
         * @return
37
 
         */
38
 
        public static byte[] imageToByteArray(ImageData data,int format){
39
 
                ByteArrayOutputStream out = new ByteArrayOutputStream();                                
40
 
                writeImage(data,out,format);                            
41
 
                return out.toByteArray();
42
 
        }
43
 
                
44
 
        /**
45
 
         * Crea un java.awt.image.BufferedImage a partir de un ImageData
46
 
         * @param data
47
 
         * @return
48
 
         */
49
 
        public static BufferedImage convertToAWT(ImageData data) {
50
 
                ColorModel colorModel = null;
51
 
                PaletteData palette = data.palette;
52
 
                if (palette.isDirect) {
53
 
                        colorModel = new DirectColorModel(data.depth, palette.redMask,palette.greenMask, palette.blueMask);
54
 
                        BufferedImage bufferedImage = new BufferedImage(colorModel,colorModel.createCompatibleWritableRaster(data.width,data.height), false, null);
55
 
                        WritableRaster raster = bufferedImage.getRaster();
56
 
                        int[] pixelArray = new int[3];
57
 
                        for (int y = 0; y < data.height; y++) {
58
 
                                for (int x = 0; x < data.width; x++) {
59
 
                                        int pixel = data.getPixel(x, y);
60
 
                                        RGB rgb = palette.getRGB(pixel);
61
 
                                        pixelArray[0] = rgb.red;
62
 
                                        pixelArray[1] = rgb.green;
63
 
                                        pixelArray[2] = rgb.blue;
64
 
                                        raster.setPixels(x, y, 1, 1, pixelArray);
65
 
                                }
66
 
                        }
67
 
                        return bufferedImage;
68
 
                } else {
69
 
                        RGB[] rgbs = palette.getRGBs();
70
 
                        byte[] red = new byte[rgbs.length];
71
 
                        byte[] green = new byte[rgbs.length];
72
 
                        byte[] blue = new byte[rgbs.length];
73
 
                        for (int i = 0; i < rgbs.length; i++) {
74
 
                                RGB rgb = rgbs[i];
75
 
                                red[i] = (byte) rgb.red;
76
 
                                green[i] = (byte) rgb.green;
77
 
                                blue[i] = (byte) rgb.blue;
78
 
                        }
79
 
                        if (data.transparentPixel != -1) {
80
 
                                colorModel = new IndexColorModel(data.depth, rgbs.length, red,green, blue, data.transparentPixel);
81
 
                        } else {
82
 
                                colorModel = new IndexColorModel(data.depth, rgbs.length, red,green, blue);
83
 
                        }
84
 
                        BufferedImage bufferedImage = new BufferedImage(colorModel,colorModel.createCompatibleWritableRaster(data.width,data.height), false, null);
85
 
                        WritableRaster raster = bufferedImage.getRaster();
86
 
                        int[] pixelArray = new int[1];
87
 
                        for (int y = 0; y < data.height; y++) {
88
 
                                for (int x = 0; x < data.width; x++) {
89
 
                                        int pixel = data.getPixel(x, y);
90
 
                                        pixelArray[0] = pixel;
91
 
                                        raster.setPixel(x, y, pixelArray);
92
 
                                }
93
 
                        }
94
 
                        return bufferedImage;
95
 
                }
96
 
        }       
97
 
        
98
 
        /**
99
 
         * Crea un com.lowagie.text.Image a partir de un ImageData
100
 
         * @param data
101
 
         * @return
102
 
         */
103
 
        public static Image convertToIText(ImageData data){
104
 
                try {                   
105
 
                        PaletteData palette = data.palette;
106
 
                        int width = data.width;
107
 
                        int height = data.height;
108
 
                        
109
 
                        byte bytes[] = new byte[(width * height * 3)];
110
 
                        for (int y = 0; y < height; y++) {
111
 
                                for (int x = 0; x < width; x++) {
112
 
                                        RGB rgb = palette.getRGB(data.getPixel(x, y));                                  
113
 
                                        bytes[y * (width * 3) + (x * 3)] = (byte)rgb.red;
114
 
                                        bytes[y * (width * 3) + (x * 3) + 1] = (byte)rgb.green;
115
 
                                        bytes[y * (width * 3) + (x * 3) + 2] = (byte)rgb.blue;
116
 
                                }
117
 
                        }                       
118
 
                        return Image.getInstance(width,height,3,8,bytes);
119
 
                } catch (BadElementException e) {
120
 
                        e.printStackTrace();
121
 
                }                       
122
 
                return null;
123
 
        }
124
 
        
125
 
        /**
126
 
         * Crea una mascara a partir de src.
127
 
         * 
128
 
         * @param src
129
 
         * @param alpha
130
 
         * @param none
131
 
         * @return ImageData
132
 
         */
133
 
        public static ImageData applyMask(ImageData src,RGB alpha,RGB none){
134
 
                ImageData maskData = new ImageData(src.width,src.height,1,new PaletteData(new RGB[]{ none,alpha }  ));          
135
 
                for(int x = 0; x< maskData.width; x++) {
136
 
                        for(int y = 0; y < maskData.height; y++) {
137
 
                                RGB rgb = src.palette.getRGB(src.getPixel(x, y));                               
138
 
                                if(rgb.red == alpha.red && rgb.green == alpha.green && rgb.blue == alpha.blue){
139
 
                                        maskData.setPixel(x, y, maskData.palette.getPixel(none));
140
 
                                }else{
141
 
                                        maskData.setPixel(x, y, maskData.palette.getPixel(alpha));
142
 
                                }
143
 
                        }
144
 
                }                                       
145
 
                return maskData;
146
 
        }
147
 
}