appl/util/RasterMetaData.java

/*******************************************************************************
 * Copyright (c) 2009 Martin O. J. Schmitz.
 * 
 * This file is part of the SCHMITZM library - a collection of utility 
 * classes based on Java 1.6, focusing (not only) on Java Swing 
 * and the Geotools library.
 * 
 * The SCHMITZM project is hosted at:
 * http://wald.intevation.org/projects/schmitzm/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License (license.txt)
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * or try this link: http://www.gnu.org/licenses/lgpl.html
 * 
 * Contributors:
 *     Martin O. J. Schmitz - initial API and implementation
 *     Stefan A. Tzeggai - additional utility classes
 ******************************************************************************/
package appl.util;

import java.awt.image.DataBuffer;
import java.io.Serializable;

import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.opengis.referencing.crs.CoordinateReferenceSystem;

import schmitzm.data.WritableGrid;

/**
 * Simple immutable class that encapsulates raster metadata, 
 * especially the MetaData of a {@link WritableGrid}. 
 * Just a constructor and getters
 * on the fields.
 * 
 * <br> 
 * @see WritableGrid for details on the variable description
 *
 * @author Dominik Appl
 */
public final class RasterMetaData implements Serializable {

    int width = 0;

    int height = 0;

    int minX = 0;

    int minY = 0;

    double realWidth = 0;

    double realHeight = 0;

    int dataType = DataBuffer.TYPE_UNDEFINED;

    double x = 0.0;

    double y = 0.0;

    CoordinateReferenceSystem crs = null;


        /**
         * @return Returns the CRS of the raster
         */
        public final CoordinateReferenceSystem getCoordinateReferenceSystem() {
          return crs;
        }

        /**
         * @return Returns the height in cells
         */
        public final int getHeight() {
                return height;
        }

        /**
         * @return Returns the width in cells.
         */
        public final int getWidth() {
                return width;
        }

        /**
         * @return Returns the dataType.
         */
        public final int getDataType() {
                return dataType;
        }

        /**
         * @return Returns minX (used to indicate a start index)
         * @see WritableGrid#getMinX()
         */
        public final int getMinX() {
                return minX;
        }

        /**
         * @return Returns the minY ((used to indicate a start index)
         * @see WritableGrid#getMinY()
         */
        public final int getMinY() {
                return minY;
        }

        /**
         * @return Returns the realHeight.
         */
        public final double getRealHeight() {
                return realHeight;
        }

        /**
         * @return Returns the realWidth.
         */
        public final double getRealWidth() {
                return realWidth;
        }

        /**
         * @return Returns the (geographic) x-coordinate
         */
        public final double getX() {
                return x;
        }


        /**
         * @return Returns  the (geographic) y-coordinate
         */
        public final double getY() {
                return y;
        }

        /**
         * @param dataType the datatype
         * @param gridWidth the width of the grid (in cells)
         * @param gridHeight the height of the grid (in cells)
         * @param minX the minX (used to indicate a start index)
         * @param minY the minY (used to indicate a start index)
         * @param realWidth the real width
         * @param realHeight the real height
         * @param x the (geographic) x-coordinate
         * @param y the (geographic) y-coordinate
     * @param crs the {@link CoordinateReferenceSystem}. Use null for DefaultCRS (WGS84)
     * 
     * @see WritableGrid
         */
        public RasterMetaData(int dataType, int gridWidth, int gridHeight,
                        int minX, int minY, double x, double y, double realWidth,
                        double realHeight, CoordinateReferenceSystem crs) {
                this.width = gridWidth;
                this.height = gridHeight;
                this.minX = minX;
                this.minY = minY;
                this.realWidth = realWidth;
                this.realHeight = realHeight;
                this.dataType = dataType;
                this.x = x;
                this.y = y;
                this.crs = (crs == null) ? DefaultGeographicCRS.WGS84 : crs;
        
        }

        /**
         * Constructs a RasterMetaData Object. The values of the real height/ width 
         * are calculated out of the cellsize. The cells are assumed to be squares.
         * 
         * @param dataType the datatype
         * @param gridWidth the width of the grid (in cells)
         * @param gridHeight the height of the grid (in cells)
         * @param minX the minX (used to indicate a start index)
         * @param minY the minY (used to indicate a start index)
         * @param x the (geographic) x-coordinate
         * @param y the (geographic) y-coordinate
         * @param cellSize the real size of one cell
     * @param crs the {@link CoordinateReferenceSystem}, use null for default CRS (WGS84)
         */
        public RasterMetaData(int dataType,  int gridWidth, int gridHeight,
                        int minX, int minY, double x, double y, double cellSize, CoordinateReferenceSystem crs) {

                this(dataType, gridWidth, gridHeight, minX, minY, x, y, gridWidth
                                * cellSize, gridHeight * cellSize,crs);
        }

