diff options
Diffstat (limited to 'noao/digiphot/daophot/allstar/dpabuf.x')
| -rw-r--r-- | noao/digiphot/daophot/allstar/dpabuf.x | 495 |
1 files changed, 495 insertions, 0 deletions
diff --git a/noao/digiphot/daophot/allstar/dpabuf.x b/noao/digiphot/daophot/allstar/dpabuf.x new file mode 100644 index 00000000..13aac109 --- /dev/null +++ b/noao/digiphot/daophot/allstar/dpabuf.x @@ -0,0 +1,495 @@ +include <imhdr.h> +include "../lib/daophotdef.h" +include "../lib/allstardef.h" + +# DP_GWT -- Return a pointer to the desired weights pixels. The weights buffer +# pointer is assumed to be NULL on the initial all. If the new line limits +# are totally contained within the old line limits no action is taken and +# the old line limits are returned. If the weights pixels are stored in a +# scratch image the pixels must be accessed sequentially, otherwise an +# error is returned. + +pointer procedure dp_gwt (dao, im, line1, line2, mode, flush) + +pointer dao # pointer to the daophot strucuture +pointer im # pointer to the input image +int line1 # the lower line limit +int line2 # the upper line limit +int mode # input / output mode +int flush # flush the output + +int nx, ny, xoff, yoff, llast1, llast2 +pointer allstar + +begin + allstar = DP_ALLSTAR(dao) + if (DP_WBUF(allstar) == NULL) { + llast1 = 0 + llast2 = 0 + } else if (flush == YES) { + line1 = llast1 + line2 = llast2 + } else if ((line1 >= llast1) && (line2 <= llast2)) { + line1 = llast1 + line2 = llast2 + return (DP_WBUF(allstar)) + } else if (line1 < llast1) + call error (0, + "ERROR: Attempting to access the weights pixels randomly") + + # All the data is cached. + if (DP_CACHE (allstar, A_WEIGHT) == YES) { + + nx = IM_LEN(im,1) + ny = IM_LEN(im,2) + xoff = 1 + yoff = 1 + DP_WBUF(allstar) = DP_WEIGHTS(allstar) + + # Read in some new data. + } else if (mode == READ_ONLY) { + + call dp_albufl2r (DP_WEIGHTS(allstar), DP_WBUF(allstar), + llast1, llast2, line1, line2, flush) + + if (flush == NO) { + nx = IM_LEN(im,1) + ny = line2 - line1 + 1 + xoff = 1 + yoff = line1 + } else { + nx = 0 + ny = 0 + xoff = 0 + yoff = 0 + } + + # Write out the old data and read in some new data. + } else if (mode == READ_WRITE) { + + call dp_albufl2rw (DP_WEIGHTS(allstar), DP_WEIGHTS(allstar), + DP_WBUF(allstar), llast1, llast2, line1, line2, flush) + + if (flush == NO) { + nx = IM_LEN(im,1) + ny = line2 - line1 + 1 + xoff = 1 + yoff = line1 + } else { + nx = 0 + ny = 0 + xoff = 0 + yoff = 0 + } + } + + # Update the required buffer parameters. + DP_WNX(allstar) = nx + DP_WNY(allstar) = ny + DP_WXOFF(allstar) = xoff + DP_WYOFF(allstar) = yoff + + # Update the buffer definition which is currently not used. + DP_WLX(allstar) = xoff + DP_WMX(allstar) = max (xoff + nx - 1, 0) + DP_WLY(allstar) = yoff + DP_WMY(allstar) = max (yoff + ny - 1, 0) + + return (DP_WBUF(allstar)) +end + + +# DP_GST -- Return a pointer to the scratch image pixels. The scratch image +# pointer is assumed to be NULL on the initial all. If the new line limits +# are totally contained within the old line limits no action is taken and +# the old line limits are returned. If the scratch image pixels are stored in a +# scratch image the pixels must be accessed sequentially, otherwise an +# error is returned. + +pointer procedure dp_gst (dao, im, line1, line2, mode, flush) + +pointer dao # pointer to the daophot structure +pointer im # pointer to the input image +int line1 # the lower line limit +int line2 # the upper line limit +int mode # input / output mode +int flush # flush the buffer + +int nx, ny, xoff, yoff, llast1, llast2 +pointer allstar + +begin + allstar = DP_ALLSTAR(dao) + if (DP_SBUF(allstar) == NULL) { + llast1 = 0 + llast2 = 0 + } else if (flush == YES) { + line1 = llast1 + line2 = llast2 + } else if ((line1 >= llast1) && (line2 <= llast2)) { + line1 = llast1 + line2 = llast2 + return (DP_SBUF(allstar)) + } else if (line1 < llast1) + call error (0, + "ERROR: Attempting to access scratch image pixels randomly") + + # All the data is cached. + if (DP_CACHE (allstar, A_SUBT) == YES) { + + nx = IM_LEN(im,1) + ny = IM_LEN(im,2) + xoff = 1 + yoff = 1 + DP_SBUF(allstar) = DP_SUBT(allstar) + + # Read in some new data. + } else if (mode == READ_ONLY) { + + call dp_albufl2r (DP_SUBT(allstar), DP_SBUF(allstar), + llast1, llast2, line1, line2, flush) + + if (flush == NO) { + nx = IM_LEN(im,1) + ny = line2 - line1 + 1 + xoff = 1 + yoff = line1 + } else { + nx = 0 + ny = 0 + xoff = 0 + yoff = 0 + } + + # Write out the old data and read in some new data. + } else if (mode == READ_WRITE) { + + call dp_albufl2rw (DP_SUBT(allstar), DP_SUBT(allstar), + DP_SBUF(allstar), llast1, llast2, line1, line2, flush) + + if (flush == NO) { + nx = IM_LEN(im,1) + ny = line2 - line1 + 1 + xoff = 1 + yoff = line1 + } else { + nx = 0 + ny = 0 + xoff = 0 + yoff = 0 + } + } + + # Update the required buffer parameters. + DP_SNX(allstar) = nx + DP_SNY(allstar) = ny + DP_SXOFF(allstar) = xoff + DP_SYOFF(allstar) = yoff + + # Update the buffer description which is not currently used. + DP_SLX(allstar) = xoff + DP_SMX(allstar) = max (xoff + nx - 1, 0) + DP_SLY(allstar) = yoff + DP_SMY(allstar) = max (yoff + ny - 1, 0) + + return (DP_SBUF(allstar)) +end + + +# DP_GDC -- Return a pointer to the subtracted image pixels. The subtracted +# image pixels pointer is assumed to be NULL on the initial all. If the new +# line limits are totally contained within the old line limits no action is +# taken and the old line limits are returned. If the subtracted image pixels are +# stored in a scratch image the pixels must be accessed sequentially, +# otherwise an error is returned. + +pointer procedure dp_gdc (dao, im, line1, line2, mode, flush) + +pointer dao # pointer to the daophot strucuture +pointer im # pointer to the input image +int line1, line2 # the upper and lower line limits +int mode # input / output mode +int flush # flush the input data + +int nx, ny, xoff, yoff, llast1, llast2 +pointer allstar + +begin + allstar = DP_ALLSTAR(dao) + if (DP_DBUF(allstar) == NULL) { + llast1 = 0 + llast2 = 0 + } else if (flush == YES) { + line1 = llast1 + line2 = llast2 + } else if ((line1 >= llast1) && (line2 <= llast2)) { + line1 = llast1 + line2 = llast2 + return (DP_DBUF(allstar)) + } else if (line1 < llast1) + call error (0, + "ERROR: Attempting to access subtracted image pixels randomly") + + # All the data is cached. + if (DP_CACHE (allstar, A_DCOPY) == YES) { + + nx = IM_LEN(im,1) + ny = IM_LEN(im,2) + xoff = 1 + yoff = 1 + DP_DBUF(allstar) = DP_DATA(allstar) + + # Read in some new data. + } else if (mode == READ_ONLY) { + + call dp_albufl2r (DP_DATA(allstar), DP_DBUF(allstar), + llast1, llast2, line1, line2, flush) + + if (flush == NO) { + nx = IM_LEN(im,1) + ny = line2 - line1 + 1 + xoff = 1 + yoff = line1 + } else { + nx = 0 + ny = 0 + xoff = 0 + yoff = 0 + } + + # Write out the old data and read in some new data. + } else if (mode == READ_WRITE) { + + call dp_albufl2rw (DP_DATA(allstar), DP_DATA(allstar), + DP_DBUF(allstar), llast1, llast2, line1, line2, flush) + + if (flush == NO) { + nx = IM_LEN(im,1) + ny = line2 - line1 + 1 + xoff = 1 + yoff = line1 + } else { + nx = 0 + ny = 0 + xoff = 0 + yoff = 0 + } + } + + # Update the required buffer parameters. + DP_DNX(allstar) = nx + DP_DNY(allstar) = ny + DP_DXOFF(allstar) = xoff + DP_DYOFF(allstar) = yoff + + # Update the buffer definition which is currently not used. + DP_DLX(allstar) = xoff + DP_DMX(allstar) = max (xoff + nx - 1, 0) + DP_DLY(allstar) = yoff + DP_DMY(allstar) = max (yoff + ny - 1, 0) + + return (DP_DBUF(allstar)) +end + + +# DP_ALBUFL2RW -- Maintain a buffer of image lines and which can be read from +# an input image and written to an output image. The input and output images +# may be the same but must have the same dimensions. A new buffer is created +# when the buffer pointer is null and reallocated when the buffer changes size. + +procedure dp_albufl2rw (inim, outim, buf, llast1, llast2, line1, line2, flush) + +pointer inim # the input image pointer +pointer outim # the output image pointer +pointer buf # pointer to the internal buffer +int llast1, llast2 # the line limits of the previous buffer +int line1, line2 # the line limits of the requested buffer +int flush # flush the output buffer + +int i, ncols, nlines, nllast, lout, nmove +pointer buf1, buf2 +pointer imgl2r(), impl2r() + +define flush_ 11 + +begin + # Write the data in the buffer to the output image and free + # the buffer. + + if (flush == YES) + go to flush_ + + # Define the size of the current buffer. + ncols = IM_LEN(inim,1) + nlines = line2 - line1 + 1 + + # If the buffer pointer is undefined then allocate memory for the + # buffer. + + if (buf == NULL) { + call malloc (buf, ncols * nlines, TY_REAL) + llast1 = 0 + llast2 = 0 + nllast = 0 + } else + nllast = llast2 - llast1 + 1 + + # Write out the lines that are not needed any more. + + if ((line1 > llast1) && (llast1 > 0)) { + buf2 = buf + lout = min (llast2, line1 - 1) + do i = llast1, lout { + buf1 = impl2r (outim, i) + call amovr (Memr[buf2], Memr[buf1], ncols) + buf2 = buf2 + ncols + } + } + + # Now move the remaining lines to the beginning of the buffer. + + nmove = 0 + if (llast2 >= line1) { + buf1 = buf + buf2 = buf + ncols * (line1 - llast1) + do i = line1, llast2 { + if (buf1 != buf2) + call amovr (Memr[buf2], Memr[buf1], ncols) + nmove = nmove + 1 + buf2 = buf2 + ncols + buf1 = buf1 + ncols + } + } + + # Resize the buffer if necessary. + + if (nlines > nllast) + call realloc (buf, ncols * nlines, TY_REAL) + + # Read only the image lines with are different from the last buffer. + + if (line2 > llast2) { + buf1 = buf + ncols * nmove + lout = max (line1, llast2 + 1) + do i = lout, line2 { + buf2 = imgl2r (inim, i) + call amovr (Memr[buf2], Memr[buf1], ncols) + buf1 = buf1 + ncols + } + } + + # Save the buffer parameters. + llast1 = line1 + llast2 = line2 + + if (flush == NO) + return +flush_ + # Flush the remaining portion of the buffer to the output image + # and free the buffer space. + + if (buf != NULL) { + + buf2 = buf + do i = llast1, llast2 { + buf1 = impl2r (outim, i) + call amovr (Memr[buf2], Memr[buf1], ncols) + buf2 = buf2 + ncols + } + call imflush (outim) + + call mfree (buf, TY_REAL) + } + + buf = NULL +end + + +# DP_ALBUFL2R -- Maintain a buffer of image lines which can be read +# sequentially from an input image. The buffer pointer must be initialized +# to NULL. A new buffer is created when the buffer pointer is null and +# reallocated when the buffer increases in size. + +procedure dp_albufl2r (inim, buf, llast1, llast2, line1, line2, flush) + +pointer inim # pointer to the input image +pointer buf # pointer to the internal buffer +int llast1, llast2 # the line limits of the previous buffer +int line1, line2 # the line limits of the requested buffer +int flush # flush the output buffer + +int i, ncols, nlines, nllast, lout, nmove +pointer buf1, buf2 +pointer imgl2r() + +define flush_ 11 + +begin + + # Write the data in the buffer to the output image and free + # the buffer. + + if (flush == YES) + go to flush_ + + # Define the size parameters for the new buffer. + + ncols = IM_LEN(inim,1) + nlines = line2 - line1 + 1 + + # If the buffer pointer is undefined then allocate memory for the + # buffer. + + if (buf == NULL) { + call malloc (buf, ncols * nlines, TY_REAL) + llast1 = 0 + llast2 = 0 + nllast = 0 + } else + nllast = llast2 - llast1 + 1 + + # Now move the remaining lines to the beginning of the buffer. + + nmove = 0 + if (llast2 >= line1) { + buf1 = buf + buf2 = buf + ncols * (line1 - llast1) + do i = line1, llast2 { + if (buf1 != buf2) + call amovr (Memr[buf2], Memr[buf1], ncols) + nmove = nmove + 1 + buf2 = buf2 + ncols + buf1 = buf1 + ncols + } + } + + # Resize the buffer if necessary. + + if (nlines > nllast) + call realloc (buf, ncols * nlines, TY_REAL) + + # Read only the image lines with are different from the last buffer. + + if (line2 > llast2) { + buf1 = buf + ncols * nmove + lout = max (line1, llast2 + 1) + do i = lout, line2 { + buf2 = imgl2r (inim, i) + call amovr (Memr[buf2], Memr[buf1], ncols) + buf1 = buf1 + ncols + } + } + + # Save the buffer parameters. + llast1 = line1 + llast2 = line2 + + if (flush == NO) + return +flush_ + + # Free the buffer space. + if (buf != NULL) + call mfree (buf, TY_REAL) + buf = NULL +end |