Revision 4377
| trunk/applications/appgvSIG/src/com/iver/cit/gvsig/gui/Panels/PropertiesRasterDialog.java | ||
|---|---|---|
| 258 | 258 |
* Constructor de la ventana de dialogo. |
| 259 | 259 |
* @param app |
| 260 | 260 |
*/ |
| 261 |
public PropertiesRasterDialog(FLyrRaster layer, int[][] rangeR, int[][] rangeG, int[][] rangeB){
|
|
| 261 |
public PropertiesRasterDialog(FLyrRaster layer, ArrayList ranges){
|
|
| 262 | 262 |
super(); |
| 263 | 263 |
fLayer = layer; |
| 264 | 264 |
if(fLayer.getStatus()==null){
|
| ... | ... | |
| 267 | 267 |
}else |
| 268 | 268 |
rasterStatus = (StatusLayerRaster)fLayer.getStatus(); |
| 269 | 269 |
initialize(); |
| 270 |
this.setRanges(rangeR, rangeG, rangeB);
|
|
| 270 |
this.setRanges(ranges);
|
|
| 271 | 271 |
setTranslation(); |
| 272 | 272 |
} |
| 273 | 273 |
|
| ... | ... | |
| 281 | 281 |
|
| 282 | 282 |
RasterTransparencyPanel tpan = this.getTransparencyPanel(); |
| 283 | 283 |
|
| 284 |
tpan.lGreenValue.setText(PluginServices.getText(this,"Valor_verde")+":"); |
|
| 285 |
tpan.lRedValue.setText(PluginServices.getText(this,"Valor_rojo")+":"); |
|
| 286 |
tpan.lBlueValue.setText(PluginServices.getText(this,"Valor_azul")+":"); |
|
| 284 |
|
|
| 287 | 285 |
tpan.getTransparencyCheck().setText(PluginServices.getText(this,"transparencia")); |
| 288 | 286 |
tpan.getOpacityCheck().setText(PluginServices.getText(this,"opacidad")); |
| 289 |
tpan.lRange.setText(PluginServices.getText(this,"usar_rango")+": 1,3,5:8"); |
|
| 290 |
tpan.lPixelValue.setText(PluginServices.getText(this,"valor_pixel")+": 0 a 255"); |
|
| 291 |
|
|
| 287 |
|
|
| 292 | 288 |
EnhancedPanel ep = this.getEnhancedPanel(); |
| 293 | 289 |
ep.lLineal.setText(PluginServices.getText(this,"lineal_directo")); |
| 294 | 290 |
ep.lQueue.setText(PluginServices.getText(this,"recorte_colas")); |
| ... | ... | |
| 331 | 327 |
initialize(); |
| 332 | 328 |
} |
| 333 | 329 |
|
| 334 |
|
|
| 335 |
|
|
| 336 | 330 |
/** |
| 337 | 331 |
* Carga los datos del panel info. |
| 338 | 332 |
*/ |
| ... | ... | |
| 385 | 379 |
*/ |
| 386 | 380 |
public void addNumBands(int numBands){
|
| 387 | 381 |
nbands += numBands; |
| 388 |
if(this.getTransparencyPanel() != null && this.getTransparencyPanel().getTRojo().isEnabled()) |
|
| 389 |
this.getTransparencyPanel().setActiveTransparencyControl(true); |
|
| 382 |
/*if(this.getTransparencyPanel() != null && this.getTransparencyPanel().getTRojo().isEnabled())
|
|
| 383 |
this.getTransparencyPanel().setActiveTransparencyControl(true); */
|
|
| 390 | 384 |
} |
| 391 | 385 |
|
| 392 | 386 |
/** |
| ... | ... | |
| 488 | 482 |
this.currentProjection = prj; |
| 489 | 483 |
} |
| 490 | 484 |
|
| 491 |
|
|
| 492 |
|
|
| 493 | 485 |
public void closeJDialog() {
|
| 494 | 486 |
PluginServices.getMDIManager().closeView(PropertiesRasterDialog.this); |
| 495 | 487 |
} |
| ... | ... | |
| 585 | 577 |
} |
| 586 | 578 |
|
| 587 | 579 |
//TRANSPARENCIA |
| 588 |
if( this.getTransparencyPanel().getTransparencyCheck().isSelected()){
|
|
| 589 |
this.checkTransparencyValues(); |
|
| 590 |
stackManager.addTransparencyFilter( this.getRangeRed(), |
|
| 591 |
this.getRangeGreen(), |
|
| 592 |
this.getRangeBlue(), |
|
| 580 |
if( this.getTransparencyPanel().getTransparencyCheck().isSelected()){
|
|
| 581 |
stackManager.addTransparencyFilter( getTransparencyPanel().getPTranspByPixel().getEntries(), |
|
| 593 | 582 |
0x10, //Transparencia |
| 594 | 583 |
0xff, //Color Transparencia R |
| 595 | 584 |
0xff, //Color Transparencia G |
| ... | ... | |
| 854 | 843 |
this.status.restoreStatus(this); |
| 855 | 844 |
fLayer.getFMap().invalidate(); |
| 856 | 845 |
} |
| 857 |
|
|
| 858 | 846 |
|
| 859 | 847 |
/** |
| 860 | 848 |
* @see com.iver.mdiApp.ui.MDIManager.View#getViewInfo() |
| ... | ... | |
| 864 | 852 |
m_viewinfo.setTitle(PluginServices.getText(this, "propiedades_raster")); |
| 865 | 853 |
return m_viewinfo; |
| 866 | 854 |
} |
| 867 |
|
|
| 868 |
|
|
| 869 | 855 |
} |
| trunk/applications/appgvSIG/src/com/iver/cit/gvsig/gui/toc/FPopupMenu.java | ||
|---|---|---|
| 363 | 363 |
RasterFilterStackManager stackManager = null; |
| 364 | 364 |
|
| 365 | 365 |
stackManager = new RasterFilterStackManager(((FLyrRaster)lyr).getSource().getFilterStack()); |
| 366 |
|
|
| 367 |
int[][] rangeR = stackManager.getTransparecyR(); |
|
| 368 |
int[][] rangeG = stackManager.getTransparecyG(); |
|
| 369 |
int[][] rangeB = stackManager.getTransparecyB(); |
|
| 370 |
|
|
| 371 |
propsDialog = new PropertiesRasterDialog(((FLyrRaster)lyr), rangeR, rangeG, rangeB); |
|
| 366 |
|
|
| 367 |
propsDialog = new PropertiesRasterDialog(((FLyrRaster)lyr), stackManager.getTransparencyRGB()); |
|
| 372 | 368 |
|
| 373 | 369 |
int alpha = 255-((FLyrRaster)lyr).getSource().getTransparency(); |
| 374 | 370 |
|
| trunk/applications/appgvSIG/src/com/iver/cit/gvsig/gui/toolListeners/SaveRasterListener.java | ||
|---|---|---|
| 40 | 40 |
*/ |
| 41 | 41 |
package com.iver.cit.gvsig.gui.toolListeners; |
| 42 | 42 |
|
| 43 |
import java.awt.geom.Point2D; |
|
| 44 |
|
|
| 43 | 45 |
import org.cresques.ui.raster.DataInputSaveRaster; |
| 44 | 46 |
import org.cresques.ui.raster.SaveRasterDialogPanel; |
| 45 | 47 |
import org.cresques.ui.raster.SaveSetupPanel; |
| 46 | 48 |
|
| 47 | 49 |
import com.iver.andami.PluginServices; |
| 48 |
|
|
| 49 | 50 |
import com.iver.cit.gvsig.fmap.MapControl; |
| 50 | 51 |
import com.iver.cit.gvsig.fmap.ViewPort; |
| 51 | 52 |
import com.iver.cit.gvsig.fmap.layers.FLayers; |
| 52 | 53 |
import com.iver.cit.gvsig.fmap.layers.FLyrRaster; |
| 53 |
import com.iver.cit.gvsig.fmap.tools.Events.RectangleEvent; |
|
| 54 | 54 |
import com.iver.cit.gvsig.fmap.tools.SaveRasterListenerImpl; |
| 55 |
import com.iver.cit.gvsig.fmap.tools.ZoomInListenerImpl; |
|
| 56 |
|
|
| 55 |
import com.iver.cit.gvsig.fmap.tools.Events.RectangleEvent; |
|
| 57 | 56 |
import com.iver.cit.gvsig.gui.View; |
| 58 | 57 |
import com.iver.cit.gvsig.gui.Panels.SaveRasterDialog; |
| 59 | 58 |
|
| ... | ... | |
| 89 | 88 |
FLayers layers = mapCtrl.getMapContext().getLayers(); |
| 90 | 89 |
|
| 91 | 90 |
SaveRasterDialog saveRaster = new SaveRasterDialog(layers, mapCtrl); |
| 92 |
if(Math.abs(rect.getMaxY()-rect.getMinY())>10 && Math.abs(rect.getMaxX()-rect.getMinX())>10){
|
|
| 91 |
ViewPort vp = mapCtrl.getViewPort(); |
|
| 92 |
Point2D ini = vp.fromMapPoint(rect.getMinX(), rect.getMinY()); |
|
| 93 |
Point2D fin = vp.fromMapPoint(rect.getMaxX(), rect.getMaxY()); |
|
| 94 |
if(Math.abs(fin.getY()-ini.getY())>10 && Math.abs(fin.getX()-ini.getX())>10){
|
|
| 93 | 95 |
saveRaster.setProjection(((View) PluginServices.getMDIManager().getActiveView()).getProjection()); |
| 94 | 96 |
//saveRaster.setLayerList(this.layerList); |
| 95 | 97 |
DataInputSaveRaster dialog = ((SaveSetupPanel)(((SaveRasterDialogPanel)saveRaster.getContentPane()).getContentPanel())).getSaveParameters(); |
| ... | ... | |
| 102 | 104 |
dialog.getTsup_izqX().setText(String.valueOf(rect.getMinX()).substring(0,indexPoint+2)); |
| 103 | 105 |
indexPoint = String.valueOf(rect.getMinY()).indexOf('.');
|
| 104 | 106 |
dialog.getTsup_izqY().setText(String.valueOf(rect.getMaxY()).substring(0,indexPoint+2)); |
| 105 |
|
|
| 106 |
/*dialog.getTinf_derX().setText(String.valueOf(rect.getMaxX())); |
|
| 107 |
dialog.getTinf_derY().setText(String.valueOf(rect.getMaxY())); |
|
| 108 |
dialog.getTsup_izqX().setText(String.valueOf(rect.getMinX())); |
|
| 109 |
dialog.getTsup_izqY().setText(String.valueOf(rect.getMinY()));*/ |
|
| 110 |
|
|
| 107 |
|
|
| 111 | 108 |
PluginServices.getMDIManager().addView(saveRaster); |
| 112 | 109 |
} |
| 113 | 110 |
} |
| trunk/applications/appgvSIG/src/com/iver/cit/gvsig/RasterVectorialControls.java | ||
|---|---|---|
| 108 | 108 |
BandSetupPanel bandSetup = null; |
| 109 | 109 |
|
| 110 | 110 |
stackManager = new RasterFilterStackManager(((FLyrRaster)lyr).getSource().getFilterStack()); |
| 111 |
|
|
| 112 |
int[][] rangeR = stackManager.getTransparecyR(); |
|
| 113 |
int[][] rangeG = stackManager.getTransparecyG(); |
|
| 114 |
int[][] rangeB = stackManager.getTransparecyB(); |
|
| 115 |
|
|
| 116 |
propsDialog = new PropertiesRasterDialog(((FLyrRaster)lyr), rangeR, rangeG, rangeB); |
|
| 117 |
|
|
| 111 |
|
|
| 112 |
propsDialog = new PropertiesRasterDialog(((FLyrRaster)lyr), stackManager.getTransparencyRGB()); |
|
| 113 |
|
|
| 118 | 114 |
int alpha = 255-((FLyrRaster)lyr).getSource().getTransparency(); |
| 119 | 115 |
|
| 120 | 116 |
bandSetup = ((FilterRasterDialogPanel)propsDialog.getContentPane()).getBandSetup(); |
| trunk/libraries/libCq CMS for java.old/src/org/cresques/io/raster/TransparencyFilter.java | ||
|---|---|---|
| 23 | 23 |
*/ |
| 24 | 24 |
package org.cresques.io.raster; |
| 25 | 25 |
|
| 26 |
import java.io.IOException; |
|
| 27 |
import java.util.ArrayList; |
|
| 26 | 28 |
|
| 29 |
|
|
| 27 | 30 |
/** |
| 28 | 31 |
* Clase base para los filtros de transparencia en sus diferentes tipos |
| 29 | 32 |
* de datos. |
| ... | ... | |
| 32 | 35 |
*/ |
| 33 | 36 |
public abstract class TransparencyFilter extends RasterFilter {
|
| 34 | 37 |
//Par?metros del filtro |
| 35 |
protected int[][] rangesR; |
|
| 36 |
protected int[][] rangesG; |
|
| 37 |
protected int[][] rangesB; |
|
| 38 |
|
|
| 38 |
/** |
|
| 39 |
* Lista de TransparencyRange |
|
| 40 |
*/ |
|
| 41 |
protected ArrayList rangesList = null; |
|
| 42 |
|
|
| 39 | 43 |
/** |
| 40 | 44 |
* Valor de transparencia |
| 41 | 45 |
*/ |
| ... | ... | |
| 63 | 67 |
public TransparencyFilter() {
|
| 64 | 68 |
super(); |
| 65 | 69 |
} |
| 66 |
|
|
| 70 |
|
|
| 67 | 71 |
/** |
| 68 | 72 |
* Obtiene par?metros del filtro desde la tabla Hash |
| 69 | 73 |
*/ |
| 70 | 74 |
public void pre() {
|
| 71 | 75 |
//Obtenci?n de par?metros comunes a todos |
| 72 |
this.rangesR = (int[][]) params.get("red");
|
|
| 73 |
this.rangesG = (int[][]) params.get("green");
|
|
| 74 |
this.rangesB = (int[][]) params.get("blue");
|
|
| 75 |
this.alpha = ((Integer) params.get("alpha")).intValue();
|
|
| 76 |
this.transparencyColorRed = ((Integer) params.get("transparencyRed")).intValue();
|
|
| 77 |
this.transparencyColorGreen = ((Integer) params.get("transparencyGreen")).intValue();
|
|
| 78 |
this.transparencyColorBlue = ((Integer) params.get("transparencyBlue")).intValue();
|
|
| 76 |
rangesList = (ArrayList)params.get("rangesList");
|
|
| 77 |
/*for(int i=0;i<rangesList.size();i++)
|
|
| 78 |
((TransparencyRange)rangesList.get(i)).show();*/
|
|
| 79 |
alpha = ((Integer) params.get("alpha")).intValue();
|
|
| 80 |
transparencyColorRed = ((Integer) params.get("transparencyRed")).intValue();
|
|
| 81 |
transparencyColorGreen = ((Integer) params.get("transparencyGreen")).intValue();
|
|
| 82 |
transparencyColorBlue = ((Integer) params.get("transparencyBlue")).intValue();
|
|
| 79 | 83 |
} |
| 80 |
|
|
| 81 |
/** |
|
| 82 |
* Para dos intervalos dados, devuelve true si el intervalo B est? dentro del A y |
|
| 83 |
* false si no lo est? |
|
| 84 |
* @param intervalA intervalo A |
|
| 85 |
* @param intervalB intervalo B |
|
| 86 |
* @return true si el intervalo B est? dentro del A y false si no lo est? |
|
| 87 |
*/ |
|
| 88 |
private boolean compareIntervals(int[][] intervalA, int[][] intervalB) {
|
|
| 89 |
if ((intervalA != null) && (intervalB != null)) {
|
|
| 90 |
boolean equalInterval = false; |
|
| 91 |
|
|
| 92 |
for (int i = 0; i < intervalB.length; i++) {
|
|
| 93 |
for (int j = 0; j < intervalA.length; j++) {
|
|
| 94 |
if ((intervalB[i][0] >= intervalA[i][0]) && |
|
| 95 |
(intervalB[i][1] <= intervalA[i][1])) {
|
|
| 96 |
equalInterval = true; |
|
| 97 |
|
|
| 98 |
break; |
|
| 99 |
} |
|
| 100 |
} |
|
| 101 |
|
|
| 102 |
if (!equalInterval) {
|
|
| 103 |
return false; |
|
| 104 |
} |
|
| 105 |
} |
|
| 106 |
|
|
| 107 |
return true; |
|
| 108 |
} |
|
| 109 |
|
|
| 110 |
if ((intervalA == null) && (intervalB == null)) {
|
|
| 111 |
return true; |
|
| 112 |
} |
|
| 113 |
|
|
| 114 |
return false; |
|
| 115 |
} |
|
| 116 |
|
|
| 117 |
/** |
|
| 118 |
* Devuelve true si el filtro pasado por par?metro es equivalente a este |
|
| 119 |
* y false si no lo es. |
|
| 120 |
* @param filter Filtro a comparar |
|
| 121 |
* @return true si son equivalentes y false si no lo son |
|
| 122 |
*/ |
|
| 123 |
public boolean isEquivalent(TransparencyFilter filter) {
|
|
| 124 |
if ((alpha != filter.alpha) || |
|
| 125 |
(transparencyColorRed != filter.transparencyColorRed) || |
|
| 126 |
(transparencyColorGreen != filter.transparencyColorGreen) || |
|
| 127 |
(transparencyColorBlue != filter.transparencyColorBlue)) {
|
|
| 128 |
return false; |
|
| 129 |
} |
|
| 130 |
|
|
| 131 |
boolean equalRange = false; |
|
| 132 |
equalRange = compareIntervals((int[][]) params.get("red"),
|
|
| 133 |
(int[][]) filter.params.get("red"));
|
|
| 134 |
|
|
| 135 |
if (!equalRange) {
|
|
| 136 |
return false; |
|
| 137 |
} |
|
| 138 |
|
|
| 139 |
equalRange = false; |
|
| 140 |
equalRange = compareIntervals((int[][]) params.get("green"),
|
|
| 141 |
(int[][]) filter.params.get("green"));
|
|
| 142 |
|
|
| 143 |
if (!equalRange) {
|
|
| 144 |
return false; |
|
| 145 |
} |
|
| 146 |
|
|
| 147 |
equalRange = false; |
|
| 148 |
equalRange = compareIntervals((int[][]) params.get("blue"),
|
|
| 149 |
(int[][]) filter.params.get("blue"));
|
|
| 150 |
|
|
| 151 |
if (!equalRange) {
|
|
| 152 |
return false; |
|
| 153 |
} |
|
| 154 |
|
|
| 155 |
return true; |
|
| 156 |
} |
|
| 157 |
|
|
| 158 |
/** |
|
| 159 |
* Obtiene los rangos de transparencia en la banda del rojo |
|
| 160 |
* @return rangos de transparencia en la banda del rojo |
|
| 161 |
*/ |
|
| 162 |
public int[][] getRangeR() {
|
|
| 163 |
return this.rangesR; |
|
| 164 |
} |
|
| 165 |
|
|
| 166 |
/** |
|
| 167 |
* Obtiene los rangos de transparencia en la banda del verde |
|
| 168 |
* @return rangos de transparencia en la banda del verde |
|
| 169 |
*/ |
|
| 170 |
public int[][] getRangeG() {
|
|
| 171 |
return this.rangesG; |
|
| 172 |
} |
|
| 173 |
|
|
| 174 |
/** |
|
| 175 |
* Obtiene los rangos de transparencia en la banda del azul |
|
| 176 |
* @return rangos de transparencia en la banda del azul |
|
| 177 |
*/ |
|
| 178 |
public int[][] getRangeB() {
|
|
| 179 |
return this.rangesB; |
|
| 180 |
} |
|
| 181 | 84 |
} |
| trunk/libraries/libCq CMS for java.old/src/org/cresques/io/raster/TransparencyImageFilter.java | ||
|---|---|---|
| 53 | 53 |
} |
| 54 | 54 |
|
| 55 | 55 |
/** |
| 56 |
* Dado un pixel y un rango, asigna ese pixel al color de transparencia por |
|
| 57 |
* defecto si el pixel en una banda determinada est? en el rango definido. |
|
| 58 |
* @param range rango |
|
| 56 |
* Asigna al pixel pasado como par?metro como transparente con |
|
| 57 |
* el color de transparencia que est? seleccionado |
|
| 58 |
* @param px Pixel a asignarle transparencia |
|
| 59 |
*/ |
|
| 60 |
private void setPixelTransparent(int[] px){
|
|
| 61 |
px[0] = this.alpha; |
|
| 62 |
px[1] = this.transparencyColorRed; |
|
| 63 |
px[2] = this.transparencyColorGreen; |
|
| 64 |
px[3] = this.transparencyColorBlue; |
|
| 65 |
} |
|
| 66 |
|
|
| 67 |
/** |
|
| 68 |
* @param range rango |
|
| 59 | 69 |
* @param banda banda |
| 60 |
* @param px pixel
|
|
| 70 |
* @param px pixel |
|
| 61 | 71 |
*/ |
| 62 |
private void processRange(int[][] range, int banda, int[] px) {
|
|
| 63 |
for (int i = 0; i < range.length; i++) {
|
|
| 64 |
if (((px[banda] >= range[i][0]) && (px[banda] <= range[i][1]))) {
|
|
| 65 |
px[0] = this.alpha; |
|
| 66 |
px[1] = this.transparencyColorRed; |
|
| 67 |
px[2] = this.transparencyColorGreen; |
|
| 68 |
px[3] = this.transparencyColorBlue; |
|
| 69 |
} |
|
| 70 |
} |
|
| 72 |
private void processRange(int[] px) {
|
|
| 73 |
for (int i = 0; i < rangesList.size(); i++) {
|
|
| 74 |
TransparencyRange tr = ((TransparencyRange)rangesList.get(i)); |
|
| 75 |
|
|
| 76 |
if(tr.isAnd()){
|
|
| 77 |
if(tr.getRed() != null) |
|
| 78 |
if (px[1] < tr.getRed()[0] || px[1] > tr.getRed()[1]) |
|
| 79 |
continue; |
|
| 80 |
if(tr.getGreen() != null) |
|
| 81 |
if (px[2] < tr.getGreen()[0] || px[2] > tr.getGreen()[1]) |
|
| 82 |
continue; |
|
| 83 |
if(tr.getBlue() != null) |
|
| 84 |
if (px[3] < tr.getBlue()[0] || px[3] > tr.getBlue()[1]) |
|
| 85 |
continue; |
|
| 86 |
if(tr.getRed() != null || tr.getGreen() != null || tr.getBlue() != null) |
|
| 87 |
setPixelTransparent(px); |
|
| 88 |
|
|
| 89 |
}else{
|
|
| 90 |
if(tr.getRed() != null){
|
|
| 91 |
if (px[1] >= tr.getRed()[0] && px[1] <= tr.getRed()[1]){
|
|
| 92 |
setPixelTransparent(px); |
|
| 93 |
continue; |
|
| 94 |
} |
|
| 95 |
} |
|
| 96 |
if(tr.getGreen() != null){
|
|
| 97 |
if (px[2] >= tr.getGreen()[0] && px[2] <= tr.getGreen()[1]){
|
|
| 98 |
setPixelTransparent(px); |
|
| 99 |
continue; |
|
| 100 |
} |
|
| 101 |
} |
|
| 102 |
if(tr.getBlue() != null){
|
|
| 103 |
if (px[3] >= tr.getBlue()[0] && px[3] <= tr.getBlue()[1]){
|
|
| 104 |
setPixelTransparent(px); |
|
| 105 |
continue; |
|
| 106 |
} |
|
| 107 |
} |
|
| 108 |
} |
|
| 109 |
} |
|
| 110 |
|
|
| 71 | 111 |
} |
| 72 |
|
|
| 112 |
|
|
| 73 | 113 |
/* (non-Javadoc) |
| 74 | 114 |
* @see org.cresques.io.raster.IRasterFilter#process(int, int) |
| 75 | 115 |
*/ |
| ... | ... | |
| 80 | 120 |
(pt & 0x00ff00) >> 8, (pt & 0x0000ff) |
| 81 | 121 |
}; |
| 82 | 122 |
|
| 83 |
if (rangesR != null) {
|
|
| 84 |
processRange(rangesR, 1, px4); |
|
| 85 |
} |
|
| 86 |
|
|
| 87 |
if (rangesG != null) {
|
|
| 88 |
processRange(rangesG, 2, px4); |
|
| 89 |
} |
|
| 90 |
|
|
| 91 |
if (rangesB != null) {
|
|
| 92 |
processRange(rangesB, 3, px4); |
|
| 93 |
} |
|
| 94 |
|
|
| 123 |
processRange(px4); |
|
| 124 |
|
|
| 95 | 125 |
((BufferedImage) image).setRGB(x, y, |
| 96 | 126 |
(((px4[0] << 24) & 0xff000000) | |
| 97 | 127 |
((px4[1] << 16) & 0x00ff0000) | |
| trunk/libraries/libCq CMS for java.old/src/org/cresques/io/raster/TransparencyRange.java | ||
|---|---|---|
| 1 |
/* |
|
| 2 |
* Cresques Mapping Suite. Graphic Library for constructing mapping applications. |
|
| 3 |
* |
|
| 4 |
* Copyright (C) 2004-5. |
|
| 5 |
* |
|
| 6 |
* This program is free software; you can redistribute it and/or |
|
| 7 |
* modify it under the terms of the GNU General Public License |
|
| 8 |
* as published by the Free Software Foundation; either version 2 |
|
| 9 |
* of the License, or (at your option) any later version. |
|
| 10 |
* |
|
| 11 |
* This program is distributed in the hope that it will be useful, |
|
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
| 14 |
* GNU General Public License for more details. |
|
| 15 |
* |
|
| 16 |
* You should have received a copy of the GNU General Public License |
|
| 17 |
* along with this program; if not, write to the Free Software |
|
| 18 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA. |
|
| 19 |
* |
|
| 20 |
* For more information, contact: |
|
| 21 |
* |
|
| 22 |
* cresques@gmail.com |
|
| 23 |
*/ |
|
| 24 |
package org.cresques.io.raster; |
|
| 25 |
|
|
| 26 |
import java.io.IOException; |
|
| 27 |
|
|
| 28 |
/** |
|
| 29 |
* Clase que representa a un conjunto de pixeles con |
|
| 30 |
* transparencia. Incluye los rangos de transparencia para cada banda, |
|
| 31 |
* la cadena que va en la lista y la operaci?n que se realiza entre |
|
| 32 |
* ellos. Un And significa que ser?n transparentes todos los pixeles |
|
| 33 |
* que cumplan con R con G y con B. Un Or significar? que tendr?n transparencia |
|
| 34 |
* todos los pixeles que cumplan con R con G o con B. |
|
| 35 |
* @author Nacho Brodin (brodin_ign@gva.es) |
|
| 36 |
* |
|
| 37 |
*/ |
|
| 38 |
public class TransparencyRange{
|
|
| 39 |
private String strEntry = null; |
|
| 40 |
private int[] red = null; |
|
| 41 |
private int[] green = null; |
|
| 42 |
private int[] blue = null; |
|
| 43 |
private boolean and = true; |
|
| 44 |
|
|
| 45 |
/** |
|
| 46 |
* Obtiene la operaci?n utilizada |
|
| 47 |
* @param and Si es true significa que se usa un AND y false implica |
|
| 48 |
* que se usa un OR |
|
| 49 |
*/ |
|
| 50 |
public boolean isAnd() {
|
|
| 51 |
return and; |
|
| 52 |
} |
|
| 53 |
|
|
| 54 |
/** |
|
| 55 |
* Asigna la operaci?n AND como la utilizada |
|
| 56 |
* @param and booleano que si est? a true significa que el la operaci?n |
|
| 57 |
* AND es la utilizada como operaci?n. |
|
| 58 |
*/ |
|
| 59 |
public void setAnd(boolean and) {
|
|
| 60 |
this.and = and; |
|
| 61 |
} |
|
| 62 |
|
|
| 63 |
/** |
|
| 64 |
* Obtiene el intervalo de valores correspondiente a la banda del azul |
|
| 65 |
* @return Array bidimensional de enteros correspondiente a la banda del azul |
|
| 66 |
*/ |
|
| 67 |
public int[] getBlue() {
|
|
| 68 |
return blue; |
|
| 69 |
} |
|
| 70 |
|
|
| 71 |
/** |
|
| 72 |
* Asigna el intervalo de valores correspondiente a la banda del azul |
|
| 73 |
* @param blue Array bidimensional de enteros correspondiente a la banda del azul |
|
| 74 |
*/ |
|
| 75 |
public void setBlue(int[] blue) {
|
|
| 76 |
this.blue = blue; |
|
| 77 |
} |
|
| 78 |
|
|
| 79 |
/** |
|
| 80 |
* Obtiene el intervalo de valores correspondiente a la banda del verde |
|
| 81 |
* @return Array bidimensional de enteros correspondiente a la banda del verde |
|
| 82 |
*/ |
|
| 83 |
public int[] getGreen() {
|
|
| 84 |
return green; |
|
| 85 |
} |
|
| 86 |
|
|
| 87 |
/** |
|
| 88 |
* Asigna el intervalo de valores correspondiente a la banda del verde |
|
| 89 |
* @param green Array bidimensional de enteros correspondiente a la banda del verde |
|
| 90 |
*/ |
|
| 91 |
public void setGreen(int[] green) {
|
|
| 92 |
this.green = green; |
|
| 93 |
} |
|
| 94 |
|
|
| 95 |
/** |
|
| 96 |
* Obtiene el intervalo de valores correspondiente a la banda del rojo |
|
| 97 |
* @return Array bidimensional de enteros correspondiente a la banda del rojo |
|
| 98 |
*/ |
|
| 99 |
public int[] getRed() {
|
|
| 100 |
return red; |
|
| 101 |
} |
|
| 102 |
|
|
| 103 |
/** |
|
| 104 |
* Asigna el intervalo de valores correspondiente a la banda del rojo |
|
| 105 |
* @param red Array bidimensional de enteros correspondiente a la banda del rojo |
|
| 106 |
*/ |
|
| 107 |
public void setRed(int[] red) {
|
|
| 108 |
this.red = red; |
|
| 109 |
} |
|
| 110 |
|
|
| 111 |
/** |
|
| 112 |
* Obtiene la cadena que representa una entrada en la tabla. |
|
| 113 |
* @return Cadena que representa una entrada en la tabla |
|
| 114 |
*/ |
|
| 115 |
public String getStrEntry() {
|
|
| 116 |
return strEntry; |
|
| 117 |
} |
|
| 118 |
|
|
| 119 |
/** |
|
| 120 |
* Asigna la cadena que representa una entrada en la tabla. |
|
| 121 |
* @param strEntry Cadena que representa una entrada en la tabla. |
|
| 122 |
*/ |
|
| 123 |
public void setStrEntry(String strEntry) {
|
|
| 124 |
this.strEntry = strEntry; |
|
| 125 |
} |
|
| 126 |
|
|
| 127 |
|
|
| 128 |
/** |
|
| 129 |
* Esta funci?n valida la cadena de entrada por medio de una m?quina de estados. Valida las |
|
| 130 |
* siguientes posibilidades en la cadena de entrada: |
|
| 131 |
* <LI> |
|
| 132 |
* <UL>(valor_rojo) & (Valor_verde) & (Valor_azul)</UL> |
|
| 133 |
* <UL>(valor_rojo) | (Valor_verde) | (Valor_azul)</UL> |
|
| 134 |
* </LI> |
|
| 135 |
* Despues de la validaci?n parsea el contenido y carga los par?metros r,g,b con los |
|
| 136 |
* intervalos de valores. Estos par?metros deben ser pasados como arrays de enteros de |
|
| 137 |
* dos elementos. |
|
| 138 |
* @param values |
|
| 139 |
* @param r Intervalo de rojo |
|
| 140 |
* @param g Intervalo de verde |
|
| 141 |
* @param b Intervalo de azul |
|
| 142 |
* @return Devuelve true si la operaci?n usada en los intervalos es un AND y false si es un OR |
|
| 143 |
*/ |
|
| 144 |
public static boolean stringToInterval(String values, int[] r, int[] g, int[] b) throws IOException {
|
|
| 145 |
int status = 0; |
|
| 146 |
int countAnd = 0, countOr = 0; |
|
| 147 |
boolean and = true; |
|
| 148 |
for(int i=0;i<values.length();i++){
|
|
| 149 |
char c = values.charAt(i); |
|
| 150 |
switch(status){
|
|
| 151 |
case 0: if(c == '(') status = 2;
|
|
| 152 |
else if(c == ' ') status = 0; |
|
| 153 |
else status = 1; |
|
| 154 |
break; |
|
| 155 |
case 1: throw new IOException("Error en la cadena de entrada "+status);
|
|
| 156 |
case 2: if (c >= 48 && c <= 57) status = 3; |
|
| 157 |
else if(c == ')') status = 6; |
|
| 158 |
else status = 1; |
|
| 159 |
break; |
|
| 160 |
case 3: if (c >= 48 && c <= 57) status = 3; |
|
| 161 |
else if(c == ')') status = 6; |
|
| 162 |
else if(c == ':') status = 4; |
|
| 163 |
else status = 1; |
|
| 164 |
break; |
|
| 165 |
case 4: if (c >= 48 && c <= 57) status = 5; |
|
| 166 |
else status = 1; |
|
| 167 |
break; |
|
| 168 |
case 5: if (c >= 48 && c <= 57) status = 5; |
|
| 169 |
else if(c == ')') status = 6; |
|
| 170 |
else status = 1; |
|
| 171 |
break; |
|
| 172 |
case 6: if(c == '&'){
|
|
| 173 |
status = 0; |
|
| 174 |
countAnd++; |
|
| 175 |
}else if(c == '|'){
|
|
| 176 |
status = 0; |
|
| 177 |
countOr++; |
|
| 178 |
}else if(c == ' ') |
|
| 179 |
status = 6; |
|
| 180 |
else |
|
| 181 |
status = 1; |
|
| 182 |
} |
|
| 183 |
|
|
| 184 |
} |
|
| 185 |
|
|
| 186 |
//Si el analisis es correcto parseamos |
|
| 187 |
if(status == 6 && ((countAnd == 2 && countOr == 0) || |
|
| 188 |
(countAnd == 0 && countOr == 2)) ){
|
|
| 189 |
String[] s = values.split(" & ");
|
|
| 190 |
if(s.length < 3){
|
|
| 191 |
s = values.split(" \\| ");
|
|
| 192 |
and = false; |
|
| 193 |
} |
|
| 194 |
|
|
| 195 |
String inter = s[0].substring(1, s[0].length() - 1); |
|
| 196 |
String[] val = inter.split(":");
|
|
| 197 |
try{
|
|
| 198 |
r[0] = Integer.parseInt(val[0]); |
|
| 199 |
if(val.length == 2) |
|
| 200 |
r[1] = Integer.parseInt(val[1]); |
|
| 201 |
else |
|
| 202 |
r[1] = Integer.parseInt(val[0]); |
|
| 203 |
}catch(NumberFormatException e){
|
|
| 204 |
r [0] = -1;r [1] = -1; |
|
| 205 |
} |
|
| 206 |
|
|
| 207 |
|
|
| 208 |
|
|
| 209 |
inter = s[1].substring(1, s[1].length() - 1); |
|
| 210 |
val = inter.split(":");
|
|
| 211 |
try{
|
|
| 212 |
g[0] = Integer.parseInt(val[0]); |
|
| 213 |
if(val.length == 2) |
|
| 214 |
g[1] = Integer.parseInt(val[1]); |
|
| 215 |
else |
|
| 216 |
g[1] = Integer.parseInt(val[0]); |
|
| 217 |
}catch(NumberFormatException e){
|
|
| 218 |
g[0] = -1;g[1] = -1; |
|
| 219 |
} |
|
| 220 |
|
|
| 221 |
|
|
| 222 |
inter = s[2].substring(1, s[2].length() - 1); |
|
| 223 |
val = inter.split(":");
|
|
| 224 |
try{
|
|
| 225 |
b[0] = Integer.parseInt(val[0]); |
|
| 226 |
if(val.length == 2) |
|
| 227 |
b[1] = Integer.parseInt(val[1]); |
|
| 228 |
else |
|
| 229 |
b[1] = Integer.parseInt(val[0]); |
|
| 230 |
}catch(NumberFormatException e){
|
|
| 231 |
b [0] = -1;b [1] = -1; |
|
| 232 |
} |
|
| 233 |
}else |
|
| 234 |
throw new IOException("Error en la cadena de entrada ");
|
|
| 235 |
|
|
| 236 |
return and; |
|
| 237 |
} |
|
| 238 |
|
|
| 239 |
public void show(){
|
|
| 240 |
if(getRed() != null) |
|
| 241 |
System.out.println(getRed()[0]+" "+getRed()[1]); |
|
| 242 |
if(getGreen() != null) |
|
| 243 |
System.out.println(getGreen()[0]+" "+getGreen()[1]); |
|
| 244 |
if(getBlue() != null) |
|
| 245 |
System.out.println(getBlue()[0]+" "+getBlue()[1]); |
|
| 246 |
System.out.println(isAnd()); |
|
| 247 |
System.out.println(getStrEntry()); |
|
| 248 |
System.out.println("--------------------");
|
|
| 249 |
} |
|
| 250 |
} |
|
| 0 | 251 | |
| trunk/libraries/libCq CMS for java.old/src/org/cresques/io/raster/RasterFilterStackManager.java | ||
|---|---|---|
| 23 | 23 |
*/ |
| 24 | 24 |
package org.cresques.io.raster; |
| 25 | 25 |
|
| 26 |
import java.io.IOException; |
|
| 26 | 27 |
import java.lang.reflect.Constructor; |
| 27 | 28 |
import java.util.ArrayList; |
| 28 | 29 |
import java.util.Hashtable; |
| ... | ... | |
| 128 | 129 |
* @param transparencyGreen Color en la banda del verde de la transparencia |
| 129 | 130 |
* @param transparencyBlue Color en la banda del azul de la transparencia |
| 130 | 131 |
*/ |
| 131 |
public void addTransparencyFilter(int[][] red, int[][] green, int[][] blue,
|
|
| 132 |
public void addTransparencyFilter(ArrayList rangesList,
|
|
| 132 | 133 |
int alpha, int transparencyRed, |
| 133 | 134 |
int transparencyGreen, |
| 134 | 135 |
int transparencyBlue) {
|
| ... | ... | |
| 146 | 147 |
} |
| 147 | 148 |
|
| 148 | 149 |
if(filtro != null){
|
| 149 |
if (red != null) {
|
|
| 150 |
filtro.addParam("red", red);
|
|
| 151 |
} |
|
| 152 |
|
|
| 153 |
if (green != null) {
|
|
| 154 |
filtro.addParam("green", green);
|
|
| 155 |
} |
|
| 156 |
|
|
| 157 |
if (blue != null) {
|
|
| 158 |
filtro.addParam("blue", blue);
|
|
| 159 |
} |
|
| 160 |
|
|
| 150 |
filtro.addParam("rangesList", rangesList);
|
|
| 161 | 151 |
filtro.addParam("alpha", new Integer(alpha));
|
| 162 | 152 |
filtro.addParam("transparencyRed", new Integer(transparencyRed));
|
| 163 | 153 |
filtro.addParam("transparencyGreen", new Integer(transparencyGreen));
|
| ... | ... | |
| 198 | 188 |
} |
| 199 | 189 |
|
| 200 | 190 |
/** |
| 201 |
* Obtiene el rango de rojo del filtro de transparencia de la pila
|
|
| 202 |
* @return rango de rojo
|
|
| 191 |
* Obtiene la lista de rangos del filtro de transparencia de la pila
|
|
| 192 |
* @return ArrayList con la lista de rangos. Cada elemento es un objeto TransparencyRange
|
|
| 203 | 193 |
*/ |
| 204 |
public int[][] getTransparecyR() {
|
|
| 205 |
for (int i = 0; i < filterStack.lenght(); i++) {
|
|
| 194 |
public ArrayList getTransparencyRGB(){
|
|
| 195 |
for (int i = 0; i < filterStack.lenght(); i++) {
|
|
| 206 | 196 |
if (filterStack.get(i) instanceof TransparencyImageFilter || |
| 207 | 197 |
filterStack.get(i) instanceof TransparencyShortFilter) {
|
| 208 |
return ((TransparencyFilter) filterStack.get(i)).rangesR;
|
|
| 198 |
return ((TransparencyFilter) filterStack.get(i)).rangesList;
|
|
| 209 | 199 |
} |
| 210 | 200 |
} |
| 211 |
|
|
| 212 | 201 |
return null; |
| 213 | 202 |
} |
| 214 |
|
|
| 203 |
|
|
| 215 | 204 |
/** |
| 216 |
* Obtiene el rango de verde del filtro de transparencia de la pila |
|
| 217 |
* @return rango de verde |
|
| 218 |
*/ |
|
| 219 |
public int[][] getTransparecyG() {
|
|
| 220 |
for (int i = 0; i < filterStack.lenght(); i++) {
|
|
| 221 |
if (filterStack.get(i) instanceof TransparencyImageFilter || |
|
| 222 |
filterStack.get(i) instanceof TransparencyShortFilter) {
|
|
| 223 |
return ((TransparencyFilter) filterStack.get(i)).rangesG; |
|
| 224 |
} |
|
| 225 |
} |
|
| 226 |
|
|
| 227 |
return null; |
|
| 228 |
} |
|
| 229 |
|
|
| 230 |
/** |
|
| 231 |
* Obtiene el rango de azul del filtro de transparencia de la pila |
|
| 232 |
* @return rango de azul |
|
| 233 |
*/ |
|
| 234 |
public int[][] getTransparecyB() {
|
|
| 235 |
for (int i = 0; i < filterStack.lenght(); i++) {
|
|
| 236 |
if (filterStack.get(i) instanceof TransparencyImageFilter || |
|
| 237 |
filterStack.get(i) instanceof TransparencyShortFilter) {
|
|
| 238 |
return ((TransparencyFilter) filterStack.get(i)).rangesB; |
|
| 239 |
} |
|
| 240 |
} |
|
| 241 |
|
|
| 242 |
return null; |
|
| 243 |
} |
|
| 244 |
|
|
| 245 |
/** |
|
| 246 | 205 |
* A?ade un filtro de eliminado de bandas. Las pone a 0 |
| 247 | 206 |
* @param bands |
| 248 | 207 |
*/ |
| ... | ... | |
| 605 | 564 |
|
| 606 | 565 |
if (rf instanceof TransparencyFilter) {
|
| 607 | 566 |
filterList.add("filter.transparency.active=true");
|
| 608 |
filterList.add("filter.transparency.rangeR=" +
|
|
| 609 |
rangeToString(((TransparencyFilter) rf).getRangeR())); |
|
| 610 |
filterList.add("filter.transparency.rangeG=" +
|
|
| 611 |
rangeToString(((TransparencyFilter) rf).getRangeG())); |
|
| 612 |
filterList.add("filter.transparency.rangeB=" +
|
|
| 613 |
rangeToString(((TransparencyFilter) rf).getRangeB())); |
|
| 567 |
for(int j=0;j<((TransparencyFilter) rf).rangesList.size();j++) |
|
| 568 |
filterList.add("filter.transparency.transparencyRange"+j+"="+
|
|
| 569 |
((TransparencyRange)((TransparencyFilter) rf).rangesList.get(j)).getStrEntry()); |
|
| 614 | 570 |
} else if (rf instanceof LinearEnhancementFilter) {
|
| 615 | 571 |
filterList.add("filter.enhanced.active=true");
|
| 616 | 572 |
filterList.add("filter.enhanced.remove=" +
|
| ... | ... | |
| 688 | 644 |
int[][] r = null; |
| 689 | 645 |
int[][] g = null; |
| 690 | 646 |
int[][] b = null; |
| 691 |
|
|
| 647 |
|
|
| 648 |
ArrayList list = new ArrayList(); |
|
| 692 | 649 |
for (int propFilter = 0;propFilter < filters.size();propFilter++) {
|
| 693 | 650 |
String elem = (String) filters.get(propFilter); |
| 694 | 651 |
|
| 695 |
if (elem.startsWith("filter.transparency.rangeR")) {
|
|
| 652 |
//TODO: Para compatibilidad con versiones anteriores hay que hacer que a partir de esto se cree un filtro |
|
| 653 |
/*if (elem.startsWith("filter.transparency.rangeR")) {
|
|
| 696 | 654 |
r = stringToRange(getValue(elem)); |
| 697 | 655 |
filters.remove(propFilter); |
| 698 | 656 |
propFilter--; |
| ... | ... | |
| 708 | 666 |
b = stringToRange(getValue(elem)); |
| 709 | 667 |
filters.remove(propFilter); |
| 710 | 668 |
propFilter--; |
| 669 |
}*/ |
|
| 670 |
if (elem.startsWith("filter.transparency.transparencyRange")) {
|
|
| 671 |
TransparencyRange tr = new TransparencyRange(); |
|
| 672 |
String value = getValue(elem); |
|
| 673 |
tr.setStrEntry(value); |
|
| 674 |
int[] red = new int[2]; |
|
| 675 |
int[] green = new int[2]; |
|
| 676 |
int[] blue = new int[2]; |
|
| 677 |
boolean and = true; |
|
| 678 |
try{
|
|
| 679 |
and = TransparencyRange.stringToInterval(value, red, green, blue); |
|
| 680 |
if(red[0] == -1) |
|
| 681 |
red = null; |
|
| 682 |
if(green[0] == -1) |
|
| 683 |
green = null; |
|
| 684 |
if(blue[0] == -1) |
|
| 685 |
blue = null; |
|
| 686 |
}catch(IOException e){
|
|
| 687 |
e.printStackTrace(); |
|
| 688 |
} |
|
| 689 |
tr.setAnd(and); |
|
| 690 |
tr.setRed(red); |
|
| 691 |
tr.setGreen(green); |
|
| 692 |
tr.setBlue(blue); |
|
| 693 |
list.add(tr); |
|
| 694 |
filters.remove(propFilter); |
|
| 695 |
propFilter--; |
|
| 711 | 696 |
} |
| 712 | 697 |
} |
| 713 | 698 |
|
| 714 |
this.addTransparencyFilter(r, g, b, 0x10, 0xff, 0xff, 0xff); |
|
| 699 |
this.addTransparencyFilter(list, 0x10, 0xff, 0xff, 0xff); |
|
| 700 |
|
|
| 715 | 701 |
filteri = -1; |
| 716 | 702 |
} |
| 717 | 703 |
|
| trunk/libraries/libCq CMS for java.old/src/org/cresques/io/raster/TransparencyShortFilter.java | ||
|---|---|---|
| 50 | 50 |
} |
| 51 | 51 |
|
| 52 | 52 |
/** |
| 53 |
* Para un vector de rangos de una banda concreta, si el punto pasado como par?metro |
|
| 54 |
* en la banda concreta est? en el rango especificado se asigna al valor de transparencia |
|
| 55 |
* por defecto. |
|
| 56 |
* @param range |
|
| 57 |
* @param banda |
|
| 58 |
* @param px |
|
| 53 |
* Asigna al pixel pasado como par?metro como transparente con |
|
| 54 |
* el color de transparencia que est? seleccionado |
|
| 55 |
* @param px Pixel a asignarle transparencia |
|
| 59 | 56 |
*/ |
| 60 |
private void processRange(int[][] range, int banda, int[] px) {
|
|
| 61 |
for (int i = 0; i < range.length; i++) {
|
|
| 62 |
if (((px[banda] >= range[i][0]) && (px[banda] <= range[i][1]))) {
|
|
| 63 |
px[3] = this.alpha; |
|
| 64 |
px[0] = this.transparencyColorRed; |
|
| 65 |
px[1] = this.transparencyColorGreen; |
|
| 66 |
px[2] = this.transparencyColorBlue; |
|
| 67 |
} |
|
| 68 |
} |
|
| 57 |
private void setPixelTransparent(int[] px){
|
|
| 58 |
px[3] = this.alpha; |
|
| 59 |
px[0] = this.transparencyColorRed; |
|
| 60 |
px[1] = this.transparencyColorGreen; |
|
| 61 |
px[2] = this.transparencyColorBlue; |
|
| 69 | 62 |
} |
| 63 |
|
|
| 64 |
/** |
|
| 65 |
* @param range rango |
|
| 66 |
* @param banda banda |
|
| 67 |
* @param px pixel |
|
| 68 |
*/ |
|
| 69 |
private void processRange(int[] px) {
|
|
| 70 |
for (int i = 0; i < rangesList.size(); i++) {
|
|
| 71 |
TransparencyRange tr = ((TransparencyRange)rangesList.get(i)); |
|
| 70 | 72 |
|
| 73 |
if(tr.isAnd()){
|
|
| 74 |
if(tr.getRed() != null) |
|
| 75 |
if (px[0] < tr.getRed()[0] || px[0] > tr.getRed()[1]) |
|
| 76 |
continue; |
|
| 77 |
if(tr.getGreen() != null) |
|
| 78 |
if (px[1] < tr.getGreen()[0] || px[1] > tr.getGreen()[1]) |
|
| 79 |
continue; |
|
| 80 |
if(tr.getBlue() != null) |
|
| 81 |
if (px[2] < tr.getBlue()[0] || px[2] > tr.getBlue()[1]) |
|
| 82 |
continue; |
|
| 83 |
if(tr.getRed() != null || tr.getGreen() != null || tr.getBlue() != null) |
|
| 84 |
setPixelTransparent(px); |
|
| 85 |
|
|
| 86 |
}else{
|
|
| 87 |
if(tr.getRed() != null){
|
|
| 88 |
if (px[0] >= tr.getRed()[0] && px[0] <= tr.getRed()[1]){
|
|
| 89 |
setPixelTransparent(px); |
|
| 90 |
continue; |
|
| 91 |
} |
|
| 92 |
} |
|
| 93 |
if(tr.getGreen() != null){
|
|
| 94 |
if (px[1] >= tr.getGreen()[0] && px[1] <= tr.getGreen()[1]){
|
|
| 95 |
setPixelTransparent(px); |
|
| 96 |
continue; |
|
| 97 |
} |
|
| 98 |
} |
|
| 99 |
if(tr.getBlue() != null){
|
|
| 100 |
if (px[2] >= tr.getBlue()[0] && px[2] <= tr.getBlue()[1]){
|
|
| 101 |
setPixelTransparent(px); |
|
| 102 |
continue; |
|
| 103 |
} |
|
| 104 |
} |
|
| 105 |
} |
|
| 106 |
} |
|
| 107 |
|
|
| 108 |
} |
|
| 109 |
|
|
| 71 | 110 |
/* (non-Javadoc) |
| 72 | 111 |
* @see org.cresques.io.raster.IRasterFilter#process(int, int) |
| 73 | 112 |
*/ |
| 74 | 113 |
public void process(int x, int y) {
|
| 75 | 114 |
raster.getElemInt(x, y, px); |
| 76 |
|
|
| 77 |
if (rangesR != null) {
|
|
| 78 |
processRange(rangesR, 0, px); |
|
| 79 |
} |
|
| 80 |
|
|
| 81 |
if (rangesG != null) {
|
|
| 82 |
processRange(rangesG, 1, px); |
|
| 83 |
} |
|
| 84 |
|
|
| 85 |
if (rangesB != null) {
|
|
| 86 |
processRange(rangesB, 2, px); |
|
| 87 |
} |
|
| 88 |
|
|
| 115 |
processRange(px); |
|
| 89 | 116 |
raster.setElemInt(x, y, px); |
| 90 | 117 |
} |
| 91 | 118 |
|
| trunk/libraries/libCq CMS for java.old/src/org/cresques/ui/raster/AddRemoveButtonsPanel.java | ||
|---|---|---|
| 1 |
package org.cresques.ui.raster; |
|
| 2 |
|
|
| 3 |
import javax.swing.JPanel; |
|
| 4 |
import javax.swing.JButton; |
|
| 5 |
|
|
| 6 |
import java.awt.Color; |
|
| 7 |
import java.awt.GridBagLayout; |
|
| 8 |
import java.awt.GridBagConstraints; |
|
| 9 |
import java.awt.FlowLayout; |
|
| 10 |
import javax.swing.ImageIcon; |
|
| 11 |
|
|
| 12 |
public class AddRemoveButtonsPanel extends JPanel {
|
|
| 13 |
|
|
| 14 |
private JPanel pBorder = null; |
|
| 15 |
private JButton bAdd = null; |
|
| 16 |
private JButton bRemove = null; |
|
| 17 |
|
|
| 18 |
/** |
|
| 19 |
* This is the default constructor |
|
| 20 |
*/ |
|
| 21 |
public AddRemoveButtonsPanel() {
|
|
| 22 |
super(); |
|
| 23 |
initialize(); |
|
| 24 |
} |
|
| 25 |
|
|
| 26 |
/** |
|
| 27 |
* This method initializes this |
|
| 28 |
* |
|
| 29 |
* @return void |
|
| 30 |
*/ |
|
| 31 |
private void initialize() {
|
|
| 32 |
FlowLayout flowLayout = new FlowLayout(); |
|
| 33 |
flowLayout.setHgap(0); |
|
| 34 |
flowLayout.setVgap(0); |
|
| 35 |
this.setLayout(flowLayout); |
|
| 36 |
this.setSize(26, 52); |
|
| 37 |
this.add(getJPanel(), null); |
|
| 38 |
} |
|
| 39 |
|
|
| 40 |
/** |
|
| 41 |
* This method initializes jPanel |
|
| 42 |
* |
|
| 43 |
* @return javax.swing.JPanel |
|
| 44 |
*/ |
|
| 45 |
private JPanel getJPanel() {
|
|
| 46 |
if (pBorder == null) {
|
|
| 47 |
GridBagConstraints gridBagConstraints1 = new GridBagConstraints(); |
|
| 48 |
gridBagConstraints1.insets = new java.awt.Insets(3,3,3,3); |
|
| 49 |
gridBagConstraints1.gridy = 1; |
|
| 50 |
gridBagConstraints1.anchor = java.awt.GridBagConstraints.WEST; |
|
| 51 |
gridBagConstraints1.gridx = 0; |
|
| 52 |
GridBagConstraints gridBagConstraints = new GridBagConstraints(); |
|
| 53 |
gridBagConstraints.insets = new java.awt.Insets(3,3,3,3); |
|
| 54 |
gridBagConstraints.gridy = 0; |
|
| 55 |
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST; |
|
| 56 |
gridBagConstraints.gridx = 0; |
|
| 57 |
pBorder = new JPanel(); |
|
| 58 |
pBorder.setLayout(new GridBagLayout()); |
|
| 59 |
pBorder.setBorder(javax.swing.BorderFactory.createEmptyBorder(0,0,0,0)); |
|
| 60 |
pBorder.add(getBAdd(), gridBagConstraints); |
|
| 61 |
pBorder.add(getBRemove(), gridBagConstraints1); |
|
| 62 |
} |
|
| 63 |
return pBorder; |
|
| 64 |
} |
|
| 65 |
|
|
| 66 |
/** |
|
| 67 |
* This method initializes jButton |
|
| 68 |
* |
|
| 69 |
* @return javax.swing.JButton |
|
| 70 |
*/ |
|
| 71 |
public JButton getBAdd() {
|
|
| 72 |
if (bAdd == null) {
|
|
| 73 |
bAdd = new JButton(); |
|
| 74 |
bAdd.setPreferredSize(new java.awt.Dimension(20,20)); |
|
| 75 |
bAdd.setIcon(new ImageIcon("./gvSIG/extensiones/com.iver.cit.gvsig/images/forward.png"));
|
|
| 76 |
} |
|
| 77 |
return bAdd; |
|
| 78 |
} |
|
| 79 |
|
|
| 80 |
/** |
|
| 81 |
* This method initializes jButton1 |
|
| 82 |
* |
|
| 83 |
* @return javax.swing.JButton |
|
| 84 |
*/ |
|
| 85 |
public JButton getBRemove() {
|
|
| 86 |
if (bRemove == null) {
|
|
| 87 |
bRemove = new JButton(); |
|
| 88 |
bRemove.setPreferredSize(new java.awt.Dimension(20,20)); |
|
| 89 |
bRemove.setIcon(new ImageIcon("./gvSIG/extensiones/com.iver.cit.gvsig/images/backward.png"));
|
|
| 90 |
} |
|
| 91 |
return bRemove; |
|
| 92 |
} |
|
| 93 |
|
|
| 94 |
/** |
|
| 95 |
* Activa o desactiva el control |
|
| 96 |
* @param enable True activa el control y false lo desactiva |
|
| 97 |
*/ |
|
| 98 |
public void setControlEnabled(boolean enabled){
|
|
| 99 |
this.getBAdd().setEnabled(enabled); |
|
| 100 |
this.getBRemove().setEnabled(enabled); |
|
| 101 |
} |
|
| 102 |
|
|
| 103 |
} |
|
| 0 | 104 | |
| trunk/libraries/libCq CMS for java.old/src/org/cresques/ui/raster/FilterRasterDialogPanel.java | ||
|---|---|---|
| 32 | 32 |
import java.awt.event.MouseEvent; |
| 33 | 33 |
import java.awt.event.MouseListener; |
| 34 | 34 |
import java.io.IOException; |
| 35 |
import java.util.ArrayList; |
|
| 35 | 36 |
import java.util.TreeMap; |
| 36 | 37 |
|
| 38 |
import javax.swing.JList; |
|
| 37 | 39 |
import javax.swing.JPanel; |
| 38 | 40 |
import javax.swing.event.ChangeEvent; |
| 39 | 41 |
import javax.swing.event.ChangeListener; |
| 40 | 42 |
|
| 41 | 43 |
import org.cresques.io.GeoRasterFile; |
| 44 |
import org.cresques.io.raster.TransparencyRange; |
|
| 42 | 45 |
import org.cresques.ui.DefaultTabPanel; |
| 43 | 46 |
|
| 44 | 47 |
|
| ... | ... | |
| 83 | 86 |
* Variable que contiene el panel de informaci?n de raster. |
| 84 | 87 |
*/ |
| 85 | 88 |
protected InfoPanel pInfo = null; |
| 86 |
private int[][] rangeRed = null; |
|
| 87 |
private int[][] rangeGreen = null; |
|
| 88 |
private int[][] rangeBlue = null; |
|
| 89 |
|
|
| 89 |
|
|
| 90 | 90 |
/** |
| 91 | 91 |
* Propiedades guardadas en una matriz Nx2 con la forma propiedad/valor. |
| 92 | 92 |
*/ |
| ... | ... | |
| 152 | 152 |
|
| 153 | 153 |
pTrans.getOpacityCheck().addActionListener(this); |
| 154 | 154 |
pTrans.getTransparencyCheck().addActionListener(this); |
| 155 |
pTrans.getTRojo().addActionListener(this); |
|
| 156 |
pTrans.getTVerde().addActionListener(this); |
|
| 157 |
pTrans.getTAzul().addActionListener(this); |
|
| 158 | 155 |
pTrans.getOpacitySlider().addChangeListener(this); |
| 159 | 156 |
pTrans.getOpacityText().addActionListener(this); |
| 160 | 157 |
pTrans.getOpacityText().addFocusListener(this); |
| 161 |
pTrans.getTRojo().addFocusListener(this); |
|
| 162 |
pTrans.getTVerde().addFocusListener(this); |
|
| 163 |
pTrans.getTAzul().addFocusListener(this); |
|
| 164 |
pTrans.getTRojo().addMouseListener(this); |
|
| 165 |
pTrans.getTVerde().addMouseListener(this); |
|
| 166 |
pTrans.getTAzul().addMouseListener(this); |
|
| 167 | 158 |
pTrans.addFocusListener(this); |
| 168 | 159 |
this.getTab().addFocusListener(this); |
| 169 | 160 |
|
| ... | ... | |
| 266 | 257 |
if (e.getSource().equals(pTrans.getTransparencyCheck())) {
|
| 267 | 258 |
//Check de opacidad activado -> Activar controles de opacidad |
| 268 | 259 |
if (pTrans.getTransparencyCheck().isSelected()) {
|
| 269 |
if (nbands == 1) {
|
|
| 270 |
pTrans.getTRojo().setEnabled(true); |
|
| 271 |
pTrans.getTVerde().setEnabled(false); |
|
| 272 |
pTrans.getTAzul().setEnabled(false); |
|
| 273 |
} |
|
| 274 |
|
|
| 275 |
if (nbands == 2) {
|
|
| 276 |
pTrans.getTRojo().setEnabled(true); |
|
| 277 |
pTrans.getTVerde().setEnabled(true); |
|
| 278 |
pTrans.getTAzul().setEnabled(false); |
|
| 279 |
} |
|
| 280 |
|
|
| 281 |
if (nbands >= 3) {
|
|
| 282 |
pTrans.getTRojo().setEnabled(true); |
|
| 283 |
pTrans.getTVerde().setEnabled(true); |
|
| 284 |
pTrans.getTAzul().setEnabled(true); |
|
| 285 |
} |
|
| 286 |
} else {
|
|
| 287 |
pTrans.getTRojo().setEnabled(false); |
|
| 288 |
pTrans.getTVerde().setEnabled(false); |
|
| 289 |
pTrans.getTAzul().setEnabled(false); |
|
| 290 |
} |
|
| 260 |
pTrans.getPTranspByPixel().setControlEnabled(true); |
|
| 261 |
pTrans.getPTranspByPixel().getPRGBInput().setActiveBands(nbands); |
|
| 262 |
}else |
|
| 263 |
pTrans.getPTranspByPixel().setControlEnabled(false); |
|
| 291 | 264 |
} |
| 292 | 265 |
|
| 293 | 266 |
//Evento sobre el textfield de opacidad |
| ... | ... | |
| 295 | 268 |
checkOpacityText(); |
| 296 | 269 |
} |
| 297 | 270 |
|
| 298 |
//Evento sobre el textfield de valor para el Rojo |
|
| 299 |
if (e.getSource().equals(pTrans.getTRojo())) {
|
|
| 300 |
try {
|
|
| 301 |
rangeRed = getTransparencyValues(pTrans.getTRojo().getText()); |
|
| 302 |
} catch (IOException exc) {
|
|
| 303 |
pTrans.getTRojo().setText("");
|
|
| 304 |
} |
|
| 305 |
} |
|
| 306 |
|
|
| 307 |
//Evento sobre el textfield de valor para el Verde |
|
| 308 |
if (e.getSource().equals(pTrans.getTVerde())) {
|
|
| 309 |
try {
|
|
| 310 |
rangeGreen = getTransparencyValues(pTrans.getTVerde().getText()); |
|
| 311 |
} catch (IOException exc) {
|
|
| 312 |
pTrans.getTVerde().setText("");
|
|
| 313 |
} |
|
| 314 |
} |
|
| 315 |
|
|
| 316 |
//Evento sobre el textfield de valor para el Azul |
|
| 317 |
if (e.getSource().equals(pTrans.getTAzul())) {
|
|
| 318 |
try {
|
|
| 319 |
rangeBlue = getTransparencyValues(pTrans.getTAzul().getText()); |
|
| 320 |
} catch (IOException exc) {
|
|
| 321 |
pTrans.getTAzul().setText("");
|
|
| 322 |
} |
|
| 323 |
} |
|
| 324 |
|
|
| 325 | 271 |
//Evento sobre el checkbox de Recorte de colas |
| 326 | 272 |
if (e.getSource().equals(pEnhan.getTailCheck())) {
|
| 327 | 273 |
if (pEnhan.getTailCheck().isSelected()) {
|
| ... | ... | |
| 335 | 281 |
if (e.getSource().equals(pEnhan.getTailText())) {
|
| 336 | 282 |
checkTailText(); |
| 337 | 283 |
} |
| 338 |
} |
|
| 284 |
}
|
|
| 339 | 285 |
|
| 340 | 286 |
/** |
| 341 |
* Obtiene el rango de valores a partir de la cadena de |
|
| 342 |
* texto introducida por el usuario. |
|
| 343 |
* @param values |
|
| 287 |
* Asigna valores para los rangos. |
|
| 288 |
* @param ranges |
|
| 344 | 289 |
*/ |
| 345 |
private int[][] getTransparencyValues(String values) |
|
| 346 |
throws IOException {
|
|
| 347 |
int[][] rangeTransparency = null; |
|
| 348 |
|
|
| 349 |
for (int i = 0; i < values.length(); i++) {
|
|
| 350 |
char c = values.charAt(i); |
|
| 351 |
|
|
| 352 |
//Control de caracter valido |
|
| 353 |
if ((c != ':') && (c != ',')) {
|
|
| 354 |
try {
|
|
| 355 |
Integer.parseInt(String.valueOf(c)); |
|
| 356 |
} catch (Exception exp) {
|
|
| 357 |
System.err.println("Caracteres incorrectos en la cadena:" +
|
|
| 358 |
c); |
|
| 359 |
throw new IOException("Caracteres incorrectos en la cadena.");
|
|
| 360 |
} |
|
| 361 |
} |
|
| 362 |
|
|
| 363 |
//Control de comienzo por un simbolo |
|
| 364 |
if (values.startsWith(",") || values.startsWith(":") ||
|
|
| 365 |
values.endsWith(",") || values.endsWith(":")) {
|
|
| 366 |
System.err.println("La cadena empieza o acaba con simbolos incorrectos");
|
|
| 367 |
throw new IOException(); |
|
| 368 |
} |
|
| 369 |
|
|
| 370 |
//Control de signos consecutivos |
|
| 371 |
if (i < (values.length() - 1)) {
|
|
| 372 |
char cmas = values.charAt(i + 1); |
|
| 373 |
|
|
| 374 |
if (((c == ',') || (c == ':')) && |
|
| 375 |
((cmas == ',') || (cmas == ':'))) {
|
|
| 376 |
System.err.println("Signos consecutivos");
|
|
| 377 |
throw new IOException(); |
|
| 378 |
} |
|
| 379 |
} |
|
| 380 |
|
|
| 381 |
//Control de dos : seguidos con un n?mero en el medio |
|
| 382 |
if ((i < (values.length() - 3)) && (c == ':')) {
|
|
| 383 |
int n = i + 1; |
|
| 384 |
|
|
| 385 |
while ((n < (values.length() - 1)) && |
|
| 386 |
(values.charAt(n) != ',') && |
|
| 387 |
(values.charAt(n) != ':')) |
|
| 388 |
n++; |
|
| 389 |
|
|
| 390 |
char signoSgte = values.charAt(n); |
|
| 391 |
|
|
| 392 |
if (signoSgte == ':') {
|
|
| 393 |
System.err.println("Dos separadores de rango consecutivos");
|
|
| 394 |
throw new IOException(); |
|
| 395 |
} |
|
| 396 |
} |
|
| 397 |
} |
|
| 398 |
|
|
| 399 |
//Obtenemos los valores de los intervalos |
|
| 400 |
if (!values.equals("")) {
|
|
| 401 |
String[] t1 = null; |
|
| 402 |
t1 = values.split("\\,");
|
|
| 403 |
rangeTransparency = new int[t1.length][2]; |
|
| 404 |
|
|
| 405 |
for (int i = 0; i < t1.length; i++) {
|
|
| 406 |
if (t1[i].indexOf(":") == -1) {
|
|
| 407 |
rangeTransparency[i][0] = rangeTransparency[i][1] = Integer.parseInt(t1[i]); |
|
| 408 |
} else {
|
|
| 409 |
String[] t2 = null; |
|
| 410 |
t2 = t1[i].split("\\:");
|
|
| 411 |
|
|
| 412 |
if (Integer.parseInt(t2[1]) > Integer.parseInt(t2[0])) {
|
|
| 413 |
rangeTransparency[i][0] = Integer.parseInt(t2[0]); |
|
| 414 |
rangeTransparency[i][1] = Integer.parseInt(t2[1]); |
|
| 415 |
} else {
|
|
| 416 |
rangeTransparency[i][0] = Integer.parseInt(t2[1]); |
|
| 417 |
rangeTransparency[i][1] = Integer.parseInt(t2[0]); |
|
| 418 |
} |
|
| 419 |
} |
|
| 420 |
|
|
| 421 |
if ((rangeTransparency[i][0] < 0) || |
|
| 422 |
(rangeTransparency[i][0] > 255) || |
|
| 423 |
(rangeTransparency[i][1] < 0) || |
|
| 424 |
(rangeTransparency[i][1] > 255)) {
|
|
| 425 |
System.err.println("Valores fuera de rango (0-255)");
|
|
| 426 |
throw new IOException(); |
|
| 427 |
} |
|
| 428 |
} |
|
| 429 |
|
|
| 430 |
return rangeTransparency; |
|
| 431 |
|
|
| 432 |
//for(int i=0;i<rangeTransparency.length;i++) |
|
| 433 |
// System.out.println("("+rangeTransparency[i][0]+":"+rangeTransparency[i][1]+")");
|
|
| 434 |
} |
|
| 435 |
|
|
| 436 |
return null; |
|
| 290 |
public void setRanges(ArrayList ranges) {
|
|
| 291 |
if(ranges != null){
|
|
| 292 |
TransparencyByPixelPanel panel = (TransparencyByPixelPanel)pTrans.getPTranspByPixel(); |
|
| 293 |
pTrans.getTransparencyCheck().setSelected(true); |
|
| 294 |
panel.setControlEnabled(true); |
|
| 295 |
panel.setEntries(ranges); |
|
| 296 |
for(int i=0;i<ranges.size();i++) |
|
| 297 |
panel.getListModel().addElement( ((TransparencyRange)ranges.get(i)).getStrEntry() ); |
|
| 298 |
} |
|
| 437 | 299 |
} |
| 438 | 300 |
|
| 439 | 301 |
/** |
| 440 |
* Devuelve el rango de valores para poner transparencia en el Rojo |
|
| 441 |
* @return |
|
| 442 |
*/ |
|
| 443 |
public int[][] getRangeRed() {
|
|
| 444 |
return rangeRed; |
|
| 445 |
} |
|
| 446 |
|
|
| 447 |
/** |
|
| 448 |
* Devuelve el rango de valores para poner transparencia en el Verde |
|
| 449 |
* @return |
|
| 450 |
*/ |
|
| 451 |
public int[][] getRangeGreen() {
|
|
| 452 |
return rangeGreen; |
|
| 453 |
} |
|
| 454 |
|
|
| 455 |
/** |
|
| 456 |
* Devuelve el rango de valores para poner transparencia en el Azul |
|
| 457 |
* @return |
|
| 458 |
*/ |
|
| 459 |
public int[][] getRangeBlue() {
|
|
| 460 |
return rangeBlue; |
|
| 461 |
} |
|
| 462 |
|
|
| 463 |
/** |
|
| 464 |
* Asigna valore para los rangos |
|
| 465 |
* @param red |
|
| 466 |
* @param green |
|
| 467 |
* @param blue |
|
| 468 |
*/ |
|
| 469 |
public void setRanges(int[][] red, int[][] green, int[][] blue) {
|
|
| 470 |
rangeRed = red; |
|
| 471 |
rangeGreen = green; |
|
| 472 |
rangeBlue = blue; |
|
| 473 |
|
|
| 474 |
if (pTrans != null) {
|
|
| 475 |
StringBuffer rango = new StringBuffer(); |
|
| 476 |
|
|
| 477 |
if (red != null) {
|
|
| 478 |
for (int i = 0; i < red.length; i++) {
|
|
| 479 |
if (red[i][0] == red[i][1]) {
|
|
| 480 |
rango.append(String.valueOf(red[i][0]) + ","); |
|
| 481 |
} else {
|
|
| 482 |
rango.append(String.valueOf(red[i][0]) + ":" + |
|
| 483 |
String.valueOf(red[i][1]) + ","); |
|
| 484 |
} |
|
| 485 |
} |
|
| 486 |
|
|
| 487 |
String t = rango.toString(); |
|
| 488 |
|
|
| 489 |
if (t.endsWith(",")) {
|
|
| 490 |
t = t.substring(0, t.length() - 1); |
|
| 491 |
} |
|
| 492 |
|
|
| 493 |
pTrans.getTRojo().setText(t); |
|
| 494 |
pTrans.setActiveTransparencyControl(true); |
|
| 495 |
} |
|
| 496 |
|
|
| 497 |
if (green != null) {
|
|
| 498 |
rango = new StringBuffer(); |
|
| 499 |
|
|
| 500 |
for (int i = 0; i < green.length; i++) {
|
|
| 501 |
if (green[i][0] == green[i][1]) {
|
|
| 502 |
rango.append(String.valueOf(green[i][0]) + ","); |
|
| 503 |
} else {
|
|
| 504 |
rango.append(String.valueOf(green[i][0]) + ":" + |
|
| 505 |
String.valueOf(green[i][1]) + ","); |
|
| 506 |
} |
|
| 507 |
} |
|
| 508 |
|
|
| 509 |
String t = rango.toString(); |
|
| 510 |
|
|
| 511 |
if (t.endsWith(",")) {
|
|
| 512 |
t = t.substring(0, t.length() - 1); |
|
| 513 |
} |
|
| 514 |
|
|
| 515 |
pTrans.getTVerde().setText(t); |
|
| 516 |
pTrans.setActiveTransparencyControl(true); |
|
| 517 |
} |
|
| 518 |
|
|
| 519 |
if (blue != null) {
|
|
| 520 |
rango = new StringBuffer(); |
|
| 521 |
|
|
| 522 |
for (int i = 0; i < blue.length; i++) {
|
|
| 523 |
if (blue[i][0] == blue[i][1]) {
|
|
| 524 |
rango.append(String.valueOf(blue[i][0]) + ","); |
|
| 525 |
} else {
|
|
| 526 |
rango.append(String.valueOf(blue[i][0]) + ":" + |
|
| 527 |
String.valueOf(blue[i][1]) + ","); |
|
| 528 |
} |
|
| 529 |
} |
|
| 530 |
|
|
| 531 |
String t = rango.toString(); |
|
| 532 |
|
|
| 533 |
if (t.endsWith(",")) {
|
|
| 534 |
t = t.substring(0, t.length() - 1); |
|
| 535 |
} |
|
| 536 |
|
|
| 537 |
pTrans.setActiveTransparencyControl(true); |
|
| 538 |
pTrans.getTAzul().setText(t); |
|
| 539 |
} |
|
| 540 |
} |
|
| 541 |
} |
|
| 542 |
|
|
| 543 |
/** |
|
| 544 | 302 |
* A?ade las bandas de los georrasterfile a los paneles |
| 545 | 303 |
* que lo necesitan |
| 546 | 304 |
* @param files |
| ... | ... | |
| 608 | 366 |
} |
| 609 | 367 |
} |
| 610 | 368 |
|
| 611 |
/** |
|
| 612 |
* Llama a las funciones que obtienen los valores de los pixels a los que se |
|
| 613 |
* quiere aplicar transparencia desde las cajas de texto. |
|
| 614 |
*/ |
|
| 615 |
public void checkTransparencyValues() {
|
|
| 616 |
if (!pTrans.getTRojo().getText().equals("")) {
|
|
| 617 |
try {
|
|
| 618 |
rangeRed = getTransparencyValues(pTrans.getTRojo().getText()); |
|
| 619 |
} catch (IOException exc) {
|
|
| 620 |
pTrans.getTRojo().setText("");
|
|
| 621 |
} |
|
| 622 |
} |
|
| 623 |
|
|
| 624 |
if (!pTrans.getTVerde().getText().equals("")) {
|
|
| 625 |
try {
|
|
| 626 |
rangeGreen = getTransparencyValues(pTrans.getTVerde().getText()); |
|
| 627 |
} catch (IOException exc) {
|
|
| 628 |
pTrans.getTVerde().setText("");
|
|
| 629 |
} |
|
| 630 |
} |
|
| 631 |
|
|
| 632 |
if (!pTrans.getTAzul().getText().equals("")) {
|
|
| 633 |
try {
|
|
| 634 |
rangeBlue = getTransparencyValues(pTrans.getTAzul().getText()); |
|
| 635 |
} catch (IOException exc) {
|
|
| 636 |
pTrans.getTAzul().setText("");
|
|
| 637 |
} |
|
Also available in: Unified diff