        /**
         * Constructs a RasterMetaDataObject out of the given Grid
         * @param w the source grid
         */
        public RasterMetaData(WritableGrid w) {
        super();
        this.width = w.getWidth();
        this.height = w.getHeight();
        this.minX = w.getMinX();
        this.minY = w.getMinY();
        this.realWidth = w.getRealWidth();
        this.realHeight = w.getRealHeight();
        this.dataType = w.getSampleType();
        this.x = w.getX();
        this.y = w.getY();
        this.crs = w.getCoordinateReferenceSystem();
    }

        /**
         * needed for serialization
         */
        private RasterMetaData() {
         this(0,0,0,0,0,0,0,0,0,null);
        }

        /**
         * @return the real width of a raster cell
         */
        public final double getCellWidth() {
                return getRealWidth() / getWidth();
        }

        /**
         * Checks if the given RasterMetaData object has the same values.
         *
         * @param rasterMeta must be a RasterMetaDataObject! Else ClassCastException will be thrown.
         * @return true, if all values are the same
         * @see java.lang.Object#equals(java.lang.Object)
         */
        @Override
        public boolean equals(Object rasterMeta) {
                RasterMetaData r = (RasterMetaData) rasterMeta;
        return (
                        this.width == r.getWidth() &&
                        this.height == r.getHeight() &&
                        this.minX == r.getMinX() &&
                        this.minY == r.getMinY() &&
                        this.realWidth == r.getRealWidth() &&
                        this.realHeight == r.getRealHeight() &&
                        this.dataType == r.getDataType() &&
                        this.x == r.getX() &&
                        this.y == r.getY()
                        );
        }

        /**
         * @return the real height of a raster cell
         */
        public final double getCellHeight() {
                return getRealHeight() / getHeight();
        }

