← Back to branch summary

~andreas.hoelzl/jhelioviewer/jhv-formatting

« back to all changes in this revision

Viewing changes to viewmodel/src/org/helioviewer/viewmodel/imagedata/RGBInt24ImageData.java

  • Committer: Andreas Hoelzl
  • Date: 2010-03-23 19:37:12 UTC
  • Revision ID: andreas_hoelzl_23@hotmail.com-20100323193712-wgx872c3tpo3y729
formatting changed

Show diffs side-by-side

added added

removed removed

Lines of Context:
viewmodel/src/org/helioviewer/viewmodel/imagedata/RGBInt24ImageData.java
8
8
import org.helioviewer.viewmodel.imagetransport.ImageTransport;
9
9
import org.helioviewer.viewmodel.imagetransport.Int32ImageTransport;
10
10
 
11
 
/** Representation of image data in RGB24 format.
 
11
/**
 
12
 * Representation of image data in RGB24 format.
12
13
 * 
13
 
 * <p>The image data contains three channels (red, green, blue),
14
 
 * each channel has eight bits per pixel.
 
14
 * <p>
 
15
 * The image data contains three channels (red, green, blue), each channel has
 
16
 * eight bits per pixel.
15
17
 * 
16
18
 * @author Ludwig Schmidt
17
19
 * @author Markus Langenberg
18
 
 *
 
20
 * 
19
21
 */
20
22
public class RGBInt24ImageData implements JavaBufferedImageData {
21
23
 
22
 
        private static final ImageFormat format = new RGB24ImageFormat();
 
24
    private static final ImageFormat format = new RGB24ImageFormat();
23
25
    private Int32ImageTransport imageTransport;
24
26
    private int width, height;
25
27
    private BufferedImage image = null;
26
28
 
27
 
    /** Constructor, given an array as data source.
28
 
     * 
29
 
     * <p>This constructor receives the raw data as a data source.
30
 
     * If the caller handles raw data as well, the use of this constructor
31
 
     * is recommended.
32
 
     * <p>The pixel data has to be given as a one-dimensional array containing
33
 
     * the pixel data line by line. Each array element represents one pixel.
34
 
     * 
35
 
     * @param newWidth width of the image
36
 
     * @param newHeight height of the image
37
 
     * @param newPixelData pixel data
 
29
    /**
 
30
     * Constructor, given an array as data source.
 
31
     * 
 
32
     * <p>
 
33
     * This constructor receives the raw data as a data source. If the caller
 
34
     * handles raw data as well, the use of this constructor is recommended.
 
35
     * <p>
 
36
     * The pixel data has to be given as a one-dimensional array containing the
 
37
     * pixel data line by line. Each array element represents one pixel.
 
38
     * 
 
39
     * @param newWidth
 
40
     *            width of the image
 
41
     * @param newHeight
 
42
     *            height of the image
 
43
     * @param newPixelData
 
44
     *            pixel data
38
45
     */
39
46
    public RGBInt24ImageData(int newWidth, int newHeight, int[] newPixelData) {
40
 
        width = newWidth;
 
47
        width = newWidth;
41
48
        height = newHeight;
42
49
        imageTransport = new Int32ImageTransport(newPixelData);
43
50
    }
44
51
 
45
 
    /** Constructor, given an BufferedImage as data source.
46
 
     * 
47
 
     * <p>This constructor receives a BufferedImage as data source.
48
 
     * If the caller operates on BufferedImages as well, the use of this
49
 
     * constructor is recommended.
50
 
     * 
51
 
     * @param newImage pixel data
 
52
    /**
 
53
     * Constructor, given an BufferedImage as data source.
 
54
     * 
 
55
     * <p>
 
56
     * This constructor receives a BufferedImage as data source. If the caller
 
57
     * operates on BufferedImages as well, the use of this constructor is
 
58
     * recommended.
 
59
     * 
 
60
     * @param newImage
 
61
     *            pixel data
52
62
     */
53
63
    public RGBInt24ImageData(BufferedImage newImage) {
54
 
        image = newImage;
55
 
        width = newImage.getWidth();
56
 
        height = newImage.getHeight();
57
 
        imageTransport = new Int32ImageTransport(((DataBufferInt) newImage.getRaster().getDataBuffer()).getData());
 
64
        image = newImage;
 
65
        width = newImage.getWidth();
 
66
        height = newImage.getHeight();
 
67
        imageTransport = new Int32ImageTransport(((DataBufferInt) newImage.getRaster().getDataBuffer()).getData());
58
68
    }
59
69
 
60
70
    /**
61
 
         * {@inheritDoc}
62
 
         */
63
 
        public int getHeight() {
 
71
     * {@inheritDoc}
 
72
     */
 
73
    public int getHeight() {
64
74
        return height;
65
75
    }
66
76
 
67
 
        /**
68
 
         * {@inheritDoc}
69
 
         */
70
 
        public int getWidth() {
 
77
    /**
 
78
     * {@inheritDoc}
 
79
     */
 
80
    public int getWidth() {
71
81
        return width;
72
82
    }
73
83
 
74
 
        /**
75
 
         * {@inheritDoc}
76
 
         */
77
 
        public BufferedImage getBufferedImage() {
78
 
        if(image == null) {
79
 
                image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
 
84
    /**
 
85
     * {@inheritDoc}
 
86
     */
 
87
    public BufferedImage getBufferedImage() {
 
88
        if (image == null) {
 
89
            image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
80
90
            image.setRGB(0, 0, width, height, imageTransport.getInt32PixelData(), 0, width);
81
 
        }
 
91
        }
82
92
        return image;
83
93
    }
84
94
 
85
 
        /**
86
 
         * {@inheritDoc}
87
 
         */
88
 
        public ImageFormat getImageFormat() {
 
95
    /**
 
96
     * {@inheritDoc}
 
97
     */
 
98
    public ImageFormat getImageFormat() {
89
99
        return format;
90
100
    }
91
101
 
92
 
        /**
93
 
         * {@inheritDoc}
94
 
         */
95
 
        public ImageTransport getImageTransport() {
 
102
    /**
 
103
     * {@inheritDoc}
 
104
     */
 
105
    public ImageTransport getImageTransport() {
96
106
        return imageTransport;
97
107
    }
98
108
}
99