netzel commited on 2024-02-21 22:59:53
Showing 8 changed files, with 1524 additions and 0 deletions.
... | ... |
@@ -0,0 +1,28 @@ |
1 |
+ |
|
2 |
+PROG = plclump4p |
|
3 |
+ |
|
4 |
+CC = gcc |
|
5 |
+ |
|
6 |
+CFLAGS=-Wall -O3 -fopenmp -msse2 -mfpmath=sse -Wl,-rpath,'$$ORIGIN/' -I/usr/include/gdal -lgdal -lezgdal -largtable3 -lm |
|
7 |
+ |
|
8 |
+COMMON_C = $(shell ls *.c) |
|
9 |
+COMMON_C_O = $(COMMON_C:%.c=%.o) |
|
10 |
+ |
|
11 |
+ifndef PREFIX |
|
12 |
+ PREFIX = /usr/local |
|
13 |
+endif |
|
14 |
+ |
|
15 |
+ |
|
16 |
+default: $(PROG) |
|
17 |
+ |
|
18 |
+$(PROG): $(COMMON_C_O) $(HEADERS) |
|
19 |
+ $(CC) $(CFLAGS) -o $(PROG) $(COMMON_O) $(COMMON_C_O) |
|
20 |
+ |
|
21 |
+$(COMMON_C_O): $(COMMON_C) $(HEADERS_C) |
|
22 |
+ $(CC) $(CFLAGS) -c $(COMMON_C) |
|
23 |
+ |
|
24 |
+install: |
|
25 |
+ cp -f $(PROG) $(PREFIX)/bin |
|
26 |
+ |
|
27 |
+clean: |
|
28 |
+ rm -f *.o $(PROG) |
... | ... |
@@ -0,0 +1,20 @@ |
1 |
+PROG = plclump4p.exe |
|
2 |
+ |
|
3 |
+CC = x86_64-w64-mingw32-gcc |
|
4 |
+ |
|
5 |
+CFLAGS= -I../../Win64_cross/gdal/include -I../../Win64_cross/ezgdal -I../../Win64_cross/argtable3 -L../../Win64_cross/argtable3 -L../../Win64_cross/gdal/bin -L../../Win64_cross/ezgdal -Wall -O3 -fopenmp -msse2 -mfpmath=sse -lgdal -llibezgdal -llibargtable3 -lm |
|
6 |
+ |
|
7 |
+COMMON_C = $(shell ls *.c) |
|
8 |
+COMMON_C_O = $(COMMON_C:%.c=%.o) |
|
9 |
+HEADERS = $(shell ls *.h) |
|
10 |
+ |
|
11 |
+default: $(PROG) |
|
12 |
+ |
|
13 |
+$(PROG): $(COMMON_C_O) $(HEADERS) |
|
14 |
+ $(CC) $(CFLAGS) -o $(PROG) $(COMMON_C_O) |
|
15 |
+ |
|
16 |
+$(COMMON_C_O): $(COMMON_C) $(HEADERS) |
|
17 |
+ $(CC) $(CFLAGS) -c $(COMMON_C) |
|
18 |
+ |
|
19 |
+clean: |
|
20 |
+ rm -f *.o $(PROG) |
... | ... |
@@ -0,0 +1,380 @@ |
1 |
+/**************************************************************************** |
|
2 |
+ * |
|
3 |
+ * PROGRAM: clump4p |
|
4 |
+ * |
|
5 |
+ * AUTHOR(S): Pawel Netzel - SIL UC |
|
6 |
+ * Jarek Jasiewicz - SIL UC |
|
7 |
+ * (the clumping algorithm for a region) |
|
8 |
+ * |
|
9 |
+ * PURPOSE: Recategorizes data in a raster map layer by grouping cells |
|
10 |
+ * that form physically discrete areas into unique categories. |
|
11 |
+ * |
|
12 |
+ * COPYRIGHT: (C) 2012 by Pawel Netzel |
|
13 |
+ * |
|
14 |
+ * This program is a free software under the GNU General Public |
|
15 |
+ * License (>=v2). |
|
16 |
+ * |
|
17 |
+ ***************************************************************************/ |
|
18 |
+ |
|
19 |
+#include <stdio.h> |
|
20 |
+#include <string.h> |
|
21 |
+#include <time.h> |
|
22 |
+#include <gdal.h> |
|
23 |
+#include <ezgdal.h> |
|
24 |
+#include <omp.h> |
|
25 |
+#include "main.h" |
|
26 |
+#include "data.h" |
|
27 |
+ |
|
28 |
+static int nextr[] = {-1, 0, 1, 0 ,-1, 1,-1, 1}; |
|
29 |
+static int nextc[] = { 0,-1, 0, 1 ,-1, 1, 1,-1}; |
|
30 |
+ |
|
31 |
+#define NR(x) 1 + r + nextr[(x)] |
|
32 |
+#define NC(x) 1 + c + nextc[(x)] |
|
33 |
+#define INDEX(r,c) ((r)-1)*ncols+(c)-1 |
|
34 |
+ |
|
35 |
+ |
|
36 |
+void clumpRegion(int regionNum, int nDirections) { |
|
37 |
+ |
|
38 |
+ int** map; |
|
39 |
+ int** map_clump; |
|
40 |
+ int nrows; |
|
41 |
+ int ncols; |
|
42 |
+ int colMax,colMin; |
|
43 |
+ |
|
44 |
+ unsigned current_clump, index, i; |
|
45 |
+ unsigned row, col, r, c; |
|
46 |
+ int last, first, next_r, next_c; |
|
47 |
+ //double sum=0; |
|
48 |
+ unsigned* queue; |
|
49 |
+ |
|
50 |
+ /* The size of the region */ |
|
51 |
+ colMin=regions[regionNum].colMin; |
|
52 |
+ colMax=regions[regionNum].colMax; |
|
53 |
+ ncols=colMax-colMin+1; |
|
54 |
+ nrows=regions[regionNum].rowMax-regions[regionNum].rowMin+1; |
|
55 |
+ |
|
56 |
+ /* Allocating memory and copying input data */ |
|
57 |
+ queue=(unsigned*)malloc((nrows+2)*(ncols+2)*sizeof(unsigned)); |
|
58 |
+ map=malloc((nrows+2)*sizeof(int*)); |
|
59 |
+ map_clump=malloc((nrows+2)*sizeof(int*)); |
|
60 |
+ map_clump[0]=calloc(ncols+2,sizeof(int)); |
|
61 |
+ map_clump[nrows+1]=calloc(ncols+2,sizeof(int)); |
|
62 |
+ map[0]=calloc(ncols+2,sizeof(int)); |
|
63 |
+ map[nrows+1]=calloc(ncols+2,sizeof(int)); |
|
64 |
+ for(r=1; r<=nrows; r++) { |
|
65 |
+ map_clump[r]=calloc(ncols+2,sizeof(int)); |
|
66 |
+ map[r]=calloc(ncols+2,sizeof(int)); |
|
67 |
+ // Data copying |
|
68 |
+ memcpy(map[r]+1,dataBuffer[r-1]+colMin,ncols*sizeof(int)); |
|
69 |
+ } |
|
70 |
+ |
|
71 |
+ /* start clumping */ |
|
72 |
+ current_clump=0; |
|
73 |
+ for(row=1;row<=nrows;row++) |
|
74 |
+ for(col=1;col<=ncols;col++) { |
|
75 |
+ if(map_clump[row][col] || !map[row][col]) /* NULL == 0 */ |
|
76 |
+ continue; |
|
77 |
+ current_clump++; |
|
78 |
+ map_clump[row][col]=current_clump; |
|
79 |
+ last=1; |
|
80 |
+ first=0; |
|
81 |
+ queue[first]=INDEX(row,col); |
|
82 |
+ do { |
|
83 |
+ index=queue[first++]; |
|
84 |
+ r=index/ncols; |
|
85 |
+ c=index%ncols; |
|
86 |
+ for(i=0; i<nDirections; i++) { |
|
87 |
+ next_r=NR(i); |
|
88 |
+ next_c=NC(i); |
|
89 |
+ if(map[r+1][c+1]==map[next_r][next_c]) { |
|
90 |
+ if(!map_clump[next_r][next_c]) { |
|
91 |
+ map_clump[next_r][next_c]=current_clump; |
|
92 |
+ queue[last++]=INDEX(next_r,next_c); |
|
93 |
+ } |
|
94 |
+ } |
|
95 |
+ } |
|
96 |
+ } while(first!=last); |
|
97 |
+ } |
|
98 |
+ |
|
99 |
+ /* Creating labels list */ |
|
100 |
+ if(current_clump>INCR) { |
|
101 |
+ free(regions[regionNum].labels); |
|
102 |
+ regions[regionNum].labels=(int *)malloc((current_clump+2)*sizeof(int)); |
|
103 |
+ } |
|
104 |
+ for(i=1; i<=current_clump; i++) |
|
105 |
+ regions[regionNum].labels[i]=i+1; |
|
106 |
+ regions[regionNum].nLabels=current_clump; |
|
107 |
+ |
|
108 |
+ /* Copying resultant map of clumps */ |
|
109 |
+ for(r=1;r<=nrows;r++) |
|
110 |
+ memcpy(resultBuffer[r-1]+colMin,map_clump[r]+1,ncols*sizeof(int)); |
|
111 |
+ |
|
112 |
+ /* Releasing memmory */ |
|
113 |
+ for(r=0;r<=nrows+1;r++) { |
|
114 |
+ free(map[r]); |
|
115 |
+ free(map_clump[r]); |
|
116 |
+ } |
|
117 |
+ free(map); |
|
118 |
+ free(map_clump); |
|
119 |
+ free(queue); |
|
120 |
+} |
|
121 |
+ |
|
122 |
+void shiftLablesForRegion(int regionNum) { |
|
123 |
+ |
|
124 |
+ int i,nLabels; |
|
125 |
+ int lbl,maxLbl, *labels; |
|
126 |
+ |
|
127 |
+ labels=regions[regionNum].labels; |
|
128 |
+ nLabels=regions[regionNum].nLabels; |
|
129 |
+ maxLbl=0; |
|
130 |
+ for(i=1; i<=nLabels; i++) { |
|
131 |
+ lbl=labels[i]; |
|
132 |
+ labels[i]+=totalIndex; |
|
133 |
+ if(lbl>maxLbl) |
|
134 |
+ maxLbl=lbl; |
|
135 |
+ } |
|
136 |
+ totalIndex+=maxLbl; |
|
137 |
+} |
|
138 |
+ |
|
139 |
+void resolveEquivalence(int labelP, int regionP, int labelQ, int regionQ) { |
|
140 |
+ int idxP,idxQ,maxLab, minLab,n;//,*kLabels; |
|
141 |
+ int j,k; |
|
142 |
+ Region* reg; |
|
143 |
+ int* lab; |
|
144 |
+ |
|
145 |
+ idxP=regions[regionP].labels[labelP]; |
|
146 |
+ idxQ=regions[regionQ].labels[labelQ]; |
|
147 |
+ if(idxP!=idxQ) { |
|
148 |
+ maxLab=(idxP>idxQ)?idxP:idxQ; |
|
149 |
+ minLab=(idxP>idxQ)?idxQ:idxP; |
|
150 |
+ |
|
151 |
+#pragma omp parallel for private(k,j,n,lab,reg) shared(maxLab,minLab,regions,regionP) |
|
152 |
+ for(k=0; k<=regionP; k++) { |
|
153 |
+ reg=regions+k; |
|
154 |
+ n=(*reg).nLabels; |
|
155 |
+ lab=(*reg).labels+1; |
|
156 |
+ if(k<regionP) reg++; |
|
157 |
+ for(j=1; j<=n; j++) { |
|
158 |
+ if(*lab>maxLab) |
|
159 |
+ (*lab)--; |
|
160 |
+ else if(*lab==maxLab) |
|
161 |
+ *lab=minLab; |
|
162 |
+ lab++; |
|
163 |
+ } |
|
164 |
+ } |
|
165 |
+ totalIndex--; |
|
166 |
+ } |
|
167 |
+} |
|
168 |
+ |
|
169 |
+void merge4(int regionNum) { |
|
170 |
+ int colMin,colMax,i,j,n; |
|
171 |
+ |
|
172 |
+ colMin=regions[regionNum].colMin; |
|
173 |
+ colMax=regions[regionNum].colMax; |
|
174 |
+ /* Left vertical border */ |
|
175 |
+ if(colMin>0) { |
|
176 |
+ n=regions[regionNum].rowMax-regions[regionNum].rowMin+1; |
|
177 |
+ j=colMin-1; |
|
178 |
+ for(i=0; i<n; i++) |
|
179 |
+ if(resultBuffer[i][colMin]>0) |
|
180 |
+ if(resultBuffer[i][j]>0 && dataBuffer[i][j]==dataBuffer[i][colMin]) |
|
181 |
+ resolveEquivalence(resultBuffer[i][colMin],regionNum, |
|
182 |
+ resultBuffer[i][j],regionNum-1); |
|
183 |
+ } |
|
184 |
+ /* Top horizontal border */ |
|
185 |
+ if(regions[regionNum].rowMin>0) |
|
186 |
+ for(i=colMin; i<=colMax; i++) { |
|
187 |
+ if(resultBuffer[0][i]>0) |
|
188 |
+ if(borderResultBuffer[i]>0 && dataBuffer[0][i]==borderDataBuffer[i]) |
|
189 |
+ resolveEquivalence(resultBuffer[0][i],regionNum, |
|
190 |
+ borderResultBuffer[i], |
|
191 |
+ regions[regionNum].regionUp); |
|
192 |
+ } |
|
193 |
+} |
|
194 |
+ |
|
195 |
+void merge8(int regionNum) { |
|
196 |
+ int colMin,colMax,i,j,n; |
|
197 |
+ |
|
198 |
+ colMin=regions[regionNum].colMin; |
|
199 |
+ colMax=regions[regionNum].colMax; |
|
200 |
+ /* Left vertical border */ |
|
201 |
+ if(colMin>0) { |
|
202 |
+ n=regions[regionNum].rowMax-regions[regionNum].rowMin; |
|
203 |
+ j=colMin-1; |
|
204 |
+ for(i=1; i<n; i++) |
|
205 |
+ if(resultBuffer[i][colMin]>0) { |
|
206 |
+ if(resultBuffer[i-1][j]>0 && dataBuffer[i-1][j]==dataBuffer[i][colMin]) |
|
207 |
+ resolveEquivalence(resultBuffer[i][colMin],regionNum, |
|
208 |
+ resultBuffer[i-1][j],regionNum-1); |
|
209 |
+ if(resultBuffer[i][j]>0 && dataBuffer[i][j]==dataBuffer[i][colMin]) |
|
210 |
+ resolveEquivalence(resultBuffer[i][colMin],regionNum, |
|
211 |
+ resultBuffer[i][j],regionNum-1); |
|
212 |
+ if(resultBuffer[i+1][j]>0 && dataBuffer[i+1][j]==dataBuffer[i][colMin]) |
|
213 |
+ resolveEquivalence(resultBuffer[i][colMin],regionNum, |
|
214 |
+ resultBuffer[i+1][j],regionNum-1); |
|
215 |
+ } |
|
216 |
+ if(resultBuffer[n][colMin]>0) { |
|
217 |
+ if(resultBuffer[n-1][j]>0 && dataBuffer[n-1][j]==dataBuffer[n][colMin]) |
|
218 |
+ resolveEquivalence(resultBuffer[n][colMin],regionNum, |
|
219 |
+ resultBuffer[n-1][j],regionNum-1); |
|
220 |
+ if(resultBuffer[n][j]>0 && dataBuffer[n][j]==dataBuffer[n][colMin]) |
|
221 |
+ resolveEquivalence(resultBuffer[n][colMin],regionNum, |
|
222 |
+ resultBuffer[n][j],regionNum-1); |
|
223 |
+ } |
|
224 |
+ } |
|
225 |
+ |
|
226 |
+ /* Left, top corner */ |
|
227 |
+ if(resultBuffer[0][colMin]>0) { |
|
228 |
+ /* Left region*/ |
|
229 |
+ if(colMin>0) { |
|
230 |
+ if(resultBuffer[0][colMin-1]>0 && dataBuffer[0][colMin]==dataBuffer[0][colMin-1]) |
|
231 |
+ resolveEquivalence(resultBuffer[0][colMin],regionNum, |
|
232 |
+ resultBuffer[0][colMin-1],regionNum-1); |
|
233 |
+ if(resultBuffer[1][colMin-1]>0 && dataBuffer[0][colMin]==dataBuffer[1][colMin-1]) |
|
234 |
+ resolveEquivalence(resultBuffer[0][colMin],regionNum, |
|
235 |
+ resultBuffer[1][colMin-1],regionNum-1); |
|
236 |
+ } |
|
237 |
+ /* Left-Top region*/ |
|
238 |
+ if((regions[regionNum].rowMin>0)&&(colMin>0)) |
|
239 |
+ if(borderResultBuffer[colMin-1]>0 && dataBuffer[0][colMin]==borderDataBuffer[colMin-1]) |
|
240 |
+ resolveEquivalence(resultBuffer[0][colMin],regionNum, |
|
241 |
+ borderResultBuffer[colMin-1], |
|
242 |
+ regions[regionNum].regionUp-1); |
|
243 |
+ /* Top region */ |
|
244 |
+ if(regions[regionNum].rowMin>0) { |
|
245 |
+ if(borderResultBuffer[colMin]>0 && dataBuffer[0][colMin]==borderDataBuffer[colMin]) |
|
246 |
+ resolveEquivalence(resultBuffer[0][colMin],regionNum, |
|
247 |
+ borderResultBuffer[colMin], |
|
248 |
+ regions[regionNum].regionUp); |
|
249 |
+ if(borderResultBuffer[colMin+1]>0 && dataBuffer[0][colMin]==borderDataBuffer[colMin+1]) |
|
250 |
+ resolveEquivalence(resultBuffer[0][colMin],regionNum, |
|
251 |
+ borderResultBuffer[colMin+1], |
|
252 |
+ regions[regionNum].regionUp); |
|
253 |
+ } |
|
254 |
+ } |
|
255 |
+ /* Top horizontal border */ |
|
256 |
+ if(regions[regionNum].rowMin>0) { |
|
257 |
+ for(i=colMin+1; i<colMax; i++) { |
|
258 |
+ if(resultBuffer[0][i]>0) { |
|
259 |
+ if(borderResultBuffer[i-1]>0 && dataBuffer[0][i]==borderDataBuffer[i-1]) |
|
260 |
+ resolveEquivalence(resultBuffer[0][i],regionNum, |
|
261 |
+ borderResultBuffer[i-1], |
|
262 |
+ regions[regionNum].regionUp);\ |
|
263 |
+ if(borderResultBuffer[i]>0 && dataBuffer[0][i]==borderDataBuffer[i]) |
|
264 |
+ resolveEquivalence(resultBuffer[0][i],regionNum, |
|
265 |
+ borderResultBuffer[i], |
|
266 |
+ regions[regionNum].regionUp);\ |
|
267 |
+ if(borderResultBuffer[i+1]>0 && dataBuffer[0][i]==borderDataBuffer[i+1]) |
|
268 |
+ resolveEquivalence(resultBuffer[0][i],regionNum, |
|
269 |
+ borderResultBuffer[i+1], |
|
270 |
+ regions[regionNum].regionUp);\ |
|
271 |
+ } |
|
272 |
+ } |
|
273 |
+ if(resultBuffer[0][i]>0) { |
|
274 |
+ if(borderResultBuffer[colMax-1]>0 && dataBuffer[0][colMax]==borderDataBuffer[colMax-1]) |
|
275 |
+ resolveEquivalence(resultBuffer[0][colMax],regionNum, |
|
276 |
+ borderResultBuffer[colMax-1], |
|
277 |
+ regions[regionNum].regionUp); |
|
278 |
+ if(borderResultBuffer[colMax]>0 && dataBuffer[0][colMax]==borderDataBuffer[colMax]) |
|
279 |
+ resolveEquivalence(resultBuffer[0][colMax],regionNum, |
|
280 |
+ borderResultBuffer[colMax-1], |
|
281 |
+ regions[regionNum].regionUp); |
|
282 |
+ } |
|
283 |
+ } |
|
284 |
+} |
|
285 |
+ |
|
286 |
+void merge(int n, int nDirections) { |
|
287 |
+ if(nDirections==4) |
|
288 |
+ merge4(n); |
|
289 |
+ else |
|
290 |
+ merge8(n); |
|
291 |
+} |
|
292 |
+ |
|
293 |
+void clump(EZGDAL_LAYER *in_fd, EZGDAL_LAYER *out_fd, int nDirections) { |
|
294 |
+ int rowMin,rowMax,i,j,n,reg; |
|
295 |
+ |
|
296 |
+ totalIndex=0; |
|
297 |
+ for(i=0; i<nRegionRows; i++) { |
|
298 |
+ reg=i*nRegionCols; |
|
299 |
+ ezgdal_show_progress(stdout,reg,nRegions); |
|
300 |
+ n=nDataCols*sizeof(int); |
|
301 |
+ if(i==0) { |
|
302 |
+ memset(borderDataBuffer,0,n); |
|
303 |
+ memset(borderResultBuffer,0,n); |
|
304 |
+ } else { |
|
305 |
+ memcpy(borderDataBuffer,dataBuffer[rowMax-rowMin],n); |
|
306 |
+ memcpy(borderResultBuffer,resultBuffer[rowMax-rowMin],n); |
|
307 |
+ } |
|
308 |
+ rowMin=regions[reg].rowMin; |
|
309 |
+ rowMax=regions[reg].rowMax; |
|
310 |
+ loadDataBuffer(in_fd,rowMin,rowMax); |
|
311 |
+ |
|
312 |
+#pragma omp parallel for private(j) shared(reg,nRegionCols,regions, dataBuffer, resultBuffer, borderDataBuffer,borderResultBuffer) |
|
313 |
+ for(j=0; j<nRegionCols; j++) |
|
314 |
+ clumpRegion(reg+j, nDirections); |
|
315 |
+ |
|
316 |
+ for(j=0; j<nRegionCols; j++) { |
|
317 |
+ n=reg+j; |
|
318 |
+ shiftLablesForRegion(n); |
|
319 |
+ merge(n,nDirections); |
|
320 |
+ } |
|
321 |
+ saveResultBuffer(out_fd,rowMin,rowMax); |
|
322 |
+ } |
|
323 |
+ ezgdal_show_progress(stdout,nRegions,nRegions); |
|
324 |
+} |
|
325 |
+ |
|
326 |
+void labelsOrdering() { |
|
327 |
+ int *index,lbl; |
|
328 |
+ int i,j,x; |
|
329 |
+ index=(int *)calloc(totalIndex+1,sizeof(int)); |
|
330 |
+ x=1; |
|
331 |
+ for(i=0; i<nRegions; i++) |
|
332 |
+ for(j=1; j<=regions[i].nLabels; j++) { |
|
333 |
+ lbl=regions[i].labels[j]; |
|
334 |
+ if(index[lbl]==0) |
|
335 |
+ index[lbl]=x++; |
|
336 |
+ } |
|
337 |
+#pragma omp parallel for private(i,j) |
|
338 |
+ for(i=0; i<nRegions; i++) |
|
339 |
+ for(j=1; j<=regions[i].nLabels; j++) |
|
340 |
+ regions[i].labels[j]=index[regions[i].labels[j]]; |
|
341 |
+ free(index); |
|
342 |
+} |
|
343 |
+ |
|
344 |
+void replaceLabels(EZGDAL_LAYER *in_fd, EZGDAL_LAYER *out_fd) { |
|
345 |
+ int rowMin,rowMax,i,colMin,colMax; |
|
346 |
+ int row,rows,col,cols,colAbs; |
|
347 |
+ |
|
348 |
+ ezgdal_show_progress(stdout,0,nRegions); |
|
349 |
+ labelsOrdering(); |
|
350 |
+ |
|
351 |
+ rowMin=regions[0].rowMin; |
|
352 |
+ rowMax=regions[0].rowMax; |
|
353 |
+ |
|
354 |
+ loadDataBuffer(in_fd,rowMin,rowMax); |
|
355 |
+ for(i=0; i<nRegions; i++) { |
|
356 |
+ ezgdal_show_progress(stdout,i,nRegions); |
|
357 |
+ if(rowMin<regions[i].rowMin) { |
|
358 |
+ saveResultBuffer(out_fd,rowMin,rowMax); |
|
359 |
+ rowMin=regions[i].rowMin; |
|
360 |
+ rowMax=regions[i].rowMax; |
|
361 |
+ loadDataBuffer(in_fd,rowMin,rowMax); |
|
362 |
+ } |
|
363 |
+ colMin=regions[i].colMin; |
|
364 |
+ colMax=regions[i].colMax; |
|
365 |
+ cols=colMax-colMin+1; |
|
366 |
+ rows=rowMax-rowMin+1; |
|
367 |
+#pragma omp parallel for private(row,col,colAbs) shared(rows,cols,dataBuffer,resultBuffer,regions) |
|
368 |
+ for(row=0; row<rows; row++) |
|
369 |
+ for(col=0; col<cols; col++) { |
|
370 |
+ colAbs=col+colMin; |
|
371 |
+ if(!ezgdal_is_null(in_fd,(double)dataBuffer[row][colAbs])) |
|
372 |
+ resultBuffer[row][colAbs]=regions[i].labels[dataBuffer[row][colAbs]]; |
|
373 |
+ else |
|
374 |
+ resultBuffer[row][colAbs]=0; |
|
375 |
+ } |
|
376 |
+ } |
|
377 |
+ saveResultBuffer(out_fd,rowMin,rowMax); |
|
378 |
+ |
|
379 |
+ ezgdal_show_progress(stdout,i,nRegions); |
|
380 |
+} |
... | ... |
@@ -0,0 +1,164 @@ |
1 |
+/**************************************************************************** |
|
2 |
+ * |
|
3 |
+ * PROGRAM: clump4p |
|
4 |
+ * |
|
5 |
+ * AUTHOR(S): Pawel Netzel - SIL UC |
|
6 |
+ * Jarek Jasiewicz - SIL UC |
|
7 |
+ * (clumping algorithm for region) |
|
8 |
+ * |
|
9 |
+ * PURPOSE: Recategorizes data in a raster map layer by grouping cells |
|
10 |
+ * that form physically discrete areas into unique categories. |
|
11 |
+ * |
|
12 |
+ * COPYRIGHT: (C) 2012 by Pawel Netzel |
|
13 |
+ * |
|
14 |
+ * This program is free software under the GNU General Public |
|
15 |
+ * License (>=v2). |
|
16 |
+ * |
|
17 |
+ ***************************************************************************/ |
|
18 |
+ |
|
19 |
+#include <stdio.h> |
|
20 |
+#include <ezgdal.h> |
|
21 |
+#include "data.h" |
|
22 |
+ |
|
23 |
+int totalIndex=0; |
|
24 |
+ |
|
25 |
+int nRegions=0; |
|
26 |
+int nRegionCols=0; |
|
27 |
+int nRegionRows=0; |
|
28 |
+Region *regions; |
|
29 |
+ |
|
30 |
+int nDataCols=0; |
|
31 |
+int nDataRows=0; |
|
32 |
+ |
|
33 |
+int *borderDataBuffer, *borderResultBuffer; |
|
34 |
+int **dataBuffer; |
|
35 |
+int **resultBuffer; |
|
36 |
+int **calcBuffer; |
|
37 |
+ |
|
38 |
+ |
|
39 |
+void createRegions() { |
|
40 |
+ int i,j,rMin,rMax,c,nr; |
|
41 |
+ |
|
42 |
+ nRegionRows=(nDataRows-1)/REGION_SIZE+1; |
|
43 |
+ nRegionCols=(nDataCols-1)/REGION_SIZE+1; |
|
44 |
+ nRegions=nRegionRows*nRegionCols; |
|
45 |
+ regions=(Region *)malloc(nRegions*sizeof(Region)); |
|
46 |
+ |
|
47 |
+ rMin=0; |
|
48 |
+ nr=0; |
|
49 |
+ c=0; |
|
50 |
+ for(i=0; i<nRegionRows; i++) { |
|
51 |
+ rMax=rMin+REGION_SIZE-1; |
|
52 |
+ if(rMax>=nDataRows) rMax=nDataRows-1; |
|
53 |
+ for(j=0; j<nRegionCols; j++) { |
|
54 |
+ regions[nr].rowMin=rMin; |
|
55 |
+ regions[nr].rowMax=rMax; |
|
56 |
+ regions[nr].colMin=c; |
|
57 |
+ c+=REGION_SIZE-1; |
|
58 |
+ if(c>=nDataCols) c=nDataCols-1; |
|
59 |
+ regions[nr].colMax=c; |
|
60 |
+ regions[nr].nLabels=0; |
|
61 |
+ regions[nr].labels=(int *)malloc(INCR*sizeof(int)); |
|
62 |
+ regions[nr].labels[0]=0; |
|
63 |
+ if(i==0) |
|
64 |
+ regions[nr].regionUp=-1; |
|
65 |
+ else |
|
66 |
+ regions[nr].regionUp=(i-1)*nRegionCols+j; |
|
67 |
+ nr++; |
|
68 |
+ c+=1; |
|
69 |
+ } |
|
70 |
+ c=0; |
|
71 |
+ rMin=rMax+1; |
|
72 |
+ } |
|
73 |
+} |
|
74 |
+ |
|
75 |
+void dumpArray(int *arr, int num) { |
|
76 |
+ int i; |
|
77 |
+ for(i=0; i<num; i++) { |
|
78 |
+ if(i>0) printf(", "); |
|
79 |
+ printf("[%d]=%d",i,arr[i]); |
|
80 |
+ } |
|
81 |
+} |
|
82 |
+ |
|
83 |
+void dumpRegions(char *Comment) { |
|
84 |
+ int i; |
|
85 |
+ printf("%s\n",Comment); |
|
86 |
+ for(i=0; i<nRegions; i++) { |
|
87 |
+ printf("%d: c(%d,%d), r(%d,%d) nLab: %d, Labs: ", |
|
88 |
+ i, regions[i].colMin,regions[i].colMax, |
|
89 |
+ regions[i].rowMin,regions[i].rowMax, |
|
90 |
+ regions[i].nLabels); |
|
91 |
+ dumpArray(regions[i].labels,regions[i].nLabels+1); |
|
92 |
+ printf("\n"); |
|
93 |
+ } |
|
94 |
+} |
|
95 |
+ |
|
96 |
+void destroyRegions() { |
|
97 |
+ int i; |
|
98 |
+ for(i=0; i<nRegions; i++) |
|
99 |
+ free(regions[i].labels); |
|
100 |
+ free(regions); |
|
101 |
+} |
|
102 |
+ |
|
103 |
+void createBuffers() { |
|
104 |
+ dataBuffer=(int **)malloc(REGION_SIZE*sizeof(int*)); |
|
105 |
+ resultBuffer=(int **)malloc(REGION_SIZE*sizeof(int*)); |
|
106 |
+ int i,n; |
|
107 |
+ n=nDataCols*sizeof(int); |
|
108 |
+ for(i=0; i<REGION_SIZE; i++) { |
|
109 |
+ dataBuffer[i]=(int *)malloc(n); |
|
110 |
+ resultBuffer[i]=(int *)malloc(n); |
|
111 |
+ } |
|
112 |
+ borderDataBuffer=(int *)calloc(n,1); |
|
113 |
+ borderResultBuffer=(int *)calloc(n,1); |
|
114 |
+} |
|
115 |
+ |
|
116 |
+void destroyBuffers() { |
|
117 |
+ int i; |
|
118 |
+ free(borderDataBuffer); |
|
119 |
+ free(borderResultBuffer); |
|
120 |
+ for(i=0; i<REGION_SIZE; i++) { |
|
121 |
+ free(dataBuffer[i]); |
|
122 |
+ free(resultBuffer[i]); |
|
123 |
+ } |
|
124 |
+ free(dataBuffer); |
|
125 |
+ free(resultBuffer); |
|
126 |
+} |
|
127 |
+ |
|
128 |
+void loadDataBuffer(EZGDAL_LAYER *layer, int minRow, int maxRow) { |
|
129 |
+ int i,n,j; |
|
130 |
+ n=maxRow-minRow+1; |
|
131 |
+ for(i=0; i<n; i++) { |
|
132 |
+ ezgdal_read_buffer(layer,i+minRow); |
|
133 |
+ for(j=0; j<nDataCols; j++) |
|
134 |
+ dataBuffer[i][j]=(int)layer->buffer[j]; |
|
135 |
+ } |
|
136 |
+} |
|
137 |
+ |
|
138 |
+void saveResultBuffer(EZGDAL_LAYER *layer, int minRow, int maxRow) { |
|
139 |
+ int i,j,n; |
|
140 |
+ n=maxRow-minRow+1; |
|
141 |
+ for(i=0; i<n; i++) { |
|
142 |
+ for(j=0; j<nDataCols; j++) |
|
143 |
+ if(resultBuffer[i][j] == 0) |
|
144 |
+ ezgdal_set_null(layer, &(layer->buffer[j])); |
|
145 |
+ else |
|
146 |
+ layer->buffer[j] = (double)resultBuffer[i][j]; |
|
147 |
+ ezgdal_write_buffer(layer, i+minRow); |
|
148 |
+ } |
|
149 |
+} |
|
150 |
+ |
|
151 |
+void initVariables(EZGDAL_LAYER *layer) { |
|
152 |
+ nDataRows = layer->rows; |
|
153 |
+ nDataCols = layer->cols; |
|
154 |
+ totalIndex=0; |
|
155 |
+ createRegions(); |
|
156 |
+ createBuffers(); |
|
157 |
+} |
|
158 |
+ |
|
159 |
+void freeVariables() { |
|
160 |
+ destroyRegions(); |
|
161 |
+ destroyBuffers(); |
|
162 |
+} |
|
163 |
+ |
|
164 |
+ |
... | ... |
@@ -0,0 +1,61 @@ |
1 |
+/**************************************************************************** |
|
2 |
+ * |
|
3 |
+ * PROGRAM: clump4p |
|
4 |
+ * |
|
5 |
+ * AUTHOR(S): Pawel Netzel - SIL UC |
|
6 |
+ * Jarek Jasiewicz - SIL UC |
|
7 |
+ * (the clumping algorithm for a region) |
|
8 |
+ * |
|
9 |
+ * PURPOSE: Recategorizes data in a raster map layer by grouping cells |
|
10 |
+ * that form physically discrete areas into unique categories. |
|
11 |
+ * |
|
12 |
+ * COPYRIGHT: (C) 2012 by Pawel Netzel |
|
13 |
+ * |
|
14 |
+ * This program is a free software under the GNU General Public |
|
15 |
+ * License (>=v2). |
|
16 |
+ * |
|
17 |
+ ***************************************************************************/ |
|
18 |
+ |
|
19 |
+#ifndef _DATA_H_ |
|
20 |
+#define _DATA_H_ |
|
21 |
+ |
|
22 |
+#include <ezgdal.h> |
|
23 |
+#include "main.h" |
|
24 |
+ |
|
25 |
+#define REGION_SIZE 500 |
|
26 |
+#define INCR 4096 |
|
27 |
+ |
|
28 |
+typedef struct { |
|
29 |
+ int rowMin,rowMax; |
|
30 |
+ int colMin,colMax; |
|
31 |
+ int nLabels; // max labal number |
|
32 |
+ int *labels; // array from 1 |
|
33 |
+ int regionUp; |
|
34 |
+} Region; |
|
35 |
+ |
|
36 |
+extern int totalIndex; |
|
37 |
+ |
|
38 |
+extern int nRegions; |
|
39 |
+extern int nRegionCols; |
|
40 |
+extern int nRegionRows; |
|
41 |
+extern Region *regions; |
|
42 |
+ |
|
43 |
+extern int nDataCols; |
|
44 |
+extern int nDataRows; |
|
45 |
+ |
|
46 |
+extern int *borderDataBuffer, *borderResultBuffer; |
|
47 |
+extern int **dataBuffer; |
|
48 |
+extern int **resultBuffer; |
|
49 |
+extern int **calcBuffer; |
|
50 |
+ |
|
51 |
+void initVariables(EZGDAL_LAYER *); |
|
52 |
+void freeVariables(); |
|
53 |
+ |
|
54 |
+void loadDataBuffer(EZGDAL_LAYER *, int, int); |
|
55 |
+void saveResultBuffer(EZGDAL_LAYER *, int, int); |
|
56 |
+ |
|
57 |
+void dumpArray(int *, int); |
|
58 |
+void dumpRegions(char *); |
|
59 |
+ |
|
60 |
+#endif |
|
61 |
+ |
... | ... |
@@ -0,0 +1,674 @@ |
1 |
+ GNU GENERAL PUBLIC LICENSE |
|
2 |
+ Version 3, 29 June 2007 |
|
3 |
+ |
|
4 |
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
|
5 |
+ Everyone is permitted to copy and distribute verbatim copies |
|
6 |
+ of this license document, but changing it is not allowed. |
|
7 |
+ |
|
8 |
+ Preamble |
|
9 |
+ |
|
10 |
+ The GNU General Public License is a free, copyleft license for |
|
11 |
+software and other kinds of works. |
|
12 |
+ |
|
13 |
+ The licenses for most software and other practical works are designed |
|
14 |
+to take away your freedom to share and change the works. By contrast, |
|
15 |
+the GNU General Public License is intended to guarantee your freedom to |
|
16 |
+share and change all versions of a program--to make sure it remains free |
|
17 |
+software for all its users. We, the Free Software Foundation, use the |
|
18 |
+GNU General Public License for most of our software; it applies also to |
|
19 |
+any other work released this way by its authors. You can apply it to |
|
20 |
+your programs, too. |
|
21 |
+ |
|
22 |
+ When we speak of free software, we are referring to freedom, not |
|
23 |
+price. Our General Public Licenses are designed to make sure that you |
|
24 |
+have the freedom to distribute copies of free software (and charge for |
|
25 |
+them if you wish), that you receive source code or can get it if you |
|
26 |
+want it, that you can change the software or use pieces of it in new |
|
27 |
+free programs, and that you know you can do these things. |
|
28 |
+ |
|
29 |
+ To protect your rights, we need to prevent others from denying you |
|
30 |
+these rights or asking you to surrender the rights. Therefore, you have |
|
31 |
+certain responsibilities if you distribute copies of the software, or if |
|
32 |
+you modify it: responsibilities to respect the freedom of others. |
|
33 |
+ |
|
34 |
+ For example, if you distribute copies of such a program, whether |
|
35 |
+gratis or for a fee, you must pass on to the recipients the same |
|
36 |
+freedoms that you received. You must make sure that they, too, receive |
|
37 |
+or can get the source code. And you must show them these terms so they |
|
38 |
+know their rights. |
|
39 |
+ |
|
40 |
+ Developers that use the GNU GPL protect your rights with two steps: |
|
41 |
+(1) assert copyright on the software, and (2) offer you this License |
|
42 |
+giving you legal permission to copy, distribute and/or modify it. |
|
43 |
+ |
|
44 |
+ For the developers' and authors' protection, the GPL clearly explains |
|
45 |
+that there is no warranty for this free software. For both users' and |
|
46 |
+authors' sake, the GPL requires that modified versions be marked as |
|
47 |
+changed, so that their problems will not be attributed erroneously to |
|
48 |
+authors of previous versions. |
|
49 |
+ |
|
50 |
+ Some devices are designed to deny users access to install or run |
|
51 |
+modified versions of the software inside them, although the manufacturer |
|
52 |
+can do so. This is fundamentally incompatible with the aim of |
|
53 |
+protecting users' freedom to change the software. The systematic |
|
54 |
+pattern of such abuse occurs in the area of products for individuals to |
|
55 |
+use, which is precisely where it is most unacceptable. Therefore, we |
|
56 |
+have designed this version of the GPL to prohibit the practice for those |
|
57 |
+products. If such problems arise substantially in other domains, we |
|
58 |
+stand ready to extend this provision to those domains in future versions |
|
59 |
+of the GPL, as needed to protect the freedom of users. |
|
60 |
+ |
|
61 |
+ Finally, every program is threatened constantly by software patents. |
|
62 |
+States should not allow patents to restrict development and use of |
|
63 |
+software on general-purpose computers, but in those that do, we wish to |
|
64 |
+avoid the special danger that patents applied to a free program could |
|
65 |
+make it effectively proprietary. To prevent this, the GPL assures that |
|
66 |
+patents cannot be used to render the program non-free. |
|
67 |
+ |
|
68 |
+ The precise terms and conditions for copying, distribution and |
|
69 |
+modification follow. |
|
70 |
+ |
|
71 |
+ TERMS AND CONDITIONS |
|
72 |
+ |
|
73 |
+ 0. Definitions. |
|
74 |
+ |
|
75 |
+ "This License" refers to version 3 of the GNU General Public License. |
|
76 |
+ |
|
77 |
+ "Copyright" also means copyright-like laws that apply to other kinds of |
|
78 |
+works, such as semiconductor masks. |
|
79 |
+ |
|
80 |
+ "The Program" refers to any copyrightable work licensed under this |
|
81 |
+License. Each licensee is addressed as "you". "Licensees" and |
|
82 |
+"recipients" may be individuals or organizations. |
|
83 |
+ |
|
84 |
+ To "modify" a work means to copy from or adapt all or part of the work |
|
85 |
+in a fashion requiring copyright permission, other than the making of an |
|
86 |
+exact copy. The resulting work is called a "modified version" of the |
|
87 |
+earlier work or a work "based on" the earlier work. |
|
88 |
+ |
|
89 |
+ A "covered work" means either the unmodified Program or a work based |
|
90 |
+on the Program. |
|
91 |
+ |
|
92 |
+ To "propagate" a work means to do anything with it that, without |
|
93 |
+permission, would make you directly or secondarily liable for |
|
94 |
+infringement under applicable copyright law, except executing it on a |
|
95 |
+computer or modifying a private copy. Propagation includes copying, |
|
96 |
+distribution (with or without modification), making available to the |
|
97 |
+public, and in some countries other activities as well. |
|
98 |
+ |
|
99 |
+ To "convey" a work means any kind of propagation that enables other |
|
100 |
+parties to make or receive copies. Mere interaction with a user through |
|
101 |
+a computer network, with no transfer of a copy, is not conveying. |
|
102 |
+ |
|
103 |
+ An interactive user interface displays "Appropriate Legal Notices" |
|
104 |
+to the extent that it includes a convenient and prominently visible |
|
105 |
+feature that (1) displays an appropriate copyright notice, and (2) |
|
106 |
+tells the user that there is no warranty for the work (except to the |
|
107 |
+extent that warranties are provided), that licensees may convey the |
|
108 |
+work under this License, and how to view a copy of this License. If |
|
109 |
+the interface presents a list of user commands or options, such as a |
|
110 |
+menu, a prominent item in the list meets this criterion. |
|
111 |
+ |
|
112 |
+ 1. Source Code. |
|
113 |
+ |
|
114 |
+ The "source code" for a work means the preferred form of the work |
|
115 |
+for making modifications to it. "Object code" means any non-source |
|
116 |
+form of a work. |
|
117 |
+ |
|
118 |
+ A "Standard Interface" means an interface that either is an official |
|
119 |
+standard defined by a recognized standards body, or, in the case of |
|
120 |
+interfaces specified for a particular programming language, one that |
|
121 |
+is widely used among developers working in that language. |
|
122 |
+ |
|
123 |
+ The "System Libraries" of an executable work include anything, other |
|
124 |
+than the work as a whole, that (a) is included in the normal form of |
|
125 |
+packaging a Major Component, but which is not part of that Major |
|
126 |
+Component, and (b) serves only to enable use of the work with that |
|
127 |
+Major Component, or to implement a Standard Interface for which an |
|
128 |
+implementation is available to the public in source code form. A |
|
129 |
+"Major Component", in this context, means a major essential component |
|
130 |
+(kernel, window system, and so on) of the specific operating system |
|
131 |
+(if any) on which the executable work runs, or a compiler used to |
|
132 |
+produce the work, or an object code interpreter used to run it. |
|
133 |
+ |
|
134 |
+ The "Corresponding Source" for a work in object code form means all |
|
135 |
+the source code needed to generate, install, and (for an executable |
|
136 |
+work) run the object code and to modify the work, including scripts to |
|
137 |
+control those activities. However, it does not include the work's |
|
138 |
+System Libraries, or general-purpose tools or generally available free |
|
139 |
+programs which are used unmodified in performing those activities but |
|
140 |
+which are not part of the work. For example, Corresponding Source |
|
141 |
+includes interface definition files associated with source files for |
|
142 |
+the work, and the source code for shared libraries and dynamically |
|
143 |
+linked subprograms that the work is specifically designed to require, |
|
144 |
+such as by intimate data communication or control flow between those |
|
145 |
+subprograms and other parts of the work. |
|
146 |
+ |
|
147 |
+ The Corresponding Source need not include anything that users |
|
148 |
+can regenerate automatically from other parts of the Corresponding |
|
149 |
+Source. |
|
150 |
+ |
|
151 |
+ The Corresponding Source for a work in source code form is that |
|
152 |
+same work. |
|
153 |
+ |
|
154 |
+ 2. Basic Permissions. |
|
155 |
+ |
|
156 |
+ All rights granted under this License are granted for the term of |
|
157 |
+copyright on the Program, and are irrevocable provided the stated |
|
158 |
+conditions are met. This License explicitly affirms your unlimited |
|
159 |
+permission to run the unmodified Program. The output from running a |
|
160 |
+covered work is covered by this License only if the output, given its |
|
161 |
+content, constitutes a covered work. This License acknowledges your |
|
162 |
+rights of fair use or other equivalent, as provided by copyright law. |
|
163 |
+ |
|
164 |
+ You may make, run and propagate covered works that you do not |
|
165 |
+convey, without conditions so long as your license otherwise remains |
|
166 |
+in force. You may convey covered works to others for the sole purpose |
|
167 |
+of having them make modifications exclusively for you, or provide you |
|
168 |
+with facilities for running those works, provided that you comply with |
|
169 |
+the terms of this License in conveying all material for which you do |
|
170 |
+not control copyright. Those thus making or running the covered works |
|
171 |
+for you must do so exclusively on your behalf, under your direction |
|
172 |
+and control, on terms that prohibit them from making any copies of |
|
173 |
+your copyrighted material outside their relationship with you. |
|
174 |
+ |
|
175 |
+ Conveying under any other circumstances is permitted solely under |
|
176 |
+the conditions stated below. Sublicensing is not allowed; section 10 |
|
177 |
+makes it unnecessary. |
|
178 |
+ |
|
179 |
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law. |
|
180 |
+ |
|
181 |
+ No covered work shall be deemed part of an effective technological |
|
182 |
+measure under any applicable law fulfilling obligations under article |
|
183 |
+11 of the WIPO copyright treaty adopted on 20 December 1996, or |
|
184 |
+similar laws prohibiting or restricting circumvention of such |
|
185 |
+measures. |
|
186 |
+ |
|
187 |
+ When you convey a covered work, you waive any legal power to forbid |
|
188 |
+circumvention of technological measures to the extent such circumvention |
|
189 |
+is effected by exercising rights under this License with respect to |
|
190 |
+the covered work, and you disclaim any intention to limit operation or |
|
191 |
+modification of the work as a means of enforcing, against the work's |
|
192 |
+users, your or third parties' legal rights to forbid circumvention of |
|
193 |
+technological measures. |
|
194 |
+ |
|
195 |
+ 4. Conveying Verbatim Copies. |
|
196 |
+ |
|
197 |
+ You may convey verbatim copies of the Program's source code as you |
|
198 |
+receive it, in any medium, provided that you conspicuously and |
|
199 |
+appropriately publish on each copy an appropriate copyright notice; |
|
200 |
+keep intact all notices stating that this License and any |
|
201 |
+non-permissive terms added in accord with section 7 apply to the code; |
|
202 |
+keep intact all notices of the absence of any warranty; and give all |
|
203 |
+recipients a copy of this License along with the Program. |
|
204 |
+ |
|
205 |
+ You may charge any price or no price for each copy that you convey, |
|
206 |
+and you may offer support or warranty protection for a fee. |
|
207 |
+ |
|
208 |
+ 5. Conveying Modified Source Versions. |
|
209 |
+ |
|
210 |
+ You may convey a work based on the Program, or the modifications to |
|
211 |
+produce it from the Program, in the form of source code under the |
|
212 |
+terms of section 4, provided that you also meet all of these conditions: |
|
213 |
+ |
|
214 |
+ a) The work must carry prominent notices stating that you modified |
|
215 |
+ it, and giving a relevant date. |
|
216 |
+ |
|
217 |
+ b) The work must carry prominent notices stating that it is |
|
218 |
+ released under this License and any conditions added under section |
|
219 |
+ 7. This requirement modifies the requirement in section 4 to |
|
220 |
+ "keep intact all notices". |
|
221 |
+ |
|
222 |
+ c) You must license the entire work, as a whole, under this |
|
223 |
+ License to anyone who comes into possession of a copy. This |
|
224 |
+ License will therefore apply, along with any applicable section 7 |
|
225 |
+ additional terms, to the whole of the work, and all its parts, |
|
226 |
+ regardless of how they are packaged. This License gives no |
|
227 |
+ permission to license the work in any other way, but it does not |
|
228 |
+ invalidate such permission if you have separately received it. |
|
229 |
+ |
|
230 |
+ d) If the work has interactive user interfaces, each must display |
|
231 |
+ Appropriate Legal Notices; however, if the Program has interactive |
|
232 |
+ interfaces that do not display Appropriate Legal Notices, your |
|
233 |
+ work need not make them do so. |
|
234 |
+ |
|
235 |
+ A compilation of a covered work with other separate and independent |
|
236 |
+works, which are not by their nature extensions of the covered work, |
|
237 |
+and which are not combined with it such as to form a larger program, |
|
238 |
+in or on a volume of a storage or distribution medium, is called an |
|
239 |
+"aggregate" if the compilation and its resulting copyright are not |
|
240 |
+used to limit the access or legal rights of the compilation's users |
|
241 |
+beyond what the individual works permit. Inclusion of a covered work |
|
242 |
+in an aggregate does not cause this License to apply to the other |
|
243 |
+parts of the aggregate. |
|
244 |
+ |
|
245 |
+ 6. Conveying Non-Source Forms. |
|
246 |
+ |
|
247 |
+ You may convey a covered work in object code form under the terms |
|
248 |
+of sections 4 and 5, provided that you also convey the |
|
249 |
+machine-readable Corresponding Source under the terms of this License, |
|
250 |
+in one of these ways: |
|
251 |
+ |
|
252 |
+ a) Convey the object code in, or embodied in, a physical product |
|
253 |
+ (including a physical distribution medium), accompanied by the |
|
254 |
+ Corresponding Source fixed on a durable physical medium |
|
255 |
+ customarily used for software interchange. |
|
256 |
+ |
|
257 |
+ b) Convey the object code in, or embodied in, a physical product |
|
258 |
+ (including a physical distribution medium), accompanied by a |
|
259 |
+ written offer, valid for at least three years and valid for as |
|
260 |
+ long as you offer spare parts or customer support for that product |
|
261 |
+ model, to give anyone who possesses the object code either (1) a |
|
262 |
+ copy of the Corresponding Source for all the software in the |
|
263 |
+ product that is covered by this License, on a durable physical |
|
264 |
+ medium customarily used for software interchange, for a price no |
|
265 |
+ more than your reasonable cost of physically performing this |
|
266 |
+ conveying of source, or (2) access to copy the |
|
267 |
+ Corresponding Source from a network server at no charge. |
|
268 |
+ |
|
269 |
+ c) Convey individual copies of the object code with a copy of the |
|
270 |
+ written offer to provide the Corresponding Source. This |
|
271 |
+ alternative is allowed only occasionally and noncommercially, and |
|
272 |
+ only if you received the object code with such an offer, in accord |
|
273 |
+ with subsection 6b. |
|
274 |
+ |
|
275 |
+ d) Convey the object code by offering access from a designated |
|
276 |
+ place (gratis or for a charge), and offer equivalent access to the |
|
277 |
+ Corresponding Source in the same way through the same place at no |
|
278 |
+ further charge. You need not require recipients to copy the |
|
279 |
+ Corresponding Source along with the object code. If the place to |
|
280 |
+ copy the object code is a network server, the Corresponding Source |
|
281 |
+ may be on a different server (operated by you or a third party) |
|
282 |
+ that supports equivalent copying facilities, provided you maintain |
|
283 |
+ clear directions next to the object code saying where to find the |
|
284 |
+ Corresponding Source. Regardless of what server hosts the |
|
285 |
+ Corresponding Source, you remain obligated to ensure that it is |
|
286 |
+ available for as long as needed to satisfy these requirements. |
|
287 |
+ |
|
288 |
+ e) Convey the object code using peer-to-peer transmission, provided |
|
289 |
+ you inform other peers where the object code and Corresponding |
|
290 |
+ Source of the work are being offered to the general public at no |
|
291 |
+ charge under subsection 6d. |
|
292 |
+ |
|
293 |
+ A separable portion of the object code, whose source code is excluded |
|
294 |
+from the Corresponding Source as a System Library, need not be |
|
295 |
+included in conveying the object code work. |
|
296 |
+ |
|
297 |
+ A "User Product" is either (1) a "consumer product", which means any |
|
298 |
+tangible personal property which is normally used for personal, family, |
|
299 |
+or household purposes, or (2) anything designed or sold for incorporation |
|
300 |
+into a dwelling. In determining whether a product is a consumer product, |
|
301 |
+doubtful cases shall be resolved in favor of coverage. For a particular |
|
302 |
+product received by a particular user, "normally used" refers to a |
|
303 |
+typical or common use of that class of product, regardless of the status |
|
304 |
+of the particular user or of the way in which the particular user |
|
305 |
+actually uses, or expects or is expected to use, the product. A product |
|
306 |
+is a consumer product regardless of whether the product has substantial |
|
307 |
+commercial, industrial or non-consumer uses, unless such uses represent |
|
308 |
+the only significant mode of use of the product. |
|
309 |
+ |
|
310 |
+ "Installation Information" for a User Product means any methods, |
|
311 |
+procedures, authorization keys, or other information required to install |
|
312 |
+and execute modified versions of a covered work in that User Product from |
|
313 |
+a modified version of its Corresponding Source. The information must |
|
314 |
+suffice to ensure that the continued functioning of the modified object |
|
315 |
+code is in no case prevented or interfered with solely because |
|
316 |
+modification has been made. |
|
317 |
+ |
|
318 |
+ If you convey an object code work under this section in, or with, or |
|
319 |
+specifically for use in, a User Product, and the conveying occurs as |
|
320 |
+part of a transaction in which the right of possession and use of the |
|
321 |
+User Product is transferred to the recipient in perpetuity or for a |
|
322 |
+fixed term (regardless of how the transaction is characterized), the |
|
323 |
+Corresponding Source conveyed under this section must be accompanied |
|
324 |
+by the Installation Information. But this requirement does not apply |
|
325 |
+if neither you nor any third party retains the ability to install |
|
326 |
+modified object code on the User Product (for example, the work has |
|
327 |
+been installed in ROM). |
|
328 |
+ |
|
329 |
+ The requirement to provide Installation Information does not include a |
|
330 |
+requirement to continue to provide support service, warranty, or updates |
|
331 |
+for a work that has been modified or installed by the recipient, or for |
|
332 |
+the User Product in which it has been modified or installed. Access to a |
|
333 |
+network may be denied when the modification itself materially and |
|
334 |
+adversely affects the operation of the network or violates the rules and |
|
335 |
+protocols for communication across the network. |
|
336 |
+ |
|
337 |
+ Corresponding Source conveyed, and Installation Information provided, |
|
338 |
+in accord with this section must be in a format that is publicly |
|
339 |
+documented (and with an implementation available to the public in |
|
340 |
+source code form), and must require no special password or key for |
|
341 |
+unpacking, reading or copying. |
|
342 |
+ |
|
343 |
+ 7. Additional Terms. |
|
344 |
+ |
|
345 |
+ "Additional permissions" are terms that supplement the terms of this |
|
346 |
+License by making exceptions from one or more of its conditions. |
|
347 |
+Additional permissions that are applicable to the entire Program shall |
|
348 |
+be treated as though they were included in this License, to the extent |
|
349 |
+that they are valid under applicable law. If additional permissions |
|
350 |
+apply only to part of the Program, that part may be used separately |
|
351 |
+under those permissions, but the entire Program remains governed by |
|
352 |
+this License without regard to the additional permissions. |
|
353 |
+ |
|
354 |
+ When you convey a copy of a covered work, you may at your option |
|
355 |
+remove any additional permissions from that copy, or from any part of |
|
356 |
+it. (Additional permissions may be written to require their own |
|
357 |
+removal in certain cases when you modify the work.) You may place |
|
358 |
+additional permissions on material, added by you to a covered work, |
|
359 |
+for which you have or can give appropriate copyright permission. |
|
360 |
+ |
|
361 |
+ Notwithstanding any other provision of this License, for material you |
|
362 |
+add to a covered work, you may (if authorized by the copyright holders of |
|
363 |
+that material) supplement the terms of this License with terms: |
|
364 |
+ |
|
365 |
+ a) Disclaiming warranty or limiting liability differently from the |
|
366 |
+ terms of sections 15 and 16 of this License; or |
|
367 |
+ |
|
368 |
+ b) Requiring preservation of specified reasonable legal notices or |
|
369 |
+ author attributions in that material or in the Appropriate Legal |
|
370 |
+ Notices displayed by works containing it; or |
|
371 |
+ |
|
372 |
+ c) Prohibiting misrepresentation of the origin of that material, or |
|
373 |
+ requiring that modified versions of such material be marked in |
|
374 |
+ reasonable ways as different from the original version; or |
|
375 |
+ |
|
376 |
+ d) Limiting the use for publicity purposes of names of licensors or |
|
377 |
+ authors of the material; or |
|
378 |
+ |
|
379 |
+ e) Declining to grant rights under trademark law for use of some |
|
380 |
+ trade names, trademarks, or service marks; or |
|
381 |
+ |
|
382 |
+ f) Requiring indemnification of licensors and authors of that |
|
383 |
+ material by anyone who conveys the material (or modified versions of |
|
384 |
+ it) with contractual assumptions of liability to the recipient, for |
|
385 |
+ any liability that these contractual assumptions directly impose on |
|
386 |
+ those licensors and authors. |
|
387 |
+ |
|
388 |
+ All other non-permissive additional terms are considered "further |
|
389 |
+restrictions" within the meaning of section 10. If the Program as you |
|
390 |
+received it, or any part of it, contains a notice stating that it is |
|
391 |
+governed by this License along with a term that is a further |
|
392 |
+restriction, you may remove that term. If a license document contains |
|
393 |
+a further restriction but permits relicensing or conveying under this |
|
394 |
+License, you may add to a covered work material governed by the terms |
|
395 |
+of that license document, provided that the further restriction does |
|
396 |
+not survive such relicensing or conveying. |
|
397 |
+ |
|
398 |
+ If you add terms to a covered work in accord with this section, you |
|
399 |
+must place, in the relevant source files, a statement of the |
|
400 |
+additional terms that apply to those files, or a notice indicating |
|
401 |
+where to find the applicable terms. |
|
402 |
+ |
|
403 |
+ Additional terms, permissive or non-permissive, may be stated in the |
|
404 |
+form of a separately written license, or stated as exceptions; |
|
405 |
+the above requirements apply either way. |
|
406 |
+ |
|
407 |
+ 8. Termination. |
|
408 |
+ |
|
409 |
+ You may not propagate or modify a covered work except as expressly |
|
410 |
+provided under this License. Any attempt otherwise to propagate or |
|
411 |
+modify it is void, and will automatically terminate your rights under |
|
412 |
+this License (including any patent licenses granted under the third |
|
413 |
+paragraph of section 11). |
|
414 |
+ |
|
415 |
+ However, if you cease all violation of this License, then your |
|
416 |
+license from a particular copyright holder is reinstated (a) |
|
417 |
+provisionally, unless and until the copyright holder explicitly and |
|
418 |
+finally terminates your license, and (b) permanently, if the copyright |
|
419 |
+holder fails to notify you of the violation by some reasonable means |
|
420 |
+prior to 60 days after the cessation. |
|
421 |
+ |
|
422 |
+ Moreover, your license from a particular copyright holder is |
|
423 |
+reinstated permanently if the copyright holder notifies you of the |
|
424 |
+violation by some reasonable means, this is the first time you have |
|
425 |
+received notice of violation of this License (for any work) from that |
|
426 |
+copyright holder, and you cure the violation prior to 30 days after |
|
427 |
+your receipt of the notice. |
|
428 |
+ |
|
429 |
+ Termination of your rights under this section does not terminate the |
|
430 |
+licenses of parties who have received copies or rights from you under |
|
431 |
+this License. If your rights have been terminated and not permanently |
|
432 |
+reinstated, you do not qualify to receive new licenses for the same |
|
433 |
+material under section 10. |
|
434 |
+ |
|
435 |
+ 9. Acceptance Not Required for Having Copies. |
|
436 |
+ |
|
437 |
+ You are not required to accept this License in order to receive or |
|
438 |
+run a copy of the Program. Ancillary propagation of a covered work |
|
439 |
+occurring solely as a consequence of using peer-to-peer transmission |
|
440 |
+to receive a copy likewise does not require acceptance. However, |
|
441 |
+nothing other than this License grants you permission to propagate or |
|
442 |
+modify any covered work. These actions infringe copyright if you do |
|
443 |
+not accept this License. Therefore, by modifying or propagating a |
|
444 |
+covered work, you indicate your acceptance of this License to do so. |
|
445 |
+ |
|
446 |
+ 10. Automatic Licensing of Downstream Recipients. |
|
447 |
+ |
|
448 |
+ Each time you convey a covered work, the recipient automatically |
|
449 |
+receives a license from the original licensors, to run, modify and |
|
450 |
+propagate that work, subject to this License. You are not responsible |
|
451 |
+for enforcing compliance by third parties with this License. |
|
452 |
+ |
|
453 |
+ An "entity transaction" is a transaction transferring control of an |
|
454 |
+organization, or substantially all assets of one, or subdividing an |
|
455 |
+organization, or merging organizations. If propagation of a covered |
|
456 |
+work results from an entity transaction, each party to that |
|
457 |
+transaction who receives a copy of the work also receives whatever |
|
458 |
+licenses to the work the party's predecessor in interest had or could |
|
459 |
+give under the previous paragraph, plus a right to possession of the |
|
460 |
+Corresponding Source of the work from the predecessor in interest, if |
|
461 |
+the predecessor has it or can get it with reasonable efforts. |
|
462 |
+ |
|
463 |
+ You may not impose any further restrictions on the exercise of the |
|
464 |
+rights granted or affirmed under this License. For example, you may |
|
465 |
+not impose a license fee, royalty, or other charge for exercise of |
|
466 |
+rights granted under this License, and you may not initiate litigation |
|
467 |
+(including a cross-claim or counterclaim in a lawsuit) alleging that |
|
468 |
+any patent claim is infringed by making, using, selling, offering for |
|
469 |
+sale, or importing the Program or any portion of it. |
|
470 |
+ |
|
471 |
+ 11. Patents. |
|
472 |
+ |
|
473 |
+ A "contributor" is a copyright holder who authorizes use under this |
|
474 |
+License of the Program or a work on which the Program is based. The |
|
475 |
+work thus licensed is called the contributor's "contributor version". |
|
476 |
+ |
|
477 |
+ A contributor's "essential patent claims" are all patent claims |
|
478 |
+owned or controlled by the contributor, whether already acquired or |
|
479 |
+hereafter acquired, that would be infringed by some manner, permitted |
|
480 |
+by this License, of making, using, or selling its contributor version, |
|
481 |
+but do not include claims that would be infringed only as a |
|
482 |
+consequence of further modification of the contributor version. For |
|
483 |
+purposes of this definition, "control" includes the right to grant |
|
484 |
+patent sublicenses in a manner consistent with the requirements of |
|
485 |
+this License. |
|
486 |
+ |
|
487 |
+ Each contributor grants you a non-exclusive, worldwide, royalty-free |
|
488 |
+patent license under the contributor's essential patent claims, to |
|
489 |
+make, use, sell, offer for sale, import and otherwise run, modify and |
|
490 |
+propagate the contents of its contributor version. |
|
491 |
+ |
|
492 |
+ In the following three paragraphs, a "patent license" is any express |
|
493 |
+agreement or commitment, however denominated, not to enforce a patent |
|
494 |
+(such as an express permission to practice a patent or covenant not to |
|
495 |
+sue for patent infringement). To "grant" such a patent license to a |
|
496 |
+party means to make such an agreement or commitment not to enforce a |
|
497 |
+patent against the party. |
|
498 |
+ |
|
499 |
+ If you convey a covered work, knowingly relying on a patent license, |
|
500 |
+and the Corresponding Source of the work is not available for anyone |
|
501 |
+to copy, free of charge and under the terms of this License, through a |
|
502 |
+publicly available network server or other readily accessible means, |
|
503 |
+then you must either (1) cause the Corresponding Source to be so |
|
504 |
+available, or (2) arrange to deprive yourself of the benefit of the |
|
505 |
+patent license for this particular work, or (3) arrange, in a manner |
|
506 |
+consistent with the requirements of this License, to extend the patent |
|
507 |
+license to downstream recipients. "Knowingly relying" means you have |
|
508 |
+actual knowledge that, but for the patent license, your conveying the |
|
509 |
+covered work in a country, or your recipient's use of the covered work |
|
510 |
+in a country, would infringe one or more identifiable patents in that |
|
511 |
+country that you have reason to believe are valid. |
|
512 |
+ |
|
513 |
+ If, pursuant to or in connection with a single transaction or |
|
514 |
+arrangement, you convey, or propagate by procuring conveyance of, a |
|
515 |
+covered work, and grant a patent license to some of the parties |
|
516 |
+receiving the covered work authorizing them to use, propagate, modify |
|
517 |
+or convey a specific copy of the covered work, then the patent license |
|
518 |
+you grant is automatically extended to all recipients of the covered |
|
519 |
+work and works based on it. |
|
520 |
+ |
|
521 |
+ A patent license is "discriminatory" if it does not include within |
|
522 |
+the scope of its coverage, prohibits the exercise of, or is |
|
523 |
+conditioned on the non-exercise of one or more of the rights that are |
|
524 |
+specifically granted under this License. You may not convey a covered |
|
525 |
+work if you are a party to an arrangement with a third party that is |
|
526 |
+in the business of distributing software, under which you make payment |
|
527 |
+to the third party based on the extent of your activity of conveying |
|
528 |
+the work, and under which the third party grants, to any of the |
|
529 |
+parties who would receive the covered work from you, a discriminatory |
|
530 |
+patent license (a) in connection with copies of the covered work |
|
531 |
+conveyed by you (or copies made from those copies), or (b) primarily |
|
532 |
+for and in connection with specific products or compilations that |
|
533 |
+contain the covered work, unless you entered into that arrangement, |
|
534 |
+or that patent license was granted, prior to 28 March 2007. |
|
535 |
+ |
|
536 |
+ Nothing in this License shall be construed as excluding or limiting |
|
537 |
+any implied license or other defenses to infringement that may |
|
538 |
+otherwise be available to you under applicable patent law. |
|
539 |
+ |
|
540 |
+ 12. No Surrender of Others' Freedom. |
|
541 |
+ |
|
542 |
+ If conditions are imposed on you (whether by court order, agreement or |
|
543 |
+otherwise) that contradict the conditions of this License, they do not |
|
544 |
+excuse you from the conditions of this License. If you cannot convey a |
|
545 |
+covered work so as to satisfy simultaneously your obligations under this |
|
546 |
+License and any other pertinent obligations, then as a consequence you may |
|
547 |
+not convey it at all. For example, if you agree to terms that obligate you |
|
548 |
+to collect a royalty for further conveying from those to whom you convey |
|
549 |
+the Program, the only way you could satisfy both those terms and this |
|
550 |
+License would be to refrain entirely from conveying the Program. |
|
551 |
+ |
|
552 |
+ 13. Use with the GNU Affero General Public License. |
|
553 |
+ |
|
554 |
+ Notwithstanding any other provision of this License, you have |
|
555 |
+permission to link or combine any covered work with a work licensed |
|
556 |
+under version 3 of the GNU Affero General Public License into a single |
|
557 |
+combined work, and to convey the resulting work. The terms of this |
|
558 |
+License will continue to apply to the part which is the covered work, |
|
559 |
+but the special requirements of the GNU Affero General Public License, |
|
560 |
+section 13, concerning interaction through a network will apply to the |
|
561 |
+combination as such. |
|
562 |
+ |
|
563 |
+ 14. Revised Versions of this License. |
|
564 |
+ |
|
565 |
+ The Free Software Foundation may publish revised and/or new versions of |
|
566 |
+the GNU General Public License from time to time. Such new versions will |
|
567 |
+be similar in spirit to the present version, but may differ in detail to |
|
568 |
+address new problems or concerns. |
|
569 |
+ |
|
570 |
+ Each version is given a distinguishing version number. If the |
|
571 |
+Program specifies that a certain numbered version of the GNU General |
|
572 |
+Public License "or any later version" applies to it, you have the |
|
573 |
+option of following the terms and conditions either of that numbered |
|
574 |
+version or of any later version published by the Free Software |
|
575 |
+Foundation. If the Program does not specify a version number of the |
|
576 |
+GNU General Public License, you may choose any version ever published |
|
577 |
+by the Free Software Foundation. |
|
578 |
+ |
|
579 |
+ If the Program specifies that a proxy can decide which future |
|
580 |
+versions of the GNU General Public License can be used, that proxy's |
|
581 |
+public statement of acceptance of a version permanently authorizes you |
|
582 |
+to choose that version for the Program. |
|
583 |
+ |
|
584 |
+ Later license versions may give you additional or different |
|
585 |
+permissions. However, no additional obligations are imposed on any |
|
586 |
+author or copyright holder as a result of your choosing to follow a |
|
587 |
+later version. |
|
588 |
+ |
|
589 |
+ 15. Disclaimer of Warranty. |
|
590 |
+ |
|
591 |
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY |
|
592 |
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT |
|
593 |
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY |
|
594 |
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, |
|
595 |
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
596 |
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM |
|
597 |
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF |
|
598 |
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION. |
|
599 |
+ |
|
600 |
+ 16. Limitation of Liability. |
|
601 |
+ |
|
602 |
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
|
603 |
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS |
|
604 |
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY |
|
605 |
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE |
|
606 |
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF |
|
607 |
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD |
|
608 |
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), |
|
609 |
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF |
|
610 |
+SUCH DAMAGES. |
|
611 |
+ |
|
612 |
+ 17. Interpretation of Sections 15 and 16. |
|
613 |
+ |
|
614 |
+ If the disclaimer of warranty and limitation of liability provided |
|
615 |
+above cannot be given local legal effect according to their terms, |
|
616 |
+reviewing courts shall apply local law that most closely approximates |
|
617 |
+an absolute waiver of all civil liability in connection with the |
|
618 |
+Program, unless a warranty or assumption of liability accompanies a |
|
619 |
+copy of the Program in return for a fee. |
|
620 |
+ |
|
621 |
+ END OF TERMS AND CONDITIONS |
|
622 |
+ |
|
623 |
+ How to Apply These Terms to Your New Programs |
|
624 |
+ |
|
625 |
+ If you develop a new program, and you want it to be of the greatest |
|
626 |
+possible use to the public, the best way to achieve this is to make it |
|
627 |
+free software which everyone can redistribute and change under these terms. |
|
628 |
+ |
|
629 |
+ To do so, attach the following notices to the program. It is safest |
|
630 |
+to attach them to the start of each source file to most effectively |
|
631 |
+state the exclusion of warranty; and each file should have at least |
|
632 |
+the "copyright" line and a pointer to where the full notice is found. |
|
633 |
+ |
|
634 |
+ <one line to give the program's name and a brief idea of what it does.> |
|
635 |
+ Copyright (C) <year> <name of author> |
|
636 |
+ |
|
637 |
+ This program is free software: you can redistribute it and/or modify |
|
638 |
+ it under the terms of the GNU General Public License as published by |
|
639 |
+ the Free Software Foundation, either version 3 of the License, or |
|
640 |
+ (at your option) any later version. |
|
641 |
+ |
|
642 |
+ This program is distributed in the hope that it will be useful, |
|
643 |
+ but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
644 |
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
645 |
+ GNU General Public License for more details. |
|
646 |
+ |
|
647 |
+ You should have received a copy of the GNU General Public License |
|
648 |
+ along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
649 |
+ |
|
650 |
+Also add information on how to contact you by electronic and paper mail. |
|
651 |
+ |
|
652 |
+ If the program does terminal interaction, make it output a short |
|
653 |
+notice like this when it starts in an interactive mode: |
|
654 |
+ |
|
655 |
+ <program> Copyright (C) <year> <name of author> |
|
656 |
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
|
657 |
+ This is free software, and you are welcome to redistribute it |
|
658 |
+ under certain conditions; type `show c' for details. |
|
659 |
+ |
|
660 |
+The hypothetical commands `show w' and `show c' should show the appropriate |
|
661 |
+parts of the General Public License. Of course, your program's commands |
|
662 |
+might be different; for a GUI interface, you would use an "about box". |
|
663 |
+ |
|
664 |
+ You should also get your employer (if you work as a programmer) or school, |
|
665 |
+if any, to sign a "copyright disclaimer" for the program, if necessary. |
|
666 |
+For more information on this, and how to apply and follow the GNU GPL, see |
|
667 |
+<http://www.gnu.org/licenses/>. |
|
668 |
+ |
|
669 |
+ The GNU General Public License does not permit incorporating your program |
|
670 |
+into proprietary programs. If your program is a subroutine library, you |
|
671 |
+may consider it more useful to permit linking proprietary applications with |
|
672 |
+the library. If this is what you want to do, use the GNU Lesser General |
|
673 |
+Public License instead of this License. But first, please read |
|
674 |
+<http://www.gnu.org/philosophy/why-not-lgpl.html>. |
... | ... |
@@ -0,0 +1,166 @@ |
1 |
+/**************************************************************************** |
|
2 |
+ * |
|
3 |
+ * PROGRAM: clump4p |
|
4 |
+ * |
|
5 |
+ * AUTHOR(S): Pawel Netzel - SIL UC |
|
6 |
+ * Jarek Jasiewicz - SIL UC |
|
7 |
+ * (the clumping algorithm for a region) |
|
8 |
+ * |
|
9 |
+ * PURPOSE: Recategorizes data in a raster map layer by grouping cells |
|
10 |
+ * that form physically discrete areas into unique categories. |
|
11 |
+ * |
|
12 |
+ * COPYRIGHT: (C) 2012 by Pawel Netzel |
|
13 |
+ * |
|
14 |
+ * This program is a free software under the GNU General Public |
|
15 |
+ * License (>=v2). |
|
16 |
+ * |
|
17 |
+ ***************************************************************************/ |
|
18 |
+ |
|
19 |
+#include <stdlib.h> |
|
20 |
+#include <string.h> |
|
21 |
+#include <unistd.h> |
|
22 |
+#include <omp.h> |
|
23 |
+#include <gdal.h> |
|
24 |
+#include <ezgdal.h> |
|
25 |
+#include <argtable3.h> |
|
26 |
+#include "data.h" |
|
27 |
+#include "main.h" |
|
28 |
+ |
|
29 |
+void usage(char *progname, void *argtable) { |
|
30 |
+ |
|
31 |
+ printf("\nclump4p recategorizes data in a raster map by grouping cells \n"); |
|
32 |
+ printf("that form physically discrete areas into unique categories.\n"); |
|
33 |
+ |
|
34 |
+ printf("\nclump4p uses \"divide and conquer\" algorithm to speed up \n"); |
|
35 |
+ printf("the clumping process. By default, clumps are generated by the four \n"); |
|
36 |
+ printf("directions clumping algorithm. One can change this to the eight directions\n"); |
|
37 |
+ printf("clumping algorithm (flag -8).\n"); |
|
38 |
+ |
|
39 |
+ printf("\nUsage:\n\t%s", progname); |
|
40 |
+ arg_print_syntax(stdout,argtable,"\n"); |
|
41 |
+ printf("\n"); |
|
42 |
+ arg_print_glossary_gnu(stdout,argtable); |
|
43 |
+ printf("\n"); |
|
44 |
+ exit(0); |
|
45 |
+} |
|
46 |
+ |
|
47 |
+ |
|
48 |
+int main(int argc, char *argv[]) |
|
49 |
+{ |
|
50 |
+ EZGDAL_LAYER *in_fd, *tmp_fd, *out_fd; |
|
51 |
+ char *OUTPUT; |
|
52 |
+ char *INPUT; |
|
53 |
+ char TEMPLAYER[1024]; |
|
54 |
+ int DIRECTIONS=4; |
|
55 |
+ |
|
56 |
+ struct arg_str *inp = arg_str1("i","input","<file_name>","name of input files (GeoTIFF)"); |
|
57 |
+ struct arg_str *out = arg_str1("o","output","<file_name>","name of output file with clumps (GeoTIFF)"); |
|
58 |
+ struct arg_int *th = arg_int0("t",NULL,"<n>","number of threads (default: 1)"); |
|
59 |
+ struct arg_lit *dirs = arg_lit0("8",NULL,"8 direction connecting"); |
|
60 |
+ struct arg_lit *local = arg_lit0("l",NULL,"temporary files in local directory (default: /tmp)"); |
|
61 |
+ struct arg_str *path = arg_str0(NULL,"path","<existing_path>","location for temporary files (default: /tmp)"); |
|
62 |
+ struct arg_lit *help = arg_lit0("h","help","print help and exit"); |
|
63 |
+ struct arg_end *end = arg_end(20); |
|
64 |
+ |
|
65 |
+ void* argtable[] = {inp,out,th,dirs,local,path,help,end}; |
|
66 |
+ |
|
67 |
+ int nerrors = arg_parse(argc,argv,argtable); |
|
68 |
+ |
|
69 |
+ if (help->count > 0) |
|
70 |
+ usage(argv[0],argtable); |
|
71 |
+ |
|
72 |
+ if (nerrors > 0) { |
|
73 |
+ arg_print_errors(stdout,end,argv[0]); |
|
74 |
+ usage(argv[0],argtable); |
|
75 |
+ } |
|
76 |
+ |
|
77 |
+ if(th->count > 0) |
|
78 |
+ omp_set_num_threads(th->ival[0]); |
|
79 |
+ else |
|
80 |
+ omp_set_num_threads(1); |
|
81 |
+ |
|
82 |
+ |
|
83 |
+ INPUT = (char *)inp->sval[0]; |
|
84 |
+ OUTPUT = (char *)out->sval[0]; |
|
85 |
+ |
|
86 |
+ if(dirs->count>0) |
|
87 |
+ DIRECTIONS=8; |
|
88 |
+ |
|
89 |
+ int pid = getpid(); |
|
90 |
+ memset(TEMPLAYER,0,1024); |
|
91 |
+ if(local->count>0) |
|
92 |
+ sprintf(TEMPLAYER,"tmp_clump_%06d.tif",pid); |
|
93 |
+ else if(path->count>0) |
|
94 |
+ sprintf(TEMPLAYER,"%s/tmp_clump_%06d.tif",path->sval[0],pid); |
|
95 |
+ else |
|
96 |
+ sprintf(TEMPLAYER,"/tmp/tmp_clump_%06d.tif",pid); |
|
97 |
+ |
|
98 |
+ if(!ezgdal_file_exists(INPUT)) { |
|
99 |
+ printf("\nThe file '%s' does not exist!\n\n",INPUT); |
|
100 |
+ exit(0); |
|
101 |
+ } |
|
102 |
+ |
|
103 |
+ printf("Opening input file..."); |
|
104 |
+ in_fd = ezgdal_open_layer(INPUT); |
|
105 |
+ |
|
106 |
+ |
|
107 |
+ if(in_fd==NULL) { |
|
108 |
+ printf("\nThe file '%s' can't be opened!\n\n",INPUT); |
|
109 |
+ exit(0); |
|
110 |
+ } else |
|
111 |
+ printf(" OK\n"); |
|
112 |
+ |
|
113 |
+ initVariables(in_fd); |
|
114 |
+ |
|
115 |
+ int nodata = -9999; |
|
116 |
+ printf("Creating temporary file..."); |
|
117 |
+ tmp_fd = ezgdal_create_layer(TEMPLAYER, |
|
118 |
+ ezgdal_layer_get_wkt(in_fd), |
|
119 |
+ "Int32", |
|
120 |
+ ezgdal_layer_get_at(in_fd), |
|
121 |
+ in_fd->rows, |
|
122 |
+ in_fd->cols, |
|
123 |
+ &nodata, EZGDAL_COMPRESS_NONE |
|
124 |
+ ); |
|
125 |
+ |
|
126 |
+ if(tmp_fd==NULL) { |
|
127 |
+ printf("\nThe file '%s' can't be created!\n\n",TEMPLAYER); |
|
128 |
+ exit(0); |
|
129 |
+ } else |
|
130 |
+ printf("OK\n"); |
|
131 |
+ |
|
132 |
+ printf("Clumping... "); |
|
133 |
+ clump(in_fd, tmp_fd, DIRECTIONS); |
|
134 |
+ printf(" OK\n"); |
|
135 |
+ |
|
136 |
+ ezgdal_close_layer(in_fd); |
|
137 |
+ ezgdal_close_layer(tmp_fd); |
|
138 |
+ |
|
139 |
+ printf("Creating output file..."); |
|
140 |
+ tmp_fd = ezgdal_open_layer(TEMPLAYER); |
|
141 |
+ out_fd = ezgdal_create_layer(OUTPUT, |
|
142 |
+ ezgdal_layer_get_wkt(tmp_fd), |
|
143 |
+ "Int32", |
|
144 |
+ ezgdal_layer_get_at(tmp_fd), |
|
145 |
+ tmp_fd->rows, |
|
146 |
+ tmp_fd->cols, |
|
147 |
+ &nodata, EZGDAL_COMPRESS_NONE |
|
148 |
+ ); |
|
149 |
+ if(out_fd==NULL) { |
|
150 |
+ printf("\nThe file '%s' can't be created!\n\n",OUTPUT); |
|
151 |
+ exit(0); |
|
152 |
+ } else |
|
153 |
+ printf(" OK\n"); |
|
154 |
+ |
|
155 |
+ |
|
156 |
+ replaceLabels(tmp_fd,out_fd); |
|
157 |
+ |
|
158 |
+ ezgdal_close_layer(out_fd); |
|
159 |
+ ezgdal_close_layer(tmp_fd); |
|
160 |
+ |
|
161 |
+ freeVariables(); |
|
162 |
+ |
|
163 |
+ unlink(TEMPLAYER); |
|
164 |
+ |
|
165 |
+ exit(EXIT_SUCCESS); |
|
166 |
+} |
... | ... |
@@ -0,0 +1,31 @@ |
1 |
+/**************************************************************************** |
|
2 |
+ * |
|
3 |
+ * PROGRAM: clump4p |
|
4 |
+ * |
|
5 |
+ * AUTHOR(S): Pawel Netzel - SIL UC |
|
6 |
+ * Jarek Jasiewicz - SIL UC |
|
7 |
+ * (clumping algorithm for region) |
|
8 |
+ * |
|
9 |
+ * PURPOSE: Recategorizes data in a raster map layer by grouping cells |
|
10 |
+ * that form physically discrete areas into unique categories. |
|
11 |
+ * |
|
12 |
+ * COPYRIGHT: (C) 2012 by Pawel Netzel |
|
13 |
+ * |
|
14 |
+ * This program is free software under the GNU General Public |
|
15 |
+ * License (>=v2). |
|
16 |
+ * |
|
17 |
+ ***************************************************************************/ |
|
18 |
+ |
|
19 |
+#ifndef __MAIN_H__ |
|
20 |
+#define __MAIN_H__ |
|
21 |
+ |
|
22 |
+typedef int CELL; |
|
23 |
+ |
|
24 |
+/* clump.c */ |
|
25 |
+void clump(EZGDAL_LAYER *, EZGDAL_LAYER *, int); |
|
26 |
+void replaceLabels(EZGDAL_LAYER *, EZGDAL_LAYER *); |
|
27 |
+ |
|
28 |
+/* main.c */ |
|
29 |
+int main(int, char *[]); |
|
30 |
+ |
|
31 |
+#endif /* __MAIN_H__ */ |
|
0 | 32 |