        public final String toString() {
                return "MetaData: type:" + dataType + " wc:" + width + "hc:" + height
                                + " minX:" + minX + " minY:" + minY + " x:" + x + " y:" + y
                                + " rw:" + realWidth + " rh:" + realHeight;
        }
}
1	/*******************************************************************************
2	* Copyright (c) 2009 Martin O. J. Schmitz.
3	*
4	* This file is part of the SCHMITZM library - a collection of utility
5	* classes based on Java 1.6, focusing (not only) on Java Swing
6	* and the Geotools library.
7	*
8	* The SCHMITZM project is hosted at:
9	* http://wald.intevation.org/projects/schmitzm/
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU Lesser General Public License
13	* as published by the Free Software Foundation; either version 3
14	* of the License, or (at your option) any later version.
15	*
16	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU Lesser General Public License (license.txt)
22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
24	* or try this link: http://www.gnu.org/licenses/lgpl.html
25	*
26	* Contributors:
27	* Martin O. J. Schmitz - initial API and implementation
28	* Stefan A. Tzeggai - additional utility classes
29	******************************************************************************/
30	package appl.util;
31
32	import java.awt.image.DataBuffer;
33	import java.io.Serializable;
34
35	import org.geotools.referencing.crs.DefaultGeographicCRS;
36	import org.opengis.referencing.crs.CoordinateReferenceSystem;
37
38	import schmitzm.data.WritableGrid;
39
40	/**
41	* Simple immutable class that encapsulates raster metadata,
42	* especially the MetaData of a {@link WritableGrid}.
43	* Just a constructor and getters
44	* on the fields.
45	*
46	* <br>
47	* @see WritableGrid for details on the variable description
48	*
49	* @author Dominik Appl
50	*/
51	public final class RasterMetaData implements Serializable {
52
53	int width = 0;
54
55	int height = 0;
56
57	int minX = 0;
58
59	int minY = 0;
60
61	double realWidth = 0;
62
63	double realHeight = 0;
64
65	int dataType = DataBuffer.TYPE_UNDEFINED;
66
67	double x = 0.0;
68
69	double y = 0.0;
70
71	CoordinateReferenceSystem crs = null;
72
73
74	/**
75	* @return Returns the CRS of the raster
76	*/
77	public final CoordinateReferenceSystem getCoordinateReferenceSystem() {
78	return crs;
79	}
80
81	/**
82	* @return Returns the height in cells
83	*/
84	public final int getHeight() {
85	return height;
86	}
87
88	/**
89	* @return Returns the width in cells.
90	*/
91	public final int getWidth() {
92	return width;
93	}
94
95	/**
96	* @return Returns the dataType.
97	*/
98	public final int getDataType() {
99	return dataType;
100	}
101
102	/**
103	* @return Returns minX (used to indicate a start index)
104	* @see WritableGrid#getMinX()
105	*/
106	public final int getMinX() {
107	return minX;
108	}
109
110	/**
111	* @return Returns the minY ((used to indicate a start index)
112	* @see WritableGrid#getMinY()
113	*/
114	public final int getMinY() {
115	return minY;
116	}
117
118	/**
119	* @return Returns the realHeight.
120	*/
121	public final double getRealHeight() {
122	return realHeight;
123	}
124
125	/**
126	* @return Returns the realWidth.
127	*/
128	public final double getRealWidth() {
129	return realWidth;
130	}
131
132	/**
133	* @return Returns the (geographic) x-coordinate
134	*/
135	public final double getX() {
136	return x;
137	}
138
139
140	/**
141	* @return Returns the (geographic) y-coordinate
142	*/
143	public final double getY() {
144	return y;
145	}
146
147	/**
148	* @param dataType the datatype
149	* @param gridWidth the width of the grid (in cells)
150	* @param gridHeight the height of the grid (in cells)
151	* @param minX the minX (used to indicate a start index)
152	* @param minY the minY (used to indicate a start index)
153	* @param realWidth the real width
154	* @param realHeight the real height
155	* @param x the (geographic) x-coordinate
156	* @param y the (geographic) y-coordinate
157	* @param crs the {@link CoordinateReferenceSystem}. Use null for DefaultCRS (WGS84)
158	*
159	* @see WritableGrid
160	*/
161	public RasterMetaData(int dataType, int gridWidth, int gridHeight,
162	int minX, int minY, double x, double y, double realWidth,
163	double realHeight, CoordinateReferenceSystem crs) {
164	this.width = gridWidth;
165	this.height = gridHeight;
166	this.minX = minX;
167	this.minY = minY;
168	this.realWidth = realWidth;
169	this.realHeight = realHeight;
170	this.dataType = dataType;
171	this.x = x;
172	this.y = y;
173	this.crs = (crs == null) ? DefaultGeographicCRS.WGS84 : crs;
174
175	}
176
177	/**
178	* Constructs a RasterMetaData Object. The values of the real height/ width
179	* are calculated out of the cellsize. The cells are assumed to be squares.
180	*
181	* @param dataType the datatype
182	* @param gridWidth the width of the grid (in cells)
183	* @param gridHeight the height of the grid (in cells)
184	* @param minX the minX (used to indicate a start index)
185	* @param minY the minY (used to indicate a start index)
186	* @param x the (geographic) x-coordinate
187	* @param y the (geographic) y-coordinate
188	* @param cellSize the real size of one cell
189	* @param crs the {@link CoordinateReferenceSystem}, use null for default CRS (WGS84)
190	*/
191	public RasterMetaData(int dataType, int gridWidth, int gridHeight,
192	int minX, int minY, double x, double y, double cellSize, CoordinateReferenceSystem crs) {
193
194	this(dataType, gridWidth, gridHeight, minX, minY, x, y, gridWidth
195	* cellSize, gridHeight * cellSize,crs);
196	}
197
198	/**
199	* Constructs a RasterMetaDataObject out of the given Grid
200	* @param w the source grid
201	*/
202	public RasterMetaData(WritableGrid w) {
203	super();
204	this.width = w.getWidth();
205	this.height = w.getHeight();
206	this.minX = w.getMinX();
207	this.minY = w.getMinY();
208	this.realWidth = w.getRealWidth();
209	this.realHeight = w.getRealHeight();
210	this.dataType = w.getSampleType();
211	this.x = w.getX();
212	this.y = w.getY();
213	this.crs = w.getCoordinateReferenceSystem();
214	}
215
216	/**
217	* needed for serialization
218	*/
219	private RasterMetaData() {
220	this(0,0,0,0,0,0,0,0,0,null);
221	}
222
223	/**
224	* @return the real width of a raster cell
225	*/
226	public final double getCellWidth() {
227	return getRealWidth() / getWidth();
228	}
229
230	/**
231	* Checks if the given RasterMetaData object has the same values.
232	*
233	* @param rasterMeta must be a RasterMetaDataObject! Else ClassCastException will be thrown.
234	* @return true, if all values are the same
235	* @see java.lang.Object#equals(java.lang.Object)
236	*/
237	@Override
238	public boolean equals(Object rasterMeta) {
239	RasterMetaData r = (RasterMetaData) rasterMeta;
240	return (
241	this.width == r.getWidth() &&
242	this.height == r.getHeight() &&
243	this.minX == r.getMinX() &&
244	this.minY == r.getMinY() &&
245	this.realWidth == r.getRealWidth() &&
246	this.realHeight == r.getRealHeight() &&
247	this.dataType == r.getDataType() &&
248	this.x == r.getX() &&
249	this.y == r.getY()
250	);
251	}
252
253	/**
254	* @return the real height of a raster cell
255	*/
256	public final double getCellHeight() {
257	return getRealHeight() / getHeight();
258	}
259
260	public final String toString() {
261	return "MetaData: type:" + dataType + " wc:" + width + "hc:" + height
262	+ " minX:" + minX + " minY:" + minY + " x:" + x + " y:" + y
263	+ " rw:" + realWidth + " rh:" + realHeight;
264	}
265	}