diff options
Diffstat (limited to 'pkg/xtools/fixpix/xtfp.x')
| -rw-r--r-- | pkg/xtools/fixpix/xtfp.x | 1271 |
1 files changed, 1271 insertions, 0 deletions
diff --git a/pkg/xtools/fixpix/xtfp.x b/pkg/xtools/fixpix/xtfp.x new file mode 100644 index 00000000..774ffa12 --- /dev/null +++ b/pkg/xtools/fixpix/xtfp.x @@ -0,0 +1,1271 @@ +include <imhdr.h> +include <pmset.h> +include "xtfixpix.h" + + + + +# XT_FP -- Get the specified line of image data and replace bad pixels by +# interpolation. + +pointer procedure xt_fps (fp, im, line, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +pointer imgl2s(), xt_fpss() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2s (im, line)) + + col1 = 1 + col2 = IM_LEN(im,1) + line1 = 1 + line2 = IM_LEN(im,2) + + return (xt_fpss (fp, im, line, col1, col2, line1, line2, fd)) +end + + +# XT_FXS -- Get the specified line of image data and replace bad pixels by +# interpolation within a specified section. + +pointer procedure xt_fpss (fp, im, line, col1, col2, line1, line2, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +int i, j, nc, nl, ncols, c1, c2, l1, l2, l3, l4 +long v[IM_MAXDIM] +real a, b, c, d, val +short indef +pointer pm, data, bp + +bool pm_linenotempty() +pointer imgl2s(), xt_fpvals() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2s (im, line)) + + # Initialize + pm = FP_PM(fp) + nc = IM_LEN(im,1) + nl = IM_LEN(im,2) + ncols = FP_NCOLS(fp) + call amovkl (long(1), v, IM_MAXDIM) + v[2] = line + + # If there might be column interpolation initialize value arrays. + if (ncols > 0 && FP_PV1(fp) == NULL) { + FP_PIXTYPE(fp) = TY_SHORT + call malloc (FP_PV1(fp), ncols, FP_PIXTYPE(fp)) + call malloc (FP_PV2(fp), ncols, FP_PIXTYPE(fp)) + indef = INDEFS + call amovks (indef, Mems[FP_V1(fp,1)], ncols) + call amovks (indef, Mems[FP_V2(fp,1)], ncols) + } + + # If there are no bad pixels in the line and the line contains + # no column interpolation endpoints return the data directly. + # Otherwise get the line and fill in any endpoints that may + # be used later. + + if (!pm_linenotempty (pm, v)) { + if (line < FP_LMIN(fp) || line > FP_LMAX(fp)) + return (imgl2s (im, line)) + else + return (xt_fpvals (fp, im, line)) + } + + # Get the pixel mask. + call malloc (bp, nc, TY_SHORT) + call pmglps (pm, v, Mems[bp], 0, nc, PIX_SRC) + bp = bp - 1 + + # Check if any column interpolation endpoints are needed and + # set them. Set any other endpoints on the same lines at + # the same time. + + if (line >= FP_LMIN(fp) && line < FP_LMAX(fp)) { + j = 1 + do i = col1, col2 { + if (Mems[bp+i] == FP_CVAL(fp)) { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + if (line>FP_L1(fp,j) && line<FP_L2(fp,j)) { + if (IS_INDEFS(Mems[FP_V1(fp,j)])) + data = xt_fpvals (fp, im, FP_L1(fp,j)) + if (IS_INDEFS(Mems[FP_V2(fp,j)])) + data = xt_fpvals (fp, im, FP_L2(fp,j)) + } + } + } + } + } + + # Fix pixels by column or line interpolation. + if (FP_DATA(fp) == NULL) { + FP_PIXTYPE(fp) = TY_SHORT + call malloc (FP_DATA(fp), nc, FP_PIXTYPE(fp)) + } + data = FP_DATA(fp) + call amovs (Mems[xt_fpvals(fp,im,line)], Mems[data], nc) + j = 1 + for (c1=col1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + while (c1 <= col2) { + c1 = c1 - 1 + for (c2=c1+2; c2<=col2 && Mems[bp+c2]!=0; c2=c2+1) + ; + a = INDEFS + do i = c1+1, c2-1 { + if (Mems[bp+i] == FP_LVAL(fp)) { + if (IS_INDEFS(a)) { + if (c1 < col1 && c2 > col2) { + c1 = c2 + 1 + next + } + if (c1 >= col1) + a = Mems[data+c1-1] + else + a = Mems[data+c2-1] + if (c2 <= col2) + b = (Mems[data+c2-1] - a) / (c2 - c1) + else + b = 0. + } + val = a + b * (i - c1) + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargs (Mems[data+i-1]) + call pargr (val) + if (c1 >= col1) { + call fprintf (fd, " %4d %4d") + call pargi (c1) + call pargi (line) + } + if (c2 <= col2) { + call fprintf (fd, " %4d %4d") + call pargi (c2) + call pargi (line) + } + call fprintf (fd, "\n") + } + } else { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + l1 = FP_L1(fp,j) + l2 = FP_L2(fp,j) + if (l1 < line1 && l2 > line2) + next + if (line > l1 && line < l2) { + if (l1 >= line1) + c = Mems[FP_V1(fp,j)] + else + c = Mems[FP_V2(fp,j)] + if (l2 <= line2) { + d = (Mems[FP_V2(fp,j)] - c) / (l2 - l1) + val = c + d * (line - l1) + } else + val = c + l3 = l1 + l4 = l2 + } + } + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargs (Mems[data+i-1]) + call pargr (val) + if (l1 >= line1) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l3) + } + if (l2 <= line2) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l4) + } + call fprintf (fd, "\n") + } + } + Mems[data+i-1] = nint (val) + } + for (c1=c2+1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + } + + call mfree (bp, TY_SHORT) + return (data) +end + + +# XT_FPVAL -- Get data for the specified line and set the values for +# all column interpolation endpoints which occur at that line. + +pointer procedure xt_fpvals (fp, im, line) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line + +int i +pointer data, imgl2s() + +begin + # Set out of bounds values to 0. These are not used but we need + # to cancel the INDEF values. + if (line < 1 || line > IM_LEN(im,2)) { + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Mems[FP_V1(fp,i)] = 0. + else if (line == FP_L2(fp,i)) + Mems[FP_V2(fp,i)] = 0. + } + return (NULL) + } + + data = imgl2s (im, line) + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Mems[FP_V1(fp,i)] = Mems[data+FP_COL(fp,i)-1] + else if (line == FP_L2(fp,i)) + Mems[FP_V2(fp,i)] = Mems[data+FP_COL(fp,i)-1] + } + + return (data) +end + + + +# XT_FP -- Get the specified line of image data and replace bad pixels by +# interpolation. + +pointer procedure xt_fpi (fp, im, line, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +pointer imgl2i(), xt_fpsi() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2i (im, line)) + + col1 = 1 + col2 = IM_LEN(im,1) + line1 = 1 + line2 = IM_LEN(im,2) + + return (xt_fpsi (fp, im, line, col1, col2, line1, line2, fd)) +end + + +# XT_FXS -- Get the specified line of image data and replace bad pixels by +# interpolation within a specified section. + +pointer procedure xt_fpsi (fp, im, line, col1, col2, line1, line2, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +int i, j, nc, nl, ncols, c1, c2, l1, l2, l3, l4 +long v[IM_MAXDIM] +real a, b, c, d, val +int indef +pointer pm, data, bp + +bool pm_linenotempty() +pointer imgl2i(), xt_fpvali() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2i (im, line)) + + # Initialize + pm = FP_PM(fp) + nc = IM_LEN(im,1) + nl = IM_LEN(im,2) + ncols = FP_NCOLS(fp) + call amovkl (long(1), v, IM_MAXDIM) + v[2] = line + + # If there might be column interpolation initialize value arrays. + if (ncols > 0 && FP_PV1(fp) == NULL) { + FP_PIXTYPE(fp) = TY_INT + call malloc (FP_PV1(fp), ncols, FP_PIXTYPE(fp)) + call malloc (FP_PV2(fp), ncols, FP_PIXTYPE(fp)) + indef = INDEFI + call amovki (indef, Memi[FP_V1(fp,1)], ncols) + call amovki (indef, Memi[FP_V2(fp,1)], ncols) + } + + # If there are no bad pixels in the line and the line contains + # no column interpolation endpoints return the data directly. + # Otherwise get the line and fill in any endpoints that may + # be used later. + + if (!pm_linenotempty (pm, v)) { + if (line < FP_LMIN(fp) || line > FP_LMAX(fp)) + return (imgl2i (im, line)) + else + return (xt_fpvali (fp, im, line)) + } + + # Get the pixel mask. + call malloc (bp, nc, TY_SHORT) + call pmglps (pm, v, Mems[bp], 0, nc, PIX_SRC) + bp = bp - 1 + + # Check if any column interpolation endpoints are needed and + # set them. Set any other endpoints on the same lines at + # the same time. + + if (line >= FP_LMIN(fp) && line < FP_LMAX(fp)) { + j = 1 + do i = col1, col2 { + if (Mems[bp+i] == FP_CVAL(fp)) { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + if (line>FP_L1(fp,j) && line<FP_L2(fp,j)) { + if (IS_INDEFI(Memi[FP_V1(fp,j)])) + data = xt_fpvali (fp, im, FP_L1(fp,j)) + if (IS_INDEFI(Memi[FP_V2(fp,j)])) + data = xt_fpvali (fp, im, FP_L2(fp,j)) + } + } + } + } + } + + # Fix pixels by column or line interpolation. + if (FP_DATA(fp) == NULL) { + FP_PIXTYPE(fp) = TY_INT + call malloc (FP_DATA(fp), nc, FP_PIXTYPE(fp)) + } + data = FP_DATA(fp) + call amovi (Memi[xt_fpvali(fp,im,line)], Memi[data], nc) + j = 1 + for (c1=col1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + while (c1 <= col2) { + c1 = c1 - 1 + for (c2=c1+2; c2<=col2 && Mems[bp+c2]!=0; c2=c2+1) + ; + a = INDEFI + do i = c1+1, c2-1 { + if (Mems[bp+i] == FP_LVAL(fp)) { + if (IS_INDEFI(a)) { + if (c1 < col1 && c2 > col2) { + c1 = c2 + 1 + next + } + if (c1 >= col1) + a = Memi[data+c1-1] + else + a = Memi[data+c2-1] + if (c2 <= col2) + b = (Memi[data+c2-1] - a) / (c2 - c1) + else + b = 0. + } + val = a + b * (i - c1) + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargi (Memi[data+i-1]) + call pargr (val) + if (c1 >= col1) { + call fprintf (fd, " %4d %4d") + call pargi (c1) + call pargi (line) + } + if (c2 <= col2) { + call fprintf (fd, " %4d %4d") + call pargi (c2) + call pargi (line) + } + call fprintf (fd, "\n") + } + } else { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + l1 = FP_L1(fp,j) + l2 = FP_L2(fp,j) + if (l1 < line1 && l2 > line2) + next + if (line > l1 && line < l2) { + if (l1 >= line1) + c = Memi[FP_V1(fp,j)] + else + c = Memi[FP_V2(fp,j)] + if (l2 <= line2) { + d = (Memi[FP_V2(fp,j)] - c) / (l2 - l1) + val = c + d * (line - l1) + } else + val = c + l3 = l1 + l4 = l2 + } + } + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargi (Memi[data+i-1]) + call pargr (val) + if (l1 >= line1) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l3) + } + if (l2 <= line2) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l4) + } + call fprintf (fd, "\n") + } + } + Memi[data+i-1] = nint (val) + } + for (c1=c2+1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + } + + call mfree (bp, TY_SHORT) + return (data) +end + + +# XT_FPVAL -- Get data for the specified line and set the values for +# all column interpolation endpoints which occur at that line. + +pointer procedure xt_fpvali (fp, im, line) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line + +int i +pointer data, imgl2i() + +begin + # Set out of bounds values to 0. These are not used but we need + # to cancel the INDEF values. + if (line < 1 || line > IM_LEN(im,2)) { + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Memi[FP_V1(fp,i)] = 0. + else if (line == FP_L2(fp,i)) + Memi[FP_V2(fp,i)] = 0. + } + return (NULL) + } + + data = imgl2i (im, line) + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Memi[FP_V1(fp,i)] = Memi[data+FP_COL(fp,i)-1] + else if (line == FP_L2(fp,i)) + Memi[FP_V2(fp,i)] = Memi[data+FP_COL(fp,i)-1] + } + + return (data) +end + + + +# XT_FP -- Get the specified line of image data and replace bad pixels by +# interpolation. + +pointer procedure xt_fpl (fp, im, line, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +pointer imgl2l(), xt_fpsl() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2l (im, line)) + + col1 = 1 + col2 = IM_LEN(im,1) + line1 = 1 + line2 = IM_LEN(im,2) + + return (xt_fpsl (fp, im, line, col1, col2, line1, line2, fd)) +end + + +# XT_FXS -- Get the specified line of image data and replace bad pixels by +# interpolation within a specified section. + +pointer procedure xt_fpsl (fp, im, line, col1, col2, line1, line2, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +int i, j, nc, nl, ncols, c1, c2, l1, l2, l3, l4 +long v[IM_MAXDIM] +real a, b, c, d, val +long indef +pointer pm, data, bp + +bool pm_linenotempty() +pointer imgl2l(), xt_fpvall() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2l (im, line)) + + # Initialize + pm = FP_PM(fp) + nc = IM_LEN(im,1) + nl = IM_LEN(im,2) + ncols = FP_NCOLS(fp) + call amovkl (long(1), v, IM_MAXDIM) + v[2] = line + + # If there might be column interpolation initialize value arrays. + if (ncols > 0 && FP_PV1(fp) == NULL) { + FP_PIXTYPE(fp) = TY_LONG + call malloc (FP_PV1(fp), ncols, FP_PIXTYPE(fp)) + call malloc (FP_PV2(fp), ncols, FP_PIXTYPE(fp)) + indef = INDEFL + call amovkl (indef, Meml[FP_V1(fp,1)], ncols) + call amovkl (indef, Meml[FP_V2(fp,1)], ncols) + } + + # If there are no bad pixels in the line and the line contains + # no column interpolation endpoints return the data directly. + # Otherwise get the line and fill in any endpoints that may + # be used later. + + if (!pm_linenotempty (pm, v)) { + if (line < FP_LMIN(fp) || line > FP_LMAX(fp)) + return (imgl2l (im, line)) + else + return (xt_fpvall (fp, im, line)) + } + + # Get the pixel mask. + call malloc (bp, nc, TY_SHORT) + call pmglps (pm, v, Mems[bp], 0, nc, PIX_SRC) + bp = bp - 1 + + # Check if any column interpolation endpoints are needed and + # set them. Set any other endpoints on the same lines at + # the same time. + + if (line >= FP_LMIN(fp) && line < FP_LMAX(fp)) { + j = 1 + do i = col1, col2 { + if (Mems[bp+i] == FP_CVAL(fp)) { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + if (line>FP_L1(fp,j) && line<FP_L2(fp,j)) { + if (IS_INDEFL(Meml[FP_V1(fp,j)])) + data = xt_fpvall (fp, im, FP_L1(fp,j)) + if (IS_INDEFL(Meml[FP_V2(fp,j)])) + data = xt_fpvall (fp, im, FP_L2(fp,j)) + } + } + } + } + } + + # Fix pixels by column or line interpolation. + if (FP_DATA(fp) == NULL) { + FP_PIXTYPE(fp) = TY_LONG + call malloc (FP_DATA(fp), nc, FP_PIXTYPE(fp)) + } + data = FP_DATA(fp) + call amovl (Meml[xt_fpvall(fp,im,line)], Meml[data], nc) + j = 1 + for (c1=col1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + while (c1 <= col2) { + c1 = c1 - 1 + for (c2=c1+2; c2<=col2 && Mems[bp+c2]!=0; c2=c2+1) + ; + a = INDEFL + do i = c1+1, c2-1 { + if (Mems[bp+i] == FP_LVAL(fp)) { + if (IS_INDEFL(a)) { + if (c1 < col1 && c2 > col2) { + c1 = c2 + 1 + next + } + if (c1 >= col1) + a = Meml[data+c1-1] + else + a = Meml[data+c2-1] + if (c2 <= col2) + b = (Meml[data+c2-1] - a) / (c2 - c1) + else + b = 0. + } + val = a + b * (i - c1) + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargl (Meml[data+i-1]) + call pargr (val) + if (c1 >= col1) { + call fprintf (fd, " %4d %4d") + call pargi (c1) + call pargi (line) + } + if (c2 <= col2) { + call fprintf (fd, " %4d %4d") + call pargi (c2) + call pargi (line) + } + call fprintf (fd, "\n") + } + } else { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + l1 = FP_L1(fp,j) + l2 = FP_L2(fp,j) + if (l1 < line1 && l2 > line2) + next + if (line > l1 && line < l2) { + if (l1 >= line1) + c = Meml[FP_V1(fp,j)] + else + c = Meml[FP_V2(fp,j)] + if (l2 <= line2) { + d = (Meml[FP_V2(fp,j)] - c) / (l2 - l1) + val = c + d * (line - l1) + } else + val = c + l3 = l1 + l4 = l2 + } + } + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargl (Meml[data+i-1]) + call pargr (val) + if (l1 >= line1) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l3) + } + if (l2 <= line2) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l4) + } + call fprintf (fd, "\n") + } + } + Meml[data+i-1] = nint (val) + } + for (c1=c2+1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + } + + call mfree (bp, TY_SHORT) + return (data) +end + + +# XT_FPVAL -- Get data for the specified line and set the values for +# all column interpolation endpoints which occur at that line. + +pointer procedure xt_fpvall (fp, im, line) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line + +int i +pointer data, imgl2l() + +begin + # Set out of bounds values to 0. These are not used but we need + # to cancel the INDEF values. + if (line < 1 || line > IM_LEN(im,2)) { + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Meml[FP_V1(fp,i)] = 0. + else if (line == FP_L2(fp,i)) + Meml[FP_V2(fp,i)] = 0. + } + return (NULL) + } + + data = imgl2l (im, line) + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Meml[FP_V1(fp,i)] = Meml[data+FP_COL(fp,i)-1] + else if (line == FP_L2(fp,i)) + Meml[FP_V2(fp,i)] = Meml[data+FP_COL(fp,i)-1] + } + + return (data) +end + + + +# XT_FP -- Get the specified line of image data and replace bad pixels by +# interpolation. + +pointer procedure xt_fpr (fp, im, line, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +pointer imgl2r(), xt_fpsr() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2r (im, line)) + + col1 = 1 + col2 = IM_LEN(im,1) + line1 = 1 + line2 = IM_LEN(im,2) + + return (xt_fpsr (fp, im, line, col1, col2, line1, line2, fd)) +end + + +# XT_FXS -- Get the specified line of image data and replace bad pixels by +# interpolation within a specified section. + +pointer procedure xt_fpsr (fp, im, line, col1, col2, line1, line2, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +int i, j, nc, nl, ncols, c1, c2, l1, l2, l3, l4 +long v[IM_MAXDIM] +real a, b, c, d, val +real indef +pointer pm, data, bp + +bool pm_linenotempty() +pointer imgl2r(), xt_fpvalr() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2r (im, line)) + + # Initialize + pm = FP_PM(fp) + nc = IM_LEN(im,1) + nl = IM_LEN(im,2) + ncols = FP_NCOLS(fp) + call amovkl (long(1), v, IM_MAXDIM) + v[2] = line + + # If there might be column interpolation initialize value arrays. + if (ncols > 0 && FP_PV1(fp) == NULL) { + FP_PIXTYPE(fp) = TY_REAL + call malloc (FP_PV1(fp), ncols, FP_PIXTYPE(fp)) + call malloc (FP_PV2(fp), ncols, FP_PIXTYPE(fp)) + indef = INDEFR + call amovkr (indef, Memr[FP_V1(fp,1)], ncols) + call amovkr (indef, Memr[FP_V2(fp,1)], ncols) + } + + # If there are no bad pixels in the line and the line contains + # no column interpolation endpoints return the data directly. + # Otherwise get the line and fill in any endpoints that may + # be used later. + + if (!pm_linenotempty (pm, v)) { + if (line < FP_LMIN(fp) || line > FP_LMAX(fp)) + return (imgl2r (im, line)) + else + return (xt_fpvalr (fp, im, line)) + } + + # Get the pixel mask. + call malloc (bp, nc, TY_SHORT) + call pmglps (pm, v, Mems[bp], 0, nc, PIX_SRC) + bp = bp - 1 + + # Check if any column interpolation endpoints are needed and + # set them. Set any other endpoints on the same lines at + # the same time. + + if (line >= FP_LMIN(fp) && line < FP_LMAX(fp)) { + j = 1 + do i = col1, col2 { + if (Mems[bp+i] == FP_CVAL(fp)) { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + if (line>FP_L1(fp,j) && line<FP_L2(fp,j)) { + if (IS_INDEFR(Memr[FP_V1(fp,j)])) + data = xt_fpvalr (fp, im, FP_L1(fp,j)) + if (IS_INDEFR(Memr[FP_V2(fp,j)])) + data = xt_fpvalr (fp, im, FP_L2(fp,j)) + } + } + } + } + } + + # Fix pixels by column or line interpolation. + if (FP_DATA(fp) == NULL) { + FP_PIXTYPE(fp) = TY_REAL + call malloc (FP_DATA(fp), nc, FP_PIXTYPE(fp)) + } + data = FP_DATA(fp) + call amovr (Memr[xt_fpvalr(fp,im,line)], Memr[data], nc) + j = 1 + for (c1=col1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + while (c1 <= col2) { + c1 = c1 - 1 + for (c2=c1+2; c2<=col2 && Mems[bp+c2]!=0; c2=c2+1) + ; + a = INDEFR + do i = c1+1, c2-1 { + if (Mems[bp+i] == FP_LVAL(fp)) { + if (IS_INDEFR(a)) { + if (c1 < col1 && c2 > col2) { + c1 = c2 + 1 + next + } + if (c1 >= col1) + a = Memr[data+c1-1] + else + a = Memr[data+c2-1] + if (c2 <= col2) + b = (Memr[data+c2-1] - a) / (c2 - c1) + else + b = 0. + } + val = a + b * (i - c1) + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargr (Memr[data+i-1]) + call pargr (val) + if (c1 >= col1) { + call fprintf (fd, " %4d %4d") + call pargi (c1) + call pargi (line) + } + if (c2 <= col2) { + call fprintf (fd, " %4d %4d") + call pargi (c2) + call pargi (line) + } + call fprintf (fd, "\n") + } + } else { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + l1 = FP_L1(fp,j) + l2 = FP_L2(fp,j) + if (l1 < line1 && l2 > line2) + next + if (line > l1 && line < l2) { + if (l1 >= line1) + c = Memr[FP_V1(fp,j)] + else + c = Memr[FP_V2(fp,j)] + if (l2 <= line2) { + d = (Memr[FP_V2(fp,j)] - c) / (l2 - l1) + val = c + d * (line - l1) + } else + val = c + l3 = l1 + l4 = l2 + } + } + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargr (Memr[data+i-1]) + call pargr (val) + if (l1 >= line1) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l3) + } + if (l2 <= line2) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l4) + } + call fprintf (fd, "\n") + } + } + Memr[data+i-1] = val + } + for (c1=c2+1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + } + + call mfree (bp, TY_SHORT) + return (data) +end + + +# XT_FPVAL -- Get data for the specified line and set the values for +# all column interpolation endpoints which occur at that line. + +pointer procedure xt_fpvalr (fp, im, line) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line + +int i +pointer data, imgl2r() + +begin + # Set out of bounds values to 0. These are not used but we need + # to cancel the INDEF values. + if (line < 1 || line > IM_LEN(im,2)) { + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Memr[FP_V1(fp,i)] = 0. + else if (line == FP_L2(fp,i)) + Memr[FP_V2(fp,i)] = 0. + } + return (NULL) + } + + data = imgl2r (im, line) + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Memr[FP_V1(fp,i)] = Memr[data+FP_COL(fp,i)-1] + else if (line == FP_L2(fp,i)) + Memr[FP_V2(fp,i)] = Memr[data+FP_COL(fp,i)-1] + } + + return (data) +end + + + +# XT_FP -- Get the specified line of image data and replace bad pixels by +# interpolation. + +pointer procedure xt_fpd (fp, im, line, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +pointer imgl2d(), xt_fpsd() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2d (im, line)) + + col1 = 1 + col2 = IM_LEN(im,1) + line1 = 1 + line2 = IM_LEN(im,2) + + return (xt_fpsd (fp, im, line, col1, col2, line1, line2, fd)) +end + + +# XT_FXS -- Get the specified line of image data and replace bad pixels by +# interpolation within a specified section. + +pointer procedure xt_fpsd (fp, im, line, col1, col2, line1, line2, fd) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line +int fd #I File descriptor for pixel list + +int col1, col2 #I Section of interest +int line1, line2 #I Section of interest + +int i, j, nc, nl, ncols, c1, c2, l1, l2, l3, l4 +long v[IM_MAXDIM] +double a, b, c, d, val +double indef +pointer pm, data, bp + +bool pm_linenotempty() +pointer imgl2d(), xt_fpvald() + +begin + # If there are no bad pixels just get the image line and return. + if (fp == NULL) + return (imgl2d (im, line)) + + # Initialize + pm = FP_PM(fp) + nc = IM_LEN(im,1) + nl = IM_LEN(im,2) + ncols = FP_NCOLS(fp) + call amovkl (long(1), v, IM_MAXDIM) + v[2] = line + + # If there might be column interpolation initialize value arrays. + if (ncols > 0 && FP_PV1(fp) == NULL) { + FP_PIXTYPE(fp) = TY_DOUBLE + call malloc (FP_PV1(fp), ncols, FP_PIXTYPE(fp)) + call malloc (FP_PV2(fp), ncols, FP_PIXTYPE(fp)) + indef = INDEFD + call amovkd (indef, Memd[FP_V1(fp,1)], ncols) + call amovkd (indef, Memd[FP_V2(fp,1)], ncols) + } + + # If there are no bad pixels in the line and the line contains + # no column interpolation endpoints return the data directly. + # Otherwise get the line and fill in any endpoints that may + # be used later. + + if (!pm_linenotempty (pm, v)) { + if (line < FP_LMIN(fp) || line > FP_LMAX(fp)) + return (imgl2d (im, line)) + else + return (xt_fpvald (fp, im, line)) + } + + # Get the pixel mask. + call malloc (bp, nc, TY_SHORT) + call pmglps (pm, v, Mems[bp], 0, nc, PIX_SRC) + bp = bp - 1 + + # Check if any column interpolation endpoints are needed and + # set them. Set any other endpoints on the same lines at + # the same time. + + if (line >= FP_LMIN(fp) && line < FP_LMAX(fp)) { + j = 1 + do i = col1, col2 { + if (Mems[bp+i] == FP_CVAL(fp)) { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + if (line>FP_L1(fp,j) && line<FP_L2(fp,j)) { + if (IS_INDEFD(Memd[FP_V1(fp,j)])) + data = xt_fpvald (fp, im, FP_L1(fp,j)) + if (IS_INDEFD(Memd[FP_V2(fp,j)])) + data = xt_fpvald (fp, im, FP_L2(fp,j)) + } + } + } + } + } + + # Fix pixels by column or line interpolation. + if (FP_DATA(fp) == NULL) { + FP_PIXTYPE(fp) = TY_DOUBLE + call malloc (FP_DATA(fp), nc, FP_PIXTYPE(fp)) + } + data = FP_DATA(fp) + call amovd (Memd[xt_fpvald(fp,im,line)], Memd[data], nc) + j = 1 + for (c1=col1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + while (c1 <= col2) { + c1 = c1 - 1 + for (c2=c1+2; c2<=col2 && Mems[bp+c2]!=0; c2=c2+1) + ; + a = INDEFD + do i = c1+1, c2-1 { + if (Mems[bp+i] == FP_LVAL(fp)) { + if (IS_INDEFD(a)) { + if (c1 < col1 && c2 > col2) { + c1 = c2 + 1 + next + } + if (c1 >= col1) + a = Memd[data+c1-1] + else + a = Memd[data+c2-1] + if (c2 <= col2) + b = (Memd[data+c2-1] - a) / (c2 - c1) + else + b = 0. + } + val = a + b * (i - c1) + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargd (Memd[data+i-1]) + call pargd (val) + if (c1 >= col1) { + call fprintf (fd, " %4d %4d") + call pargi (c1) + call pargi (line) + } + if (c2 <= col2) { + call fprintf (fd, " %4d %4d") + call pargi (c2) + call pargi (line) + } + call fprintf (fd, "\n") + } + } else { + for (; j<=ncols && FP_COL(fp,j)!=i; j=j+1) + ; + for (; j<=ncols && FP_COL(fp,j)==i; j=j+1) { + l1 = FP_L1(fp,j) + l2 = FP_L2(fp,j) + if (l1 < line1 && l2 > line2) + next + if (line > l1 && line < l2) { + if (l1 >= line1) + c = Memd[FP_V1(fp,j)] + else + c = Memd[FP_V2(fp,j)] + if (l2 <= line2) { + d = (Memd[FP_V2(fp,j)] - c) / (l2 - l1) + val = c + d * (line - l1) + } else + val = c + l3 = l1 + l4 = l2 + } + } + if (fd != NULL) { + call fprintf (fd, "%4d %4d %8g %8g") + call pargi (i) + call pargi (line) + call pargd (Memd[data+i-1]) + call pargd (val) + if (l1 >= line1) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l3) + } + if (l2 <= line2) { + call fprintf (fd, " %4d %4d") + call pargi (i) + call pargi (l4) + } + call fprintf (fd, "\n") + } + } + Memd[data+i-1] = val + } + for (c1=c2+1; c1<=col2 && Mems[bp+c1]==0; c1=c1+1) + ; + } + + call mfree (bp, TY_SHORT) + return (data) +end + + +# XT_FPVAL -- Get data for the specified line and set the values for +# all column interpolation endpoints which occur at that line. + +pointer procedure xt_fpvald (fp, im, line) + +pointer fp #I FIXPIX pointer +pointer im #I Image pointer +int line #I Line + +int i +pointer data, imgl2d() + +begin + # Set out of bounds values to 0. These are not used but we need + # to cancel the INDEF values. + if (line < 1 || line > IM_LEN(im,2)) { + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Memd[FP_V1(fp,i)] = 0. + else if (line == FP_L2(fp,i)) + Memd[FP_V2(fp,i)] = 0. + } + return (NULL) + } + + data = imgl2d (im, line) + do i = 1, FP_NCOLS(fp) { + if (line == FP_L1(fp,i)) + Memd[FP_V1(fp,i)] = Memd[data+FP_COL(fp,i)-1] + else if (line == FP_L2(fp,i)) + Memd[FP_V2(fp,i)] = Memd[data+FP_COL(fp,i)-1] + } + + return (data) +end + + |