Context Navigation

source: soft/giet_vm/applications/rosenfeld/nrc2/src/nrsort1.c @ 772

Last change on this file since 772 was 772, checked in by meunier, 8 years ago
Ajout de l'application rosenfeld Changement du nom du flag O_CREATE en O_CREAT
File size: 11.5 KB

Line
1	/* ----------------- */
2	/* --- nrsort1.c --- */
3	/* ----------------- */
4
5	/*
6	* Copyright (c) 2000-2014, Lionel Lacassagne, All rights reserved
7	* Univ Paris Sud XI, CNRS
8	*
9	* Distributed under the Boost Software License, Version 1.0
10	* see accompanying file LICENSE.txt or copy it at
11	* http://www.boost.org/LICENSE_1_0.txt
12	*/
13
14
15	#include <stdio.h>
16	#include <stddef.h>
17	#include <stdlib.h>
18	#include <math.h> // fabs
19
20	#include "mypredef.h"
21	#include "nrtype.h"
22	#include "nrdef.h"
23	#include "nrmacro.h"
24	#include "nrkernel.h"
25
26	#include "nrset1.h"
27	#include "nrsort1.h"
28
29	/* ------------------------------------------------------------------------------ */
30	IMAGE_EXPORT(void) extractnz_boundaries_ui8vector(uint8 v, long nl, long nh, long nlnz, long *nhnz)
31	/* ------------------------------------------------------------------------------ */
32	{
33	long left = nl, right = nh;;
34
35	while(!v[left ] && left <= nh) left++;
36	while(!v[right] && right >= nl) right--;
37
38	nlnz = left; nhnz = right;
39	}
40	/* ------------------------------------------------------------------------------ */
41	IMAGE_EXPORT(void) extractnz_boundaries_si16vector(sint16 v, long nl, long nh, long nlnz, long *nhnz)
42	/* ------------------------------------------------------------------------------ */
43	{
44	long left = nl, right = nh;;
45
46	while(!v[left ] && left <= nh) left++;
47	while(!v[right] && right >= nl) right--;
48
49	nlnz = left; nhnz = right;
50	}
51	/* --------------------------------------------------------------------------------- */
52	IMAGE_EXPORT(void) extractnz_boundaries_ui16vector(uint16 v, long nl, long nh, long nlnz, long *nhnz)
53	/* --------------------------------------------------------------------------------- */
54	{
55	long left = nl, right = nh;;
56
57	while(!v[left ] && left <= nh) left++;
58	while(!v[right] && right >= nl) right--;
59
60	nlnz = left; nhnz = right;
61	}
62	/* ----------------------------------------------------------------------------- */
63	IMAGE_EXPORT(void) extractnz_boundaries_si32vector(sint32 v, long nl, long nh, long nlnz, long *nhnz)
64	/* ----------------------------------------------------------------------------- */
65	{
66	long left = nl, right = nh;;
67
68	while(!v[left ] && left <= nh) left++;
69	while(!v[right] && right >= nl) right--;
70
71	nlnz = left; nhnz = right;
72	}
73	/* ------------------------------------------------------------------------------- */
74	IMAGE_EXPORT(void) extractnz_boundaries_ui32vector(uint32 v, long nl, long nh, long nlnz, long *nhnz)
75	/* ------------------------------------------------------------------------------- */
76	{
77	long left = nl, right = nh;;
78
79	while(!v[left ] && left <= nh) left++;
80	while(!v[right] && right >= nl) right--;
81
82	nlnz = left; nhnz = right;
83	}
84	/* ---------------------------------------------------------------------------------------------- */
85	IMAGE_EXPORT(void) extractnz_boundaries_f32vector(float32 v, long nl, long nh, long nlnz, long *nhnz, float32 epsillon)
86	/* ---------------------------------------------------------------------------------------------- */
87	{
88	long left = nl, right = nh;;
89
90	while(fabs(v[left ])<epsillon && left <= nh) left++;
91	while(fabs(v[right])<epsillon && right >= nl) right--;
92
93	nlnz = left; nhnz = right;
94	}
95	/* ------------------------------------------------------------------------------------------------- */
96	IMAGE_EXPORT(void) extractnz_boundaries_f64vector(float64 v, long nl, long nh, long nlnz, long *nhnz, float64 epsillon)
97	/* ------------------------------------------------------------------------------------------------- */
98	{
99	long left = nl, right = nh;;
100
101	while(fabs(v[left ])<epsillon && left <= nh) left++;
102	while(fabs(v[right])<epsillon && right >= nl) right--;
103
104	nlnz = left; nhnz = right;
105	}
106
107	/* ------------------------------------------------------------------------------------ */
108	IMAGE_EXPORT(void) sort_index_f64vector_selection(float64 key, long nl, long nh, int index)
109	/* ------------------------------------------------------------------------------------ */
110	{
111	int i, j, pos, tmp;
112	float64 x, min;
113
114	for(i=nl; i<=nh; i++) {
115	index[i] = i-nl;
116	}
117
118	for(i=nl; i<nh; i++) {
119	min = key[i];
120	pos = i;
121	for(j=i+1; j<=nh; j++) {
122	x = key[j];
123	if(x < min) {
124	min = x;
125	pos = j;
126	}
127	}
128	key[pos] = key[i];
129	key[i] = min;
130
131	tmp = index[i];
132	index[i] = index[pos];
133	index[pos] = tmp;
134	}
135	}
136	/* ------------------------------------------------------------------------------------- */
137	IMAGE_EXPORT(void) sort_index_ivector_selection_min(int key, long nl, long nh, int index)
138	/* ------------------------------------------------------------------------------------- */
139	{
140	int i, j, pos, tmp;
141	int x, min;
142
143	for(i=nl; i<=nh; i++) {
144	//index[i] = i-nl;
145	index[i] = i;/**/
146	}
147
148	for(i=nl; i<nh; i++) {
149	min = key[i];
150	pos = i;
151	for(j=i+1; j<=nh; j++) {
152	x = key[j];
153	if(x < min) {
154	min = x;
155	pos = j;
156	}
157	}
158	key[pos] = key[i];
159	key[i] = min;
160
161	tmp = index[i];
162	index[i] = index[pos];
163	index[pos] = tmp;
164	}
165	}
166	/* ------------------------------------------------------------------------------------- */
167	IMAGE_EXPORT(void) sort_index_ivector_selection_max(int key, long nl, long nh, int index)
168	/* ------------------------------------------------------------------------------------- */
169	{
170	int i, j, pos, tmp;
171	int x, max;
172
173	for(i=nl; i<=nh; i++) {
174	//index[i] = i-nl;
175	index[i] = i;
176	}
177
178	for(i=nl; i<nh; i++) {
179	max = key[i];
180	pos = i;
181	for(j=i+1; j<=nh; j++) {
182	x = key[j];
183	if(x > max) {
184	max = x;
185	pos = j;
186	}
187	}
188	key[pos] = key[i];
189	key[i] = max;
190
191	tmp = index[i];
192	index[i] = index[pos];
193	index[pos] = tmp;
194	}
195	}
196	/* -------------------------------------------------------------------------------------- */
197	IMAGE_EXPORT(void) sort_index_vector_selection_min(float key, long nl, long nh, int index)
198	/* -------------------------------------------------------------------------------------- */
199	{
200	int i, j, pos, tmp;
201	float x, min;
202
203	for(i=nl; i<=nh; i++) {
204	//index[i] = i-nl;
205	index[i] = i;
206	}
207
208	for(i=nl; i<nh; i++) {
209	min = key[i];
210	pos = i;
211	for(j=i+1; j<=nh; j++) {
212	x = key[j];
213	if(x < min) {
214	min = x;
215	pos = j;
216	}
217	}
218	key[pos] = key[i];
219	key[i] = min;
220
221	tmp = index[i];
222	index[i] = index[pos];
223	index[pos] = tmp;
224	}
225	}
226	/* -------------------------------------------------------------------------------------- */
227	IMAGE_EXPORT(void) sort_index_vector_selection_max(float key, long nl, long nh, int index)
228	/* -------------------------------------------------------------------------------------- */
229	{
230	int i, j, pos, tmp;
231	float x, max;
232
233	for(i=nl; i<=nh; i++) {
234	//index[i] = i-nl;
235	index[i] = i;
236	}
237
238	for(i=nl; i<nh; i++) {
239	max = key[i];
240	pos = i;
241	for(j=i+1; j<=nh; j++) {
242	x = key[j];
243	if(x > max) {
244	max = x;
245	pos = j;
246	}
247	}
248	key[pos] = key[i];
249	key[i] = max;
250
251	tmp = index[i];
252	index[i] = index[pos];
253	index[pos] = tmp;
254	}
255	}
256	/* ---------------------------------------------------------------------------------------------- */
257	IMAGE_EXPORT(void) sort_index_vector_selection_kmin(float key, long nl, long nh, int index, int k)
258	/* ---------------------------------------------------------------------------------------------- */
259	{
260	/*
261	* ATTENTION, ke tableau index DOIT etre initialise
262	*/
263	int i, j, pos, tmp, il, ih;
264	float x, min;
265
266	il = nl;
267	ih = il + k;
268
269	/*for(i=il; i<=ih; i++) {
270	index[i] = i-il;
271	}*/
272
273	for(i=il; i<ih; i++) {
274	min = key[i];
275	pos = i;
276	for(j=i+1; j<=nh; j++) {
277	x = key[j];
278	if(x < min) {
279	min = x;
280	pos = j;
281	}
282	}
283	key[pos] = key[i];
284	key[i] = min;
285
286	tmp = index[i];
287	index[i] = index[pos];
288	index[pos] = tmp;
289	}
290	}
291	/* --------------------------------------------------------------------------------------------- */
292	IMAGE_EXPORT(void) sort_index_ivector_selection_kmin(int key, long nl, long nh, int index, int k)
293	/* --------------------------------------------------------------------------------------------- */
294	{
295	/*
296	* ATTENTION, ke tableau index DOIT etre initialise
297	*/
298	int i, j, pos, tmp, il, ih;
299	int x, min;
300
301	il = nl;
302	ih = il + k;
303
304	/*for(i=il; i<=ih; i++) {
305	index[i] = i-il;
306	}*/
307
308	for(i=il; i<ih; i++) {
309	min = key[i];
310	pos = i;
311	for(j=i+1; j<=nh; j++) {
312	x = key[j];
313	if(x < min) {
314	min = x;
315	pos = j;
316	}
317	}
318	key[pos] = key[i];
319	key[i] = min;
320
321	tmp = index[i];
322	index[i] = index[pos];
323	index[pos] = tmp;
324	}
325	}
326	/* ---------------------------------------------------------------------------------------------- */
327	IMAGE_EXPORT(void) sort_index_vector_selection_kmax(float key, long nl, long nh, int index, int k)
328	/* ---------------------------------------------------------------------------------------------- */
329	{
330	/*
331	* ATTENTION, ke tableau index DOIT etre initialise
332	*/
333	int i, j, pos, tmp, il, ih;
334	float x, max;
335
336	il = nl;
337	ih = il + k;
338
339	/*for(i=il; i<=ih; i++) {
340	index[i] = i-il;
341	}*/
342
343	for(i=il; i<ih; i++) {
344	max = key[i];
345	pos = i;
346	for(j=i+1; j<=nh; j++) {
347	x = key[j];
348	if(x > max) {
349	max = x;
350	pos = j;
351	}
352	}
353	key[pos] = key[i];
354	key[i] = max;
355
356	tmp = index[i];
357	index[i] = index[pos];
358	index[pos] = tmp;
359	}
360	}
361	/* --------------------------------------------------------------------------------------------- */
362	IMAGE_EXPORT(void) sort_index_ivector_selection_kmax(int key, long nl, long nh, int index, int k)
363	/* --------------------------------------------------------------------------------------------- */
364	{
365	/*
366	* ATTENTION, ke tableau index DOIT etre initialise
367	*/
368	int i, j, pos, tmp, il, ih;
369	int x, max;
370
371	il = nl;
372	ih = il + k;
373
374	/*for(i=il; i<=ih; i++) {
375	index[i] = i-il;
376	}*/
377
378	for(i=il; i<ih; i++) {
379	max = key[i];
380	pos = i;
381	for(j=i+1; j<=nh; j++) {
382	x = key[j];
383	if(x > max) {
384	max = x;
385	pos = j;
386	}
387	}
388	key[pos] = key[i];
389	key[i] = max;
390
391	tmp = index[i];
392	index[i] = index[pos];
393	index[pos] = tmp;
394	}
395	}
396	/* ------------------------------------------------------------------ */
397	IMAGE_EXPORT(void) sort_bvector_selection_min(byte *v, long nl, long nh)
398	/* ------------------------------------------------------------------ */
399	{
400	int i, j;
401	int x, min, pos;
402
403	for(i=nl; i<nh; i++) {
404	min = v[i];
405	pos = i;
406	for(j=i+1; j<=nh; j++) {
407	x = v[j];
408	if(x < min) {
409	min = x;
410	pos = j;
411	}
412	}
413	v[pos] = v[i];
414	v[i] = min;
415	}
416	}
417	/* -------------------------------------------------------------- */
418	IMAGE_EXPORT(byte) select_bvector(byte *v, long nl, long nh, long k)
419	/* -------------------------------------------------------------- */
420	{
421	int i, j, il, ih;
422	int x, min, pos;
423
424	il = nl;
425	ih = il + k;
426
427	for(i=il; i<ih; i++) {
428	min = v[i];
429	pos = i;
430	for(j=i+1; j<=nh; j++) {
431	x = v[j];
432	if(x < min) {
433	min = x;
434	pos = j;
435	}
436	}
437	v[pos] = v[i];
438	v[i] = min;
439	}
440	return v[ih];
441	}
442	/* ----------------------------------------------------------------- */
443	IMAGE_EXPORT(rgb8) select_rgb8vector(rgb8 *v, long nl, long nh, long k)
444	/* ----------------------------------------------------------------- */
445	{
446	int i, j, il, ih;
447
448	int rpos, gpos, bpos;
449	rgb8 xi, xj;
450	byte r,g,b;
451	byte rmin, gmin, bmin;
452
453	il = nl;
454	ih = il + k;
455
456	for(i=il; i<ih; i++) {
457
458	xi = v[i];
459	rmin = xi.r; gmin = xi.g; bmin = xi.b;
460	rpos = gpos = bpos = i;
461
462	for(j=i+1; j<=nh; j++) {
463	xj = v[j];
464	r = xj.r; g = xj.g; b = xj.b;
465	if(r < rmin) { rmin = r; rpos = j; }
466	if(g < gmin) { gmin = r; gpos = j; }
467	if(b < bmin) { bmin = r; bpos = j; }
468	}
469	v[rpos].r = v[i].r; v[i].r = rmin;
470	v[rpos].g = v[i].g; v[i].g = gmin;
471	v[rpos].b = v[i].b; v[i].b = bmin;
472	}
473	return v[ih];
474	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: