Statistics
| Revision:

root / trunk / libraries / libCq_CMS_praster / src / org / cresques / filter / correction / MedianIntegerFilter.java @ 8026

History | View | Annotate | Download (4.79 KB)

1 8026 nacho
package org.cresques.filter.correction;
2
3
import java.util.Arrays;
4
5
import org.cresques.io.data.RasterBuf;
6
7
public class MedianIntegerFilter extends MedianFilter {
8
9
        public void process(int col, int line) {
10
                int[] pxOut = new int[4];
11
                int[] px = new int[4];
12
13
                ladoVentana = Math.abs(ladoVentana);     // El lado de la ventana debe
14
                if(ladoVentana % 2 == 0) ladoVentana++;  // ser positivo e impar.
15
            int tamVentana = ladoVentana*ladoVentana;
16
            int mitadLado = (ladoVentana-1)>>1;
17
                int [] ventanaR = new int[tamVentana];
18
                int [] ventanaG = new int[tamVentana];
19
                int [] ventanaB = new int[tamVentana];
20
                int k;
21
22
                raster.getElemInt(line,col,px);
23
24
                if((col-mitadLado >= 0) && (line-mitadLado >= 0) &&(col+mitadLado < width)&&(line+mitadLado < height))
25
                {
26
                                // Obtener el vector con la ventanas de muestras (una por componente banda)
27
                                k=0;
28
                                for (int i=-mitadLado;i<=mitadLado;i++)
29
                                        for(int j=-mitadLado;j<=mitadLado;j++)
30
                                        {
31
                                                raster.getElemInt(line+j,col+i,px);
32
                                                ventanaR[k] =px[0];
33
                                                ventanaG[k] =px[1];
34
                                                ventanaB[k] =px[2];
35
                                                k++;
36
                                        }
37
38
                                // Ordenar los valores de las ventanas
39
                                    // se supone que usa quickSort.
40
                                Arrays.sort(ventanaR);
41
                                Arrays.sort(ventanaG);
42
                                Arrays.sort(ventanaB);
43
44
                                pxOut[0]=ventanaR[(tamVentana-1)/2];
45
                                pxOut[1]=ventanaG[(tamVentana-1)/2];
46
                                pxOut[2]=ventanaB[(tamVentana-1)/2];
47
48
                        //Extraer los elementos centrales y asignarselos al pixel (x,y)
49
50
                                rasterResult.setElemInt(line, col, pxOut);
51
                }
52
                else rasterResult.setElemInt(line, col, px);
53
54
        }
55
56
        public void processSuperSampling(int col, int line) {
57
                int[] px = new int[4];
58
                int[] pxOut = new int[4];
59
                ladoVentana = Math.abs(ladoVentana);     // El lado de la ventana debe
60
                if(ladoVentana % 2 == 0) ladoVentana++;  // ser positivo e impar.
61
            int tamVentana = ladoVentana*ladoVentana;
62
            int mitadLado = (ladoVentana-1)>>1;
63
            int indiceX,indiceY,origenX,origenY;
64
65
            int [] ventanaR = new int[tamVentana];
66
                int [] ventanaG = new int[tamVentana];
67
                int [] ventanaB = new int[tamVentana];
68
69
                raster.getElemInt(line,col,px);
70
71
                if ((contX+1-mitadLado>=0) && (contY+1-mitadLado>=0)&& (contX+1+mitadLado<stepX.length) && (contY+1+mitadLado<stepY.length)){
72
73
                        // Calcular el alcance del kernel cuyo centro es (x,y)
74
                        int offsetX=0;
75
                        int offsetY=0;
76
                        for (int i=0;i<mitadLado;i++){
77
                                offsetX=offsetX+stepX[contX+i+1];
78
                                offsetY=offsetY+stepY[contY+i+1];
79
                        }
80
                        if((col+offsetX<width)&&(line+offsetY<height)){
81
//                                 Obtener el vector con las ventanas de muestras (una por banda) **************************
82
                                // Me situo en la esquina superior izquierda del "kernel"
83
                                origenX=col;
84
                                origenY=line;
85
                                for (int i=0;i<mitadLado;i++){
86
                                        origenX=origenX-stepX[contX-i];
87
                                        origenY=origenY-stepY[contY-i];
88
                                }
89
                                //Recorro el kernel seg�n los step
90
                                int k=0;
91
                                indiceX=origenX;
92
                                for (int i=-mitadLado;i<=mitadLado;i++){
93
                                        indiceY=origenY;
94
                                        for(int j=-mitadLado;j<=mitadLado;j++){
95
                                                raster.getElemInt(indiceY,indiceX,px);
96
                                                ventanaR[k] =px[0];
97
                                                ventanaG[k] =px [1];
98
                                                ventanaB[k] =px[2];
99
                                                indiceY=indiceY+stepY[contY+j+1];
100
                                                k++;
101
                                        }
102
                                        indiceX=indiceX+stepX[contX+i+1];
103
                                }
104
                                //**************************************************************************************************
105
106
                                // Ordenar los valores de las ventanas
107
                                    // se supone que usa quickSort.
108
                                Arrays.sort(ventanaR);
109
                                Arrays.sort(ventanaG);
110
                                Arrays.sort(ventanaB);
111
112
                                pxOut[0]=ventanaR[(tamVentana-1)/2];
113
                                pxOut[1]=ventanaG[(tamVentana-1)/2];
114
                                pxOut[2]=ventanaB[(tamVentana-1)/2];
115
116
                                //Extraer los elementos centrales y asignarselos al pixel (x,y)
117
                                for(int i = col; i < width && i < (col + stepX[contX + 1]); i++)
118
                                        for(int j = line; j < height && j < (line + stepY[contY + 1]); j++)
119
                                                rasterResult.setElemInt(j, i,pxOut);
120
                                return;
121
                        }
122
                }
123
124
                // Si la ventana se sale de la imagen dejar el pixeles original
125
                for(int i = col; i < width && i < (col + stepX[contX + 1]); i++)
126
                        for(int j = line; j < height && j < (line + stepY[contY + 1]); j++)
127
                                rasterResult.setElemInt(j, i,px);
128
        }
129
130
        public void processLine(int y) {
131
                // TODO Auto-generated method stub
132
133
        }
134
135
        public int getInRasterDataType() {
136
                return RasterBuf.TYPE_INT;
137
        }
138
139
        public int getOutRasterDataType() {
140
                return RasterBuf.TYPE_INT;
141
        }
142
143
        public Object getResult(String name) {
144
                if (name.equals("raster")) {
145
            return (Object) this.rasterResult;
146
        } else {
147
            return null;
148
        }
149
        }
150
151
        public void pre() {
152
                exec = true;
153
                this.raster = (RasterBuf) params.get("raster");
154
                height = raster.getHeight();
155
        width = raster.getWidth();
156
                this.ladoVentana = ((Integer) params.get("ladoVentana")).intValue();
157
                this.rasterResult = new RasterBuf(raster.getDataType(),width,height,raster.getBandCount(),true);
158
159
                super.pre();
160
        }
161
162
}