diff options
Diffstat (limited to 'sys/pmio')
65 files changed, 5415 insertions, 0 deletions
diff --git a/sys/pmio/README b/sys/pmio/README new file mode 100644 index 00000000..303c464b --- /dev/null +++ b/sys/pmio/README @@ -0,0 +1,284 @@ +PMIO -- The Pixel Mask I/O package (PLIO for image masks). +PLIO -- The Pixel List I/O package (no ties to IMIO) + + A PIXEL LIST is a compressed, region oriented data structure used to store +an image matrix. The pixel list package is used to create, manage, and access +this data structure. Although the PLIO package can stand alone and is useful +in its own right, one of the main uses of the pixel list package is in the IMIO +interface, which can access a pixel list as if it were a MASK IMAGE. +See PLIO.hlp for further information on the PLIO package and image masks. + +The pixel list package itself does not support any fancy image coordinate +transformations. If an image has an associated pixel mask, the pixel mask +refers to the physical image matrix. An application written at the IMIO level +where an image section transformation may be defined for an image should +normally use the PMIO (pixel mask) package in preference to PLIO. PMIO is +equivalent to PLIO, except that coordinates are input in image section +coordinates, and a reference image is used to map such coordinates onto the +physical image matrix. + + +1. IMIO Mask Image Interface + + im = im_pmmap (maskname, mode, ref_im|NULL) + im = im_pmmapo (pm, ref_im) + + imseti (im, IM_RLIO, YES|NO) # enable range list i/o + imseti (im, IM_PMDES, pm) # inquire PM descriptor + pm = imstati (im, IM_PMDES) + + bool = im_pmlne[123] (im[, lineno[, bandno]]) + bool = im_pmsne[123] (im, x1, x2[, y1, y2[, z1, z2]]) + bool = im_pmlnev (im, v) + bool = im_pmsnev (im, vs, ve, ndim) + + mp = mio_open (maskname, flags, im) # Masked Image I/O + mp = mio_openo (pm, im) + value = mio_stati (mp, param) + mio_seti (mp, param, value) + mio_setrange (mp, vs, ve, ndim) + n|EOF = mio_[gp]lseg[silrdx] (mp, ptr, mval, v, npix) + mio_close (mp) + + +2. Pixel Mask Interface (uses reference image for section transformation) + + pm = pm_newmask (ref_im, depth) + + pm = pm_open (bufptr|NULL) + pm = pm_create (naxes, axlen, depth) + pm = pm_newcopy (pm) + pm_close (pm) + + pm_[sg]size (pm, naxes, alxen, depth) + pm_seti (pm, param, value) + value = pm_stati (pm, param) + pm_debug (pm, outfd, maxcol, flags) + bool = pm_empty (pm) + pm_compress (pm) + pm_clear (pm) + + pm_load (pm, bufptr) + nwords = pm_save (pm, bufptr, buflen, save_flags) + pm_loadf (pm, fname, title, maxch) + pm_savef (pm, fname, title, save_flags) + pm_[load|save]im (pm, imname[, save_flags]) + + ptr = pm_access (pm, v) + bool = pm_linenotempty (pm, v) + bool = pm_sectnotempty (pm, vs, ve, ndim) + pm[gp]l[lrp][sil] (pm, v, buf, b_depth, npix, rop) + + pm_[set|get]plane (pm, v) + pm_point (pm, x, y, rop) + pm_circle (pm, x, y, r, rop) + pm_box (pm, x1,y1, x2,y2, rop) + pm_line (pm, x1,y1, x2,y2, width, rop) + pm_polygon (pm, x, y, npts, rop) + + pm_rop (pm_src, vs, pm_dst, vs, vn, rop) + pm_stencil (pm_src, vs, pm_dst, vs, pm_stl, vs, vn, rop) + + +2.1 Random Access to a Pixel Mask + + pmr = pmr_open (pm, plane, buflimit) + pmr_setrect (pmr, x1,y1, x2,y2) + mval = pmr_getpix (pmr, i, j) + pmr_close (pmr) + + +3. Pixel List Interface (stands alone; independent of IMIO; no coord xforms) + + pl = pl_open (bufptr|NULL) + pl = pl_create (naxes, axlen, depth) + pl = pl_newcopy (pl) + pl_close (pl) + + pl_[sg]size (pl, naxes, axlen, depth) + pl_seti (pl, param, value) + value = pl_stati (pl, param) + pl_debug (pl, outfd, maxcol, flags) + bool = pl_empty (pl) + pl_compress (pl) + pl_clear (pl) + + pl_load (pl, bufptr) + nwords = pl_save (pl, bufptr, buflen, save_flags) + pl_loadf (pl, fname, title, maxch) + pl_savef (pl, fname, title, save_flags) + pl_[load|save]im (pl, imname[, save_flags]) + + ptr = pl_access (pl, v) + bool = pl_linenotempty (pl, v) + bool = pl_sectnotempty (pl, vs, ve, ndim) + pl[gp]l[lrp][sil] (pl, v, buf, b_depth, npix, rop) + + pl_[set|get]plane (pl, v) + pl_point (pl, x, y, rop) + pl_circle (pl, x, y, r, rop) + pl_box (pl, x1,y1, x2,y2, rop) + pl_line (pl, x1,y1, x2,y2, width, rop) + pl_polygon (pl, x, y, npts, rop) + + pl_rop (pl_src, vs, pl_dst, vs, vn, rop) + pl_stencil (pl_src, vs, pl_dst, vs, pl_stl, vs, vn, rop) + + +3.1 Random Access to a Pixel List + + plr = plr_open (pl, plane, buflimit) + plr_setrect (plr, x1,y1, x2,y2) + mval = plr_getpix (plr, i, j) + plr_getlut (plr, bufp, xsize,ysize, xblock,yblock) + plr_close (plr) + + +3.2 Pixel, Line, and Range List Routines + + pl_pixrop (px_src, xs, src_maxval, + px_dst, ds, dst_maxval, npix, rop) + pl_linerop (ll_src, xs, src_maxval, + ll_dst, ds, dst_maxval, ll_out, npix, rop) + pl_rangerop (rl_src, xs, src_maxval, + rl_dst, ds, dst_maxval, rl_out, npix, rop) + pl_linestencil (ll_src, xs, src_maxval, ll_dst, ds, dst_maxval, + ll_stn, xs, ll_out, npix, rop) + + n = pl_[lrp]2[lrp][sil] (op_src, xs, op_dst, npix) + + +4. EXAMPLE + +4.1 Sample Mask (pl_draw output) + + 40 .1111111..............................................................22222 + 39 .1111111..............................................................22222 + 38 .1111111...............................................................2222 + 37 .1111111...............................................................2222 + 36 .1111111............................................................4...... + 35 .1111111.....................11111111111111111111111111...........4444..... + 34 .1111111.....................11111111111111111111111111........44444444.... + 33 .1111111......................1111111111111111111111111......44444444...... + 32 .1111111......................1111111111111111111111111...44444444......... + 31 .1111111......................1111111111111111111111111.44444444........... + 30 .1111111...........4..........1111111111111111111111115444444.............. + 29 .1111111...........4..........11111111111111111111155554444................ + 28 .1111111...........4..........111111111111111111155555544.................. + 27 .1111111...........4..........1111111111111111555555551.................... + 26 .1111111.....................11111111111111155555555111.................... + 25 .1111111.....................11111111111115555555111111.................... + 24 ............................1111111111155444444.1111111.................... + 23 ...........................111111111155544444....111111.................... + 22 ..............1...........1111111155555444........11111.................... + 21 ........................1111111155555554..........11111.................... + 20 ........................111111555555511...........11111.................... + 19 ........................111555555551111...........11111.................... + 18 ........................155555555111111...........11111.................... + 17 ......................445555551111111111.........111111.................... + 16 ....................444455551111111111111.......1111111.................... + 15 ..................4444445111111111111111111111111111111.................... + 14 ...............44444444.1111111111111111111111111111111.................... + 13 .............44444444...................................................... + 12 ..........44444444......................................................... + 11 ........44444444........................................................... + 10 .........4444........................22222................................. + 9 ..........4.........................2222222..............22222............. + 8 ....................................2222222.............2222222............ + 7 ....................................2222222.............2222222............ + 6 .....................................22222..............2222222............ + 5 11111111111111111111.....................................22222............. + 4 11111111111111111111....................................................... + 3 11111111111111111111....................................................... + 2 11111111111111111111....................................................... + 1 11111111111111111111....................................................... + 123456789012345678901234567890123456789012345678901234567890123456789012345 + 1 2 3 4 5 6 7 + + +4.2 Sample Debug Output (for above mask) + +Mask 1EECD naxes=2 [75,40] maxval=177 plane=[75,40] +max buffered line size 1024, max actual line size 16 +40 lines total, 40 are nonempty, mask is nonempty +llbp=42AF5, len=1190, op=583, free=189, nupdates=35 +Index at 1EFF1 containing 40 lines: + 4 4 4 4 17 26 35 35 166 177 187 + 194 201 208 218 228 241 254 266 554 292 568 + 319 333 347 360 492 507 523 539 423 435 447 + 459 471 483 148 148 157 157 +Line list containing 40 lines: +[1:4] IH48(49) H20 Z55 (75,49) +[5] IH48(49) H20 IH1(50) Z37 H5 Z13 (75,50) +[6] IH49(50) Z37 H5 Z14 H7 Z12 (75,50) +[7:8] IH49(50) Z36 H7 Z13 H7 Z12 (75,50) +[9] IH51(52) P11 DH2(50) Z25 H7 Z14 H5 Z13 (75,50) +[10] IH51(52) Z9 H4 DH2(50) Z24 H5 Z33 (75,50) +[11] IH51(52) Z8 H8 Z59 (75,52) +[12] IH51(52) Z10 H8 Z57 (75,52) +[13] IH51(52) Z13 H8 Z54 (75,52) +[14] IH51(52) Z15 H8 DH3(49) Z1 H31 Z20 (75,49) +[15] IH51(52) Z18 H6 IS1(53) DH4(49) H30 Z20 (75,49) +[16] IH51(52) Z20 H4 IH1(53) H4 DH4(49) H13 Z7 H7 Z20 (75,49) +[17] IH51(52) Z22 H2 IH1(53) H6 DH4(49) H10 Z9 H6 Z20 (75,49) +[18] IH48(49) P25 IH4(53) H8 DH4(49) H6 Z11 H5 Z20 (75,49) +[19] IH48(49) Z24 H3 IH4(53) H8 DH4(49) H4 Z11 H5 Z20 (75,49) +[20] IH48(49) Z24 H6 IH4(53) H7 DH4(49) H2 Z11 H5 Z20 (75,49) +[21] IH48(49) Z24 H8 IH4(53) H7 DS1(52) DH3(49) Z10 H5 Z20 (75,49) +[22] IH48(49) P15 Z11 H8 IH4(53) H5 DH1(52) H3 DH3(49) Z8 H5 Z20 (75,49) +[23] IH48(49) Z27 H10 IH4(53) H3 DH1(52) H5 DH3(49) Z4 H6 Z20 (75,49) +[24] IH48(49) Z28 H11 IH4(53) H2 DH1(52) H6 DH3(49) Z1 H7 Z20 (75,49) +[25] IH48(49) Z1 H7 Z21 H13 IH4(53) H7 DH4(49) H6 Z20 (75,49) +[26] IH48(49) Z1 H7 Z21 H15 IH4(53) H8 DH4(49) H3 Z20 (75,49) +[27] IH48(49) Z1 H7 IH3(52) P12 DH3(49) Z10 H16 IH4(53) H8 DS4(49) Z20 + (75,49) +[28] IH48(49) Z1 H7 IH3(52) P12 DH3(49) Z10 H19 IH4(53) H6 DH1(52) H2 Z18 + (75,52) +[29] IH48(49) Z1 H7 IH3(52) P12 DH3(49) Z10 H21 IH4(53) H4 DH1(52) H4 Z16 + (75,52) +[30] IH48(49) Z1 H7 IH3(52) P12 DH3(49) Z10 H24 IS4(53) DH1(52) H6 Z14 + (75,52) +[31] IH48(49) Z1 H7 Z22 H25 IH3(52) Z1 H8 Z11 (75,52) +[32] IH48(49) Z1 H7 Z22 H25 IH3(52) Z3 H8 Z9 (75,52) +[33] IH48(49) Z1 H7 Z22 H25 IH3(52) Z6 H8 Z6 (75,52) +[34] IH48(49) Z1 H7 Z21 H26 IH3(52) Z8 H8 Z4 (75,52) +[35] IH48(49) Z1 H7 Z21 H26 IH3(52) Z11 H4 Z5 (75,52) +[36] IH48(49) Z1 H7 IH3(52) P61 Z6 (75,52) +[37:38] IH48(49) Z1 H7 IH1(50) Z63 H4 (75,50) +[39:40] IH48(49) Z1 H7 IH1(50) Z62 H5 (75,50) + +Line list containing 40 lines: +[1:4] 1-20(49) +[5] 1-20(49) 58-62(50) +[6] 38-42(50) 57-63(50) +[7:8] 37-43(50) 57-63(50) +[9] 11(52) 37-43(50) 58-62(50) +[10] 10-13(52) 38-42(50) +[11] 9-16(52) +[12] 11-18(52) +[13] 14-21(52) +[14] 16-23(52) 25-55(49) +[15] 19-24(52) 25(53) 26-55(49) +[16] 21-24(52) 25-28(53) 29-41(49) 49-55(49) +[17] 23-24(52) 25-30(53) 31-40(49) 50-55(49) +[18] 25(49) 26-33(53) 34-39(49) 51-55(49) +[19] 25-27(49) 28-35(53) 36-39(49) 51-55(49) +[20] 25-30(49) 31-37(53) 38-39(49) 51-55(49) +[21] 25-32(49) 33-39(53) 40(52) 51-55(49) +[22] 15(49) 27-34(49) 35-39(53) 40-42(52) 51-55(49) +[23] 28-37(49) 38-40(53) 41-45(52) 50-55(49) +[24] 29-39(49) 40-41(53) 42-47(52) 49-55(49) +[25] 2-8(49) 30-42(49) 43-49(53) 50-55(49) +[26] 2-8(49) 30-44(49) 45-52(53) 53-55(49) +[27] 2-8(49) 20(52) 31-46(49) 47-54(53) 55(49) +[28] 2-8(49) 20(52) 31-49(49) 50-55(53) 56-57(52) +[29] 2-8(49) 20(52) 31-51(49) 52-55(53) 56-59(52) +[30] 2-8(49) 20(52) 31-54(49) 55(53) 56-61(52) +[31] 2-8(49) 31-55(49) 57-64(52) +[32] 2-8(49) 31-55(49) 59-66(52) +[33] 2-8(49) 31-55(49) 62-69(52) +[34] 2-8(49) 30-55(49) 64-71(52) +[35] 2-8(49) 30-55(49) 67-70(52) +[36] 2-8(49) 69(52) +[37:38] 2-8(49) 72-75(50) +[39:40] 2-8(49) 71-75(50) diff --git a/sys/pmio/mio.h b/sys/pmio/mio.h new file mode 100644 index 00000000..11e4c9d0 --- /dev/null +++ b/sys/pmio/mio.h @@ -0,0 +1,56 @@ +# MIO -- Image i/o through a mask. +# +# The MIO routines are used to sequentially read or write the portion of +# the image IM which is "visible" through the mask denoted by the mask name +# PLNAME or the open mask descriptor PM. An image pixel is said to be visible +# if the associated mask pixel is nonzero. The PMIO routines may be used prior +# to performing any i/o to prepare the desired mask, e.g., a mask might be +# inverted to access only the "masked" pixels, or a mask might be ANDed with a +# region to limit i/o to only the portions of the image visible through both +# the mask and the region. Certain commonly performed mask conversions may be +# performed at MIO_OPEN time via the FLAGS argument, e.g., inversion, or +# conversion of an integer mask to a boolean mask. +# +# mp = mio_open (mask, flags, im) +# mp = mio_openo (pm, im) +# value = mio_stati (mp, param) +# mio_seti (mp, param, value) +# mio_setrange (mp, vs, ve, ndim) +# n|EOF = mio_[gp]lseg[silrdx] (mp, ptr, mval, v, npix) +# mio_close (mp) +# +# mio_open flags (defined in <pmset.h>): +# +# INVERT_MASK invert mask (PIX_NOT(PIX_SRC)) +# BOOLEAN_MASK convert mask to boolean if not already +# +# set/stat params (defined in <pmset.h>): +# +# P_PMDES pixel mask descriptor +# P_IMDES image descriptor +# P_REGCOORDS mio_setrange region relative coords +# +# The get/put line segment i/o routines return successive line segments of +# constant value from the data image IM, advancing through the image in storage +# order starting at the position vector [1,1,1...,N]. A pointer to each line +# segment is returned in PTR, with the associated integer mask value in MVAL, +# and the vector coordinates and length of the line segment in V and NPIX. +# EOF is returned when there are no more visible pixels to be read through the +# masked region. + +define LEN_MIODES 50 +define M_IM Memi[$1] # image descriptor +define M_PM Memi[$1+1] # mask descriptor +define M_PMCLOSE Memi[$1+2] # have mio_close close mask +define M_DEPTH Memi[$1+3] # have mio_close close mask +define M_ACTIVE Memi[$1+4] # set once i/o begins +define M_LBP Memi[$1+5] # line buffer pointer +define M_RLP Memi[$1+6] # range list pointer +define M_RLI Memi[$1+7] # range list index +define M_NDIM Memi[$1+8] # dimensionality of section +define M_LINEIO Memi[$1+9] # section is entire line +define M_REGCOORDS Memi[$1+10] # region relative coords +define M_V Meml[$1+11+$2-1] # current vector +define M_VS Meml[$1+20+$2-1] # start vector +define M_VE Meml[$1+30+$2-1] # end vector +define M_VN Meml[$1+40+$2-1] # size of section diff --git a/sys/pmio/mioclose.x b/sys/pmio/mioclose.x new file mode 100644 index 00000000..7b321512 --- /dev/null +++ b/sys/pmio/mioclose.x @@ -0,0 +1,18 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include "mio.h" + +# MIO_CLOSE -- Close an MIO descriptor. + +procedure mio_close (mp) + +pointer mp #I MIO descriptor + +begin + if (M_PMCLOSE(mp) == YES) + call pm_close (M_PM(mp)) + if (M_RLP(mp) != NULL) + call mfree (M_RLP(mp), TY_INT) + call mfree (mp, TY_STRUCT) +end diff --git a/sys/pmio/miogl.gx b/sys/pmio/miogl.gx new file mode 100644 index 00000000..3b02710e --- /dev/null +++ b/sys/pmio/miogl.gx @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glseg$t (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2$t(), imgl3$t(), imggs$t() +errchk imgl2$t, imgl3$t, imggs$t, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2$t (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3$t (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggs$t (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/mioopen.x b/sys/pmio/mioopen.x new file mode 100644 index 00000000..b22c2022 --- /dev/null +++ b/sys/pmio/mioopen.x @@ -0,0 +1,31 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include "mio.h" + +# MIO_OPEN -- Open a pixel mask for masked i/o on the given data image. +# The data image also serves as the reference image for coordinate (section) +# transformations. + +pointer procedure mio_open (mask, flags, im) + +char mask[ARB] #I mask name +int flags #I flag bits +pointer im #I data (and reference) image + +pointer pm, mp +char title[1] +pointer im_pmopen(), mio_openo() +errchk im_pmopen + +begin + pm = im_pmopen (mask, flags, title, 0, im) + mp = mio_openo (pm, im) + + M_PMCLOSE(mp) = YES + M_DEPTH(mp) = PM_MAXDEPTH + if (and (flags, BOOLEAN_MASK) != 0) + M_DEPTH(mp) = 1 + + return (mp) +end diff --git a/sys/pmio/mioopeno.x b/sys/pmio/mioopeno.x new file mode 100644 index 00000000..bd3a6a96 --- /dev/null +++ b/sys/pmio/mioopeno.x @@ -0,0 +1,30 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include "mio.h" + +# MIO_OPENO -- Open an MIO descriptor for the given mask and data image. + +pointer procedure mio_openo (pm, im) + +pointer pm #I mask descriptor +pointer im #I image descriptor + +pointer mp + +begin + call calloc (mp, LEN_MIODES, TY_STRUCT) + call malloc (M_RLP(mp), RL_MAXLEN(pm), TY_INT) + RLI_LEN(M_RLP(mp)) = 0 + + call amovkl (1, M_VS(mp,1), IM_MAXDIM) + call amovl (IM_LEN(im,1), M_VN(mp,1), IM_MAXDIM) + + M_IM(mp) = im + M_PM(mp) = pm + call pm_seti (pm, P_REFIM, im) + call mio_setrange (mp, M_VS(mp,1), M_VN(mp,1), IM_NDIM(im)) + + return (mp) +end diff --git a/sys/pmio/miopl.gx b/sys/pmio/miopl.gx new file mode 100644 index 00000000..be7b7b95 --- /dev/null +++ b/sys/pmio/miopl.gx @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plseg$t (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2$t(), impl3$t(), impgs$t() +errchk impl2$t, impl3$t, impgs$t, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2$t (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3$t (im, v[2], v[3]) + else + bp = impgs$t (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/mioseti.x b/sys/pmio/mioseti.x new file mode 100644 index 00000000..ef4fe116 --- /dev/null +++ b/sys/pmio/mioseti.x @@ -0,0 +1,30 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <syserr.h> +include <pmset.h> +include "mio.h" + +# MIO_SETI -- Set an MIO parameter. + +procedure mio_seti (mp, param, value) + +pointer mp #I MIO descriptor +int param #I parameter to be set +int value #I new value + +begin + switch (param) { + case P_PMDES: + M_PM(mp) = value + M_ACTIVE(mp) = NO + case P_IMDES: + M_IM(mp) = value + M_ACTIVE(mp) = NO + case P_REGCOORDS: + M_REGCOORDS(mp) = value + case P_PMCLOSE: + M_PMCLOSE(mp) = value + default: + call syserr (SYS_PLINVPAR) + } +end diff --git a/sys/pmio/miosrange.x b/sys/pmio/miosrange.x new file mode 100644 index 00000000..26b42727 --- /dev/null +++ b/sys/pmio/miosrange.x @@ -0,0 +1,33 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include "mio.h" + +# MIO_SETRANGE -- Set the region of the image to be accessed, and rewind the +# i/o pointer to the beginning of the specified region. + +procedure mio_setrange (mp, vs, ve, ndim) + +pointer mp #I MIO descriptor +long vs[IM_MAXDIM] #I vector coords of start of region +long ve[IM_MAXDIM] #I vector coords of end of region +int ndim #I dimensionality of region + +int i +int btoi() + +begin + do i = 1, IM_MAXDIM + if (i <= ndim) { + M_VS(mp,i) = min (vs[i], ve[i]) + M_VN(mp,i) = abs (ve[i] - vs[i]) + 1 + } else { + M_VS(mp,i) = 1 + M_VN(mp,i) = 1 + } + + M_LINEIO(mp) = btoi (vs[1] == 1 && ve[1] == IM_LEN(M_IM(mp),1)) + M_REGCOORDS(mp) = YES + M_ACTIVE(mp) = NO + M_NDIM(mp) = ndim +end diff --git a/sys/pmio/miostati.x b/sys/pmio/miostati.x new file mode 100644 index 00000000..3f492daa --- /dev/null +++ b/sys/pmio/miostati.x @@ -0,0 +1,27 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <syserr.h> +include <pmset.h> +include "mio.h" + +# MIO_STATI -- Stat an MIO parameter. + +int procedure mio_stati (mp, param) + +pointer mp #I MIO descriptor +int param #I parameter to be set + +begin + switch (param) { + case P_PMDES: + return (M_PM(mp)) + case P_IMDES: + return (M_IM(mp)) + case P_REGCOORDS: + return (M_REGCOORDS(mp)) + case P_PMCLOSE: + return (M_PMCLOSE(mp)) + default: + call syserr (SYS_PLINVPAR) + } +end diff --git a/sys/pmio/mkpkg b/sys/pmio/mkpkg new file mode 100644 index 00000000..0c03f90d --- /dev/null +++ b/sys/pmio/mkpkg @@ -0,0 +1,68 @@ +# Make the PM package library. + +$checkout libex.a lib$ +$update libex.a +$checkin libex.a lib$ +$exit + +tfiles: + $set PFLAGS = "-k -t silrdx -p tf/" + $set GFLAGS = "-k -t sil -p tf/" + $ifolder (tf/miogli.x, miogl.gx) $generic $(PFLAGS) miogl.gx $endif + $ifolder (tf/miopli.x, miopl.gx) $generic $(PFLAGS) miopl.gx $endif + $ifolder (tf/pmglpi.x, pmglp.gx) $generic $(GFLAGS) pmglp.gx $endif + $ifolder (tf/pmglri.x, pmglr.gx) $generic $(GFLAGS) pmglr.gx $endif + $ifolder (tf/pmplpi.x, pmplp.gx) $generic $(GFLAGS) pmplp.gx $endif + $ifolder (tf/pmplri.x, pmplr.gx) $generic $(GFLAGS) pmplr.gx $endif + ; + +zzdebug: +zzdebug.e: + $set XFLAGS = "$(XFLAGS) -q" + $omake zzinterp.x <error.h> <ctype.h> <fset.h> <pmset.h> + $omake zzdebug.x <error.h> <imhdr.h> <ctype.h> <fset.h> <pmset.h> + $link zzdebug.o zzinterp.o -o zzdebug.e + ; + +libex.a: + # Retranslate any recently modified generic sources. + $ifeq (hostid, unix) + $call tfiles + $endif + + # Transfer <plset.h> dependency to <pmset.h>. + $ifnewer (<plset.h>, <pmset.h>) + $copy <pmset.h> temp.pm + $move temp.pm <pmset.h> + $endif + + @tf # Update datatype expanded files. + + mioclose.x mio.h <pmset.h> + mioopen.x mio.h <pmset.h> + mioopeno.x mio.h <imhdr.h> <pmset.h> + mioseti.x mio.h <pmset.h> + miosrange.x mio.h <imhdr.h> + miostati.x mio.h <pmset.h> + pmaccess.x pmio.com <plio.h> <pmset.h> + pmascii.x pmio.com <plio.h> <pmset.h> + pmbox.x pmio.com <plio.h> <pmset.h> + pmcircle.x pmio.com <plio.h> <pmset.h> + pmclear.x pmio.com <imhdr.h> <plio.h> <pmset.h> + pmempty.x pmio.com <imhdr.h> <plio.h> <pmset.h> + pmglls.x pmio.com <imhdr.h> <plio.h> <pmset.h> + pmline.x pmio.com <plio.h> <pmset.h> + pmlinene.x pmio.com <plio.h> <imhdr.h> <pmset.h> + pmnewmask.x <imhdr.h> <imio.h> <plio.h> <pmset.h> + pmplls.x pmio.com <plio.h> <pmset.h> + pmpoint.x pmio.com <plio.h> <pmset.h> + pmpolygon.x pmio.com <plio.h> <pmset.h> + pmrio.x pmio.com <plio.h> <pmset.h> + pmrop.x pmio.com <plio.h> <imhdr.h> <pmset.h> + pmsectnc.x pmio.com <plio.h> <pmset.h> + pmsectne.x pmio.com <plio.h> <pmset.h> + pmseti.x <imio.h> <plio.h> <pmset.h> + pmstati.x <imio.h> <plio.h> <pmset.h> + pmsplane.x pmio.com <plio.h> <pmset.h> + pmsten.x pmio.com <plio.h> <imhdr.h> <pmset.h> + ; diff --git a/sys/pmio/plprop.gx b/sys/pmio/plprop.gx new file mode 100644 index 00000000..60d1c603 --- /dev/null +++ b/sys/pmio/plprop.gx @@ -0,0 +1,177 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <plset.h> +include <plio.h> + +# PL_PIXROP -- Rasterop between source and destination pixel arrays. + +procedure pl_pixrop$t (px_src,xs,src_maxval, px_dst,ds,dst_maxval, npix, rop) + +PIXEL px_src[ARB] #I source pixel array +int xs #I starting pixel index in src +int src_maxval #I max pixel value in src mask +PIXEL px_dst[ARB] #O destination pixel array +int ds #I starting pixel index in dst +int dst_maxval #I max pixel value in dst mask +int npix #I number of pixels to convert +int rop #I rasterop + +pointer sp, src +int opcode, i +PIXEL data, ceil, src_value +int and(), or(), xor(), not() +define out_ 91 + +begin + opcode = R_OPCODE(rop) + data = R_DATA(rop) + ceil = 0 + + # Pixel value to be used if input mask is boolean. + if (src_maxval == 1) { + src_value = data + if (src_value <= 0) + src_value = dst_maxval + } + + # Handle the easy cases first. + switch (opcode) { + case PIX_CLR: + call aclr$t (px_dst[ds], npix) + return + case PIX_SET: + call amovk$t (data, px_dst[ds], npix) + goto out_ + case PIX_SRC: + if (src_maxval != 1) + call amov$t (px_src[xs], px_dst[ds], npix) + else { + do i = 1, npix + if (px_src[xs+i-1] > 0) + px_dst[ds+i-1] = src_value + else + px_dst[ds+i-1] = 0 + } + + goto out_ + case PIX_DST: + return # no-op + } + + # Integer or boolean source mask? + if (src_maxval != 1) { + # Integer source mask; operate directly on source mask. + + switch (opcode) { + case PIX_NOTSRC: + do i = 1, npix + px_dst[ds+i-1] = not (px_src[xs+i-1]) + case PIX_NOTDST: + do i = 1, npix + px_dst[ds+i-1] = not (px_dst[xs+i-1]) + + case PIX_SRC_AND_DST: + do i = 1, npix + px_dst[ds+i-1] = and (px_src[xs+i-1], px_dst[ds+i-1]) + case PIX_SRC_OR_DST: + do i = 1, npix + px_dst[ds+i-1] = or (px_src[xs+i-1], px_dst[ds+i-1]) + case PIX_SRC_XOR_DST: + do i = 1, npix + px_dst[ds+i-1] = xor (px_src[xs+i-1], px_dst[ds+i-1]) + + case PIX_SRC_AND_NOTDST: + do i = 1, npix + px_dst[ds+i-1] = and (px_src[xs+i-1], not(px_dst[ds+i-1])) + case PIX_SRC_OR_NOTDST: + do i = 1, npix + px_dst[ds+i-1] = or (px_src[xs+i-1], not(px_dst[ds+i-1])) + case PIX_NOTSRC_AND_DST: + do i = 1, npix + px_dst[ds+i-1] = and (not(px_src[xs+i-1]), px_dst[ds+i-1]) + case PIX_NOTSRC_OR_DST: + do i = 1, npix + px_dst[ds+i-1] = or (not(px_src[xs+i-1]), px_dst[ds+i-1]) + + case PIX_NOT_SRC_AND_DST: + do i = 1, npix + px_dst[ds+i-1] = not (and (px_src[xs+i-1], px_dst[ds+i-1])) + case PIX_NOT_SRC_OR_DST: + do i = 1, npix + px_dst[ds+i-1] = not ( or (px_src[xs+i-1], px_dst[ds+i-1])) + case PIX_NOT_SRC_XOR_DST: + do i = 1, npix + px_dst[ds+i-1] = not (xor (px_src[xs+i-1], px_dst[ds+i-1])) + } + + } else { + # Boolean source mask; use integer DATA value from ROP if source + # mask pixel is set. + + call smark (sp) + call salloc (src, npix, TY_PIXEL) + + do i = 1, npix + if (px_src[xs+i-1] > 0) + Mem$t[src+i-1] = src_value + else + Mem$t[src+i-1] = 0 + + switch (opcode) { + case PIX_NOTSRC: + do i = 1, npix + px_dst[ds+i-1] = not (Mem$t[src+i-1]) + case PIX_NOTDST: + do i = 1, npix + px_dst[ds+i-1] = not (px_dst[xs+i-1]) + + case PIX_SRC_AND_DST: + do i = 1, npix + px_dst[ds+i-1] = and (Mem$t[src+i-1], px_dst[ds+i-1]) + case PIX_SRC_OR_DST: + do i = 1, npix + px_dst[ds+i-1] = or (Mem$t[src+i-1], px_dst[ds+i-1]) + case PIX_SRC_XOR_DST: + do i = 1, npix + px_dst[ds+i-1] = xor (Mem$t[src+i-1], px_dst[ds+i-1]) + + case PIX_SRC_AND_NOTDST: + do i = 1, npix + px_dst[ds+i-1] = and (Mem$t[src+i-1], not(px_dst[ds+i-1])) + case PIX_SRC_OR_NOTDST: + do i = 1, npix + px_dst[ds+i-1] = or (Mem$t[src+i-1], not(px_dst[ds+i-1])) + case PIX_NOTSRC_AND_DST: + do i = 1, npix + px_dst[ds+i-1] = and (not(Mem$t[src+i-1]), px_dst[ds+i-1]) + case PIX_NOTSRC_OR_DST: + do i = 1, npix + px_dst[ds+i-1] = or (not(Mem$t[src+i-1]), px_dst[ds+i-1]) + + case PIX_NOT_SRC_AND_DST: + do i = 1, npix + px_dst[ds+i-1] = not (and (Mem$t[src+i-1], px_dst[ds+i-1])) + case PIX_NOT_SRC_OR_DST: + do i = 1, npix + px_dst[ds+i-1] = not ( or (Mem$t[src+i-1], px_dst[ds+i-1])) + case PIX_NOT_SRC_XOR_DST: + do i = 1, npix + px_dst[ds+i-1] = not (xor (Mem$t[src+i-1], px_dst[ds+i-1])) + } + + call sfree (sp) + } +out_ + # If writing to an integer mask, mask the data to the indicated max + # value (necessary to avoid very large values if any NOT operations + # occurred). If writing to a boolean mask, map positive integer mask + # values to 1. + + if (dst_maxval == 1) { + data = 1 + call argt$t (px_dst[ds], npix, ceil, data) + } else if (dst_maxval > 1) { + data = dst_maxval + call aandk$t (px_dst[ds], data, px_dst[ds], npix) + } +end diff --git a/sys/pmio/pmaccess.x b/sys/pmio/pmaccess.x new file mode 100644 index 00000000..74f73e72 --- /dev/null +++ b/sys/pmio/pmaccess.x @@ -0,0 +1,24 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_ACCESS -- Return a pointer (type short) to the indicated mask image +# line. A valid pointer is always returned; if the mask line is empty, the +# pointer will reference the "empty line" linelist. + +pointer procedure pm_access (pl, v) + +pointer pl #I mask descriptor +long v[PM_MAXDIM] #I coordinates of desired line + +pointer pl_access() +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call imaplv (PM_REFIM(pl), v, v1, PM_MAXDIM) + return (pl_access (pl, v1)) + } else + return (pl_access (pl, v)) +end diff --git a/sys/pmio/pmascii.x b/sys/pmio/pmascii.x new file mode 100644 index 00000000..3e85d0af --- /dev/null +++ b/sys/pmio/pmascii.x @@ -0,0 +1,27 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_ASCIIDUMP -- Dump a two dimensional region of a mask as a printable ASCII +# character array on the output stream. Intended as a simple debugging tool; +# see also PM_SAVEIM. + +procedure pm_asciidump (pl, vs, ve, outfd) + +pointer pl #I mask descriptor +long vs[ARB] #I ll vector (only first two elements used) +long ve[ARB] #I ur vector (only first two elements used) +int outfd #I output file + +include "pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_asciidump (pl, vs, ve, outfd) + else { + call imaplv (PM_REFIM(pl), vs, v1, PM_MAXDIM) + call imaplv (PM_REFIM(pl), ve, v2, PM_MAXDIM) + call pl_asciidump (pl, v1, v2, outfd) + } +end diff --git a/sys/pmio/pmbox.x b/sys/pmio/pmbox.x new file mode 100644 index 00000000..d54eb8fa --- /dev/null +++ b/sys/pmio/pmbox.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_BOX -- Rasterop between a box as source, and an existing mask as dest. +# This is a 2-dim operator. The pm_setplane procedure is used to specify +# the plane to be modified. + +procedure pm_box (pl, x1,y1, x2,y2, rop) + +pointer pl #I mask descriptor +int x1,y1 #I lower left corner of box +int x2,y2 #I upper right corner of box +int rop #I rasterop + +errchk pl_getplane +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call pl_getplane (pl, v1) + v1[1] = x1; v1[2] = y1 + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call pl_getplane (pl, v3) + v3[1] = x2; v3[2] = y2 + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + call pl_box (pl, v2[1],v2[2], v4[1],v4[2], rop) + + } else + call pl_box (pl, x1,y1, x2,y2, rop) +end diff --git a/sys/pmio/pmcircle.x b/sys/pmio/pmcircle.x new file mode 100644 index 00000000..086da99a --- /dev/null +++ b/sys/pmio/pmcircle.x @@ -0,0 +1,37 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_CIRCLE -- Rasterop between a circular region as source, and an existing +# mask as destination. It is not necessary for the center of the circle to +# be inside the mask; if it is outside, the boundary of the circle will be +# clipped to the boundary of the mask. This is a 2-dim operator. If the +# image dimensionality is greater than two the pm_setplane procedure should +# be called first to specify the plane to be modified. + +procedure pm_circle (pl, x, y, radius, rop) + +pointer pl #I mask descriptor +int x,y #I center coords of circle +int radius #I radius of circle +int rop #I rasterop + +errchk pl_getplane +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call pl_getplane (pl, v1) + v1[1] = x; v1[2] = y + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call pl_getplane (pl, v3) + v3[1] = x + radius; v3[2] = y + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + call pl_circle (pl, v2[1], v2[2], abs(v4[1]-v2[1]), rop) + + } else + call pl_circle (pl, x, y, radius, rop) +end diff --git a/sys/pmio/pmclear.x b/sys/pmio/pmclear.x new file mode 100644 index 00000000..1aed4013 --- /dev/null +++ b/sys/pmio/pmclear.x @@ -0,0 +1,28 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_CLEAR -- Clear a mask. The entire surface is cleared. This is equivalent +# to a full surface pm_rop with rop=PIX_CLR, but is more convenient and can be +# implemented more efficiently since the entire surface is cleared. + +procedure pm_clear (pl) + +pointer pl #I mask descriptor + +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call amovkl (1, v1, PM_MAXDIM) + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + call amovl (IM_LEN(PM_REFIM(pl),1), v3, PM_MAXDIM) + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + call pl_rop (NULL, NULL, pl, v2, v4, PIX_CLR) + + } else + call pl_clear (pl) +end diff --git a/sys/pmio/pmempty.x b/sys/pmio/pmempty.x new file mode 100644 index 00000000..c8797663 --- /dev/null +++ b/sys/pmio/pmempty.x @@ -0,0 +1,27 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_EMPTY -- Test whether a mask is empty, i.e., contains no nonzero pixels. + +bool procedure pm_empty (pl) + +pointer pl #I mask descriptor + +bool pl_empty(), pl_sectnotempty() +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call amovkl (1, v1, PM_MAXDIM) + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + call amovl (IM_LEN(PM_REFIM(pl),1), v3, PM_MAXDIM) + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + return (!pl_sectnotempty (pl, v2, v4, PM_MAXDIM)) + + } else + return (pl_empty (pl)) +end diff --git a/sys/pmio/pmglls.x b/sys/pmio/pmglls.x new file mode 100644 index 00000000..6604c999 --- /dev/null +++ b/sys/pmio/pmglls.x @@ -0,0 +1,78 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_GLLS -- Get a line segment as a list list, applying the given ROP to +# combine the pixels with those of the output line list. + +procedure pm_glls (pl, v, ll_dst, ll_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +short ll_dst[ARB] #O output line list +int ll_depth #I line list depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int ll_len, temp, np, step, xstep +pointer sp, px_src, ll_src, ll_out, im +int pl_p2li() +include "pmio.com" + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glls (pl, v, ll_dst, ll_depth, npix, rop) + return + } + + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_INT) + call pl_glpi (pl, v1, Memi[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Memi[px_src], Memi[px_src], npix, SZ_INT, step) + if (xstep < 0) + call imaflp (Memi[px_src], npix, SZ_INT) + + # Convert to a line list. + ll_len = pl_p2li (Memi[px_src], 1, Mems[ll_src], npix) + + # Copy to or combine with destination. + if (!R_NEED_DST(rop)) { + ll_len = LP_LEN(ll_src) + call amovs (Mems[ll_src], ll_dst, ll_len) + } else { + call salloc (ll_out, LL_MAXLEN(pl), TY_SHORT) + call pl_linerop (Mems[ll_src], 1, PL_MAXVAL(pl), ll_dst, 1, + MV(ll_depth), Mems[ll_out], npix, rop) + ll_len = LP_LEN(ll_out) + call amovs (Mems[ll_out], ll_dst, ll_len) + } + + call sfree (sp) +end diff --git a/sys/pmio/pmglp.gx b/sys/pmio/pmglp.gx new file mode 100644 index 00000000..26c6b2e0 --- /dev/null +++ b/sys/pmio/pmglp.gx @@ -0,0 +1,69 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_GLP -- Get a line segment as a pixel array, applying the given ROP to +# combine the pixels with those of the output array. + +procedure pm_glp$t (pl, v, px_dst, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +PIXEL px_dst[ARB] #O output pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int temp, np, step, xstep +pointer sp, px_src, px_out, im +include "../pmio.com" + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glp$t (pl, v, px_dst, px_depth, npix, rop) + return + } + + call smark (sp) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_PIXEL) + call pl_glp$t (pl, v1, Mem$t[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Mem$t[px_src], Mem$t[px_src], npix, SZ_PIXEL, step) + if (xstep < 0) + call imaflp (Mem$t[px_src], npix, SZ_PIXEL) + + if (!R_NEED_DST(rop)) + call amov$t (Mem$t[px_src], px_dst, npix) + else { + call salloc (px_out, npix, TY_PIXEL) + call pl_pixrop$t (Mem$t[px_src], 1, PL_MAXVAL(pl), px_dst, 1, + MV(px_depth), npix, rop) + call amov$t (Mem$t[px_out], px_dst, npix) + } + + call sfree (sp) +end diff --git a/sys/pmio/pmglr.gx b/sys/pmio/pmglr.gx new file mode 100644 index 00000000..9c2e2606 --- /dev/null +++ b/sys/pmio/pmglr.gx @@ -0,0 +1,85 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_GLR -- Get a line segment as a range list, applying the given ROP to +# combine the pixels with those of the output line list. Note that this +# operator uses IMIO if a section transformation is needed, hence if the +# application also uses IMIO to directly access the mask image, care must +# be taken to avoid confusion over the use of IMIO allocated pixel buffers. + +procedure pm_glr$t (pl, v, rl_dst, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +PIXEL rl_dst[3,ARB] #O output line list +int rl_depth #I line list depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int rl_len, temp, step, xstep, np +pointer sp, px_src, rl_src, rl_out, im +include "../pmio.com" +int pl_p2r$t() + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glr$t (pl, v, rl_dst, rl_depth, npix, rop) + return + } + + call smark (sp) + call salloc (rl_src, RL_MAXLEN(pl), TY_PIXEL) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_PIXEL) + call pl_glp$t (pl, v1, Mem$t[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Mem$t[px_src], Mem$t[px_src], npix, SZ_PIXEL, step) + if (xstep < 0) + call imaflp (Mem$t[px_src], npix, SZ_PIXEL) + + # Convert to a range list. + rl_len = pl_p2r$t (Mem$t[px_src], 1, Mem$t[rl_src], npix) + + # Copy to or combine with destination. + if (!R_NEED_DST(rop)) { + rl_len = RLI_LEN(rl_src) * RL_LENELEM + call amov$t (Mem$t[rl_src], rl_dst, rl_len) + } else { + call salloc (rl_out, RL_MAXLEN(pl), TY_PIXEL) + call pl_rangerop$t (Mem$t[rl_src], 1, PL_MAXVAL(pl), rl_dst, 1, + MV(rl_depth), Mem$t[rl_out], npix, rop) + $if (datatype == s) + rl_len = RLS_LEN(rl_out) * RL_LENELEM + $else + rl_len = RLI_LEN(rl_out) * RL_LENELEM + $endif + call amov$t (Mem$t[rl_out], rl_dst, rl_len) + } + + call sfree (sp) +end diff --git a/sys/pmio/pmio.com b/sys/pmio/pmio.com new file mode 100644 index 00000000..76616e6a --- /dev/null +++ b/sys/pmio/pmio.com @@ -0,0 +1,5 @@ +# PMIO.COM -- A few scratch vectors used in many of the PMIO routines, +# defined in common to save some space. + +long v1[PM_MAXDIM], v2[PM_MAXDIM], v3[PM_MAXDIM], v4[PM_MAXDIM] +common /pmiocom/ v1, v2, v3, v4 diff --git a/sys/pmio/pmline.x b/sys/pmio/pmline.x new file mode 100644 index 00000000..36be1cb4 --- /dev/null +++ b/sys/pmio/pmline.x @@ -0,0 +1,36 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_LINE -- Perform a rasterop operation upon a line of arbitrary width drawn +# at an arbitrary orientation in a 2-dimensional plane of a mask. If the +# dimensionality of the mask exceeds 2, the pm_setplane() procedure should be +# called first to define the plane of the mask to be modified. + +procedure pm_line (pl, x1, y1, x2, y2, width, rop) + +pointer pl #I mask descriptor +int x1,y1 #I start point of line +int x2,y2 #I end point of line +int width #I width of line to be drawn, pixels +int rop #I rasterop defining operation + +errchk pl_getplane +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call pl_getplane (pl, v1) + v1[1] = x1; v1[2] = y1 + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call pl_getplane (pl, v3) + v3[1] = x2; v3[2] = y2 + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + call pl_line (pl, v2[1],v2[2], v4[1],v4[2], width, rop) + + } else + call pl_line (pl, x1, y1, x2, y2, width, rop) +end diff --git a/sys/pmio/pmlinene.x b/sys/pmio/pmlinene.x new file mode 100644 index 00000000..0e49de54 --- /dev/null +++ b/sys/pmio/pmlinene.x @@ -0,0 +1,28 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_LINENOTEMPTY -- Test whether the indicated mask image line is empty. + +bool procedure pm_linenotempty (pl, v) + +pointer pl #I mask descriptor +long v[PM_MAXDIM] #I coordinates of desired line + +bool pl_sectnotempty(), pl_linenotempty() +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call imaplv (PM_REFIM(pl), v, v1, PM_MAXDIM) + call amovl (v, v2, PM_MAXDIM) + v2[1] = IM_LEN(PM_REFIM(pl),1) + call imaplv (PM_REFIM(pl), v2, v3, PM_MAXDIM) + + return (pl_sectnotempty (pl, v1, v3, PM_MAXDIM)) + + } else + return (pl_linenotempty (pl, v)) +end diff --git a/sys/pmio/pmnewmask.x b/sys/pmio/pmnewmask.x new file mode 100644 index 00000000..200e4841 --- /dev/null +++ b/sys/pmio/pmnewmask.x @@ -0,0 +1,28 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <imhdr.h> +include <imio.h> +include <plio.h> + +# PM_NEWMASK -- Create an empty mask with the same dimensionality and size as +# the given reference image. + +pointer procedure pm_newmask (ref_im, depth) + +pointer ref_im #I reference image +int depth #I mask depth, bits + +pointer pl +pointer pl_open() +errchk pl_open + +begin + pl = pl_open (NULL) + call pl_ssize (pl, IM_NDIM(ref_im), IM_SVLEN(ref_im,1), depth) + + PM_REFIM(pl) = ref_im + PM_MAPXY(pl) = IM_SECTUSED(ref_im) + + return (pl) +end diff --git a/sys/pmio/pmplls.x b/sys/pmio/pmplls.x new file mode 100644 index 00000000..b7f0e826 --- /dev/null +++ b/sys/pmio/pmplls.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLLS -- Put a line segment input as a list list to a mask, applying the +# given ROP to combine the pixels with those of the output mask. + +procedure pm_plls (pl, v, ll_raw, ll_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +short ll_raw[ARB] #I input line list +int ll_depth #I line list depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src, ll_dst, ll_stn, ll_out, px_src, im +int ll_len, step, xstep, temp, np, ip, i +int pl_l2pi(), pl_p2li() +pointer pl_access() +include "pmio.com" + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_plls (pl, v, ll_raw, ll_depth, npix, rop) + return + } + + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + np = (npix - 1) * step + 1 + ll_stn = NULL + + # Resample and flip the line list if necessary. Construct a stencil + # list if the step size is greater than 1. + + if (xstep < 0 || step > 1) { + call salloc (px_src, np, TY_INT) + i = pl_l2pi (ll_raw, 1, Memi[px_src], npix) + call aclri (Memi[px_src+i], np - i) + + # Flip data array. + if (xstep < 0) + call imaflp (Memi[px_src], npix, SZ_INT) + + if (step > 1) { + # Resample data array. + ip = px_src + npix - 1 + do i = np, 1, -step { + Memi[px_src+i-1] = Memi[ip] + ip = ip - 1 + } + + # Construct stencil. + call salloc (ll_stn, LL_MAXLEN(pl), TY_SHORT) + call aclri (Memi[px_src], np) + do i = 1, np, step + Memi[px_src+i-1] = 1 + ll_len = pl_p2li (Memi[px_src], 1, Mems[ll_stn], np) + } + + # Convert flipped and resampled data back to line list. + ll_len = pl_p2li (Memi[px_src], 1, Mems[ll_src], np) + + } else { + ll_len = LL_LEN(ll_raw) + call amovs (ll_raw, Mems[ll_src], ll_len) + } + + # Copy to or combine with destination. + if (ll_stn == NULL) + call pl_plls (pl, v1, Mems[ll_src], ll_depth, np, rop) + else { + call salloc (ll_out, LL_MAXLEN(pl), TY_SHORT) + ll_dst = pl_access (pl, v1) + call pl_linestencil (Mems[ll_src], 1, MV(ll_depth), + Mems[ll_dst], v1, PL_MAXVAL(pl), Mems[ll_stn], 1, + Mems[ll_out], np, rop) + call pl_update (pl, v1, Mems[ll_out]) + } + + call sfree (sp) +end diff --git a/sys/pmio/pmplp.gx b/sys/pmio/pmplp.gx new file mode 100644 index 00000000..90246ddc --- /dev/null +++ b/sys/pmio/pmplp.gx @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLP -- Put a line segment input as a pixel array a mask, applying the +# given ROP to combine the pixels with those of the mask. + +procedure pm_plp$t (pl, v, px_src, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +PIXEL px_src[ARB] #I input pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_p2l$t() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plp$t (pl, v, px_src, px_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_p2l$t (px_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], px_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/pmplr.gx b/sys/pmio/pmplr.gx new file mode 100644 index 00000000..6f87601b --- /dev/null +++ b/sys/pmio/pmplr.gx @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLR -- Put a line segment input as a range list to a mask, applying the +# given ROP to combine the pixels with those of the output mask. + +procedure pm_plr$t (pl, v, rl_src, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +PIXEL rl_src[3,ARB] #I input range list +int rl_depth #I range list pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_r2l$t() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plr$t (pl, v, rl_src, rl_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_r2l$t (rl_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], rl_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/pmpoint.x b/sys/pmio/pmpoint.x new file mode 100644 index 00000000..c464c47e --- /dev/null +++ b/sys/pmio/pmpoint.x @@ -0,0 +1,31 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_POINT -- Perform a rasterop operation on a single point in a line of a +# 2-dimensional plane of a mask. If the dimensionality of the mask exceeds 2, +# the pm_setplane() procedure should be called first to define the plane of +# the mask to be modified. + +procedure pm_point (pl, x, y, rop) + +pointer pl #I mask descriptor +int x #I pixel to be modified +int y #I line to be modified +int rop #I rasterop defining operation + +errchk pl_getplane +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call pl_getplane (pl, v1) + v1[1] = x; v1[2] = y + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call pl_point (pl, v2[1], v2[2], rop) + + } else + call pl_point (pl, x, y, rop) +end diff --git a/sys/pmio/pmpolygon.x b/sys/pmio/pmpolygon.x new file mode 100644 index 00000000..5e09e5b7 --- /dev/null +++ b/sys/pmio/pmpolygon.x @@ -0,0 +1,42 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_POLYGON -- Perform a rasterop operation on the area enclosed by a polygon +# drawn in a 2-dimensional plane of a mask. If the dimensionality of the mask +# exceeds 2, the pm_setplane() procedure should be called first to define the +# plane of the mask to be modified. + +procedure pm_polygon (pl, x, y, npts, rop) + +pointer pl #I mask descriptor +int x[npts] #I polygon x-vertices +int y[npts] #I polygon y-vertices +int npts #I number of points in polygon +int rop #I rasterop defining operation + +int i +pointer sp, xp, yp +errchk pl_getplane +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call smark (sp) + call salloc (xp, npts, TY_INT) + call salloc (yp, npts, TY_INT) + + call pl_getplane (pl, v1) + do i = 1, npts { + v1[1] = x[i]; v1[2] = y[i] + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + Memi[xp+i-1] = v2[1]; Memi[yp+i-1] = v2[2] + } + + call pl_polygon (pl, Memi[xp], Memi[yp], npts, rop) + call sfree (sp) + + } else + call pl_polygon (pl, x, y, npts, rop) +end diff --git a/sys/pmio/pmrio.x b/sys/pmio/pmrio.x new file mode 100644 index 00000000..278c7f30 --- /dev/null +++ b/sys/pmio/pmrio.x @@ -0,0 +1,128 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +.help PMRIO +.nf --------------------------------------------------------------------------- +PMRIO -- A small package used to provide a means for efficient random +sampling (at the pixel level) of large PMIO masks. In other words, if we have +a large mask and want to determine the values of successive mask pixels at +random locations in the mask, this package provides a more efficient means +for doing so than calling a routine such as PM_GLPI. The mask must already +exist; means are not provided within this package for creating or editing +masks, only for reading them. + + pmr = pmr_open (pm, plane, buflimit) + pmr_setrect (pmr, x1,y1, x2,y2) + mval = pmr_getpix (pmr, x, y) + pmr_close (pmr) + +PMR_OPEN opens the indicated 2 dimensional plane of the N dimensional mask PM. +Buffer space used to provide an efficient means of randomly sampling the mask +will be kept to within approximately BUFLIMIT integer units of storage (the +internal table used to sample the mask is type integer, so BUFLIMIT is the +approximate number of entries in the table). Random sampling of the mask is +provided by the integer function PMR_GETPIX, which returns the mask value at +the point [i,j] within the specified plane. PMR_SETRECT may be called before +calling PMR_GETPIX to set the clipping rectangle, which defaults to the +boundaries of the mask. If a PMR_GETPIX call references outside the clipping +region, ERR will be returned as the mask value (normal mask values are >= 0). +Use of a clipping region other than the boundaries of the full mask can avoid +the need for redundant clipping operations in the client. PMR_CLOSE should +be called to free the PMRIO table space (which can be extensive) when no longer +needed. + +This package is a front end to the PLRIO package in PLIO, which does all the +real work. +.endhelp ---------------------------------------------------------------------- + +# The following definitions must agree with those in plio$plrio.x. +define PMR_PL Memi[$1] # backpointer to PLIO descriptor +define PMR_PLANE Memi[$1+10+($2)-1] # defines 2D plane in ND mask + + +# PMR_OPEN -- Open a PMIO mask for random pixel access. Provides efficient +# random pixel level access to any size mask. This is a 2-dimensional +# operator, but can be used to sample any 2-dim plane of an N-dim mask. + +pointer procedure pmr_open (pl, plane, buflimit) + +pointer pl #I PMIO/PLIO descriptor +int plane[ARB] #I 2-dim plane to be accessed +int buflimit #I approximate table size, or 0 if don't care + +pointer plr_open() +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call imaplv (PM_REFIM(pl), plane, v1, PM_MAXDIM) + return (plr_open (pl, v1, buflimit)) + } else + return (plr_open (pl, plane, buflimit)) +end + + +# PMR_GETPIX -- Return the value of the given mask pixel, identified by the +# 2-dim coordinates of the pixel relative to the plane of the N-dim mask +# specified at open time. + +int procedure pmr_getpix (pmr, i, j) + +pointer pmr #I PMR descriptor +int i, j #I plane-relative coordinates of pixel + +pointer pl +int plr_getpix() +include "pmio.com" + +begin + pl = PMR_PL(pmr) + if (PM_MAPXY(pl) == YES) { + PMR_PLANE(pmr,1) = i + PMR_PLANE(pmr,2) = j + call imaplv (PM_REFIM(pl), PMR_PLANE(pmr,1), v1, PM_MAXDIM) + return (plr_getpix (pmr, v1[1], v1[2])) + } else + return (plr_getpix (pmr, i, j)) +end + + +# PMR_SETRECT -- Set the clipping region for PMR_GETPIX. + +procedure pmr_setrect (pmr, x1,y1, x2,y2) + +pointer pmr #I PMR descriptor +int x1,y1 #I lower left corner of region +int x2,y2 #I upper right corner of region + +pointer pl +include "pmio.com" + +begin + pl = PMR_PL(pmr) + if (PM_MAPXY(pl) == YES) { + call amovi (PMR_PLANE(pmr,1), v1, PM_MAXDIM) + v1[1] = x1; v1[2] = y1 + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call amovi (PMR_PLANE(pmr,1), v3, PM_MAXDIM) + v3[1] = x2; v3[2] = y2 + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + call plr_setrect (pmr, v2[1],v2[2], v4[1],v4[2]) + } else + call plr_setrect (pmr, x1,y1, x2,y2) +end + + +# PMR_CLOSE -- Free a PMRIO descriptor. + +procedure pmr_close (pmr) + +pointer pmr #I PMR descriptor + +begin + call plr_close (pmr) +end diff --git a/sys/pmio/pmrop.x b/sys/pmio/pmrop.x new file mode 100644 index 00000000..ddd77d37 --- /dev/null +++ b/sys/pmio/pmrop.x @@ -0,0 +1,74 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_ROP -- Perform a rasterop operation from the source mask to the +# destination mask at the given offsets. The source and destination need +# not be the same size or dimensionality, but out of bounds references are +# not permitted. If the source is of lesser dimensionality than the +# indicated section of the destination, then the source will be rewound +# and reread as necessary to operate upon the entire destination subregion, +# e.g., a line source mask may be applied to successive lines of a plane, +# or a plane mask may be applied to successive planes of a 3D mask. +# The source and destination masks may be the same if desired, but if the +# source and destination regions overlap feedback may occur (this could be +# fixed). With some rasterops, e.g, PIX_SET or PIX_CLR, no source mask is +# required, and pm_src=NULL is permitted. + +procedure pm_rop (pm_src, vs_src, pm_dst, vs_dst, vn, rop) + +pointer pm_src #I source mask or NULL +long vs_src[PM_MAXDIM] #I start vector in source mask +pointer pm_dst #I destination mask (required) +long vs_dst[PM_MAXDIM] #I start vector in destination mask +long vn[PM_MAXDIM] #I vector giving subregion size +long rop #I rasterop + +int i +include "pmio.com" + +begin + # If an image section is used on either the source or destination + # mask, map the input vectors into the physical image space and + # perform the rasterop operation there. + + if (PM_MAPXY(pm_src) == YES || PM_MAPXY(pm_dst) == YES) { + # Compute V1, the start vector in the source mask. + call imaplv (PM_REFIM(pm_src), vs_src, v1, PM_MAXDIM) + + # Compute V3, the end vector in the source mask. + call aaddl (vs_src, vn, v2, PM_MAXDIM) + call asubkl (v2, 1, v2, PL_MAXDIM) + call aminl (v2, IM_LEN(PM_REFIM(pm_src),1), v2, PM_MAXDIM) + call imaplv (PM_REFIM(pm_src), v2, v3, PM_MAXDIM) + + # Swap V1 and V3 if necessary. + call aminl (v1, v3, v1, PM_MAXDIM) + + # Compute V2, the start vector in the destination mask. + call imaplv (PM_REFIM(pm_dst), vs_dst, v2, PM_MAXDIM) + + # Compute V4, the end vector in the destination mask. + call aaddl (vs_dst, vn, v3, PM_MAXDIM) + call asubkl (v3, 1, v3, PL_MAXDIM) + call aminl (v3, IM_LEN(PM_REFIM(pm_dst),1), v3, PM_MAXDIM) + call imaplv (PM_REFIM(pm_dst), v3, v4, PM_MAXDIM) + + # Compute v3 = vn for rasterop. Input: SRC=v1:v3, DST=v2:v4 + # This also swaps v2 and v4 if necessary. + + do i = 1, PM_MAXDIM + if (v2[i] > v4[i]) { + v3[i] = v2[i] - v4[i] + 1 + v2[i] = v4[i] + } else + v3[i] = v4[i] - v2[i] + 1 + + # Perform the rasterop. + call pl_rop (pm_src, v1, pm_dst, v2, v3, rop) + + } else + call pl_rop (pm_src, vs_src, pm_dst, vs_dst, vn, rop) +end diff --git a/sys/pmio/pmsectnc.x b/sys/pmio/pmsectnc.x new file mode 100644 index 00000000..ce424c3e --- /dev/null +++ b/sys/pmio/pmsectnc.x @@ -0,0 +1,35 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_SECTNOTCONST -- Test whether the indicated mask image section is constant, +# i.e., all the mask pixels therein are set to the same value. If so, return +# the mask value as an output argument. + +bool procedure pm_sectnotconst (pl, vs, ve, ndim, mval) + +pointer pl #I mask descriptor +long vs[PM_MAXDIM] #I starting coordinates of section +long ve[PM_MAXDIM] #I ending coordinates of section +int ndim #I dimension of section +int mval #O mask value + +bool pl_sectnotconst() +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call amovkl ( 1, v1, PM_MAXDIM) + call amovl (vs, v1, ndim) + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call amovkl ( 1, v3, PM_MAXDIM) + call amovl (ve, v3, ndim) + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + return (pl_sectnotconst (pl, v2, v4, PM_MAXDIM, mval)) + + } else + return (pl_sectnotconst (pl, vs, ve, ndim, mval)) +end diff --git a/sys/pmio/pmsectne.x b/sys/pmio/pmsectne.x new file mode 100644 index 00000000..654c53b1 --- /dev/null +++ b/sys/pmio/pmsectne.x @@ -0,0 +1,32 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_SECTNOTEMPTY -- Test whether the indicated mask image section is empty. + +bool procedure pm_sectnotempty (pl, vs, ve, ndim) + +pointer pl #I mask descriptor +long vs[PM_MAXDIM] #I starting coordinates of section +long ve[PM_MAXDIM] #I ending coordinates of section +int ndim + +bool pl_sectnotempty() +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call amovkl ( 1, v1, PM_MAXDIM) + call amovl (vs, v1, ndim) + call imaplv (PM_REFIM(pl), v1, v2, PM_MAXDIM) + + call amovkl ( 1, v3, PM_MAXDIM) + call amovl (ve, v3, ndim) + call imaplv (PM_REFIM(pl), v3, v4, PM_MAXDIM) + + return (pl_sectnotempty (pl, v2, v4, PM_MAXDIM)) + + } else + return (pl_sectnotempty (pl, vs, ve, ndim)) +end diff --git a/sys/pmio/pmseti.x b/sys/pmio/pmseti.x new file mode 100644 index 00000000..ef1fd99e --- /dev/null +++ b/sys/pmio/pmseti.x @@ -0,0 +1,30 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <syserr.h> +include <pmset.h> +include <plio.h> +include <imio.h> + +# PM_SETI -- Set a PMIO or PLIO parameter. + +procedure pm_seti (pl, param, value) + +pointer pl #I mask descriptor +int param #I parameter code +int value #I parameter value + +begin + switch (param) { + case P_REFIM: + PM_REFIM(pl) = value + PM_MAPXY(pl) = IM_SECTUSED(value) + case P_MAPXY: + PM_MAPXY(pl) = value + case P_MAXLINE: + PL_MAXLINE(pl) = value + case P_DEPTH: + PL_MAXVAL(pl) = MV(value) + default: + call syserr (SYS_PLINVPAR) + } +end diff --git a/sys/pmio/pmsplane.x b/sys/pmio/pmsplane.x new file mode 100644 index 00000000..4fcad1fd --- /dev/null +++ b/sys/pmio/pmsplane.x @@ -0,0 +1,22 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_SETPLANE -- Set the 2-Dim plane to be referenced in calls to the pm_box, +# pm_circle, etc. geometric region masking operators. + +procedure pm_setplane (pl, v) + +pointer pl #I mask descriptor +long v[ARB] #I vector defining plane + +include "pmio.com" + +begin + if (PM_MAPXY(pl) == YES) { + call imaplv (PM_REFIM(pl), v, v1, PM_MAXDIM) + call pl_setplane (pl, v1) + } else + call pl_setplane (pl, v) +end diff --git a/sys/pmio/pmstati.x b/sys/pmio/pmstati.x new file mode 100644 index 00000000..4e8566d2 --- /dev/null +++ b/sys/pmio/pmstati.x @@ -0,0 +1,32 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <syserr.h> +include <pmset.h> +include <plio.h> +include <imio.h> + +# PM_STATI -- Stat a PMIO or PLIO parameter. + +int procedure pm_stati (pl, param) + +pointer pl #I mask descriptor +int param #I parameter code + +int i + +begin + switch (param) { + case P_REFIM: + return (PM_REFIM(pl)) + case P_MAPXY: + return (PM_MAPXY(pl)) + case P_MAXLINE: + return (PL_MAXLINE(pl)) + case P_DEPTH: + do i = 0, ARB + if (2**i > min (I_PVMAX, PL_MAXVAL(pl))) + return (i) + default: + call syserr (SYS_PLINVPAR) + } +end diff --git a/sys/pmio/pmsten.x b/sys/pmio/pmsten.x new file mode 100644 index 00000000..09a34a52 --- /dev/null +++ b/sys/pmio/pmsten.x @@ -0,0 +1,77 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_STENCIL -- Perform a rasterop operation from the source mask to the +# destination mask at the given offsets, but only within the regions set to +# one in the stencil mask. + +procedure pm_stencil (pm_src, vs_src, pm_dst, vs_dst, pm_stn, vs_stn, vn, rop) + +pointer pm_src #I source mask or NULL +long vs_src[PM_MAXDIM] #I start vector in source mask +pointer pm_dst #I destination mask (required) +long vs_dst[PM_MAXDIM] #I start vector in destination mask +pointer pm_stn #I stencil mask (required) +long vs_stn[PM_MAXDIM] #I start vector in stencil mask +long vn[PM_MAXDIM] #I vector giving subregion size +long rop #I rasterop + +int i +long v5[PM_MAXDIM], v6[PM_MAXDIM] +include "pmio.com" + +begin + # If an image section is in use on any of the input mask operands, + # perform a coordination transformation into physical mask space + # before performing the stencil operation. + + if (PM_MAPXY(pm_src) == YES || PM_MAPXY(pm_dst) == YES || + PM_MAPXY(pm_stn) == YES) { + + # Compute the geometry V1:V3 of the source mask. + call imaplv (PM_REFIM(pm_src), vs_src, v1, PM_MAXDIM) + + call aaddl (vs_src, vn, v2, PM_MAXDIM) + call asubkl (v2, 1, v2, PM_MAXDIM) + call aminl (v2, IM_LEN(PM_REFIM(pm_src),1), v2, PM_MAXDIM) + call imaplv (PM_REFIM(pm_src), v2, v3, PM_MAXDIM) + + # Swap V1 and V3 if necessary. + call aminl (v1, v3, v1, PM_MAXDIM) + + # Compute the geometry V2:V4 of the destination mask. + call imaplv (PM_REFIM(pm_dst), vs_dst, v2, PM_MAXDIM) + + call aaddl (vs_dst, vn, v3, PM_MAXDIM) + call asubkl (v3, 1, v3, PM_MAXDIM) + call aminl (v3, IM_LEN(PM_REFIM(pm_dst),1), v3, PM_MAXDIM) + call imaplv (PM_REFIM(pm_dst), v3, v4, PM_MAXDIM) + + # Compute v3 = vn for rasterop. Input: SRC=v1:v3, DST=v2:v4 + # This also swaps v2 and v4 if necessary. + + do i = 1, PM_MAXDIM + if (v2[i] > v4[i]) { + v3[i] = v2[i] - v4[i] + 1 + v2[i] = v4[i] + } else + v3[i] = v4[i] - v2[i] + 1 + + # Compute the start vector V4 of the stencil mask. + call imaplv (PM_REFIM(pm_stn), vs_stn, v4, PM_MAXDIM) + call aaddl (vs_stn, vn, v5, PM_MAXDIM) + call asubkl (v5, 1, v5, PM_MAXDIM) + call aminl (v5, IM_LEN(PM_REFIM(pm_stn),1), v5, PM_MAXDIM) + call imaplv (PM_REFIM(pm_stn), v5, v6, PM_MAXDIM) + call aminl (v4, v6, v4, PM_MAXDIM) + + # Perform the rasterop operation. + call pl_stencil (pm_src, v1, pm_dst, v2, pm_stn, v4, v3, rop) + + } else + call pl_stencil (pm_src, vs_src, pm_dst, vs_dst, + pm_stn, vs_stn, vn, rop) +end diff --git a/sys/pmio/tf/miogld.x b/sys/pmio/tf/miogld.x new file mode 100644 index 00000000..7c3dc743 --- /dev/null +++ b/sys/pmio/tf/miogld.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glsegd (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2d(), imgl3d(), imggsd() +errchk imgl2d, imgl3d, imggsd, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2d (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3d (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggsd (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miogli.x b/sys/pmio/tf/miogli.x new file mode 100644 index 00000000..726f46f1 --- /dev/null +++ b/sys/pmio/tf/miogli.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glsegi (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2i(), imgl3i(), imggsi() +errchk imgl2i, imgl3i, imggsi, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2i (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3i (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggsi (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miogll.x b/sys/pmio/tf/miogll.x new file mode 100644 index 00000000..6566ae01 --- /dev/null +++ b/sys/pmio/tf/miogll.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glsegl (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2l(), imgl3l(), imggsl() +errchk imgl2l, imgl3l, imggsl, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2l (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3l (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggsl (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/mioglr.x b/sys/pmio/tf/mioglr.x new file mode 100644 index 00000000..d0fa8de0 --- /dev/null +++ b/sys/pmio/tf/mioglr.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glsegr (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2r(), imgl3r(), imggsr() +errchk imgl2r, imgl3r, imggsr, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2r (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3r (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggsr (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miogls.x b/sys/pmio/tf/miogls.x new file mode 100644 index 00000000..4973da4f --- /dev/null +++ b/sys/pmio/tf/miogls.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glsegs (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2s(), imgl3s(), imggss() +errchk imgl2s, imgl3s, imggss, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2s (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3s (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggss (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/mioglx.x b/sys/pmio/tf/mioglx.x new file mode 100644 index 00000000..44f866a2 --- /dev/null +++ b/sys/pmio/tf/mioglx.x @@ -0,0 +1,103 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_GLSEG -- Get a line segment from a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_glsegx (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U coords of first pixel in output ine segment +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer imgl2x(), imgl3x(), imggsx() +errchk imgl2x, imgl3x, imggsx, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, M_NDIM(mp)) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = imgl2x (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = imgl3x (im, v[2], v[3]) + else { + call amovl (v, ve, M_NDIM(mp)); ve[1] = M_VE(mp,1) + bp = imggsx (im, v, ve, M_NDIM(mp)) + } + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miopld.x b/sys/pmio/tf/miopld.x new file mode 100644 index 00000000..33515220 --- /dev/null +++ b/sys/pmio/tf/miopld.x @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plsegd (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2d(), impl3d(), impgsd() +errchk impl2d, impl3d, impgsd, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2d (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3d (im, v[2], v[3]) + else + bp = impgsd (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miopli.x b/sys/pmio/tf/miopli.x new file mode 100644 index 00000000..80ab9ab2 --- /dev/null +++ b/sys/pmio/tf/miopli.x @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plsegi (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2i(), impl3i(), impgsi() +errchk impl2i, impl3i, impgsi, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2i (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3i (im, v[2], v[3]) + else + bp = impgsi (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miopll.x b/sys/pmio/tf/miopll.x new file mode 100644 index 00000000..c59564b4 --- /dev/null +++ b/sys/pmio/tf/miopll.x @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plsegl (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2l(), impl3l(), impgsl() +errchk impl2l, impl3l, impgsl, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2l (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3l (im, v[2], v[3]) + else + bp = impgsl (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/mioplr.x b/sys/pmio/tf/mioplr.x new file mode 100644 index 00000000..05471efd --- /dev/null +++ b/sys/pmio/tf/mioplr.x @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plsegr (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2r(), impl3r(), impgsr() +errchk impl2r, impl3r, impgsr, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2r (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3r (im, v[2], v[3]) + else + bp = impgsr (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/miopls.x b/sys/pmio/tf/miopls.x new file mode 100644 index 00000000..85288e28 --- /dev/null +++ b/sys/pmio/tf/miopls.x @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plsegs (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2s(), impl3s(), impgss() +errchk impl2s, impl3s, impgss, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2s (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3s (im, v[2], v[3]) + else + bp = impgss (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/mioplx.x b/sys/pmio/tf/mioplx.x new file mode 100644 index 00000000..238cb7eb --- /dev/null +++ b/sys/pmio/tf/mioplx.x @@ -0,0 +1,102 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> +include "../mio.h" + +# MIO_PLSEG -- Put a line segment to a masked image. A line segment is a +# region of the data image for which the corresponding region of the mask has +# the constant nonzero value MVAL. Line segments are returned for each line in +# the region VS to VE, returning the number of pixels in each line segment as +# the function value, or EOF when the region is exhausted. Once EOF is +# reached, repeated calls will continue to return EOF until the next call to +# MIO_SETRANGE. Repeated calls to MIO_SETRANGE may be used to access a series +# of distinct regions in the image. If a subregion of the image is being +# accessed with MIO_SETRANGE, the vector coordinates V returned below will +# be relative to the defined subregion (if this is not what is desired, +# the range should be set to the full image and a region mask used to mask +# off the subregion to be accessed). + +int procedure mio_plsegx (mp, ptr, mval, v, npix) + +pointer mp #I MIO descriptor +pointer ptr #O pointer to a buffer containing the data +int mval #O mask value for the output line segment +long v[IM_MAXDIM] #U vector coordinates of first pixel +int npix #O number of pixels in output line segment + +int x1, i +long ve[IM_MAXDIM] +pointer pm, im, rl, rp, bp +pointer impl2x(), impl3x(), impgsx() +errchk impl2x, impl3x, impgsx, pm_glri +bool pm_sectnotempty() +int plloop() + +begin + pm = M_PM(mp) + rl = M_RLP(mp) + + # Initialization performed for the first i/o on a new region. + if (M_ACTIVE(mp) == NO) { + call plsslv (pm, M_VS(mp,1), M_VN(mp,1), M_V(mp,1), M_VE(mp,1)) + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + M_ACTIVE(mp) = YES + } + + # Get a new mask line? + while (M_RLI(mp) > RLI_LEN(rl)) + if (plloop (M_V(mp,1), M_VS(mp,1), M_VE(mp,1), + M_NDIM(mp)) == LOOP_DONE) { + return (EOF) + } else { + call amovl (M_V(mp,1), ve, M_NDIM(mp)) + ve[1] = M_VE(mp,1) + if (pm_sectnotempty (pm, M_V(mp,1), ve, M_NDIM(mp))) { + call pm_glri (pm, + M_V(mp,1), Memi[rl], M_DEPTH(mp), M_VN(mp,1), PIX_SRC) + M_RLI(mp) = RL_FIRST + } + } + + + # Get a new image line? + if (M_RLI(mp) == RL_FIRST) { + call amovl (M_V(mp,1), v, IM_MAXDIM) + im = M_IM(mp) + + if (M_LINEIO(mp) == YES && M_NDIM(mp) == 2) + bp = impl2x (im, v[2]) + else if (M_LINEIO(mp) == YES && M_NDIM(mp) == 3) + bp = impl3x (im, v[2], v[3]) + else + bp = impgsx (im, v, ve, M_NDIM(mp)) + + M_LBP(mp) = bp + } else + bp = M_LBP(mp) + + # Return the next line segment. + rp = rl + (M_RLI(mp) - 1) * RL_LENELEM + M_RLI(mp) = M_RLI(mp) + 1 + + x1 = Memi[rp+RL_XOFF] + npix = Memi[rp+RL_NOFF] + mval = Memi[rp+RL_VOFF] + ptr = bp + x1 - M_VS(mp,1) + + if (M_REGCOORDS(mp) == NO) { + v[1] = x1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) + } else { + v[1] = x1 - M_VS(mp,1) + 1 + do i = 2, M_NDIM(mp) + v[i] = M_V(mp,i) - M_VS(mp,i) + 1 + } + + return (npix) +end diff --git a/sys/pmio/tf/mkpkg b/sys/pmio/tf/mkpkg new file mode 100644 index 00000000..2d51c91e --- /dev/null +++ b/sys/pmio/tf/mkpkg @@ -0,0 +1,33 @@ +# Update the type expanded generic files in the PMIO package library. + +$checkout libex.a lib$ +$update libex.a +$checkin libex.a lib$ +$exit + +libex.a: + miogld.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miogli.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miogll.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + mioglr.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miogls.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + mioglx.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miopld.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miopli.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miopll.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + mioplr.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + miopls.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + mioplx.x ../mio.h <imhdr.h> <plio.h> <pmset.h> + pmglpi.x ../pmio.com <plio.h> <pmset.h> + pmglpl.x ../pmio.com <plio.h> <pmset.h> + pmglps.x ../pmio.com <plio.h> <pmset.h> + pmglri.x ../pmio.com <imhdr.h> <plio.h> <pmset.h> + pmglrl.x ../pmio.com <imhdr.h> <plio.h> <pmset.h> + pmglrs.x ../pmio.com <imhdr.h> <plio.h> <pmset.h> + pmplpi.x ../pmio.com <plio.h> <pmset.h> + pmplpl.x ../pmio.com <plio.h> <pmset.h> + pmplps.x ../pmio.com <plio.h> <pmset.h> + pmplri.x ../pmio.com <plio.h> <pmset.h> + pmplrl.x ../pmio.com <plio.h> <pmset.h> + pmplrs.x ../pmio.com <plio.h> <pmset.h> + ; diff --git a/sys/pmio/tf/pmglpi.x b/sys/pmio/tf/pmglpi.x new file mode 100644 index 00000000..2de53760 --- /dev/null +++ b/sys/pmio/tf/pmglpi.x @@ -0,0 +1,69 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_GLP -- Get a line segment as a pixel array, applying the given ROP to +# combine the pixels with those of the output array. + +procedure pm_glpi (pl, v, px_dst, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +int px_dst[ARB] #O output pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int temp, np, step, xstep +pointer sp, px_src, px_out, im +include "../pmio.com" + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glpi (pl, v, px_dst, px_depth, npix, rop) + return + } + + call smark (sp) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_INT) + call pl_glpi (pl, v1, Memi[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Memi[px_src], Memi[px_src], npix, SZ_INT, step) + if (xstep < 0) + call imaflp (Memi[px_src], npix, SZ_INT) + + if (!R_NEED_DST(rop)) + call amovi (Memi[px_src], px_dst, npix) + else { + call salloc (px_out, npix, TY_INT) + call pl_pixropi (Memi[px_src], 1, PL_MAXVAL(pl), px_dst, 1, + MV(px_depth), npix, rop) + call amovi (Memi[px_out], px_dst, npix) + } + + call sfree (sp) +end diff --git a/sys/pmio/tf/pmglpl.x b/sys/pmio/tf/pmglpl.x new file mode 100644 index 00000000..24e4b6ff --- /dev/null +++ b/sys/pmio/tf/pmglpl.x @@ -0,0 +1,69 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_GLP -- Get a line segment as a pixel array, applying the given ROP to +# combine the pixels with those of the output array. + +procedure pm_glpl (pl, v, px_dst, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +long px_dst[ARB] #O output pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int temp, np, step, xstep +pointer sp, px_src, px_out, im +include "../pmio.com" + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glpl (pl, v, px_dst, px_depth, npix, rop) + return + } + + call smark (sp) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_LONG) + call pl_glpl (pl, v1, Meml[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Meml[px_src], Meml[px_src], npix, SZ_LONG, step) + if (xstep < 0) + call imaflp (Meml[px_src], npix, SZ_LONG) + + if (!R_NEED_DST(rop)) + call amovl (Meml[px_src], px_dst, npix) + else { + call salloc (px_out, npix, TY_LONG) + call pl_pixropl (Meml[px_src], 1, PL_MAXVAL(pl), px_dst, 1, + MV(px_depth), npix, rop) + call amovl (Meml[px_out], px_dst, npix) + } + + call sfree (sp) +end diff --git a/sys/pmio/tf/pmglps.x b/sys/pmio/tf/pmglps.x new file mode 100644 index 00000000..bcc50de4 --- /dev/null +++ b/sys/pmio/tf/pmglps.x @@ -0,0 +1,69 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_GLP -- Get a line segment as a pixel array, applying the given ROP to +# combine the pixels with those of the output array. + +procedure pm_glps (pl, v, px_dst, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +short px_dst[ARB] #O output pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int temp, np, step, xstep +pointer sp, px_src, px_out, im +include "../pmio.com" + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glps (pl, v, px_dst, px_depth, npix, rop) + return + } + + call smark (sp) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_SHORT) + call pl_glps (pl, v1, Mems[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Mems[px_src], Mems[px_src], npix, SZ_SHORT, step) + if (xstep < 0) + call imaflp (Mems[px_src], npix, SZ_SHORT) + + if (!R_NEED_DST(rop)) + call amovs (Mems[px_src], px_dst, npix) + else { + call salloc (px_out, npix, TY_SHORT) + call pl_pixrops (Mems[px_src], 1, PL_MAXVAL(pl), px_dst, 1, + MV(px_depth), npix, rop) + call amovs (Mems[px_out], px_dst, npix) + } + + call sfree (sp) +end diff --git a/sys/pmio/tf/pmglri.x b/sys/pmio/tf/pmglri.x new file mode 100644 index 00000000..3b3881f8 --- /dev/null +++ b/sys/pmio/tf/pmglri.x @@ -0,0 +1,81 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_GLR -- Get a line segment as a range list, applying the given ROP to +# combine the pixels with those of the output line list. Note that this +# operator uses IMIO if a section transformation is needed, hence if the +# application also uses IMIO to directly access the mask image, care must +# be taken to avoid confusion over the use of IMIO allocated pixel buffers. + +procedure pm_glri (pl, v, rl_dst, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +int rl_dst[3,ARB] #O output line list +int rl_depth #I line list depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int rl_len, temp, step, xstep, np +pointer sp, px_src, rl_src, rl_out, im +include "../pmio.com" +int pl_p2ri() + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glri (pl, v, rl_dst, rl_depth, npix, rop) + return + } + + call smark (sp) + call salloc (rl_src, RL_MAXLEN(pl), TY_INT) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_INT) + call pl_glpi (pl, v1, Memi[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Memi[px_src], Memi[px_src], npix, SZ_INT, step) + if (xstep < 0) + call imaflp (Memi[px_src], npix, SZ_INT) + + # Convert to a range list. + rl_len = pl_p2ri (Memi[px_src], 1, Memi[rl_src], npix) + + # Copy to or combine with destination. + if (!R_NEED_DST(rop)) { + rl_len = RLI_LEN(rl_src) * RL_LENELEM + call amovi (Memi[rl_src], rl_dst, rl_len) + } else { + call salloc (rl_out, RL_MAXLEN(pl), TY_INT) + call pl_rangeropi (Memi[rl_src], 1, PL_MAXVAL(pl), rl_dst, 1, + MV(rl_depth), Memi[rl_out], npix, rop) + rl_len = RLI_LEN(rl_out) * RL_LENELEM + call amovi (Memi[rl_out], rl_dst, rl_len) + } + + call sfree (sp) +end diff --git a/sys/pmio/tf/pmglrl.x b/sys/pmio/tf/pmglrl.x new file mode 100644 index 00000000..d78b891e --- /dev/null +++ b/sys/pmio/tf/pmglrl.x @@ -0,0 +1,81 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_GLR -- Get a line segment as a range list, applying the given ROP to +# combine the pixels with those of the output line list. Note that this +# operator uses IMIO if a section transformation is needed, hence if the +# application also uses IMIO to directly access the mask image, care must +# be taken to avoid confusion over the use of IMIO allocated pixel buffers. + +procedure pm_glrl (pl, v, rl_dst, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +long rl_dst[3,ARB] #O output line list +int rl_depth #I line list depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int rl_len, temp, step, xstep, np +pointer sp, px_src, rl_src, rl_out, im +include "../pmio.com" +int pl_p2rl() + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glrl (pl, v, rl_dst, rl_depth, npix, rop) + return + } + + call smark (sp) + call salloc (rl_src, RL_MAXLEN(pl), TY_LONG) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_LONG) + call pl_glpl (pl, v1, Meml[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Meml[px_src], Meml[px_src], npix, SZ_LONG, step) + if (xstep < 0) + call imaflp (Meml[px_src], npix, SZ_LONG) + + # Convert to a range list. + rl_len = pl_p2rl (Meml[px_src], 1, Meml[rl_src], npix) + + # Copy to or combine with destination. + if (!R_NEED_DST(rop)) { + rl_len = RLI_LEN(rl_src) * RL_LENELEM + call amovl (Meml[rl_src], rl_dst, rl_len) + } else { + call salloc (rl_out, RL_MAXLEN(pl), TY_LONG) + call pl_rangeropl (Meml[rl_src], 1, PL_MAXVAL(pl), rl_dst, 1, + MV(rl_depth), Meml[rl_out], npix, rop) + rl_len = RLI_LEN(rl_out) * RL_LENELEM + call amovl (Meml[rl_out], rl_dst, rl_len) + } + + call sfree (sp) +end diff --git a/sys/pmio/tf/pmglrs.x b/sys/pmio/tf/pmglrs.x new file mode 100644 index 00000000..79fea4f6 --- /dev/null +++ b/sys/pmio/tf/pmglrs.x @@ -0,0 +1,81 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <imhdr.h> +include <pmset.h> +include <plio.h> + +# PM_GLR -- Get a line segment as a range list, applying the given ROP to +# combine the pixels with those of the output line list. Note that this +# operator uses IMIO if a section transformation is needed, hence if the +# application also uses IMIO to directly access the mask image, care must +# be taken to avoid confusion over the use of IMIO allocated pixel buffers. + +procedure pm_glrs (pl, v, rl_dst, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +short rl_dst[3,ARB] #O output line list +int rl_depth #I line list depth, bits +int npix #I number of pixels desired +int rop #I rasterop + +int rl_len, temp, step, xstep, np +pointer sp, px_src, rl_src, rl_out, im +include "../pmio.com" +int pl_p2rs() + +begin + im = PM_REFIM(pl) + if (PM_MAPXY(pl) == NO) { + call pl_glrs (pl, v, rl_dst, rl_depth, npix, rop) + return + } + + call smark (sp) + call salloc (rl_src, RL_MAXLEN(pl), TY_SHORT) + + # Determine physical coords of line segment. + call amovl (v, v3, PM_MAXDIM) + call imaplv (im, v3, v1, PM_MAXDIM) + v3[1] = v3[1] + npix - 1 + call imaplv (im, v3, v2, PM_MAXDIM) + + # Get line scaling parameters. + if (npix <= 1) + xstep = 1 + else + xstep = (v2[1] - v1[1]) / (npix - 1) + step = xstep + if (xstep < 0) { + temp = v1[1]; v1[1] = v2[1]; v2[1] = temp + step = -step + } + + # Extract the pixels. + np = (npix - 1) * step + 1 + call salloc (px_src, np, TY_SHORT) + call pl_glps (pl, v1, Mems[px_src], 0, np, PIX_SRC) + + # Subsample and flip if necessary. + if (step > 1) + call imsamp (Mems[px_src], Mems[px_src], npix, SZ_SHORT, step) + if (xstep < 0) + call imaflp (Mems[px_src], npix, SZ_SHORT) + + # Convert to a range list. + rl_len = pl_p2rs (Mems[px_src], 1, Mems[rl_src], npix) + + # Copy to or combine with destination. + if (!R_NEED_DST(rop)) { + rl_len = RLI_LEN(rl_src) * RL_LENELEM + call amovs (Mems[rl_src], rl_dst, rl_len) + } else { + call salloc (rl_out, RL_MAXLEN(pl), TY_SHORT) + call pl_rangerops (Mems[rl_src], 1, PL_MAXVAL(pl), rl_dst, 1, + MV(rl_depth), Mems[rl_out], npix, rop) + rl_len = RLS_LEN(rl_out) * RL_LENELEM + call amovs (Mems[rl_out], rl_dst, rl_len) + } + + call sfree (sp) +end diff --git a/sys/pmio/tf/pmplpi.x b/sys/pmio/tf/pmplpi.x new file mode 100644 index 00000000..b62b333a --- /dev/null +++ b/sys/pmio/tf/pmplpi.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLP -- Put a line segment input as a pixel array a mask, applying the +# given ROP to combine the pixels with those of the mask. + +procedure pm_plpi (pl, v, px_src, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +int px_src[ARB] #I input pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_p2li() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plpi (pl, v, px_src, px_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_p2li (px_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], px_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/tf/pmplpl.x b/sys/pmio/tf/pmplpl.x new file mode 100644 index 00000000..2194d9f9 --- /dev/null +++ b/sys/pmio/tf/pmplpl.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLP -- Put a line segment input as a pixel array a mask, applying the +# given ROP to combine the pixels with those of the mask. + +procedure pm_plpl (pl, v, px_src, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +long px_src[ARB] #I input pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_p2ll() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plpl (pl, v, px_src, px_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_p2ll (px_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], px_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/tf/pmplps.x b/sys/pmio/tf/pmplps.x new file mode 100644 index 00000000..68e26f7d --- /dev/null +++ b/sys/pmio/tf/pmplps.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLP -- Put a line segment input as a pixel array a mask, applying the +# given ROP to combine the pixels with those of the mask. + +procedure pm_plps (pl, v, px_src, px_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +short px_src[ARB] #I input pixel array +int px_depth #I pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_p2ls() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plps (pl, v, px_src, px_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_p2ls (px_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], px_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/tf/pmplri.x b/sys/pmio/tf/pmplri.x new file mode 100644 index 00000000..4a2f1435 --- /dev/null +++ b/sys/pmio/tf/pmplri.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLR -- Put a line segment input as a range list to a mask, applying the +# given ROP to combine the pixels with those of the output mask. + +procedure pm_plri (pl, v, rl_src, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +int rl_src[3,ARB] #I input range list +int rl_depth #I range list pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_r2li() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plri (pl, v, rl_src, rl_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_r2li (rl_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], rl_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/tf/pmplrl.x b/sys/pmio/tf/pmplrl.x new file mode 100644 index 00000000..260daa21 --- /dev/null +++ b/sys/pmio/tf/pmplrl.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLR -- Put a line segment input as a range list to a mask, applying the +# given ROP to combine the pixels with those of the output mask. + +procedure pm_plrl (pl, v, rl_src, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +long rl_src[3,ARB] #I input range list +int rl_depth #I range list pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_r2ll() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plrl (pl, v, rl_src, rl_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_r2ll (rl_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], rl_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/tf/pmplrs.x b/sys/pmio/tf/pmplrs.x new file mode 100644 index 00000000..43b99b98 --- /dev/null +++ b/sys/pmio/tf/pmplrs.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <pmset.h> +include <plio.h> + +# PM_PLR -- Put a line segment input as a range list to a mask, applying the +# given ROP to combine the pixels with those of the output mask. + +procedure pm_plrs (pl, v, rl_src, rl_depth, npix, rop) + +pointer pl #I mask descriptor +long v[PL_MAXDIM] #I vector coords of line segment +short rl_src[3,ARB] #I input range list +int rl_depth #I range list pixel depth, bits +int npix #I number of pixels affected +int rop #I rasterop + +pointer sp, ll_src +int ll_len, pl_r2ls() +include "../pmio.com" + +begin + if (PM_MAPXY(pl) == NO) + call pl_plrs (pl, v, rl_src, rl_depth, npix, rop) + else { + call smark (sp) + call salloc (ll_src, LL_MAXLEN(pl), TY_SHORT) + + ll_len = pl_r2ls (rl_src, 1, Mems[ll_src], npix) + call pm_plls (pl, v, Mems[ll_src], rl_depth, npix, rop) + + call sfree (sp) + } +end diff --git a/sys/pmio/zzdebug.x b/sys/pmio/zzdebug.x new file mode 100644 index 00000000..e21e500d --- /dev/null +++ b/sys/pmio/zzdebug.x @@ -0,0 +1,217 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <error.h> +include <imhdr.h> +include <ctype.h> +include <fset.h> +include <pmset.h> +include <plio.h> + +task pmtest = t_pmtest, + mkmask = t_mkmask, + pmcopy = t_pmcopy, + mio = t_mio + + +# MKMASK -- Make a mask for the given image. + +procedure t_mkmask() + +char image[SZ_FNAME] +char mask[SZ_FNAME] +char cmdfile[SZ_FNAME] +char cmd[SZ_FNAME] + +pointer im, pm +int x, y, r, x1, y1, x2, y2, fd +pointer immap(), pm_newmask() +int open(), nscan(), fscan() +bool streq() + +begin + call clgstr ("image", image, SZ_FNAME) + call clgstr ("mask", mask, SZ_FNAME) + + # Open the image and an empty mask. + im = immap (image, READ_ONLY, 0) + pm = pm_newmask (im, 1) + + # Get the list of commands to be processed. + call clgstr ("cmdfile", cmdfile, SZ_FNAME) + fd = open (cmdfile, READ_ONLY, TEXT_FILE) + + # Process the commands and draw the mask. + while (fscan (fd) != EOF) { + call gargwrd (cmd, SZ_FNAME) + if (nscan() < 1) + break + + if (streq (cmd, "point")) { + # Command: point x y + call gargi (x) + call gargi (y) + if (nscan() < 3) { + call eprintf ("point: bad arg list\n") + next + } + + call eprintf ("point %d %d\n") + call pargi (x); call pargi (y) + call pm_point (pm, x, y, PIX_SET + PIX_VALUE(1)) + + } else if (streq (cmd, "circle")) { + # Command: circle x y r + call gargi (x) + call gargi (y) + call gargi (r) + if (nscan() < 4) { + call eprintf ("circle: bad arg list\n") + next + } + + call eprintf ("circle %d %d %d\n") + call pargi (x); call pargi (y); call pargi (r) + call pm_circle (pm, x, y, r, PIX_SET + PIX_VALUE(1)) + + } else if (streq (cmd, "box")) { + # Command: box x1 y1 x2 y2 + call gargi (x1); call gargi (y1) + call gargi (x2); call gargi (y2) + if (nscan() < 5) { + call eprintf ("box: bad arg list\n") + next + } + + call eprintf ("box %d %d %d %d\n") + call pargi (x1); call pargi (y1) + call pargi (x2); call pargi (y2) + call pm_box (pm, x1,y1, x2,y2, PIX_SET + PIX_VALUE(1)) + + } else { + call eprintf ("bad command %s\n") + call pargstr (cmd) + } + + # call pm_debug (pm, STDERR, 80, PD_INDEX) + } + + # Save the mask in a file. + call pm_savef (pm, mask, "mkmask", 0) + + call pm_close (pm) + call imunmap (im) +end + + +# PMCOPY -- Copy an image mask. + +procedure t_pmcopy + +char refim[SZ_FNAME] +char mask[SZ_FNAME], newmask[SZ_FNAME], title[SZ_LINE] + +pointer im, old_pm, new_pm +long vs[PM_MAXDIM], vn[PM_MAXDIM] +pointer immap(), pm_open(), pm_newmask() +int pm_stati() + +begin + call clgstr ("mask", mask, SZ_FNAME) + call clgstr ("refim", refim, SZ_FNAME) + call clgstr ("newmask", newmask, SZ_FNAME) + + # Open reference image. + im = immap (refim, READ_ONLY, 0) + + # Open old mask. + old_pm = pm_open (NULL) + call pm_loadf (old_pm, mask, title, SZ_LINE) + call pm_seti (old_pm, P_REFIM, im) + + # Create a new mask. + new_pm = pm_newmask (im, pm_stati(old_pm,P_DEPTH)) + + # Copy the mask. + call amovkl (1, vs, PM_MAXDIM) + call amovkl (IM_LEN(im,1), vn, PM_MAXDIM) + call pm_rop (old_pm, vs, new_pm, vs, vn, PIX_SRC) + + # Save in a file. + call pm_savef (new_pm, newmask, title, 0) + + call pm_close (new_pm) + call pm_close (old_pm) + call imunmap (im) +end + + +# MIO -- Test MIO. + +procedure t_mio() + +char image[SZ_FNAME] +char mask[SZ_FNAME] + +real rsum +pointer im, mp, pm, bp +bool debug, usefullimage +long v[IM_MAXDIM], vs[2], ve[2] +int mval, npix, totpix + +real asums() +bool clgetb() +pointer immap(), mio_open() +int clgeti(), mio_glsegs(), mio_stati(), clscan(), nscan() + +begin + call clgstr ("image", image, SZ_FNAME) + call clgstr ("mask", mask, SZ_FNAME) + debug = clgetb ("debug") + + im = immap (image, READ_ONLY, 0) + mp = mio_open (mask, clgeti("flags"), im) + + # The following assumes a 2D image. + usefullimage = true + if (clscan ("region") != EOF) { + call gargi(vs[1]); call gargi (vs[2]) + call gargi(ve[1]); call gargi (ve[2]) + usefullimage = (nscan() != 4) + } + if (usefullimage) { + call amovkl (1, vs, 2) + call amovl (IM_LEN(im,1), ve, 2) + } + call mio_setrange (mp, vs, ve, 2) + + if (debug) { + pm = mio_stati (mp, P_PMDES) + call pm_debug (pm, STDERR, 80, PD_LLOUT) + } + + totpix = 0 + rsum = 0.0 + + while (mio_glsegs (mp, bp, mval, v, npix) != EOF) { + if (debug) { + call eprintf ("x=%3d, y=%3d, n=%3d, mval=%o\n") + call pargl (v[1]) + call pargl (v[2]) + call pargi (npix) + call pargi (mval) + } + totpix = totpix + npix + rsum = rsum + asums (Mems[bp], npix) + } + + call eprintf ("totpix=%d, sum=%g, mean=%g\n") + call pargi (totpix) + call pargr (rsum) + if (totpix == 0) + call pargr (INDEFR) + else + call pargr (rsum / totpix) + + call mio_close (mp) + call imunmap (im) +end diff --git a/sys/pmio/zzinterp.x b/sys/pmio/zzinterp.x new file mode 100644 index 00000000..cd23aaf2 --- /dev/null +++ b/sys/pmio/zzinterp.x @@ -0,0 +1,1142 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <error.h> +include <ctype.h> +include <fset.h> +include <pmset.h> +include <plio.h> + +.help pmtest +.nf ------------------------------------------------------------------------- +PMTEST -- PMIO package debug and test facility. + + Due to the complexity of the PMIO package, testing is performed using an +interactive interpreter which reads commands from the standard input. +All commands operate internally upon a set of four mask registers A-D, +and a set of ten vector registers V[0-9]. + + a,b,c,d - mask registers + v0,...,v9 - vector registers + +The following commands are defined: + + help # print command summary + timer # toggle timing of commands + run fname # read commands from a file + clear # clear the screen + bye # all done (also EOF) + + create [mask] naxes axlen depth # create a new mask + load [mask] fname # load mask from file + save [mask] fname [title] # save mask in file + loadim [mask] image # load mask from image + saveim [mask] image [title] # save mask in image + erase [mask] [vs ve] # erase a mask or region + draw [mask] [vs ve] [>ofile] # draw mask or region of mask + + set [mask] # set reference mask + set [vector] i j k... # load vector register + show [vector] # print vector register + show [mask] [index] [ll] [rl] [>ofile] # print debug info for a mask + + box [mask] P1 P2 rop # draw a box + circle [mask] P1 r rop # draw a circle + line [mask] P1 P2 width rop # draw a line segment + point [mask] P1 rop # draw a point + polygon [mask] P1 ... PN rop # draw a polygon + + rop src [vs] dst [vs] [vn] rop # rasterop + stencil src [vs] dst [vs] stn [vs] [vn] rop # stencil + + compare mask1 mask2 # compare two masks + rtest mask1 mask2 # range list conversion test + ptest mask1 mask2 # pixel array conversion test + +Rasterops may be specified either as integer constants (any radix) or via +a simple symbolic notation, e.g.: "opcode+[value]". + +A mask may be examined in detail with SHOW, which calls pm_debug to decode +the contents of a mask. A graphic image of a mask may be drawn with DRAW, +which renders each pixel in the mask as a printable character. +.endhelp -------------------------------------------------------------------- + +define SZ_SBUF 512 # size limiting parameters +define DEF_MASKSIZE_X 75 +define DEF_MASKSIZE_Y 40 +define MAXKWLEN 20 +define MAXARGS 50 +define MAXMREG 4 +define MAXVREG 10 +define MAXINCL 10 +define WIDTH 80 + +define INT_ARG 1 # argument types +define STRING_ARG 2 +define VECTOR_ARG 3 +define MASK_ARG 4 + +define v_i argval[$1] # integer argument +define v_s sbuf[argval[$1]] # string argument +define v_si sbuf[argval[$1]+$2-1] # indexed string argument +define v_v v_reg[1,argval[$1]+1] # vector argument +define v_vi v_reg[$2,argval[$1]+1] # indexed vector argument +define v_m v_mask[argval[$1]] # mask argument + +define KW_BOX 1 # interpreter commands +define KW_BYE 2 +define KW_CIRCLE 3 +define KW_CLEAR 4 +define KW_COMPARE 5 +define KW_CREATE 6 +define KW_DRAW 7 +define KW_ERASE 8 +define KW_HELP 9 +# eol 10 +define KW_LINE 11 +define KW_POINT 12 +define KW_POLYGON 13 +define KW_LOAD 14 +define KW_LOADIM 15 +define KW_PTEST 16 +define KW_ROP 17 +define KW_RTEST 18 +define KW_RUN 19 +define KW_SAVE 20 +define KW_SAVEIM 21 +# eol 22 +define KW_SET 23 +define KW_SHOW 24 +define KW_STENCIL 25 +define KW_TIMER 26 + + +# PMTEST -- Test the PMIO package. Read and execute commands from the standard +# input until EOF or BYE is seen. + +procedure t_pmtest() + +bool timer +long time[2] +int x, y, r +int px[MAXARGS], py[MAXARGS] +int what, rop, v_arg, x1, x2, y1, y2, ip, op, ch, i, j +pointer pm, pm_1, pm_2, def_pm, pm_src, pm_dst, pm_stn, tty +char cmd[SZ_LINE], kwname[SZ_FNAME], fname[SZ_FNAME], title[SZ_LINE] +int opcode, save_fd[MAXINCL], in, fd, o_fd, maskno, depth, naxes, npts +int v1[PL_MAXDIM], v2[PL_MAXDIM], v3[PL_MAXDIM], v4[PL_MAXDIM], v[PL_MAXDIM] +int fstati(), strdic(), open(), getline(), strncmp() +pointer pm_create(), ttyodes() + +char sbuf[SZ_SBUF] +int v_mask[MAXMREG], v_reg[PL_MAXDIM,MAXVREG] +int nargs, argno, argtype[MAXARGS], argval[MAXARGS], s_op, width +common /pmzcom/ v_mask, v_reg, nargs, argno, argtype, argval, s_op, sbuf +define argerr_ 91 +define eof_ 92 + +string keywords "|box|bye|circle|clear|compare|create|draw|erase|help|\ + |line|point|polygon|load|loadim|ptest|rop|rtest|run|save|saveim|\ + |set|show|stencil|timer|" + +begin + in = 0 + ip = 1 + fd = STDIN + cmd[ip] = EOS + timer = false + + # Initialize the mask registers. + v[1] = DEF_MASKSIZE_X + v[2] = DEF_MASKSIZE_Y + do i = 1, MAXMREG + v_mask[i] = pm_create (2, v, 7) + def_pm = v_mask[1] + + # Initialize the vector registers. + do i = 1, MAXVREG + call amovki (1, v_reg[1,i], PL_MAXDIM) + + # Main interpreter loop. + # --------------------------- + + repeat { + # Get next command. + if (cmd[ip] == '\n' || cmd[ip] == '#' || cmd[ip] == EOS) { + # Prompt if reading from the standard input. + if (in == 0 && fstati (STDIN, F_REDIR) == NO) { + call putline (STDOUT, "* ") + call flush (STDOUT) + } + + # Handle EOF on the current command stream. + if (getline (fd, cmd) == EOF) { +eof_ if (in > 0) { + call close (fd) + fd = save_fd[in] + in = in - 1 + } else + break + } + + ip = 1 + } + + # Skip blank lines and comment lines. + for (ip=1; IS_WHITE(cmd[ip]) || cmd[ip] == ';'; ip=ip+1) + ; + if (cmd[ip] == '\n' || cmd[ip] == '#' || cmd[ip] == EOS) + next + + # Extract the keyword into the KWNAME buffer. Leave the input + # pointer positioned to the first char following the keyword. + + for (op=1; cmd[ip] != EOS && cmd[ip] != '\n'; ip=ip+1) { + ch = cmd[ip] + if (IS_ALNUM(ch)) { + kwname[op] = ch + op = op + 1 + } else + break + } + kwname[op] = EOS + + # Look up the keyword in the dictionary. If not found ring the + # bell, but do not quit. + + opcode = strdic (kwname, kwname, MAXKWLEN, keywords) + if (opcode <= 0) { + call eprintf ("unknown command\007\n") + call flush (STDERR) + ip=1; cmd[ip] = EOS + next + } + + # Parse the argument list. + call parse_args (cmd, ip) + + # Process the command. + # ------------------------- + + switch (opcode) { + case KW_BYE: + goto eof_ + + case KW_POINT: + # Draw a point. + + # Get mask. + pm = def_pm + if (argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get coords of point. + if (argtype[argno] == VECTOR_ARG) { + # Coords given as vectors. + x1 = v_vi(argno,1) + y1 = v_vi(argno,2) + argno = argno + 1 + } else { + # Coords given explicitly. + do i = 1, 2 + if (argtype[argno+i-1] != INT_ARG) + goto argerr_ + + x1 = v_i(argno); argno = argno + 1 + y1 = v_i(argno); argno = argno + 1 + } + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else + rop = or (PIX_SRC, PIX_DST) + PIX_VALUE('1') + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_point (pm, x1, y1, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_BOX: + # Draw a box. + + # Get mask. + pm = def_pm + if (argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get corner coords of box. + if (argtype[argno] == VECTOR_ARG) { + # Coords given as vectors. + x1 = v_vi(argno,1) + y1 = v_vi(argno,2) + argno = argno + 1 + if (argtype[argno] != VECTOR_ARG) + goto argerr_ + x2 = v_vi(argno,1) + y2 = v_vi(argno,2) + argno = argno + 1 + + } else { + # Coords given explicitly. + do i = 1, 4 + if (argtype[argno+i-1] != INT_ARG) + goto argerr_ + + x1 = v_i(argno); argno = argno + 1 + y1 = v_i(argno); argno = argno + 1 + x2 = v_i(argno); argno = argno + 1 + y2 = v_i(argno); argno = argno + 1 + } + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else + rop = or (PIX_SRC, PIX_DST) + PIX_VALUE('2') + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_box (pm, x1, y1, x2, y2, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_LINE: + # Draw a line of arbitrary orientation and width. + + # Get mask. + pm = def_pm + if (argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get endpoints of line. + if (argtype[argno] == VECTOR_ARG) { + # Coords given as vectors. + x1 = v_vi(argno,1) + y1 = v_vi(argno,2) + argno = argno + 1 + if (argtype[argno] != VECTOR_ARG) + goto argerr_ + x2 = v_vi(argno,1) + y2 = v_vi(argno,2) + argno = argno + 1 + + } else { + # Coords given explicitly. + do i = 1, 4 + if (argtype[argno+i-1] != INT_ARG) + goto argerr_ + + x1 = v_i(argno); argno = argno + 1 + y1 = v_i(argno); argno = argno + 1 + x2 = v_i(argno); argno = argno + 1 + y2 = v_i(argno); argno = argno + 1 + } + + # Get line width. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + width = v_i(argno); argno = argno + 1 + } else + width = 1 + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else + rop = or (PIX_SRC, PIX_DST) + PIX_VALUE('4') + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_line (pm, x1, y1, x2, y2, width, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_CIRCLE: + # Draw a circle. + + # Get mask. + pm = def_pm + if (argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get center coords and radius of circle. + if (argtype[argno] == VECTOR_ARG) { + # Center coords given as a vector. + x = v_vi(argno,1) + y = v_vi(argno,2) + argno = argno + 1 + + } else { + # Center coords given explicitly. + do i = 1, 2 + if (argtype[argno+i-1] != INT_ARG) + goto argerr_ + + x = v_i(argno); argno = argno + 1 + y = v_i(argno); argno = argno + 1 + } + + if (argtype[argno] != INT_ARG) + goto argerr_ + r = v_i(argno); argno = argno + 1 + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else + rop = or (PIX_SRC, PIX_DST) + PIX_VALUE('Q') + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_circle (pm, x, y, r, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_POLYGON: + # Draw a polygon. + + # Get mask. + pm = def_pm + if (argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get the coordinates of the polygon. + for (npts=0; argno <= nargs; ) { + npts = npts + 1 + + if (argtype[argno] == VECTOR_ARG) { + # Coords of point given as a vector. + px[npts] = v_vi(argno,1) + py[npts] = v_vi(argno,2) + argno = argno + 1 + + } else if (argtype[argno] == INT_ARG && + argtype[argno+1] == INT_ARG) { + + # Center coords given explicitly. + px[npts] = v_i(argno); argno = argno + 1 + py[npts] = v_i(argno); argno = argno + 1 + } + } + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else + rop = or (PIX_SRC, PIX_DST) + PIX_VALUE('R') + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_polygon (pm, px, py, npts, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_CLEAR: + # Clear the screen. + tty = ttyodes ("terminal") + call ttyclear (STDOUT, tty) + call ttycdes (tty) + + case KW_COMPARE: + # Compare two masks. + if (nargs < 2) + goto argerr_ + + # Get mask 1. + if (argtype[argno] == MASK_ARG) { + pm_1 = v_m(argno) + argno = argno + 1 + } else + goto argerr_ + + # Get mask 2. + if (argtype[argno] == MASK_ARG) { + pm_2 = v_m(argno) + argno = argno + 1 + } else + goto argerr_ + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_compare (pm_1, pm_2, STDOUT) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_CREATE: + # Create a new, emtpy mask of the given size and depth. + + # Get mask. + if (argtype[argno] == MASK_ARG) { + maskno = v_i(argno) + argno = argno + 1 + } + + # Get naxes. + if (argtype[argno] != INT_ARG) + goto argerr_ + naxes = v_i(argno); argno = argno + 1 + + # Get mask size. + if (argtype[argno] == VECTOR_ARG) { + # Mask size given as vector. + call amovi (v_v(argno), v1, PL_MAXDIM) + argno = argno + 1 + } else { + # Mask size given explicitly. + do i = 1, naxes { + if (argtype[argno+i-1] != INT_ARG) + goto argerr_ + v1[i] = v_i(argno) + argno = argno + 1 + } + } + + # Get mask depth. + if (argtype[argno] != INT_ARG) + depth = 1 + else { + depth = v_i(argno) + argno = argno + 1 + } + + # Perform the operation. + if (timer) + call sys_mtime (time) + v_mask[maskno] = pm_create (naxes, v1, depth) + def_pm = v_mask[maskno] + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_DRAW: + # Draw a mask or region of a mask on the screen. + + # Get mask. + pm = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get vector coords of region to be drawn. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v1, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v1, PL_MAXDIM) + + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v2, PL_MAXDIM) + argno = argno + 1 + } else + call amovi (PL_AXLEN(pm,1), v2, PL_MAXDIM) + + # Perform the operation. + call pm_asciidump (pm, v1, v2, STDOUT) + + case KW_ERASE: + # Erase a mask, or a region of a mask. + + # Get mask. + pm = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get vector coords of region to be erased. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v1, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v1, PL_MAXDIM) + + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v2, PL_MAXDIM) + argno = argno + 1 + } else + call amovi (PL_AXLEN(pm,1), v2, PL_MAXDIM) + + # Perform the operation. + if (timer) + call sys_mtime (time) + if (nargs <= 1) + call pm_clear (pm) + else + call pm_rop (NULL, 0, pm, v1, v2, PIX_CLR) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_HELP: + # Print a command summary. + call print_help (STDOUT) + + case KW_RUN: + # Read commands from a file. + if (nargs < 1 || argtype[argno] != STRING_ARG) + goto argerr_ + + in = in + 1 + if (in > MAXINCL) + call error (1, "too many nested run files\n") + save_fd[in] = fd + iferr (fd = open (v_s(argno), READ_ONLY, TEXT_FILE)) { + call erract (EA_WARN) + fd = save_fd[in] + in = in - 1 + } + + case KW_SET: + # Set the value of a mask or vector register. + if (nargs < 1) { + goto argerr_ + + } else if (argtype[argno] == MASK_ARG) { + # Set the default mask. + def_pm = v_m(argno) + maskno = v_i(argno) + + } else if (argtype[argno] == VECTOR_ARG) { + # Set a vector register. + v_arg = argno + argno = argno + 1 + + do i = 1, PL_MAXDIM + if (argno <= nargs && argtype[argno] == INT_ARG) { + v[i] = v_i(argno) + argno = argno + 1 + } else + v[i] = 1 + + call amovi (v, v_v(v_arg), PL_MAXDIM) + } + + case KW_SHOW: + # Print information about a mask or vector register. + + if (nargs < 1 || argtype[argno] == MASK_ARG) { + # Print information about a mask. + + if (nargs < 1) + pm = def_pm + else { + pm = v_m(argno) + argno = argno + 1 + } + + o_fd = STDOUT + + # Process option selects. + what = PD_SUMMARY + while (argno <= nargs && argtype[argno] == STRING_ARG) { + if (strncmp (v_s(argno), "i", 1) == 0) { + what = or (what, PD_INDEX) + } else if (strncmp (v_s(argno), "ll", 2) == 0) { + what = or (what, PD_LLOUT) + } else if (strncmp (v_s(argno), "rl", 2) == 0) { + what = or (what, PD_RLOUT) + } else if (strncmp (v_s(argno), "lh", 2) == 0) { + what = or (what, PD_LHDR) + + } else if (v_s(argno) == '>') { + # Write output to a file. + if (v_si(argno,2) == '>') { + iferr (o_fd = open (v_si(argno,3), + APPEND, TEXT_FILE)) { + call erract (EA_WARN) + o_fd = STDOUT + } + } else { + iferr (o_fd = open (v_si(argno,2), + NEW_FILE, TEXT_FILE)) { + call erract (EA_WARN) + o_fd = STDOUT + } + } + } else { + call eprintf ("unknown option `%s'\n") + call pargstr (v_s(argno)) + } + argno = argno + 1 + } + + # Perform the operation. + call pm_debug (pm, o_fd, WIDTH, what) + if (o_fd != STDOUT) + call close (o_fd) + + } else if (argtype[argno] == VECTOR_ARG) { + # Print the value of a vector register. + call printf ("v%d: ") + call pargi (v_i(argno)) + do i = 1, PL_MAXDIM { + call printf (" %d") + call pargi (v_vi(argno,i)) + } + call printf ("\n") + + } else { + # Print the value of all vector registers. + do j = 1, MAXVREG { + call printf ("v%d: ") + call pargi (j-1) + do i = 1, PL_MAXDIM { + call printf (" %d") + call pargi (v_reg(i,j)) + } + call printf ("\n") + } + } + + case KW_LOAD: + # Load a mask from a file. + + # Get mask to be loaded. + pm = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get mask filename. + if (argno > nargs || argtype[argno] != STRING_ARG) + goto argerr_ + + # Perform the operation. + if (timer) + call sys_mtime (time) + iferr (call pm_loadf (pm, v_s(argno), title, SZ_LINE)) + call erract (EA_WARN) + else if (title[1] != EOS) { + call printf ("mask: %s\n") + call pargstr (title) + call flush (STDOUT) + } + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_SAVE: + # Save a mask in a file. + + # Get mask to be saved. + pm = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get mask filename. + if (argno > nargs || argtype[argno] != STRING_ARG) + goto argerr_ + else { + call strcpy (v_s(argno), fname, SZ_FNAME) + argno = argno + 1 + } + + # Get title string. + if (argno <= nargs && argtype[argno] == STRING_ARG) { + call strcpy (v_s(argno), title, SZ_LINE) + argno = argno + 1 + } + + # Perform the operation. + if (timer) + call sys_mtime (time) + iferr (call pm_savef (pm, fname, title, 0)) + call erract (EA_WARN) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_LOADIM: + # Load a mask from an image. + + # Get mask to be loaded. + pm = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get image section. + if (argno > nargs || argtype[argno] != STRING_ARG) + goto argerr_ + + # Perform the operation. + if (timer) + call sys_mtime (time) + iferr (call pm_loadim (pm, v_s(argno), title, 0)) + call erract (EA_WARN) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_SAVEIM: + # Save a mask in an image. + + # Get mask to be saved. + pm = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm = v_m(argno) + argno = argno + 1 + } + + # Get output image name. + if (argno > nargs || argtype[argno] != STRING_ARG) + goto argerr_ + else { + call strcpy (v_s(argno), fname, SZ_FNAME) + argno = argno + 1 + } + + # Get title string. + if (argno <= nargs && argtype[argno] == STRING_ARG) { + call strcpy (v_s(argno), title, SZ_LINE) + argno = argno + 1 + } + + # Perform the operation. + if (timer) + call sys_mtime (time) + iferr (call pm_saveim (pm, fname, title, 0)) + call erract (EA_WARN) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_ROP: + # General rasterop operation. + + # Get source mask. + pm_src = def_pm + if (argtype[argno] == MASK_ARG) { + pm_src = v_m(argno) + argno = argno + 1 + } + + # Get start vector in source mask. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v1, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v1, PL_MAXDIM) + + # Get destination mask. + pm_dst = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm_dst = v_m(argno) + argno = argno + 1 + } + + # Get start vector in destination mask. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v2, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v2, PL_MAXDIM) + + # Get vector defining size of region to be modified. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v3, PL_MAXDIM) + argno = argno + 1 + } else + call amovi (PL_AXLEN(pm_dst,1), v3, PL_MAXDIM) + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else + rop = PIX_SRC + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_rop (pm_src, v1, pm_dst, v2, v3, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_STENCIL: + # Rasterop operation though a stencil mask. + + # Get source mask. + pm_src = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm_src = v_m(argno) + argno = argno + 1 + } + + # Get start vector in source mask. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v1, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v1, PL_MAXDIM) + + # Get destination mask. + pm_dst = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm_dst = v_m(argno) + argno = argno + 1 + } + + # Get start vector in destination mask. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v2, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v2, PL_MAXDIM) + + # Get stencil mask. + pm_stn = def_pm + if (nargs >= 1 && argtype[argno] == MASK_ARG) { + pm_stn = v_m(argno) + argno = argno + 1 + } + + # Get start vector in stencil mask. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v3, PL_MAXDIM) + argno = argno + 1 + } else + call amovki (1, v3, PL_MAXDIM) + + # Get vector defining size of region to be modified. + if (argtype[argno] == VECTOR_ARG) { + call amovi (v_v(argno), v4, PL_MAXDIM) + argno = argno + 1 + } else + call amovi (PL_AXLEN(pm_dst,1), v4, PL_MAXDIM) + + # Get rop. + if (argno <= nargs) { + if (argtype[argno] != INT_ARG) + goto argerr_ + rop = v_i(argno); argno = argno + 1 + } else { + call eprintf ("no rop specified - copying src to dst\n") + rop = PIX_SRC + } + + # Perform the operation. + if (timer) + call sys_mtime (time) + call pm_stencil (pm_src, v1, pm_dst, v2, pm_stn, v3, v4, rop) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_PTEST, KW_RTEST: + # Line list to pixel array or range list conversion test. + if (nargs < 2) + goto argerr_ + + # Get mask 1. + if (argtype[argno] == MASK_ARG) { + pm_1 = v_m(argno) + argno = argno + 1 + } else + goto argerr_ + + # Get mask 2. + if (argtype[argno] == MASK_ARG) { + pm_2 = v_m(argno) + argno = argno + 1 + } else + goto argerr_ + + # Perform the operation. + if (timer) + call sys_mtime (time) + call conv_test (pm_1, pm_2, STDOUT, opcode) + if (timer) + call sys_ptime (STDOUT, "", time) + + case KW_TIMER: + if (timer) { + call printf ("timer off\n") + timer = false + } else { + call printf ("timer on\n") + timer = true + } + + default: + # Unrecognized command. + call eprintf ("unknown switch\007\n") + call flush (STDERR) + } + + call flush (STDOUT) + next +argerr_ + call eprintf ("invalid argument list\n") + } + + do i = 1, MAXMREG + call pm_close (v_mask[i]) +end + + +# PARSE_ARGS -- Parse the argument list to an interpreter command, leaving +# the decoded arguments in the interpreter common, and returning the number +# of arguments as the function value. + +procedure parse_args (args, ip) + +char args[ARB] # argument list +int ip # pointer into argument list + +double dval +int nchars, junk, i +int ctowrd(), stridx(), gctod(), strlen() + +char sbuf[SZ_SBUF] +int v_mask[MAXMREG], v_reg[PL_MAXDIM,MAXVREG] +int nargs, argno, argtype[MAXARGS], argval[MAXARGS], s_op +common /pmzcom/ v_mask, v_reg, nargs, argno, argtype, argval, s_op, sbuf + +begin + s_op = 1 + argno = 1 + nargs = 0 + + do i = 1, MAXARGS + argtype[i] = 0 + + # Get next token. + junk = ctowrd (args, ip, sbuf[s_op], SZ_SBUF-s_op) + nchars = strlen (sbuf[s_op]) + + while (nchars > 0) { + nargs = nargs + 1 + if (nargs > MAXARGS) + call error (1, "too many arguments") + + if (nchars == 1 && sbuf[s_op] == '=') { + # Discard assignment operator. + nargs = nargs - 1 + + } else if (nchars == 1 && stridx (sbuf[s_op], "abcd") > 0) { + # Mask register. + argval[nargs] = stridx (sbuf[s_op], "abcd") + argtype[nargs] = MASK_ARG + + } else if (nchars == 2 && sbuf[s_op] == 'v' && + # Vector register. + IS_DIGIT(sbuf[s_op+1])) { + argval[nargs] = TO_INTEG(sbuf[s_op+1]) + argtype[nargs] = VECTOR_ARG + + } else if (IS_DIGIT (sbuf[s_op])) { + # Get an integer constant. + i=1; nchars = gctod (sbuf[s_op], i, dval) + argval[nargs] = nint(dval) + argtype[nargs] = INT_ARG + + # Handle the notation "opcode+value", for rasterops. + if (sbuf[s_op+i-1] == '+') { + i=i+1; nchars = gctod (sbuf[s_op], i, dval) + argval[nargs] = argval[nargs] + PIX_VALUE(nint(dval)) + } + + } else { + # String constant. + argval[nargs] = s_op + argtype[nargs] = STRING_ARG + s_op = s_op + nchars + 1 + } + + while (IS_WHITE(args[ip])) + ip = ip + 1 + if (args[ip] == ';' || args[ip] == '\n') { + ip = ip + 1 + break + } + + # Get next token. + junk = ctowrd (args, ip, sbuf[s_op], SZ_SBUF-s_op) + nchars = strlen (sbuf[s_op]) + } +end + + +# CONV_TEST -- Test the line list to pixel array or range list conversion +# routines. + +procedure conv_test (pm_1, pm_2, fd, opcode) + +pointer pm_1 #I input mask +pointer pm_2 #I output mask +int fd #I output file, for reporting errors +int opcode #I KW_[PR]TEST + +begin + call fprintf (fd, "conv_test called\n") +end + + +# PRINT_HELP -- Print the PMIO test interpreter commands help summary. + +procedure print_help (fd) + +int fd #I output file + +begin + call fprintf (fd, "help%48t# print command summary\n") + call fprintf (fd, "timer%48t# toggle timing of commands\n") + call fprintf (fd, "run fname%48t# read commands from a file\n") + call fprintf (fd, "clear%48t# clear the screen\n") + call fprintf (fd, "bye%48t# all done (also EOF)\n\n") + call fprintf (fd, + "create [mask] naxes axlen [depth]%48t# create a new mask\n") + call fprintf (fd, "load [mask] fname%48t# load mask from file\n") + call fprintf (fd, "save [mask] fname%48t# save mask in file\n") + call fprintf (fd, "loadim [mask] image%48t# load mask from image\n") + call fprintf (fd, "saveim [mask] image%48t# save mask in image\n") + call fprintf (fd, "erase [mask] [vs ve]%48t# erase a mask or region\n") + call fprintf (fd, + "draw [mask] [vs ve] [>ofile]%48t# draw mask or region of mask\n\n") + call fprintf (fd, "set [mask]%48t# set reference mask\n") + call fprintf (fd, "set [vector] i j k...%48t# load vector register\n") + call fprintf (fd, "show [vector]%48t# print vector register\n") + call fprintf (fd, +"show [mask] [index] [ll] [rl] [>ofile]%48t# print debug info for a mask\n\n") + call fprintf (fd, "box P1 P2 rop%48t# draw a box\n") + call fprintf (fd, "circle P1 r rop%48t# draw a circle\n \n") + call fprintf (fd, + "line [mask] P1 P2 width rop%48t# draw a line segment\n") + call fprintf (fd, "point [mask] P1 rop%48t# draw a point\n") + call fprintf (fd, "polygon [mask] P1 ... PN rop%48t# draw a polygon\n") + call fprintf (fd, "rop src [vs] dst [vs] [vn] rop%48t# rasterop\n") + call fprintf (fd, + "stencil src [vs] dst [vs] stn [vs] [vn] rop%48t# stencil\n \n") + call fprintf (fd, "compare mask1 mask2%48t# compare two masks\n") + call fprintf (fd, "rtest mask1 mask2%48t# range list conversion test\n") + call fprintf (fd, + "ptest mask1 mask2%48t# pixel array conversion test\n") +end |