37 #include "muse_cplwrappers.h"
79 cpl_ensure_code(aTarget && aImage, CPL_ERROR_NULL_INPUT);
80 cpl_ensure_code(cpl_image_get_type(aTarget) == CPL_TYPE_INT,
81 CPL_ERROR_INVALID_TYPE);
82 cpl_ensure_code(cpl_image_get_type(aImage) == CPL_TYPE_INT,
83 CPL_ERROR_INVALID_TYPE);
84 cpl_ensure_code(cpl_image_get_size_x(aTarget) == cpl_image_get_size_x(aImage),
85 CPL_ERROR_ILLEGAL_INPUT);
86 cpl_ensure_code(cpl_image_get_size_y(aTarget) == cpl_image_get_size_y(aImage),
87 CPL_ERROR_ILLEGAL_INPUT);
89 int *target = cpl_image_get_data_int(aTarget);
90 const int *data = cpl_image_get_data_int_const(aImage);
91 cpl_size nData = cpl_image_get_size_x(aImage) * cpl_image_get_size_y(aImage);
93 for (i = 0; i < nData; i++, data++, target++) {
94 *target |= *data & mask;
96 return CPL_ERROR_NONE;
117 cpl_ensure(aImage1 || aImage2, CPL_ERROR_NULL_INPUT, NULL);
118 if (aImage1 == NULL) {
119 return cpl_image_duplicate(aImage2);
121 if (aImage2 == NULL) {
122 return cpl_image_duplicate(aImage1);
124 cpl_type type = cpl_image_get_type(aImage1);
125 cpl_ensure(type == cpl_image_get_type(aImage2), CPL_ERROR_ILLEGAL_INPUT, NULL);
126 cpl_size xsize = cpl_image_get_size_x(aImage1);
127 cpl_ensure(xsize == cpl_image_get_size_x(aImage2), CPL_ERROR_ILLEGAL_INPUT, NULL);
129 cpl_size ysize1 = cpl_image_get_size_y(aImage1);
130 cpl_size ysize2 = cpl_image_get_size_y(aImage2);
131 cpl_image *res = cpl_image_new(xsize, ysize1 + ysize2, type);
132 void *resdata = cpl_image_get_data(res);
133 const void *data1 = cpl_image_get_data_const(aImage1);
134 cpl_size size1 = xsize * ysize1 * cpl_type_get_sizeof(type);
135 const void *data2 = cpl_image_get_data_const(aImage2);
136 cpl_size size2 = xsize * ysize2 * cpl_type_get_sizeof(type);
137 memcpy(resdata, data1, size1);
138 memcpy((
char *)resdata+size1, data2, size2);
161 cpl_ensure(aImage1 || aImage2, CPL_ERROR_NULL_INPUT, NULL);
162 if (aImage1 == NULL) {
163 return cpl_image_duplicate(aImage2);
165 if (aImage2 == NULL) {
166 return cpl_image_duplicate(aImage1);
168 cpl_type type = cpl_image_get_type(aImage1);
169 cpl_ensure(type == cpl_image_get_type(aImage2), CPL_ERROR_ILLEGAL_INPUT, NULL);
170 cpl_size ysize = cpl_image_get_size_y(aImage1);
171 cpl_ensure(ysize == cpl_image_get_size_y(aImage2), CPL_ERROR_ILLEGAL_INPUT, NULL);
173 cpl_size xsize1 = cpl_image_get_size_x(aImage1);
174 cpl_size xsize2 = cpl_image_get_size_x(aImage2);
175 cpl_image *res = cpl_image_new(xsize1 + xsize2, ysize, type);
176 void *resdata = cpl_image_get_data(res);
177 const void *data1 = cpl_image_get_data_const(aImage1);
178 cpl_size size1 = xsize1 * cpl_type_get_sizeof(type);
179 const void *data2 = cpl_image_get_data_const(aImage2);
180 cpl_size size2 = xsize2 * cpl_type_get_sizeof(type);
181 cpl_size size = (size1 + size2) * ysize;
183 for (y = 0, y3 = 0, y4 = 0; y < size; y+=size1+size2, y3+=size1, y4+=size2) {
184 memcpy((
char *)resdata + y, (
char *)data1 + y3, size1);
185 memcpy((
char *)resdata + y + size1, (
char *)data2 + y4, size2);
204 unsigned int aNX,
unsigned int aNY)
206 cpl_ensure(aImage, CPL_ERROR_NULL_INPUT, NULL);
208 cpl_ensure((aNX & 1) && (aNY & 1), CPL_ERROR_ILLEGAL_INPUT, NULL);
211 cpl_image *filtered = cpl_image_new(cpl_image_get_size_x(aImage),
212 cpl_image_get_size_y(aImage),
215 cpl_mask *mask = cpl_mask_new(aNX, aNY);
217 cpl_errorstate prestate = cpl_errorstate_get();
218 cpl_image_filter_mask(filtered, aImage, mask, CPL_FILTER_MEDIAN,
220 if (!cpl_errorstate_is_equal(prestate)) {
221 cpl_msg_error(__func__,
"filtering failed: %s", cpl_error_get_message());
222 cpl_mask_delete(mask);
223 cpl_image_delete(filtered);
226 cpl_mask_delete(mask);
229 cpl_image *subtracted = cpl_image_subtract_create(aImage, filtered);
230 cpl_image_delete(filtered);
260 cpl_ensure(aImage && aWindow, CPL_ERROR_NULL_INPUT, NULL);
262 cpl_image *image = cpl_image_duplicate(aImage);
263 cpl_image_accept_all(image);
265 cpl_vector *slopes = cpl_vector_new(2);
267 for (k = 0; k <= 1; k++) {
269 cpl_image *coll = cpl_image_collapse_window_create(image,
270 aWindow[0], aWindow[2],
271 aWindow[1], aWindow[3],
274 cpl_image_delete(image);
275 cpl_vector_delete(slopes);
280 cpl_image_divide_scalar(coll, aWindow[3] - aWindow[2] + 1);
282 cpl_image_divide_scalar(coll, aWindow[1] - aWindow[0] + 1);
284 int npx = k == 0 ? cpl_image_get_size_x(coll) : cpl_image_get_size_y(coll);
286 cpl_matrix *coords = cpl_matrix_new(1, npx);
287 cpl_vector *values = cpl_vector_new(npx);
288 float *data = cpl_image_get_data_float(coll);
290 for (i = 0; i < npx; i++) {
291 cpl_matrix_set(coords, 0, i, i + 1);
294 cpl_vector_set(values, i, data[i]);
297 cpl_polynomial *fit = cpl_polynomial_new(1);
298 const cpl_boolean sym = CPL_FALSE;
299 const cpl_size mindeg = 0, maxdeg = 1;
300 cpl_error_code err = cpl_polynomial_fit(fit, coords, &sym, values, NULL,
301 CPL_FALSE, &mindeg, &maxdeg);
302 cpl_matrix_delete(coords);
303 cpl_vector_delete(values);
304 cpl_image_delete(coll);
306 if (err != CPL_ERROR_NONE) {
307 cpl_msg_warning(__func__,
"Could not fit %s slope: %s",
308 k == 0 ?
"horizontal" :
"vertical",
309 cpl_error_get_message());
310 cpl_polynomial_delete(fit);
311 cpl_vector_delete(slopes);
312 cpl_image_delete(image);
316 printf(
"%s: fit (%s)\n", __func__, k == 0 ?
"rows" :
"cols");
317 cpl_polynomial_dump(fit, stdout);
320 const cpl_size pows = { 1 };
321 cpl_vector_set(slopes, k, cpl_polynomial_get_coeff(fit, &pows));
322 cpl_polynomial_delete(fit);
324 cpl_image_delete(image);
326 printf(
"slopes vector:\n");
327 cpl_vector_dump(slopes, stdout);
348 cpl_ensure(aImage != NULL, CPL_ERROR_NULL_INPUT, 0.0);
352 cpl_size n = cpl_array_get_size(a);
354 if (aFraction < 0) aFraction = 0;
355 if (aFraction > 1) aFraction = 1;
356 n = lround(n * aFraction);
357 double res = cpl_array_get(a, n-1, NULL);
381 cpl_ensure(imlist, CPL_ERROR_NULL_INPUT, NULL);
382 int count = cpl_imagelist_get_size(imlist);
383 cpl_ensure(count > 0, CPL_ERROR_ILLEGAL_INPUT, NULL);
384 cpl_image *res = cpl_image_duplicate(cpl_imagelist_get_const(imlist, 0));
386 unsigned int mask = 0xffffffff;
387 for (i = 1; i < count; i++) {
389 if (r != CPL_ERROR_NONE) {
390 cpl_image_delete(res);
418 cpl_ensure(aMask && aImage, CPL_ERROR_NULL_INPUT, NULL);
421 enum corner { NONE = 0,
422 BOTTOMLEFT = 1, BOTTOMRIGHT = 2,
423 TOPRIGHT = 3, TOPLEFT = 4 };
424 const char *cnames[] = {
"none",
425 "bottom left",
"bottom right",
426 "top right",
"top left" };
427 int nx = cpl_mask_get_size_x(aMask),
428 ny = cpl_mask_get_size_y(aMask),
429 nximage = cpl_image_get_size_x(aImage),
430 nyimage = cpl_image_get_size_y(aImage),
432 enum corner nmaxcorner = NONE;
433 int ncount = cpl_mask_count_window(aMask, 1, 1, nx/2, ny/2);
435 nmaxcorner = BOTTOMLEFT;
438 ncount = cpl_mask_count_window(aMask, nx/2, 1, nx, ny/2);
440 nmaxcorner = BOTTOMRIGHT;
443 ncount = cpl_mask_count_window(aMask, nx/2, ny/2, nx, ny);
445 nmaxcorner = TOPRIGHT;
448 ncount = cpl_mask_count_window(aMask, 1, ny/2, nx/2, ny);
450 nmaxcorner = TOPLEFT;
453 if (nmaxcorner == NONE) {
454 cpl_error_set_message(__func__, CPL_ERROR_DATA_NOT_FOUND,
"No masked "
455 "quadrant found, cannot adapt %dx%d mask to %dx%d "
456 "image size!", nx, ny, nximage, nyimage);
459 cpl_msg_debug(__func__,
"Adapting %dx%d mask in %s quadrant (%d masked pixels)"
460 " to %dx%d image", nx, ny, cnames[nmaxcorner], nmax,
464 switch (nmaxcorner) {
466 xmask = cpl_mask_extract(aMask, 1, 1, nx/2, ny/2);
469 xmask = cpl_mask_extract(aMask, nx/2, 1, nx, ny/2);
472 xmask = cpl_mask_extract(aMask, nx/2, ny/2, nx, ny);
475 xmask = cpl_mask_extract(aMask, 1, ny/2, nx/2, ny);
478 nx = cpl_mask_get_size_x(xmask);
479 ny = cpl_mask_get_size_y(xmask);
482 cpl_mask *outmask = cpl_mask_new(nximage, nyimage);
484 cpl_error_code rc = CPL_ERROR_NONE;
485 switch (nmaxcorner) {
487 rc = cpl_mask_copy(outmask, xmask, 1, 1);
490 rc = cpl_mask_copy(outmask, xmask, nximage - nx + 1, 1);
493 rc = cpl_mask_copy(outmask, xmask, nximage - nx + 1, nyimage - ny + 1);
496 rc = cpl_mask_copy(outmask, xmask, 1, nyimage - ny + 1);
498 cpl_mask_delete(xmask);
499 if (rc != CPL_ERROR_NONE) {
500 cpl_mask_delete(outmask);
501 cpl_error_set_message(__func__, rc,
"Could not copy %dx%d quadrant with "
502 "masked region into new %dx%d mask", nx, ny,
523 cpl_ensure(aVector, CPL_ERROR_NULL_INPUT, 0.);
525 cpl_size i, n = cpl_vector_get_size(aVector);
526 for (i = 0; i < n; i++) {
527 mdev += fabs(cpl_vector_get(aVector, i) - aCenter);
529 return mdev / (double)n;
549 cpl_ensure(aVector, CPL_ERROR_NULL_INPUT, 0.);
550 double median = cpl_vector_get_median(aVector),
552 cpl_size i, n = cpl_vector_get_size(aVector);
553 for (i = 0; i < n; i++) {
554 mdev += fabs(cpl_vector_get(aVector, i) - median);
559 return mdev / (double)n;
581 double median = cpl_vector_get_median_const(aVector);
582 cpl_vector *v = cpl_vector_duplicate(aVector), *v2;
583 int i, splitindex = 0;
585 cpl_vector_sort(v, +1);
587 cpl_vector_dump(v, stdout);
589 printf(
"median=%f%d\n", median);
593 splitindex = cpl_vector_find(v, median);
596 v2 = cpl_vector_new(cpl_vector_get_size(v) - splitindex - 1);
598 printf(
"Copying elements %d to %d\n", splitindex+1, cpl_vector_get_size(v)-1);
600 for (i = splitindex; i < cpl_vector_get_size(v); i++){
602 printf(
" %d %f\n", i+1, cpl_vector_get(v, i));
604 cpl_vector_set(v2, i-splitindex, cpl_vector_get(v, i));
610 sqr = cpl_vector_get_median(v2);
611 cpl_vector_delete(v2);
614 v2 = cpl_vector_new(splitindex - 1);
616 printf(
"Copying elements %d to %d\n", 1, splitindex+1);
618 for (i = 0; i <= splitindex; i++) {
620 printf(
" %d %f\n", i+1, cpl_vector_get(v, i));
622 cpl_vector_set(v2, i, cpl_vector_get(v, i));
628 sqr -= cpl_vector_get_median(v2);
629 cpl_vector_delete(v2);
657 double aLoVal,
double aHiVal)
659 cpl_ensure_code(aVec, CPL_ERROR_NULL_INPUT);
660 cpl_ensure_code(aLoCut <= aHiCut, CPL_ERROR_ILLEGAL_INPUT);
662 double *data = cpl_vector_get_data(aVec);
663 int i, n = cpl_vector_get_size(aVec);
664 for (i = 0; i < n; i++) {
665 if (data[i] > aHiCut) {
667 }
else if (data[i] < aLoCut) {
672 return CPL_ERROR_NONE;
691 cpl_ensure_code(aVector, CPL_ERROR_NULL_INPUT);
692 int size = cpl_vector_get_size(aVector);
693 cpl_ensure_code(aElement >= 0 && aElement < size, CPL_ERROR_ILLEGAL_INPUT);
695 if (aElement < size - 1) {
698 double *data = cpl_vector_get_data(aVector);
699 memmove(&data[aElement], &data[aElement+1],
700 (size-1 - aElement) *
sizeof(
double));
704 return cpl_vector_set_size(aVector, size - 1);
719 cpl_ensure(aVector, CPL_ERROR_NULL_INPUT, -1);
720 cpl_vector *sorted = cpl_vector_duplicate(aVector);
721 cpl_vector_sort(sorted, CPL_SORT_ASCENDING);
722 double *data = cpl_vector_get_data(sorted);
723 cpl_size i, n = cpl_vector_get_size(sorted),
725 for (i = 1; i < n; i++) {
726 if (data[i] != data[i - 1]) {
730 cpl_vector_delete(sorted);
746 cpl_ensure(aVector, CPL_ERROR_NULL_INPUT, NULL);
747 cpl_vector *sorted = cpl_vector_duplicate(aVector);
748 cpl_vector_sort(sorted, CPL_SORT_ASCENDING);
749 double *data = cpl_vector_get_data(sorted);
750 cpl_size i, n = cpl_vector_get_size(sorted),
752 cpl_vector *vunique = cpl_vector_new(n);
753 cpl_vector_set(vunique, iunique++, data[0]);
754 for (i = 1; i < n; i++) {
755 if (data[i] != data[i - 1]) {
756 cpl_vector_set(vunique, iunique++, data[i]);
759 cpl_vector_delete(sorted);
760 cpl_vector_set_size(vunique, iunique);
778 cpl_ensure(aDef, CPL_ERROR_NULL_INPUT, NULL);
779 cpl_table *res = cpl_table_new(aLength);
780 for (; aDef->
name != NULL; aDef++) {
781 cpl_error_code rc = CPL_ERROR_NONE;
782 if (aDef->
type & CPL_TYPE_POINTER) {
783 rc = cpl_table_new_column_array(res, aDef->
name, aDef->
type, 2);
785 rc = cpl_table_new_column(res, aDef->
name, aDef->
type);
787 if (rc != CPL_ERROR_NONE) {
788 cpl_table_delete(res);
791 if (aDef->
unit != NULL) {
792 if (cpl_table_set_column_unit(res, aDef->
name,
793 aDef->
unit) != CPL_ERROR_NONE) {
797 if (aDef->
format != NULL) {
798 if (cpl_table_set_column_format(res, aDef->
name,
799 aDef->
format) != CPL_ERROR_NONE) {
824 int extension = cpl_fits_find_extension(aFile, aExtension);
825 if (extension <= 0) {
826 cpl_error_set_message(__func__, cpl_error_get_code(),
"%s['%s']: "
827 "extension not found by EXTNAME", aFile, aExtension);
830 cpl_msg_debug(__func__,
"Loading %s['%s'] from extension %d", aFile,
831 aExtension, extension);
832 cpl_table *tbl = cpl_table_load(aFile, extension, 2);
834 cpl_table_delete(tbl);
860 const char *aExtension,
862 cpl_ensure_code(aTable != NULL, CPL_ERROR_NULL_INPUT);
863 cpl_ensure_code(aFile != NULL, CPL_ERROR_NULL_INPUT);
864 cpl_ensure_code(aExtension != NULL, CPL_ERROR_NULL_INPUT);
866 if (r != CPL_ERROR_NONE) {
867 cpl_msg_error(__func__,
" %s['%s'] Table format error", aFile, aExtension);
868 cpl_error_set(__func__, r);
871 cpl_propertylist *props = cpl_propertylist_new();
872 cpl_propertylist_update_string(props,
"EXTNAME", aExtension);
873 r = cpl_table_save(aTable, NULL, props, aFile, CPL_IO_EXTEND);
874 cpl_propertylist_delete(props);
875 if (r != CPL_ERROR_NONE) {
876 cpl_msg_error(__func__,
"%s[%s]: %s", aFile, aExtension,
877 cpl_error_get_message());
893 if (aTable == NULL) {
894 cpl_msg_error(__func__,
"NULL table");
895 cpl_error_set(__func__, CPL_ERROR_NULL_INPUT);
896 return CPL_ERROR_NULL_INPUT;
899 return CPL_ERROR_NONE;
901 cpl_error_code rc = CPL_ERROR_NONE;
902 for (; aDef->
name != NULL; aDef++) {
903 if (!cpl_table_has_column(aTable, aDef->
name)) {
905 rc = CPL_ERROR_ILLEGAL_INPUT;
906 cpl_error_set_message(__func__, rc,
"table column '%s' not found",
911 cpl_type coltype = cpl_table_get_column_type(aTable, aDef->
name);
912 if (((coltype | CPL_TYPE_POINTER) != (aDef->
type | CPL_TYPE_POINTER)) ||
913 ((coltype & CPL_TYPE_POINTER) && !(aDef->
type & CPL_TYPE_POINTER))) {
914 rc = CPL_ERROR_ILLEGAL_INPUT;
915 cpl_error_set_message(__func__, rc,
916 "table column '%s' format '%s' is not '%s'",
917 aDef->
name, cpl_type_get_name(coltype),
918 cpl_type_get_name(aDef->
type));
945 cpl_ensure(aTable && aColumn, CPL_ERROR_NULL_INPUT, NULL);
946 cpl_size nRows = cpl_table_get_nrow(aTable);
948 cpl_type type = cpl_table_get_column_type(aTable, aColumn);
950 return cpl_array_new(0, type);
952 if (type == CPL_TYPE_DOUBLE) {
953 double *src = cpl_table_get_data_double(aTable, aColumn);
954 return cpl_array_wrap_double(src, nRows);
955 }
else if (type == CPL_TYPE_FLOAT) {
956 float *src = cpl_table_get_data_float(aTable, aColumn);
957 return cpl_array_wrap_float(src, nRows);
958 }
else if (type == CPL_TYPE_INT) {
959 int *src = cpl_table_get_data_int(aTable, aColumn);
960 return cpl_array_wrap_int(src, nRows);
962 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
963 cpl_msg_error(__func__,
"%s: %i - %s", cpl_error_get_message(), type,
964 cpl_type_get_name(type));
982 const cpl_array *aArray)
984 cpl_ensure_code(aTable && aColumn && aArray, CPL_ERROR_NULL_INPUT);
985 cpl_size n_rows = cpl_table_get_nrow(aTable);
987 for (i = 0; i < n_rows; i++) {
989 double d = cpl_array_get(aArray, i, &flag);
991 cpl_table_set(aTable, aColumn, i, d);
993 cpl_table_set_invalid(aTable, aColumn, i);
996 return CPL_ERROR_NONE;
1014 cpl_ensure(aTable && aColumn, CPL_ERROR_NULL_INPUT, NULL);
1015 if (cpl_table_get_column_type(aTable, aColumn) & CPL_TYPE_POINTER) {
1016 return cpl_array_duplicate(cpl_table_get_array(aTable, aColumn, aRow));
1019 = cpl_array_new(1, cpl_table_get_column_type(aTable, aColumn));
1021 cpl_array_set(res, 0, cpl_table_get(aTable, aColumn, aRow, &flag));
1023 cpl_array_delete(res);
1049 cpl_ensure(aTable && aColumn, CPL_ERROR_NULL_INPUT, 0);
1052 cpl_array_unwrap(array);
1067 cpl_size nx = cpl_image_get_size_x(aImage);
1068 cpl_size ny = cpl_image_get_size_y(aImage);
1069 cpl_array *array = cpl_array_new(nx*ny, cpl_image_get_type(aImage));
1072 for (iy = 1; iy <= ny; iy++) {
1074 for (ix = 1; ix <= nx; ix++, i++) {
1076 double d = cpl_image_get(aImage, ix, iy, &rej);
1077 cpl_array_set(array, i, d);
1079 cpl_array_set_invalid(array, i);
1103 cpl_ensure_code(aArray && aCoeff, CPL_ERROR_NULL_INPUT);
1104 const cpl_size nrows = cpl_array_get_size(aArray);
1105 cpl_size order = cpl_array_get_size(aCoeff);
1107 cpl_array_fill_window(aArray, 0, nrows, 0.0);
1108 return CPL_ERROR_NONE;
1111 cpl_array *x = cpl_array_duplicate(aArray);
1112 cpl_array_fill_window(aArray, 0, nrows, cpl_array_get(aCoeff, order, NULL));
1115 for (k = order-1; k >= 0; k--) {
1116 cpl_array_multiply(aArray, x);
1117 cpl_array_add_scalar(aArray, cpl_array_get(aCoeff, k, NULL));
1120 cpl_array_delete(x);
1122 return CPL_ERROR_NONE;
1141 cpl_ensure(aCoeff, CPL_ERROR_NULL_INPUT, NAN);
1142 cpl_size order = cpl_array_get_size(aCoeff);
1147 double res = cpl_array_get(aCoeff, order, NULL);
1149 for (k = order-1; k >= 0; k--) {
1150 res = res * aDouble + cpl_array_get(aCoeff, k, NULL);
1168 cpl_ensure_code(aArray && aName, CPL_ERROR_NULL_INPUT);
1169 cpl_size i, size = cpl_array_get_size(aArray);
1170 for (i = 0; i < size; i++) {
1171 printf(
"%s[%"CPL_SIZE_FORMAT
"] = %g\n", aName, i,
1172 cpl_array_get(aArray, i, NULL));
1174 return CPL_ERROR_NONE;
1187 cpl_ensure_code(aArray != NULL, CPL_ERROR_NULL_INPUT);
1188 cpl_size n = cpl_array_get_size(aArray);
1189 cpl_size n_val = n - cpl_array_count_invalid(aArray);
1190 cpl_msg_debug(__func__,
"size = %li, %li valid", (
long)n, (
long)n_val);
1192 return CPL_ERROR_NONE;
1196 for (i = 0; (i < n) && (idx < n_val); i++) {
1198 double d = cpl_array_get(aArray, i, &rej);
1201 cpl_array_set(aArray, idx, d);
1206 cpl_array_set_size(aArray, n_val);
1207 return CPL_ERROR_NONE;
1228 cpl_size aGap,
double aLimit)
1230 cpl_ensure(aArray && aHistogram, CPL_ERROR_NULL_INPUT, -1);
1233 double value = cpl_array_get(aArray, 0, &err);
1234 cpl_ensure(err >= 0, CPL_ERROR_ILLEGAL_INPUT, -2);
1237 const double *hpos = cpl_bivector_get_x_data_const(aHistogram),
1238 *hval = cpl_bivector_get_y_data_const(aHistogram);
1239 cpl_size nhist = cpl_bivector_get_size(aHistogram);
1240 cpl_array *ahist = cpl_array_wrap_double((
double *)hval, nhist);
1242 cpl_array_get_maxpos(ahist, &imax);
1243 cpl_array_unwrap(ahist);
1246 double loval = hpos[0],
1247 hival = hpos[nhist - 1];
1248 cpl_size i, nlow = 0;
1249 for (i = imax; i >= 0; i--) {
1250 if (hval[i] <= aLimit) {
1258 }
else if (nlow > 0) {
1264 for (i = imax; i < nhist; i++) {
1265 if (hval[i] <= aLimit) {
1273 }
else if (nlow > 0) {
1275 hival = hpos[nhist - 1];
1278 cpl_msg_debug(__func__,
"Histogram gaps (%"CPL_SIZE_FORMAT
" consecutive "
1279 "entries <= %f) at %f and %f", aGap, aLimit, loval, hival);
1283 cpl_size idx, narray = cpl_array_get_size(aArray);
1284 for (idx = 0; idx < narray; idx++) {
1285 value = cpl_array_get(aArray, idx, NULL);
1286 if (value > hival || value < loval) {
1287 cpl_array_set_invalid(aArray, idx);
1292 cpl_size nbad = cpl_array_count_invalid(aArray);
1302 static int cmp_double_asc(
const void *p1,
const void *p2) {
1303 double d = (*(
const double *)p1 - *(
const double *)p2);
1304 return (d < 0)?-1:(d>0)?1:0;
1307 static int cmp_double_desc(
const void *p1,
const void *p2) {
1308 double d = (*(
const double *)p1 - *(
const double *)p2);
1309 return (d < 0)?1:(d>0)?-1:0;
1312 static int cmp_float_asc(
const void *p1,
const void *p2) {
1313 float d = (*(
const float *)p1 - *(
const float *)p2);
1314 return (d < 0)?-1:(d>0)?1:0;
1317 static int cmp_float_desc(
const void *p1,
const void *p2) {
1318 float d = (*(
const float *)p1 - *(
const float *)p2);
1319 return (d < 0)?1:(d>0)?-1:0;
1322 static int cmp_int_asc(
const void *p1,
const void *p2) {
1323 return (*(
const int *)p1 - *(
const int *)p2);
1326 static int cmp_int_desc(
const void *p1,
const void *p2) {
1327 return (*(
const int *)p2 - *(
const int *)p1);
1344 cpl_ensure_code(aArray != NULL, CPL_ERROR_NULL_INPUT);
1345 cpl_ensure_code(!cpl_array_has_invalid(aArray), CPL_ERROR_NULL_INPUT);
1347 cpl_size n = cpl_array_get_size(aArray);
1348 if (cpl_array_get_type(aArray) == CPL_TYPE_DOUBLE) {
1349 double *d = cpl_array_get_data_double(aArray);
1350 qsort(d, n,
sizeof(
double), (aOrder)?cmp_double_asc:cmp_double_desc);
1351 return CPL_ERROR_NONE;
1352 }
else if (cpl_array_get_type(aArray) == CPL_TYPE_FLOAT) {
1353 float *d = cpl_array_get_data_float(aArray);
1354 qsort(d, n,
sizeof(
float), (aOrder)?cmp_float_asc:cmp_float_desc);
1355 return CPL_ERROR_NONE;
1356 }
else if (cpl_array_get_type(aArray) == CPL_TYPE_INT) {
1357 int *d = cpl_array_get_data_int(aArray);
1358 qsort(d, n,
sizeof(
int), (aOrder)?cmp_int_asc:cmp_int_desc);
1359 return CPL_ERROR_NONE;
1361 return CPL_ERROR_ILLEGAL_INPUT;
1387 double aMin,
double aMax)
1389 cpl_ensure(aArray, CPL_ERROR_NULL_INPUT, NULL);
1392 double value = cpl_array_get(aArray, 0, &err);
1393 cpl_ensure(err >= 0, CPL_ERROR_INVALID_TYPE, NULL);
1394 if (!isnan(aMin) && !isnan(aMax) && aMin >= aMax) {
1395 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
1399 aMin = cpl_array_get_min(aArray);
1402 aMax = cpl_array_get_max(aArray);
1404 cpl_size hlen = lround((aMax - aMin) / aWidth) + 1;
1405 cpl_bivector *histogram = cpl_bivector_new(hlen);
1408 double *hpos = cpl_bivector_get_x_data(histogram);
1410 for (i = 0; i < hlen; i++) {
1411 hpos[i] = i * aWidth + aMin;
1415 double *hval = cpl_bivector_get_y_data(histogram);
1417 cpl_vector_fill(cpl_bivector_get_y(histogram), 0.);
1418 cpl_size n = cpl_array_get_size(aArray);
1419 for (i = 0; i < n; i++) {
1420 value = cpl_array_get(aArray, i, &err);
1425 cpl_size idx = lround((value - aMin) / aWidth);
1426 if (idx >= hlen || idx < 0) {
1433 printf(
"histogram %f...%f / %f\n", aMin, aMax, aWidth);
1434 cpl_bivector_dump(histogram, stdout);
1457 cpl_ensure(aArray, CPL_ERROR_NULL_INPUT, 0);
1459 cpl_size max = cpl_array_get_size(aArray);
1460 cpl_type type = cpl_array_get_type(aArray);
1461 if (type == CPL_TYPE_DOUBLE) {
1462 const double *data = cpl_array_get_data_double_const(aArray);
1463 while (max - min > 1) {
1464 int i = (max + min)/2;
1465 if (data[i] > aValue) {
1471 }
else if (type == CPL_TYPE_FLOAT) {
1472 const float *data = cpl_array_get_data_float_const(aArray);
1473 while (max - min > 1) {
1474 int i = (max + min)/2;
1475 if (data[i] > aValue) {
1481 }
else if (type == CPL_TYPE_INT) {
1482 const int *data = cpl_array_get_data_int_const(aArray);
1483 while (max - min > 1) {
1484 int i = (max + min)/2;
1485 if (data[i] > aValue) {
1492 cpl_msg_error(__func__,
"illegal type %i", type);
1493 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
1518 cpl_ensure(aArray, CPL_ERROR_NULL_INPUT, CPL_FALSE);
1519 cpl_type type = cpl_array_get_type(aArray);
1523 case CPL_TYPE_LONG_LONG:
1527 cpl_error_set(__func__, CPL_ERROR_UNSUPPORTED_MODE);
1531 cpl_size idx, n = cpl_array_get_size(aArray);
1532 for (idx = 0; idx < n - 1; idx++) {
1534 cpl_size v1 = cpl_array_get(aArray, idx, &err);
1539 for (idx2 = idx + 1; idx2 < n; idx2++) {
1540 cpl_size v2 = cpl_array_get(aArray, idx2, &err);
1546 cpl_msg_debug(__func__,
"entry[%"CPL_SIZE_FORMAT
"] == entry[%"
1547 CPL_SIZE_FORMAT
"] == %"CPL_SIZE_FORMAT, idx, idx2, v1);
1573 cpl_size nrows = cpl_array_get_size(aArray);
1574 if (aCount > nrows - aStart) {
1575 aCount = nrows - aStart;
1577 cpl_type type = cpl_array_get_type(aArray);
1578 if (type == CPL_TYPE_DOUBLE) {
1579 return cpl_array_wrap_double(cpl_array_get_data_double(aArray) + aStart,
1581 }
else if (type == CPL_TYPE_FLOAT) {
1582 return cpl_array_wrap_float(cpl_array_get_data_float(aArray) + aStart,
1584 }
else if (type == CPL_TYPE_INT) {
1585 return cpl_array_wrap_int(cpl_array_get_data_int(aArray) + aStart,
1588 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
1609 const cpl_array *aArray)
1611 cpl_ensure_code(aDest && aArray, CPL_ERROR_NULL_INPUT);
1612 cpl_size count = cpl_array_get_size(aArray);
1614 if (destArray == NULL) {
1615 return CPL_ERROR_ILLEGAL_INPUT;
1617 cpl_array_add(destArray, aArray);
1618 cpl_array_unwrap(destArray);
1620 return CPL_ERROR_NONE;
1637 cpl_ensure(aArray, CPL_ERROR_NULL_INPUT, NULL);
1638 cpl_ensure(aOffset > 0, CPL_ERROR_ILLEGAL_INPUT, NULL);
1639 cpl_size nrows = cpl_array_get_size(aArray);
1641 cpl_array *a1 = cpl_array_extract(aArray, 0, nrows - aOffset);
1642 cpl_array *a2 = cpl_array_extract(aArray, aOffset, nrows - aOffset);
1643 if (a1 == NULL || a2 == NULL) {
1644 cpl_array_delete(a1);
1645 cpl_array_delete(a2);
1648 cpl_array_subtract(a2, a1);
1649 cpl_array_delete(a1);
1670 cpl_ensure_code(aArray, CPL_ERROR_NULL_INPUT);
1671 cpl_type type = cpl_array_get_type(aArray);
1672 cpl_size n = cpl_array_get_size(aArray);
1673 if (type == CPL_TYPE_DOUBLE) {
1674 double *d = cpl_array_get_data_double(aArray);
1676 for (i = 0; i < n; i++, d++) {
1679 }
else if (type == CPL_TYPE_FLOAT) {
1680 float *d = cpl_array_get_data_float(aArray);
1682 for (i = 0; i < n; i++, d++) {
1686 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
1687 return CPL_ERROR_ILLEGAL_INPUT;
1689 return CPL_ERROR_NONE;
1709 cpl_ensure_code(aArray, CPL_ERROR_NULL_INPUT);
1710 cpl_type type = cpl_array_get_type(aArray);
1711 cpl_size n = cpl_array_get_size(aArray);
1712 if (type == CPL_TYPE_DOUBLE) {
1713 double *d = cpl_array_get_data_double(aArray);
1715 for (i = 0; i < n; i++, d++) {
1718 }
else if (type == CPL_TYPE_FLOAT) {
1719 float *d = cpl_array_get_data_float(aArray);
1721 for (i = 0; i < n; i++, d++) {
1725 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
1726 return CPL_ERROR_ILLEGAL_INPUT;
1728 return CPL_ERROR_NONE;
1758 const cpl_array *aSourceAbscissa,
1759 const cpl_array *aSourceOrdinate)
1761 cpl_ensure(aTargetAbscissa && aSourceAbscissa && aSourceOrdinate,
1762 CPL_ERROR_NULL_INPUT, NULL);
1764 double *targetX = cpl_array_get_data_double((cpl_array *)aTargetAbscissa);
1765 double *srcX = cpl_array_get_data_double((cpl_array *)aSourceAbscissa);
1766 double *srcY = cpl_array_get_data_double((cpl_array *)aSourceOrdinate);
1767 cpl_ensure(targetX && srcX && srcY, CPL_ERROR_ILLEGAL_INPUT, NULL);
1769 cpl_array *targetOrdinate = cpl_array_duplicate(aTargetAbscissa);
1770 double *targetY = cpl_array_get_data_double(targetOrdinate);
1772 cpl_size n_src = cpl_array_get_size(aSourceAbscissa);
1773 cpl_vector *srcX_vec = cpl_vector_wrap(n_src, srcX);
1774 cpl_vector *srcY_vec = cpl_vector_wrap(n_src, srcY);
1775 cpl_bivector *src_vec = cpl_bivector_wrap_vectors(srcX_vec, srcY_vec);
1777 cpl_size offset = (srcX[0] <= targetX[0])?0:
1782 cpl_vector *targetX_vec = cpl_vector_wrap(n_target, targetX + offset);
1783 cpl_vector *targetY_vec = cpl_vector_wrap(n_target, targetY + offset);
1784 cpl_bivector *target_vec = cpl_bivector_wrap_vectors(targetX_vec,
1787 cpl_array_fill_window_invalid(targetOrdinate, 0, offset);
1789 if (offset + n_target < (
unsigned)cpl_array_get_size(targetOrdinate)) {
1790 cpl_array_fill_window_invalid(targetOrdinate, offset + n_target,
1791 cpl_array_get_size(targetOrdinate)
1792 - (offset + n_target));
1794 cpl_bivector_interpolate_linear(target_vec, src_vec);
1795 cpl_bivector_unwrap_vectors(target_vec);
1796 cpl_vector_unwrap(targetX_vec);
1797 cpl_vector_unwrap(targetY_vec);
1798 cpl_bivector_unwrap_vectors(src_vec);
1799 cpl_vector_unwrap(srcX_vec);
1800 cpl_vector_unwrap(srcY_vec);
1802 return targetOrdinate;
1827 const cpl_table *aSrcTable,
1828 const char *aSrcAbscissa,
1829 const char *aSrcOrdinate)
1836 cpl_array_unwrap(sabs);
1837 cpl_array_unwrap(sord);
1859 cpl_ensure(aString && aDelim, CPL_ERROR_NULL_INPUT, NULL);
1861 char *
string = cpl_strdup(aString);
1864 char *prev = string, *next;
1865 cpl_array *out = cpl_array_new(0, CPL_TYPE_STRING);
1868 next = strstr(prev, aDelim);
1873 cpl_array_set_size(out, ++ntok);
1874 cpl_array_set_string(out, ntok - 1, prev);
1876 prev = next + strlen(aDelim);
1881 printf(
"Input string %s and delimiter %s resulted in output\n",
1883 cpl_array_dump(out, 0, cpl_array_get_size(out), stdout);
1908 cpl_ensure(aArray, CPL_ERROR_NULL_INPUT, NULL);
1909 cpl_ensure(cpl_array_get_type(aArray) == CPL_TYPE_STRING,
1910 CPL_ERROR_ILLEGAL_INPUT, NULL);
1912 cpl_size i, n = cpl_array_get_size(aArray);
1913 cpl_array *darray = cpl_array_new(n, CPL_TYPE_DOUBLE);
1914 for (i = 0; i < n; i++) {
1915 const char *
string = cpl_array_get_string(aArray, i);
1919 cpl_array_set_double(darray, i, atof(
string));
1941 const char *aPrefix,
const char *aName)
1943 char *fullname = cpl_sprintf(
"%s.%s", aPrefix, aName);
1944 cpl_parameter *p = cpl_parameterlist_find(aParameters, fullname);
1979 cpl_ensure(aHeader, CPL_ERROR_NULL_INPUT, NULL);
1980 cpl_ensure(aRecNum > 0, CPL_ERROR_ILLEGAL_INPUT, NULL);
1983 char *kw = cpl_sprintf(
"ESO PRO REC%d ID", aRecNum);
1984 const char *recipe = cpl_propertylist_get_string(aHeader, kw);
1986 cpl_ensure(recipe, CPL_ERROR_ILLEGAL_INPUT, NULL);
1988 kw = cpl_sprintf(
"ESO PRO REC%d PIPE ID", aRecNum);
1989 const char *pipeid = cpl_propertylist_get_string(aHeader, kw);
1991 cpl_ensure(strstr(recipe,
"muse_") && strstr(pipeid,
"muse"),
1992 CPL_ERROR_INCOMPATIBLE_INPUT, NULL);
1993 char *context = cpl_sprintf(
"muse.%s", recipe);
1996 cpl_parameterlist *parlist = cpl_parameterlist_new();
1998 for (npar = 1; npar < cpl_propertylist_get_size(aHeader); npar++) {
1999 char *kwname = cpl_sprintf(
"ESO PRO REC%d PARAM%d NAME", aRecNum, npar),
2000 *kwvalue = cpl_sprintf(
"ESO PRO REC%d PARAM%d VALUE", aRecNum, npar);
2001 if (!cpl_propertylist_has(aHeader, kwname) ||
2002 !cpl_propertylist_has(aHeader, kwvalue)) {
2007 const cpl_property *prop = cpl_propertylist_get_property_const(aHeader,
2011 const char *value = cpl_property_get_string(prop);
2012 cpl_type type = CPL_TYPE_STRING;
2013 if (!strncmp(value,
"true", 5) || !strncmp(value,
"false", 6)) {
2014 type = CPL_TYPE_BOOL;
2015 }
else if (!strchr(value,
',') &&
2016 ((value[0] >=
'0' && value[0] <=
'9') ||
2017 value[0] ==
'-' || value[0] ==
'+')) {
2019 if (strchr(value,
'.') || strchr(value,
'E')) {
2020 type = CPL_TYPE_DOUBLE;
2022 type = CPL_TYPE_INT;
2025 char *parname = cpl_sprintf(
"muse.%s.%s", recipe,
2026 cpl_propertylist_get_string(aHeader, kwname));
2027 cpl_parameter *par = cpl_parameter_new_value(parname, type,
2028 cpl_propertylist_get_comment(aHeader, kwname),
2033 if (!strncmp(value,
"true", 5)) {
2034 cpl_parameter_set_bool(par, CPL_TRUE);
2036 cpl_parameter_set_bool(par, CPL_FALSE);
2040 cpl_parameter_set_int(par, atoi(value));
2042 case CPL_TYPE_DOUBLE:
2043 cpl_parameter_set_double(par, atof(value));
2045 case CPL_TYPE_STRING:
2046 cpl_parameter_set_string(par, value);
2049 cpl_msg_warning(__func__,
"property of type %s (%d) found!",
2050 cpl_type_get_name(type), type);
2052 cpl_parameterlist_append(parlist, par);
2076 cpl_ensure(aPList, CPL_ERROR_NULL_INPUT, NULL);
2078 cpl_parameterlist *list = cpl_parameterlist_new();
2079 const cpl_parameter *par = cpl_parameterlist_get_first_const(aPList);
2081 cpl_parameterlist_append(list, cpl_parameter_duplicate(par));
2082 par = cpl_parameterlist_get_next_const(aPList);
2108 const char *aKeyword, cpl_size aValue)
2110 cpl_ensure_code(aHeader && aKeyword, CPL_ERROR_NULL_INPUT);
2111 cpl_property *p = cpl_propertylist_get_property(aHeader, aKeyword);
2112 cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
2113 cpl_error_code rc = CPL_ERROR_NONE;
2114 switch (cpl_property_get_type(p)) {
2115 case CPL_TYPE_LONG_LONG:
2116 rc = cpl_property_set_long_long(p, aValue);
2119 rc = cpl_property_set_long(p, aValue);
2122 rc = cpl_property_set_int(p, aValue);
2142 cpl_ensure_code(aFrames, CPL_ERROR_NULL_INPUT);
2143 cpl_error_code rc = CPL_ERROR_NONE;
2145 while (cpl_frameset_get_size(aFrames) > 0 && rc == CPL_ERROR_NONE) {
2146 cpl_frame *frame = cpl_frameset_get_position(aFrames, 0);
2147 rc = cpl_frameset_erase_frame(aFrames, frame);
2173 cpl_ensure_code(aFrames, CPL_ERROR_NULL_INPUT);
2175 printf(
"\n\n\n%s input frameset (with duplicates):\n", __func__);
2176 cpl_frameset_dump(aFrames, stdout);
2177 printf(
"---------------------------------------------------------------------------\n");
2180 cpl_error_code rc = CPL_ERROR_NONE;
2184 for (i = 0; i < cpl_frameset_get_size(aFrames) - 1; i++) {
2185 cpl_frame *fref = cpl_frameset_get_position(aFrames, i);
2187 for (j = i + 1; j < cpl_frameset_get_size(aFrames); j++) {
2188 cpl_frame *fother = cpl_frameset_get_position(aFrames, j);
2189 cpl_boolean areequal = CPL_FALSE;
2190 cpl_errorstate state = cpl_errorstate_get();
2191 const char *fn1 = cpl_frame_get_filename(fref),
2192 *fn2 = cpl_frame_get_filename(fother);
2193 if (!cpl_errorstate_is_equal(state)) {
2194 cpl_errorstate_set(state);
2196 if ((!fn1 && fn2) || (fn1 && !fn2)) {
2197 areequal = CPL_FALSE;
2198 }
else if (!fn1 && !fn2) {
2199 areequal = CPL_TRUE;
2201 areequal = !strcmp(fn1, fn2);
2204 && !strcmp(cpl_frame_get_tag(fref), cpl_frame_get_tag(fother));
2206 && (cpl_frame_get_group(fref) == cpl_frame_get_group(fother));
2208 && (cpl_frame_get_level(fref) == cpl_frame_get_level(fother));
2210 && (cpl_frame_get_type(fref) == cpl_frame_get_type(fother));
2213 printf(
"%ld/%ld are equal: %s/%s, %s/%s, %d/%d, %d/%d, %d/%d\n", i, j,
2214 fn1, fn2, tag1, tag2,
2215 cpl_frame_get_group(fref), cpl_frame_get_group(fother),
2216 cpl_frame_get_level(fref), cpl_frame_get_level(fother),
2217 cpl_frame_get_type(fref), cpl_frame_get_type(fother));
2222 rc = cpl_frameset_erase_frame(aFrames, fref);
2229 printf(
"---------------------------------------------------------------------------\n");
2230 printf(
"%s input frameset (without duplicates):\n", __func__);
2231 cpl_frameset_dump(aFrames, stdout);
2232 printf(
"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n\n");
2254 const cpl_boolean is_reverse = aFirst > aLast ? CPL_TRUE : CPL_FALSE;
2255 const char *revmsg = is_reverse ?
" in reverse order" :
"";
2256 const unsigned newest = is_reverse ? aFirst : aLast,
2257 nmax = labs(aLast - aFirst) + 1;
2258 unsigned ndump = 20;
2259 if (getenv(
"MUSE_CPL_ERRORSTATE_NDUMP") &&
2260 atoi(getenv(
"MUSE_CPL_ERRORSTATE_NDUMP")) > 0) {
2261 ndump = atoi(getenv(
"MUSE_CPL_ERRORSTATE_NDUMP"));
2263 ndump = nmax < ndump ? nmax : ndump;
2266 if (aCurrent == aLast - (ndump-1)) {
2267 cpl_msg_error(__func__,
"Dumping the %u most recent error(s) out of a "
2268 "total of %u errors%s:", ndump, newest, revmsg);
2269 cpl_msg_indent_more();
2271 if (aCurrent >= aLast - (ndump-1)) {
2272 cpl_msg_error(__func__,
"[%u/%u] '%s' (%u) at %s", aCurrent, newest,
2273 cpl_error_get_message(), cpl_error_get_code(),
2274 cpl_error_get_where());
2276 if (aCurrent == aLast) {
2277 cpl_msg_indent_less();
2280 cpl_msg_info(__func__,
"No error(s) to dump");
2300 #ifdef HAVE_READLINK
2301 char buffer[FILENAME_MAX] =
"\0";
2302 int length = readlink(
"/proc/self/exe", buffer,
sizeof(buffer) - 1);
2304 buffer[length] =
'\0';
2306 if (strstr(buffer,
"esorex")) {
2308 }
else if (strstr(buffer,
"python")) {
2310 }
else if (strstr(buffer,
"jre")) {
cpl_error_code muse_cplarray_erase_invalid(cpl_array *aArray)
Erase all invalid values from an array.
cpl_type type
Column type (use CPL_TYPE_POINTER for array columns).
cpl_array * muse_cplarray_interpolate_table_linear(const cpl_array *aTargetAbscissa, const cpl_table *aSrcTable, const char *aSrcAbscissa, const char *aSrcOrdinate)
Linear interpolation of a 1d column.
const int required
Is column required?
cpl_error_code muse_cplarray_dump_name(const cpl_array *aArray, const char *aName)
Dump a numerical array to stdout with a name prefixed to each line.
cpl_image * muse_cplimage_filter_median_subtract(cpl_image *aImage, unsigned int aNX, unsigned int aNY)
Subtract a median-filtered version of the input image from itself.
cpl_array * muse_cplarray_extract(cpl_array *aArray, cpl_size aStart, cpl_size aCount)
Create an array from a section of another array.
muse_cplframework_type muse_cplframework(void)
Return the CPL framework the recipe is run under.
cpl_array * muse_cplarray_string_to_double(const cpl_array *aArray)
Convert a string array into an array of type double.
cpl_error_code muse_cplarray_sort(cpl_array *aArray, cpl_boolean aOrder)
Sort float, int or double array by quicksort.
const char * unit
Column unit, or NULL.
cpl_error_code muse_cplarray_poly1d(cpl_array *aArray, const cpl_array *aCoeff)
Apply a polynomial to an array.
double muse_cplvector_get_median_dev(cpl_vector *aVector, double *aMedian)
Compute the median and average absolute deviation against the median of a vector. ...
cpl_vector * muse_cplvector_get_unique(const cpl_vector *aVector)
Separate out all unique entries in a given vector into a new one.
double muse_cplvector_get_semiquartile(cpl_vector *aVector)
compute the semi-quartile range of a vector of elements
cpl_boolean muse_cplarray_has_duplicate(const cpl_array *aArray)
Check, if an array contains duplicate values.
cpl_image * muse_cplimage_concat_y(const cpl_image *aImage1, const cpl_image *aImage2)
Concatenate two images in y direction.
cpl_error_code muse_cpltable_check(const cpl_table *aTable, const muse_cpltable_def *aDef)
Check whether the table contains the fields of the definition.
cpl_table * muse_cpltable_load(const char *aFile, const char *aExtension, const muse_cpltable_def aDefinition[])
Load a table from disk (and check against definition).
cpl_table * muse_cpltable_new(const muse_cpltable_def *aDef, cpl_size aLength)
Create an empty table according to the specified definition.
cpl_error_code muse_cplarray_exp(cpl_array *aArray)
Compute the exponential function of array elements.
cpl_error_code muse_cplimage_or(cpl_image *aTarget, const cpl_image *aImage, unsigned int mask)
Provide an 'OR' operation of two integer images.
cpl_array * muse_cplarray_new_from_delimited_string(const char *aString, const char *aDelim)
Convert a delimited string into an array of strings.
cpl_array * muse_cpltable_get_array_copy(cpl_table *aTable, const char *aColumn, cpl_size aRow)
Return the copy of an array of a table cell.
cpl_array * muse_cpltable_extract_column(cpl_table *aTable, const char *aColumn)
Create an array from a section of a column.
cpl_error_code muse_cplvector_erase_element(cpl_vector *aVector, int aElement)
delete the given element from the input vector
const char * name
Column name.
const char * format
Default print format, or NULL.
cpl_array * muse_cplarray_new_from_image(const cpl_image *aImage)
Copy the image data into an array.
cpl_bivector * muse_cplarray_histogram(const cpl_array *aArray, double aWidth, double aMin, double aMax)
Create a histogram for a numerical array.
cpl_array * muse_cplarray_interpolate_linear(const cpl_array *aTargetAbscissa, const cpl_array *aSourceAbscissa, const cpl_array *aSourceOrdinate)
Linear interpolation of a 1d array.
double muse_cplimage_get_percentile(const cpl_image *aImage, double aFraction)
Get the percentile of an image.
void muse_cplerrorstate_dump_some(unsigned aCurrent, unsigned aFirst, unsigned aLast)
Dump some CPL errors.
cpl_vector * muse_cplimage_slope_window(const cpl_image *aImage, const cpl_size *aWindow)
Compute slopes of an image, both horizontally and vertically.
cpl_error_code muse_cplarray_erf(cpl_array *aArray)
Compute the error function of array elements.
cpl_error_code muse_cplarray_add_window(cpl_array *aDest, cpl_size aStart, const cpl_array *aArray)
Add the value of an array to a window of a table column.
cpl_error_code muse_cplpropertylist_update_long_long(cpl_propertylist *aHeader, const char *aKeyword, cpl_size aValue)
Update an integer-like property irrespective of the real type.
cpl_size muse_cpltable_find_sorted(const cpl_table *aTable, const char *aColumn, double aValue)
Find a row in a table.
cpl_image * muse_cplimage_concat_x(const cpl_image *aImage1, const cpl_image *aImage2)
Concatenate two images in x direction.
cpl_error_code muse_cpltable_copy_array(cpl_table *aTable, const char *aColumn, const cpl_array *aArray)
Copy an array into a table.
cpl_array * muse_cplarray_diff(const cpl_array *aArray, int aOffset)
Build the difference of any element and one of the next elements.
cpl_parameterlist * muse_cplparameterlist_duplicate(const cpl_parameterlist *aPList)
Duplicate a CPL parameter list.
cpl_error_code muse_cplframeset_erase_duplicate(cpl_frameset *aFrames)
Erase all duplicate frames from a frameset.
cpl_error_code muse_cplframeset_erase_all(cpl_frameset *aFrames)
Erase all frames in a frameset.
cpl_size muse_cplarray_erase_outliers(cpl_array *aArray, const cpl_bivector *aHistogram, cpl_size aGap, double aLimit)
Erase outliers from an array using histogram information.
muse_cplframework_type
Type for the framework that called the recipe.
cpl_size muse_cplvector_count_unique(const cpl_vector *aVector)
Count the number of unique entries in a given vector.
Definition of a cpl table structure.
double muse_cplvector_get_adev_const(const cpl_vector *aVector, double aCenter)
Compute the average absolute deviation of a (constant) vector.
cpl_parameter * muse_cplparamerterlist_find_prefix(cpl_parameterlist *aParameters, const char *aPrefix, const char *aName)
Return the full recipe parameter belonging to prefix and shortname.
double muse_cplarray_poly1d_double(double aDouble, const cpl_array *aCoeff)
Apply a polynomial to a double value.
cpl_size muse_cplarray_find_sorted(const cpl_array *aArray, double aValue)
Find a row in an array.
cpl_error_code muse_cplvector_threshold(cpl_vector *aVec, double aLoCut, double aHiCut, double aLoVal, double aHiVal)
Threshold a vector to a given interval.
cpl_mask * muse_cplmask_adapt_to_image(const cpl_mask *aMask, const cpl_image *aImage)
Adapt mask with masked region in one quadrant to size of an image.
cpl_parameterlist * muse_cplparameterlist_from_propertylist(const cpl_propertylist *aHeader, int aRecNum)
Recreate a cpl_parameterlist from the RECi headers of an output MUSE product.
cpl_image * muse_cplimagelist_collapse_or_create(const cpl_imagelist *imlist)
Compute the OR of an image list to a single image.
cpl_error_code muse_cpltable_append_file(const cpl_table *aTable, const char *aFile, const char *aExtension, const muse_cpltable_def aDefinition[])
Save a table to disk (into a FITS extension)