/**
* Salva la tabla de color al fichero rmf.
*
* @param fName
* @throws IOException
*/
private void saveToRmf(String fileName) {
RasterDataset rds = null;
int limitNumberOfRequests = 20;
while (rds == null && limitNumberOfRequests > 0) {
try {
rds = rasterSE.getDataSource().getDataset(0)[0];
} catch (IndexOutOfBoundsException e) {
// En ocasiones, sobre todo con servicios remotos al pedir un
// datasource da una excepción de este tipo
// se supone que es porque hay un refresco en el mismo momento
// de la petición por lo que como es más lento de
// gestionar pilla a la capa sin datasources asociados ya que
// está reasignandolo. Si volvemos a pedirlo debe
// haberlo cargado ya.
try {
Thread.sleep(200);
} catch (InterruptedException e1) {
}
}
limitNumberOfRequests--;
}
if (rds == null) {
// RasterToolsUtil.messageBoxError("error_load_layer", this, new
// Exception("Error writing RMF. limitNumberOfRequests=" +
// limitNumberOfRequests));
return;
}
RasterFilterList rasterFilterList = rasterSE.getRenderFilterList();
// Guardamos en el RMF el valor NoData
if (Configuration.getValue("nodata_transparency_enabled", Boolean.FALSE).booleanValue()) {
try {
RasterDataset.saveObjectToRmfFile(
fileName,
NoData.class,
new NoData(
rasterSE.getNoDataValue(), rasterSE.getNoDataType(), rasterSE.getDataType()[0]));
} catch (RmfSerializerException e) {
RasterToolsUtil.messageBoxError("error_salvando_rmf", this, e);
}
}
// Guardamos en el RMF la tabla de color
ColorTableFilter colorTableFilter =
(ColorTableFilter) rasterFilterList.getByName(ColorTableFilter.names[0]);
if (colorTableFilter != null) {
GridPalette gridPalette =
new GridPalette((ColorTable) colorTableFilter.getColorTable().clone());
try {
RasterDataset.saveObjectToRmfFile(fileName, ColorTable.class, (ColorTable) gridPalette);
} catch (RmfSerializerException e) {
RasterToolsUtil.messageBoxError("error_salvando_rmf", this, e);
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.gvsig.gui.beans.imagenavigator.IClientImageNavigator#drawImage(java
* .awt.Graphics2D, double, double, double, double, double, int, int)
*/
public void drawImage(IRasterRendering rendering) {
rendering.getRenderFilterList().clear();
if (getFilterPanel().getCBShowFilters().isSelected()) {
RasterFilterList filterList = rendering.getRenderFilterList();
RasterFilterListManager stackManager = new RasterFilterListManager(filterList);
ArrayList listFilterUsed = applyFilters(rendering);
ArrayList exc = new ArrayList();
for (int i = 0; i < listFilterUsed.size(); i++) {
IRasterFilterListManager filterManager =
stackManager.getManagerByFilterClass(
((ParamStruct) listFilterUsed.get(i)).getFilterClass());
try {
filterManager.addFilter(
((ParamStruct) listFilterUsed.get(i)).getFilterClass(),
((ParamStruct) listFilterUsed.get(i)).getFilterParam());
} catch (FilterTypeException e) {
exc.add(e);
}
}
if (exc.size() != 0) {
RasterToolsUtil.messageBoxError(
PluginServices.getText(this, "error_adding_filters"), this, exc);
exc.clear();
}
}
}
/**
* Método donde se ejecutará el Thread. Este hará las acciones globales para cualquier tarea y
* llamará al método execute especifico de una tarea.
*/
public void run() {
long t1 = new java.util.Date().getTime();
try {
rasterTask = new RasterTask(this);
RasterTaskQueue.register(rasterTask);
execute();
} catch (InterruptedException e) {
if (externalActions != null) externalActions.interrupted();
Thread.currentThread().interrupt();
} catch (Exception e) {
if (progressActive) {
if (incrementableTask != null) {
getIncrementableTask().processFinalize();
incrementableTask = null;
}
}
RasterToolsUtil.messageBoxError("error_processing", this, e);
queueActions = null;
} finally {
RasterTaskQueue.remove(rasterTask);
if (progressActive) {
if (incrementableTask != null) getIncrementableTask().processFinalize();
}
if (queueActions != null) queueActions.end(this);
time = new java.util.Date().getTime() - t1;
}
}
public void setBuffer() {
IRasterDataSource dsetCopy = null;
dsetCopy = rasterSE.getDataSource().newDataset();
BufferFactory bufferFactory = new BufferFactory(dsetCopy);
if (!RasterBuffer.loadInMemory(dsetCopy)) bufferFactory.setReadOnly(true);
try {
bufferFactory.setDrawableBands(this.bands);
bufferFactory.setAreaOfInterest();
buffer = bufferFactory.getRasterBuf();
} catch (RasterDriverException e) {
RasterToolsUtil.messageBoxError(
PluginServices.getText(this, "raster_buffer_invalid_extension"), this, e);
} catch (InterruptedException e) {
RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_preview_stop"), this, e);
}
}
/** Aplica las acciones */
public void apply() {
try {
process.grayScaleProcess(previewRender, data);
} catch (FilterTypeException e) {
RasterToolsUtil.messageBoxError("error_filtering", null, e);
}
// refreshPreview();
}
/** Método de finalización del proceso. */
private void tasseledCapFinalize(String fileName) {
if (!new File(fileName).exists()) return;
try {
RasterToolsUtil.loadLayer(viewName, fileName, null);
} catch (RasterNotLoadException e) {
RasterToolsUtil.messageBoxError("error_load_layer", this, e);
}
if (externalActions != null) {
externalActions.end(fileName);
}
}
/**
* Acciones que se realizan al finalizar de crear los recortes de imagen. Este método es llamado
* por el thread TailRasterProcess al finalizar.
*/
public void loadLayerInToc(String fileName) {
if (!getFilterPanel().getNewLayerPanel().isNewLayerSelected()) return;
if (!new File(fileName).exists()) return;
try {
RasterToolsUtil.loadLayer(getFilterPanel().getViewName(), fileName, null);
} catch (RasterNotLoadException e) {
RasterToolsUtil.messageBoxError("error_cargar_capa", this, e);
}
if (filterPanel != null) filterPanel.updateNewLayerText();
}
/**
* Parámetros obligatorios al proceso:
*
* <UL>
* <LI>filename: Nombre del fichero de salida
* <LI>datawriter: Escritor de datos
* <LI>viewname: Nombre de la vista sobre la que se carga la capa al acabar el proceso
* <LI>layer: Capa de entrada para la transformación
* <LI>type: Tipo de transformación
* </UL>
*/
public void init() {
// Se toman los parametros del proceso
fileName = getStringParam("filename");
writerBufferServer = (WriterBufferServer) getParam("datawriter");
viewName = getStringParam("viewname");
bands = (int[]) getParam("bands");
rasterSE = getLayerParam("layer");
type = getIntParam("type");
// Obtenido el tipo se determina la matriz de coeficientes asociada
switch (type) {
case 0:
matrixParams = LandSatMS;
transformType = PluginServices.getText(this, "landsatMS");
if (bands.length != 4) {
this.incrementableTask.processFinalize();
RasterToolsUtil.messageBoxError(PluginServices.getText(this, "transformMS_error"), this);
exec = false;
}
break;
case 1:
matrixParams = LandSatTM;
transformType = PluginServices.getText(this, "landsatTM");
if (bands.length != 6) {
this.incrementableTask.processFinalize();
RasterToolsUtil.messageBoxError(PluginServices.getText(this, "transformTM_error"), this);
exec = false;
}
break;
case 2:
matrixParams = LandSatETM;
transformType = PluginServices.getText(this, "landsatETM");
if (bands.length != 6) {
this.incrementableTask.processFinalize();
RasterToolsUtil.messageBoxError(PluginServices.getText(this, "transformETM_error"), this);
exec = false;
}
break;
}
aTransform = rasterSE.getAffineTransform();
}
/*
* (non-Javadoc)
* @see org.gvsig.raster.IProcessActions#end(java.lang.Object)
*/
public void end(Object param) {
FLyrRasterSE grayConv = null;
try {
if (param instanceof String)
grayConv =
FLyrRasterSE.createLayer(
RasterLibrary.getOnlyLayerName(), (String) param, sourceLayer.getProjection());
} catch (LoadLayerException e) {
RasterToolsUtil.messageBoxError("error_generating_layer", null, e);
}
if (endActions != null) endActions.end(new Object[] {this, grayConv});
}
/**
* Obtiene la lista de parámetros de los filtros añadidos
*
* @param lyr Capa raster
* @return ArrayList
*/
public ArrayList getParamStruct(
FLyrRasterSE lyr, StretchPreviewRender prevRender, StretchData data) {
RasterFilterList filterList = new RasterFilterList();
filterList.setInitDataType(lyr.getDataType()[0]);
RasterFilterListManager filterManager = new RasterFilterListManager(filterList);
try {
prevRender.addPosterization(filterManager, lyr);
} catch (FilterTypeException e1) {
RasterToolsUtil.messageBoxError(RasterToolsUtil.getText(null, "noposterization"), null, e1);
}
return getParams(filterList);
}
/**
* Función de pintado del canvas. Pintamos un marco a la imagen para saber donde la movemos.
*
* <p>Para dibujar el marco alrededor del raster hacemos lo mismo que para pintar el raster
* rotado. En realidad dibujamos un cuadrado y luego le aplicamos las transformaciones necesarias
* para que se vea con la misma forma del raster al que representa.
*/
public void paintComponent(Graphics g) {
if (isMoveable && lyr != null && ptoFin != null && ptoIni != null) {
try {
ViewPort vp = grBehavior.getMapControl().getMapContext().getViewPort();
AffineTransform at = (AffineTransform) lyr.getAffineTransform().clone();
at.preConcatenate(vp.getAffineTransform());
Extent ext = lyr.getFullRasterExtent();
Point2D pt = new Point2D.Double(ext.getULX(), ext.getULY());
vp.getAffineTransform().transform(pt, pt);
at.inverseTransform(pt, pt);
Point2D size = new Point2D.Double(ext.getLRX(), ext.getLRY());
vp.getAffineTransform().transform(size, size);
at.inverseTransform(size, size);
double distX = ptoFin.getX() - ptoIni.getX();
double distY = ptoFin.getY() - ptoIni.getY();
Point2D d = new Point2D.Double(ext.getULX() + distX, ext.getULY() + distY);
vp.getAffineTransform().transform(d, d);
at.inverseTransform(d, d);
// Giramos el graphics se dibuja y se vuelve a dejar como estaba
((Graphics2D) g).transform(at);
g.setColor(rectangleColor);
AlphaComposite alpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.1f);
((Graphics2D) g).setComposite(alpha);
g.fillRect(
(int) pt.getX() + (int) d.getX(),
(int) pt.getY() + (int) d.getY(),
(int) size.getX(),
(int) size.getY());
((Graphics2D) g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
g.drawRect(
(int) pt.getX() + (int) d.getX(),
(int) pt.getY() + (int) d.getY(),
(int) size.getX(),
(int) size.getY());
((Graphics2D) g).transform(at.createInverse());
} catch (NoninvertibleTransformException e1) {
RasterToolsUtil.messageBoxError("error_transformacion1", this, e1);
}
}
}
/*
* (non-Javadoc)
*
* @see org.gvsig.raster.gui.wizards.IFileOpen#execute(java.io.File[])
*/
public Rectangle2D createLayer(File file, MapControl mapControl, CoordinateReferenceSystem crs) {
this.mapControl = mapControl;
FLyrRasterSE lyr = null;
String layerName = RasterToolsUtil.getLayerNameFromFile(file);
int nLayer = -1;
// Si hay capas en la lista la buscamos allí
if (lyrsRaster.size() != 0) {
for (int i = 0; i < lyrsRaster.size(); i++) {
if (((FLyrRasterSE) lyrsRaster.get(i)).getName().equals(layerName)) {
lyr = (FLyrRasterSE) lyrsRaster.get(i);
lyr.setCrs(crs);
nLayer = i;
}
}
}
// Si no hay capa la cargamos
if (lyr == null) {
try {
lyr = FLyrRasterSE.createLayer(layerName, file, crs);
layerActions(defaultActionLayer, lyr);
} catch (LoadLayerException e) {
RasterToolsUtil.messageBoxError("error_carga_capa", this, e);
}
}
if (lyr != null) {
boolean actionsAdded = false;
if ((nLayer >= 0) && (nLayer < actionList.size())) {
Object obj = actionList.get(nLayer);
if (obj != null && obj instanceof Integer) {
actionsAdded = true;
layerActions(((Integer) obj).intValue(), lyr);
}
}
if (!actionsAdded) layerActions(defaultActionLayer, lyr);
return lyr.getFullExtent();
}
return null;
}
/**
* Acciones que se realizan al finalizar de crear los recortes de imagen. Este método es llamado
* por el thread TailRasterProcess al finalizar.
*/
private void cutFinalize(String fileName, long milis) {
if (!new File(fileName).exists()) return;
if (viewName != null) {
if (RasterToolsUtil.messageBoxYesOrNot("cargar_toc", this)) {
try {
FLayer lyr = RasterToolsUtil.loadLayer(viewName, fileName, null);
if (lyr != null && lyr instanceof FLyrRasterSE)
((FLyrRasterSE) lyr).setRois(rasterSE.getRois());
} catch (RasterNotLoadException e) {
RasterToolsUtil.messageBoxError("error_load_layer", this, e);
}
}
}
if (showEndDialog && externalActions != null)
externalActions.end(new Object[] {fileName, new Long(milis)});
}
/** Coloca el cursor del ratón con el icono adecuado cuando entra dentro de la imagen. */
public boolean mouseMoved(MouseEvent e) throws BehaviorException {
ViewPort vp = grBehavior.getMapControl().getMapContext().getViewPort();
try {
lyr = grBehavior.getLayer();
if (lyr == null) {
setActiveTool(false);
return false;
}
Point2D pto = vp.toMapPoint(e.getX(), e.getY());
try {
if (lyr.isInside(pto)) {
grBehavior
.getMapControl()
.setCursor(
Toolkit.getDefaultToolkit()
.createCustomCursor(handCursor, new Point(16, 16), ""));
defaultCursorActive = false;
setActiveTool(true);
return true;
} else {
if (!defaultCursorActive) {
grBehavior.getMapControl().setCursor(defaultCursor);
defaultCursorActive = true;
setActiveTool(false);
return false;
}
}
} catch (HeadlessException e1) {
e1.printStackTrace();
} catch (IndexOutOfBoundsException e1) {
e1.printStackTrace();
}
} catch (ClassCastException exc) {
RasterToolsUtil.messageBoxError("error_capa_puntos", this, exc);
}
setActiveTool(false);
return false;
}
/** Que acciones se ejecutaran al haber presionado el botón aceptar o aplicar */
public void accept() {
IRasterDataSource raster = ((FLyrRasterSE) getFilterPanel().getLayer()).getDataSource();
if (raster == null) return;
String path = null;
if (!getFilterPanel().getNewLayerPanel().isOnlyViewSelected()) {
path = getFilterPanel().getNewLayerPanel().getFileSelected();
if (path == null) return;
}
// Rendering rendering = ((FLyrRasterSE)
// getFilterPanel().getLayer()).getRender();
IRasterRendering rendering = (IRasterRendering) getFilterPanel().getLayer();
// Array para guardar los filtros que se van a usar en forma de
// ParamStruct
ArrayList listFilterUsed = applyFilters(rendering);
if (filterPanel.getNewLayerPanel().isOnlyViewSelected()) {
try {
FilterProcess.addSelectedFilters(rendering.getRenderFilterList(), listFilterUsed);
((FLyrRasterSE) getFilterPanel().getLayer())
.setRenderFilterList(rendering.getRenderFilterList());
getFilterPanel().getLayer().getMapContext().invalidate();
} catch (FilterTypeException e) {
RasterToolsUtil.messageBoxError(
PluginServices.getText(this, "error_adding_filters"), this, e);
}
} else {
FilterProcess filterProcess = new FilterProcess();
filterProcess.setActions(this);
filterProcess.addParam("rendering", rendering);
filterProcess.addParam("filename", path);
filterProcess.addParam("rasterdatasource", raster);
filterProcess.addParam("layer", ((FLyrRasterSE) getFilterPanel().getLayer()));
filterProcess.addParam("listfilterused", listFilterUsed);
filterProcess.start();
}
}
/*
* (non-Javadoc)
*
* @see org.gvsig.raster.gui.wizards.IFileOpen#post(java.io.File[])
*/
public File post(File file) throws LoadLayerException {
// Si el fichero es raw lanzamos el dialogo de parámetros de raw
if (RasterUtilities.getExtensionFromFileName(file.getAbsolutePath()).equals("raw")) {
OpenRawFileDefaultView view = new OpenRawFileDefaultView(file.getAbsolutePath());
file = view.getImageFile();
}
if (file == null || file.getAbsoluteFile() == null) return null;
// Si el fichero es vrt chequeamos que sea correcto
if (RasterUtilities.getExtensionFromFileName(file.getAbsolutePath()).equals("vrt")) {
try {
checkFileVRT(file);
} catch (FileOpenVRTException e) {
RasterToolsUtil.messageBoxError(
PluginServices.getText(this, "error_abrir_fichero")
+ " "
+ file.getName()
+ "\n\n"
+ PluginServices.getText(this, "informacion_adicional")
+ ":\n\n "
+ e.getMessage(),
this,
e);
return null;
}
}
try {
FLyrRasterSE lyrRaster = null;
String lyr_name = RasterToolsUtil.getLayerNameFromFile(file);
lyrRaster = FLyrRasterSE.createLayer(lyr_name, file, null);
// Si hay que generar las overviews por el panel de preferencias
// if (Configuration.getValue("overviews_ask_before_loading",
// Boolean.FALSE).booleanValue() == true) {
// try {
// boolean generate = false;
// for (int i = 0; i < lyrRaster.getFileCount(); i++) {
// if
// (lyrRaster.getDataSource().getDataset(i)[0].getOverviewCount(0)
// == 0) {
// generate = true;
// break;
// }
// }
// if (generate) {
// if (firstTaskOverview) {
// execOverview =
// RasterToolsUtil.messageBoxYesOrNot("generar_overviews", this);
// firstTaskOverview = false;
// }
//
// if (execOverview) {
// RasterProcess process = new OverviewsProcess();
// process.setCancelable(false);
// process.addParam("layer", (FLyrRasterSE) lyrRaster);
// UniqueProcessQueue.getSingleton().add(process);
// }
// }
// } catch (Exception e) {
// // Si no se puede generar la overview no hacemos nada
// }
// }
// Mostramos el cuadro que pide la georreferenciación si la capa no
// tiene y si la opción está activa en preferencias
if (RasterModule.askCoordinates) {
if (lyrRaster.getFullExtent().getMinX() == 0
&& lyrRaster.getFullExtent().getMinY() == 0
&& lyrRaster.getFullExtent().getMaxX() == ((FLyrRasterSE) lyrRaster).getPxWidth()
&& lyrRaster.getFullExtent().getMaxY() == ((FLyrRasterSE) lyrRaster).getPxHeight()) {
if (RasterToolsUtil.messageBoxYesOrNot(
lyrRaster.getName() + "\n" + PluginServices.getText(this, "layer_without_georref"),
null)) {
GeoLocationOpeningRasterDialog gld = new GeoLocationOpeningRasterDialog(lyrRaster);
PluginServices.getMDIManager().addWindow(gld);
}
}
}
// Opciones de proyección
boolean compareProj =
Configuration.getValue("general_ask_projection", Boolean.valueOf(false)).booleanValue();
if (compareProj) compareProjections(lyrRaster);
else actionList.add(new Integer(defaultActionLayer));
lyrsRaster.add(lyrRaster);
} catch (LoadLayerException e) {
RasterToolsUtil.messageBoxError("error_carga_capa", this, e);
throw new LoadLayerException("error_carga_capa", e);
}
return super.post(file);
}
/** Tarea de recorte */
public void process() throws InterruptedException {
IRasterDataSource dsetCopy = null;
if (rasterSE != null) rasterSE.setReadingData(Thread.currentThread().toString());
try {
long t2;
long t1 = new java.util.Date().getTime();
insertLineLog(RasterToolsUtil.getText(this, "leyendo_raster"));
dsetCopy = rasterSE.getDataSource().newDataset();
BufferFactory bufferFactory = new BufferFactory(dsetCopy);
bufferFactory.setDrawableBands(drawableBands);
if (interpolationMethod != BufferInterpolation.INTERPOLATION_Undefined) {
try {
if (pValues != null) {
if (RasterBuffer.isBufferTooBig(
new double[] {pValues[0], pValues[3], pValues[2], pValues[1]},
drawableBands.length)) bufferFactory.setReadOnly(true);
bufferFactory.setAreaOfInterest(
pValues[0], pValues[3], pValues[2] - pValues[0], pValues[1] - pValues[3]);
} else if (wcValues != null) {
// if (RasterBuffer.isBufferTooBig(new double[] {
// wcValues[0], wcValues[3], wcValues[2], wcValues[1] },
// rasterSE.getCellSize(), drawableBands.length))
if (!rasterSE.isActionEnabled(IRasterLayerActions.REMOTE_ACTIONS))
bufferFactory.setReadOnly(true);
bufferFactory.setAreaOfInterest(
wcValues[0],
wcValues[1],
Math.abs(wcValues[0] - wcValues[2]),
Math.abs(wcValues[1] - wcValues[3]));
}
} catch (InvalidSetViewException e) {
RasterToolsUtil.messageBoxError(
"No se ha podido asignar la vista al inicial el proceso de recorte.", this, e);
}
buffer = bufferFactory.getRasterBuf();
insertLineLog(RasterToolsUtil.getText(this, "interpolando"));
if (buffer != null)
buffer =
((RasterBuffer) buffer)
.getAdjustedWindow(resolutionWidth, resolutionHeight, interpolationMethod);
else {
RasterToolsUtil.messageBoxError(
"El proceso de recorte ha fallado porque el buffer no contenía datos.",
this,
new NullPointerException());
return;
}
} else {
try {
if (RasterBuffer.isBufferTooBig(
new double[] {0, 0, resolutionWidth, resolutionHeight}, drawableBands.length))
bufferFactory.setReadOnly(true);
if (pValues != null)
bufferFactory.setAreaOfInterest(
pValues[0],
pValues[3],
Math.abs(pValues[2] - pValues[0]) + 1,
Math.abs(pValues[1] - pValues[3]) + 1,
resolutionWidth,
resolutionHeight);
else if (wcValues != null)
bufferFactory.setAreaOfInterest(
wcValues[0],
wcValues[1],
wcValues[2],
wcValues[3],
resolutionWidth,
resolutionHeight);
buffer = bufferFactory.getRasterBuf();
if (buffer == null) {
RasterToolsUtil.messageBoxError(
"El proceso de recorte ha fallado porque el buffer no contenía datos.",
this,
new NullPointerException());
return;
}
} catch (InvalidSetViewException e) {
RasterToolsUtil.messageBoxError(
"No se ha podido asignar la vista al inicial el proceso de recorte.", this, e);
}
}
// TODO: FUNCIONALIDAD: Poner los getWriter con la proyección del
// fichero fuente
if ((selectedRois != null) && (!bufferFactory.isReadOnly())) {
if (selectedRois.size() > 0) {
int despX = 0;
int despY = 0;
if (pValues != null) {
despX = pValues[0];
despY = pValues[1];
} else if (wcValues != null) {
despX =
(int) dsetCopy.worldToRaster(new Point2D.Double(wcValues[0], wcValues[1])).getX();
despY =
(int) dsetCopy.worldToRaster(new Point2D.Double(wcValues[0], wcValues[1])).getY();
}
drawOnlyROIs(buffer, selectedRois, despX, despY);
}
}
insertLineLog(RasterToolsUtil.getText(this, "salvando_imagen"));
String finalFileName = "";
if (oneLayerPerBand) {
long[] milis = new long[drawableBands.length];
String[] fileNames = new String[drawableBands.length];
for (int i = 0; i < drawableBands.length; i++) {
fileNames[i] = fileName + "_B" + drawableBands[i] + ".tif";
writerBufferServer.setBuffer(buffer, i);
Params p = null;
if (params == null) p = GeoRasterWriter.getWriter(fileNames[i]).getParams();
else p = params;
grw =
GeoRasterWriter.getWriter(
writerBufferServer,
fileNames[i],
1,
affineTransform,
buffer.getWidth(),
buffer.getHeight(),
buffer.getDataType(),
p,
null);
grw.setColorBandsInterpretation(new String[] {DatasetColorInterpretation.GRAY_BAND});
grw.setWkt(dsetCopy.getWktProjection());
grw.setCancellableRasterDriver(cancellableObj);
grw.dataWrite();
grw.writeClose();
saveToRmf(fileNames[i]);
t2 = new java.util.Date().getTime();
milis[i] = (t2 - t1);
t1 = new java.util.Date().getTime();
}
if (incrementableTask != null) {
incrementableTask.processFinalize();
incrementableTask = null;
}
if (viewName != null) {
if (RasterToolsUtil.messageBoxYesOrNot("cargar_toc", this)) {
try {
for (int i = 0; i < drawableBands.length; i++) {
FLayer lyr = RasterToolsUtil.loadLayer(viewName, fileNames[i], null);
if (lyr != null && lyr instanceof FLyrRasterSE)
((FLyrRasterSE) lyr).setRois(rasterSE.getRois());
}
} catch (RasterNotLoadException e) {
RasterToolsUtil.messageBoxError("error_load_layer", this, e);
}
}
}
for (int i = 0; i < drawableBands.length; i++) {
if (externalActions != null)
externalActions.end(
new Object[] {fileName + "_B" + drawableBands[i] + ".tif", new Long(milis[i])});
}
} else {
if (isUsingFile(fileName)) {
incrementableTask.hideWindow();
RasterToolsUtil.messageBoxError("error_opened_file", this);
return;
}
File f = new File(fileName);
if (f.exists()) {
f.delete();
}
f = null;
writerBufferServer.setBuffer(buffer, -1);
if (params == null) {
finalFileName = fileName + ".tif";
params = GeoRasterWriter.getWriter(finalFileName).getParams();
} else finalFileName = fileName;
grw =
GeoRasterWriter.getWriter(
writerBufferServer,
finalFileName,
buffer.getBandCount(),
affineTransform,
buffer.getWidth(),
buffer.getHeight(),
buffer.getDataType(),
params,
null);
if (colorInterp != null) grw.setColorBandsInterpretation(colorInterp.getValues());
grw.setWkt(dsetCopy.getWktProjection());
grw.setCancellableRasterDriver(cancellableObj);
grw.dataWrite();
grw.writeClose();
saveToRmf(finalFileName);
t2 = new java.util.Date().getTime();
if (incrementableTask != null) {
incrementableTask.processFinalize();
incrementableTask = null;
}
// Damos tiempo a parar el Thread del incrementable para que no
// se cuelgue la ventana
// El tiempo es como mínimo el de un bucle del run de la tarea
// incrementable
Thread.sleep(600);
cutFinalize(finalFileName, (t2 - t1));
}
} catch (NotSupportedExtensionException e) {
RasterToolsUtil.messageBoxError("error_not_suported_extension", this, e);
} catch (RasterDriverException e) {
RasterToolsUtil.messageBoxError("error_writer", this, e);
} catch (IOException e) {
RasterToolsUtil.messageBoxError("error_georasterwriter", this, e);
} finally {
if (rasterSE != null) rasterSE.setReadingData(null);
if (dsetCopy != null) dsetCopy.close();
buffer = null;
}
}
/** Proceso de calculo de la transformación tasseeledCap */
public void process() throws InterruptedException {
if (!exec) return;
setBuffer();
GridExtent layerExtent = new GridExtent(rasterSE.getFullRasterExtent(), rasterSE.getCellSize());
// TODO: Tipo salida float
rasterResult =
RasterBuffer.getBuffer(
IBuffer.TYPE_FLOAT,
layerExtent.getNX(),
layerExtent.getNY(),
matrixParams.length,
true);
// Algoritmo TasseledCap. Trasformacion
double valor = 0;
int iNX = layerExtent.getNX();
int iNY = layerExtent.getNY();
// BUFFER TYPE_BYTE
if (buffer.getDataType() == IBuffer.TYPE_BYTE) {
for (int i = 0; i < iNY; i++) {
for (int j = 0; j < iNX; j++) {
for (int k = 0; k < matrixParams.length; k++) {
for (int s = 0; s < matrixParams[0].length; s++) {
valor += (double) (buffer.getElemByte(i, j, s) & 0xff) * matrixParams[k][s];
}
rasterResult.setElem(i, j, k, (float) valor);
valor = 0;
}
}
percent = (int) (i * 100 / iNY);
}
}
// BUFFER TYPE_SHORT
if (buffer.getDataType() == IBuffer.TYPE_SHORT) {
for (int i = 0; i < iNY; i++) {
for (int j = 0; j < iNX; j++) {
for (int k = 0; k < matrixParams.length; k++) {
for (int s = 0; s < matrixParams[0].length; s++) {
valor += (double) buffer.getElemShort(i, j, s) * matrixParams[k][s];
}
rasterResult.setElem(i, j, k, (float) valor);
valor = 0;
}
}
percent = (int) (i * 100 / iNY);
}
}
// BUFFER TYPE INT
if (buffer.getDataType() == IBuffer.TYPE_INT) {
for (int i = 0; i < iNY; i++) {
for (int j = 0; j < iNX; j++) {
for (int k = 0; k < matrixParams.length; k++) {
for (int s = 0; s < matrixParams[0].length; s++) {
valor += (double) buffer.getElemInt(i, j, s) * matrixParams[k][s];
}
rasterResult.setElem(i, j, k, (float) valor);
valor = 0;
}
}
percent = (int) (i * 100 / iNY);
}
}
// BUFFER TYPE FLOAT
if (buffer.getDataType() == IBuffer.TYPE_FLOAT) {
for (int i = 0; i < iNY; i++) {
for (int j = 0; j < iNX; j++) {
for (int k = 0; k < matrixParams.length; k++) {
for (int s = 0; s < matrixParams[0].length; s++) {
valor += (double) buffer.getElemFloat(i, j, s) * matrixParams[k][s];
}
rasterResult.setElem(i, j, k, (float) valor);
valor = 0;
}
}
percent = (int) (i * 100 / iNY);
}
}
// BUFFER TYPE DOUBLE
if (buffer.getDataType() == IBuffer.TYPE_DOUBLE) {
for (int i = 0; i < iNY; i++) {
for (int j = 0; j < iNX; j++) {
for (int k = 0; k < matrixParams.length; k++) {
for (int s = 0; s < matrixParams[0].length; s++) {
valor += (double) buffer.getElemDouble(i, j, s) * matrixParams[k][s];
}
rasterResult.setElem(i, j, k, (float) valor);
valor = 0;
}
}
percent = (int) (i * 100 / iNY);
}
}
// Escritura del resultado en disco
GeoRasterWriter grw = null;
writerBufferServer = new WriterBufferServer(rasterResult);
if (fileName == null) return;
int endIndex = fileName.lastIndexOf(".");
if (endIndex < 0) endIndex = fileName.length();
try {
grw =
GeoRasterWriter.getWriter(
writerBufferServer,
fileName,
rasterResult.getBandCount(),
aTransform,
rasterResult.getWidth(),
rasterResult.getHeight(),
rasterResult.getDataType(),
GeoRasterWriter.getWriter(fileName).getParams(),
null);
grw.dataWrite();
grw.setWkt(rasterSE.getWktProjection());
grw.writeClose();
rasterResult.free();
tasseledCapFinalize(fileName);
} catch (NotSupportedExtensionException e1) {
RasterToolsUtil.messageBoxError(
PluginServices.getText(this, "error_writer_notsupportedextension"), this, e1);
} catch (RasterDriverException e1) {
e1.printStackTrace();
} catch (IOException e) {
RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_writer"), this, e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
/**
* Aqui se seleccionan que filtros se van a aplicar y se devuelven en forma de ArrayList tanto
* para el dibujado como cuando aceptan o aplican el panel.
*
* @param rendering
* @return
*/
public ArrayList applyFilters(IRasterRendering rendering) {
ArrayList listFilterUsed = new ArrayList();
RasterFilterList filterList = new RasterFilterList();
filterList.setEnv(rendering.getRenderFilterList().getEnv());
RasterFilterListManager stackManager = new RasterFilterListManager(filterList);
// Conservamos filtros no visibles ya existentes
ArrayList filtersInit = getFilterPanel().getLayerVisualStatus().getLast().getFilterStatus();
for (int i = 0; i < filtersInit.size(); i++) {
// Si es visible no hacemos nada
if (((RasterFilter) filtersInit.get(i)).isVisible()) continue;
RasterFilter obj = null;
for (int j = 0; j < stackManager.getRasterFilterList().size(); j++) {
Class classFilter = (Class) stackManager.getRasterFilterList().get(j);
try {
obj = (RasterFilter) classFilter.newInstance();
if (obj.getName().equals(((RasterFilter) filtersInit.get(i)).getName())) break;
} catch (InstantiationException e) {
RasterToolsUtil.messageBoxError("error_creando_filtro", this, e);
} catch (IllegalAccessException e) {
RasterToolsUtil.messageBoxError("error_creando_filtro", this, e);
}
}
// Si no encontramos el filtro apropiado, nos olvidamos de el
if (obj == null) continue;
// Si no es visible tenemos que conservar el filtro
try {
Params params =
(Params)
((RasterFilter) filtersInit.get(i))
.getUIParams(((RasterFilter) filtersInit.get(i)).getName())
.clone();
// Añado el parametro RenderBands a los parametros del filtro
String rgb =
rendering.getRenderBands()[0]
+ " "
+ rendering.getRenderBands()[1]
+ " "
+ rendering.getRenderBands()[2];
params.setParam("RenderBands", rgb, 0, null);
params.setParam("alphaBand", new Integer(rendering.getAlphaBandNumber()), 0, null);
ParamStruct newParam = new ParamStruct();
newParam.setFilterClass(obj.getClass());
newParam.setFilterName(((RasterFilter) filtersInit.get(i)).getName());
newParam.setFilterParam(params);
listFilterUsed.add(newParam);
} catch (CloneNotSupportedException e) {
}
}
// Metemos los filtros seleccionados en el panel
ListModel list = getFilterPanel().getMainPanel().getTreeListContainer().getListModel();
for (int i = 0; i < list.getSize(); i++) {
Hashtable hastTable = getFilterPanel().getMainPanel().getTreeListContainer().getMap();
for (int j = 0; j < paramsList.size(); j++) {
boolean active = true;
Param param = ((ParamStruct) paramsList.get(j)).getFilterParam().getParamById("enabled");
if ((param != null)
&& param.defaultValue instanceof Boolean
&& ((((Boolean) param.defaultValue).booleanValue()) == false)) active = false;
if (active) {
if (((ParamStruct) paramsList.get(j))
.getFilterName()
.equals(hastTable.get(list.getElementAt(i)))) {
try {
Params params = (Params) ((ParamStruct) paramsList.get(j)).getFilterParam().clone();
// Añado el parametro RenderBands a los parametros
// del filtro
String rgb =
rendering.getRenderBands()[0]
+ " "
+ rendering.getRenderBands()[1]
+ " "
+ rendering.getRenderBands()[2];
params.setParam("RenderBands", rgb, 0, null);
params.setParam("alphaBand", new Integer(rendering.getAlphaBandNumber()), 0, null);
ParamStruct newParam = new ParamStruct();
newParam.setFilterClass(((ParamStruct) paramsList.get(j)).getFilterClass());
newParam.setFilterName(((ParamStruct) paramsList.get(j)).getFilterName());
newParam.setFilterParam(params);
listFilterUsed.add(newParam);
} catch (CloneNotSupportedException e) {
}
}
}
}
}
return listFilterUsed;
}