aboutsummaryrefslogtreecommitdiff
path: root/pkg/proto/maskexpr/meregmask.x
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/proto/maskexpr/meregmask.x')
-rw-r--r--pkg/proto/maskexpr/meregmask.x753
1 files changed, 753 insertions, 0 deletions
diff --git a/pkg/proto/maskexpr/meregmask.x b/pkg/proto/maskexpr/meregmask.x
new file mode 100644
index 00000000..45db9079
--- /dev/null
+++ b/pkg/proto/maskexpr/meregmask.x
@@ -0,0 +1,753 @@
+include <mach.h>
+include <ctype.h>
+include <imhdr.h>
+include <imset.h>
+include <pmset.h>
+include <evvexpr.h>
+
+define DEF_LINELEN 8192
+
+define LEN_RGEXPR 25
+define RG_PMIM Memi[$1] # the mask image
+define RG_PMIBUF Memi[$1+1] # the mask input data
+define RG_IPMV Meml[P2L($1+2+($2)-1)] # input position in mask image
+define RG_OPMV Meml[P2L($1+9+($2)-1)] # output position in mask image
+
+
+# ME_RGMASK -- Given a region expression, a condition equals true expression,
+# a condition equals false expression, and an existing pixel mask imio
+# descriptor of dimensions, size of each dimension, and depth in bits create
+# a mask image and return an imio pointer to the mask.
+
+int procedure me_rgmask (rexpr, texpr, fexpr, pmim)
+
+char rexpr[ARB] #I the boolean region expression
+char texpr[ARB] #I the condition equals true expression
+char fexpr[ARB] #I the condition equals true expression
+pointer pmim #I the pixel mask imio descriptor
+
+pointer sp, rg, oexpr, expr, obuf
+int i, npix, nlines, depth, pmaxval, stat
+
+pointer evvexpr()
+int imstati(), locpr(), pm_stati()
+int imgnli(), impnli(), impnls(), impnll()
+extern rg_getop(), rg_fcn()
+
+begin
+ # Allocate some work space.
+ call smark (sp)
+ call salloc (expr, 3 * SZ_LINE, TY_CHAR)
+
+ # Allocate space for the mask expression structure.
+ call calloc (rg, LEN_RGEXPR, TY_STRUCT)
+ RG_PMIM(rg) = pmim
+
+ # Initalize the i/o pointers.
+ call amovkl (long(1), RG_OPMV(rg,1), IM_MAXDIM)
+ call amovkl (long(1), RG_IPMV(rg,1), IM_MAXDIM)
+
+ # Create the conditional expression to be evaluated.
+ call sprintf (Memc[expr], 3 * SZ_LINE, "(%s) ? %s : %s")
+ call pargstr (rexpr)
+ call pargstr (texpr)
+ call pargstr (fexpr)
+
+ # Compute the total number of output image lines.
+ npix = IM_LEN(pmim,1)
+ nlines = 1
+ do i = 2, IM_NDIM(pmim)
+ nlines = nlines * IM_LEN(pmim, i)
+ depth = INDEFI
+
+ # Loop over the mask output image lines which are by default always
+ # integer.
+ stat = OK
+ do i = 1, nlines {
+
+ # Get the input mask lines.
+ if (imgnli (pmim, RG_PMIBUF(rg), RG_IPMV(rg,1)) == EOF)
+ call error (2, "Error reading input mask data")
+
+ # Determine the depth of the mask.
+ if (IS_INDEFI(depth)) {
+ depth = pm_stati (imstati (pmim, IM_PLDES), P_DEPTH)
+ if (depth > 0) {
+ pmaxval = min (depth, PL_MAXDEPTH)
+ pmaxval = 2 ** depth - 1
+ } else
+ pmaxval = 2 ** PL_MAXDEPTH - 1
+ }
+
+ # Evalute the expression.
+ oexpr = evvexpr (Memc[expr], locpr(rg_getop), rg, locpr(rg_fcn),
+ rg, 0)
+ if (O_TYPE(oexpr) == ERR) {
+ call eprintf ("Error evaluting expression\n")
+ stat = ERR
+ break
+ }
+
+ # Copy the evaluated expression to the image.
+ if (O_LEN(oexpr) == 0) {
+ switch (O_TYPE(oexpr)) {
+ case TY_BOOL:
+ if (impnli (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixropi (NULL, 1, MAX_INT, Memi[obuf], 1, pmaxval,
+ npix, PIX_CLR + PIX_VALUE(O_VALI(oexpr)))
+ case TY_SHORT:
+ if (impnls (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixrops (NULL, 1, MAX_SHORT, Mems[obuf], 1,
+ pmaxval, npix, PIX_CLR + PIX_VALUE(O_VALS(oexpr)))
+ case TY_INT:
+ if (impnli (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixropi (NULL, 1, MAX_INT, Memi[obuf], 1,
+ pmaxval, npix, PIX_CLR + PIX_VALUE(O_VALI(oexpr)))
+ case TY_LONG:
+ if (impnll (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixropl (NULL, 1, MAX_LONG, Meml[obuf], 1,
+ pmaxval, npix, PIX_CLR + PIX_VALUE(O_VALL(oexpr)))
+ case TY_REAL:
+ call error (3, "Type real expressions are not supported")
+ case TY_DOUBLE:
+ call error (3, "Type double expressions are not supported")
+ default:
+ call error (3, "Unknown expression value type")
+ }
+
+ } else {
+ switch (O_TYPE(oexpr)) {
+ case TY_BOOL:
+ if (impnli (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixropi (Memi[O_VALP(oexpr)], 1, MAX_INT,
+ Memi[obuf], 1, pmaxval, npix, PIX_SRC)
+ case TY_SHORT:
+ if (impnls (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixrops (Mems[O_VALP(oexpr)], 1, MAX_SHORT,
+ Mems[obuf], 1, pmaxval, npix, PIX_SRC)
+ case TY_INT:
+ if (impnli (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixropi (Memi[O_VALP(oexpr)], 1, MAX_INT,
+ Memi[obuf], 1, pmaxval, npix, PIX_SRC)
+ case TY_LONG:
+ if (impnll (pmim, obuf, RG_OPMV(rg,1)) == EOF)
+ call error (2, "Error writing output mask data")
+ call pl_pixropl (Meml[O_VALP(oexpr)], 1, MAX_LONG,
+ Meml[obuf], 1, pmaxval, npix, PIX_SRC)
+ case TY_REAL:
+ call error (3, "Type real expressions are not supported")
+ case TY_DOUBLE:
+ call error (3, "Type double expressions are not supported")
+ default:
+ call error (3, "Unknown expression value type")
+ }
+ }
+
+ call evvfree (oexpr)
+ }
+
+ # Cleanup.
+ call mfree (rg, TY_STRUCT)
+
+ call sfree (sp)
+
+ return (stat)
+end
+
+
+# RG_GETOP -- Called by evvexpr to fetch an input image operand.
+
+procedure rg_getop (rg, opname, o)
+
+pointer rg #I mskexpr descriptor
+char opname[ARB] #I operand name
+pointer o #I output operand to be filled in
+
+pointer sp, param, data, im
+int i, axis
+int imgftype(), btoi()
+double imgetd()
+int imgeti()
+bool imgetb()
+errchk malloc
+define err_ 91
+
+begin
+ call smark (sp)
+
+ # Pixel image operand.
+ if ((opname[1] == 'p') && (opname[2] == EOS)) {
+
+ if (RG_PMIM(rg) == NULL)
+ goto err_
+
+ O_TYPE(o) = TY_INT
+ O_LEN(o) = IM_LEN(RG_PMIM(rg), 1)
+ O_FLAGS(o) = 0
+ O_VALP(o) = RG_PMIBUF(rg)
+
+ call sfree (sp)
+ return
+
+ # Reference image header parameter operand.
+ } else if ((opname[1] == 'p') && (opname[2] == '.')) {
+
+ im = RG_PMIM(rg)
+ if (im == NULL)
+ goto err_
+
+ # Get the parameter value and set up operand struct.
+ call salloc (param, SZ_FNAME, TY_CHAR)
+ call strcpy (opname[3], Memc[param], SZ_FNAME)
+ iferr (O_TYPE(o) = imgftype (im, Memc[param]))
+ goto err_
+
+ switch (O_TYPE(o)) {
+
+ case TY_BOOL:
+ O_LEN(o) = 0
+ iferr (O_VALI(o) = btoi (imgetb (im, Memc[param])))
+ goto err_
+
+ case TY_CHAR:
+ O_LEN(o) = SZ_LINE
+ O_FLAGS(o) = O_FREEVAL
+ iferr {
+ call malloc (O_VALP(o), SZ_LINE, TY_CHAR)
+ call imgstr (im, Memc[param], O_VALC(o), SZ_LINE)
+ } then
+ goto err_
+
+ case TY_SHORT, TY_INT, TY_LONG:
+ iferr (O_VALI(o) = imgeti (im, Memc[param]))
+ goto err_
+
+ case TY_REAL, TY_DOUBLE:
+ O_TYPE(o) = TY_DOUBLE
+ iferr (O_VALD(o) = imgetd (im, Memc[param]))
+ goto err_
+
+ default:
+ goto err_
+ }
+
+ call sfree (sp)
+ return
+
+ # The current pixel coordinate [I,J,K,...]. The line coordinate
+ # is a special case since the image is computed a line at a time.
+ # If "I" is requested return a vector where v[i] = i. For J, K,
+ # etc. just return the scalar index value.
+
+ } else if (IS_UPPER(opname[1]) && opname[2] == EOS) {
+
+ axis = opname[1] - 'I' + 1
+ if (axis == 1) {
+ O_TYPE(o) = TY_INT
+ if (IM_LEN(RG_PMIM(rg), 1) > 0)
+ O_LEN(o) = IM_LEN(RG_PMIM(rg), 1)
+ else
+ O_LEN(o) = DEF_LINELEN
+ call malloc (data, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[data+i-1] = i
+ O_VALP(o) = data
+ O_FLAGS(o) = O_FREEVAL
+ } else {
+ O_TYPE(o) = TY_INT
+ if (IM_LEN(RG_PMIM(rg), 1) > 0)
+ O_LEN(o) = IM_LEN(RG_PMIM(rg), 1)
+ else
+ O_LEN(o) = DEF_LINELEN
+ call malloc (data, O_LEN(o), TY_INT)
+ if (axis < 1 || axis > IM_MAXDIM)
+ call amovki (1, Memi[data], O_LEN(o))
+ else
+ call amovki (RG_OPMV(rg,axis), Memi[data], O_LEN(o))
+ O_VALP(o) = data
+ O_FLAGS(o) = O_FREEVAL
+ }
+
+ call sfree (sp)
+ return
+ }
+
+err_
+ O_TYPE(o) = ERR
+ call sfree (sp)
+end
+
+
+# define the builtin functions
+
+define RG_FUNCS "|circle|ellipse|box|rectangle|polygon|cols|lines|\
+vector|pie|cannulus|eannulus|rannulus|pannulus|point|"
+
+define RG_CIRCLE 1
+define RG_ELLIPSE 2
+define RG_BOX 3
+define RG_RECTANGLE 4
+define RG_POLYGON 5
+define RG_COLS 6
+define RG_LINES 7
+define RG_VECTOR 8
+define RG_PIE 9
+define RG_CANNULUS 10
+define RG_EANNULUS 11
+define RG_RANNULUS 12
+define RG_PANNULUS 13
+define RG_POINT 14
+
+
+# RG_FCN -- Called by evvexpr to execute a mskexpr special function.
+
+procedure rg_fcn (rg, fcn, args, nargs, o)
+
+pointer rg #I imexpr descriptor
+char fcn[ARB] #I function name
+pointer args[ARB] #I input arguments
+int nargs #I number of input arguments
+pointer o #I output operand to be filled in
+
+real width
+pointer sp, ufunc, rval1, rval2, orval1, orval2, ix, iy
+int i, ip, func, v_nargs, nver
+int strdic(), ctor()
+bool strne()
+
+begin
+ # Allocate working space.
+ call smark (sp)
+ call salloc (ufunc, SZ_LINE, TY_CHAR)
+
+ # Get the function.
+ func = strdic (fcn, Memc[ufunc], SZ_LINE, RG_FUNCS)
+ if (func > 0 && strne (fcn, Memc[ufunc]))
+ func = 0
+
+ # Test the function.
+ if (func <= 0) {
+ O_TYPE(o) = ERR
+ call sfree (sp)
+ return
+ }
+
+ # Determine number of arguments. This is a separate case statement.
+ # in case we need to deal with a variable number of arguments
+ # function at a later point.
+ switch (func) {
+ case RG_POINT, RG_CIRCLE, RG_ELLIPSE, RG_BOX, RG_RECTANGLE, RG_POLYGON:
+ v_nargs = -1
+ case RG_CANNULUS, RG_EANNULUS, RG_RANNULUS, RG_PANNULUS:
+ v_nargs = -1
+ case RG_COLS, RG_LINES:
+ v_nargs = -1
+ case RG_VECTOR, RG_PIE:
+ v_nargs = -1
+ default:
+ v_nargs = 0
+ }
+
+ # Check the number of arguments.
+ if (v_nargs > 0 && nargs != v_nargs) {
+ O_TYPE(o) = ERR
+ call sfree (sp)
+ return
+ }
+ if (v_nargs < 0 && nargs < abs (v_nargs)) {
+ O_TYPE(o) = ERR
+ call sfree (sp)
+ return
+ }
+
+ if (func == RG_POLYGON && nargs < 6) {
+ O_TYPE(o) = ERR
+ call sfree (sp)
+ return
+ }
+
+ # Type convert the arguments appropriately. At the moment this is
+ # simple if we assume that all the required arguments are real.
+ call salloc (rval1, nargs, TY_REAL)
+ call salloc (rval2, nargs, TY_REAL)
+ do i = 1, nargs {
+ switch (O_TYPE(args[i])) {
+ case TY_CHAR:
+ ip = 1
+ if (ctor (O_VALC(args[i]), ip, Memr[rval1+i-1]) == 0)
+ Memr[rval1+i-1] = 0.
+ case TY_INT:
+ Memr[rval1+i-1] = O_VALI(args[i])
+ case TY_REAL:
+ Memr[rval1+i-1] = O_VALR(args[i])
+ case TY_DOUBLE:
+ Memr[rval1+i-1] = O_VALD(args[i])
+ }
+ }
+
+ # Evaluate the function. Worry about some duplication of code later.
+ switch (func) {
+
+ case RG_CIRCLE:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 5) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_circle (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4])
+ } else if (nargs == 3) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_circle (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_ELLIPSE:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 7) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_ellipse (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5], Memr[rval1+6])
+ } else if (nargs == 5) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_ellipse (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_BOX:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 6) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_box (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5])
+ } else if (nargs == 4) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_box (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_RECTANGLE:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 7) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_rectangle (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5], Memr[rval1+6])
+ } else if (nargs == 5) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_rectangle (Memi[ix], Memi[iy], Memi[O_VALP(o)],
+ O_LEN(o), Memr[rval1], Memr[rval1+1], Memr[rval1+2],
+ Memr[rval1+3], Memr[rval1+4])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_POLYGON:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs < 6) {
+ O_TYPE(o) = ERR
+ } else if (O_LEN(args[1]) > 0 && O_LEN(args[2]) > 0) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ nver = (nargs - 2) / 2
+ do i = 1, nver
+ Memr[rval2+i-1] = Memr[rval1+2*i+1]
+ do i = 1, nver
+ Memr[rval1+i-1] = Memr[rval1+2*i]
+ call me_polygon (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1], Memr[rval2], nver)
+ } else {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ nver = nargs / 2
+ do i = 1, nver
+ Memr[rval2+i-1] = Memr[rval1+2*i-1]
+ do i = 1, nver
+ Memr[rval1+i-1] = Memr[rval1+2*i-2]
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_polygon (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval2], nver)
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ }
+
+ case RG_COLS:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 2) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_cols (Memi[O_VALP(args[1])], Memi[O_VALP(o)], O_LEN(o),
+ O_VALC(args[2]))
+ } else if (nargs == 1) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_cols (Memi[ix], Memi[O_VALP(o)], O_LEN(o),
+ O_VALC(args[1]))
+ call mfree (ix, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_LINES:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 2) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_lines (Memi[O_VALP(args[1])], Memi[O_VALP(o)], O_LEN(o),
+ O_VALC(args[2]))
+ } else if (nargs == 1) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call amovki (RG_OPMV(rg,2), Memi[ix], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_lines (Memi[ix], Memi[O_VALP(o)], O_LEN(o),
+ O_VALC(args[1]))
+ call mfree (ix, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_VECTOR:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 7) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_vector (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5], Memr[rval1+6])
+ } else if (nargs == 5) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_vector (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_PIE:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 6) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_pie (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5], IM_LEN(RG_PMIM(rg),1),
+ IM_LEN(RG_PMIM(rg),2))
+ } else if (nargs == 4) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_pie (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3],
+ IM_LEN(RG_PMIM(rg),1), IM_LEN(RG_PMIM(rg),2))
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_CANNULUS:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 6) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_cannulus (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5])
+ } else if (nargs == 4) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_cannulus (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_EANNULUS:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 8) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_eannulus (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5], Memr[rval1+6], Memr[rval1+7])
+ } else if (nargs == 6) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_eannulus (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_RANNULUS:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 8) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_rannulus (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5], Memr[rval1+6], Memr[rval1+7])
+ } else if (nargs == 6) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_rannulus (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1], Memr[rval1+2], Memr[rval1+3],
+ Memr[rval1+4], Memr[rval1+5])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+
+ case RG_PANNULUS:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs < 7) {
+ O_TYPE(o) = ERR
+ } else if (O_LEN(args[1]) > 0 && O_LEN(args[2]) > 0) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ width = Memr[rval1+2]
+ nver = (nargs - 3) / 2
+ do i = 1, nver
+ #Memr[rval2+i-1] = Memr[rval1+2*i+1]
+ Memr[rval2+i-1] = Memr[rval1+2*i+2]
+ do i = 1, nver
+ #Memr[rval1+i-1] = Memr[rval1+2*i+2]
+ Memr[rval1+i-1] = Memr[rval1+2*i+1]
+ call salloc (orval1, nver, TY_REAL)
+ call salloc (orval2, nver, TY_REAL)
+ call me_pyexpand (Memr[rval1], Memr[rval2], Memr[orval1],
+ Memr[orval2], nver, width)
+ call me_apolygon (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1], Memr[rval2],
+ Memr[orval1], Memr[orval2], nver)
+ } else {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ width = Memr[rval1]
+ nver = (nargs - 1) / 2
+ do i = 1, nver
+ Memr[rval2+i-1] = Memr[rval1+2*i]
+ do i = 1, nver
+ Memr[rval1+i-1] = Memr[rval1+2*i-1]
+ call salloc (orval1, nver, TY_REAL)
+ call salloc (orval2, nver, TY_REAL)
+ call me_pyexpand (Memr[rval1], Memr[rval2], Memr[orval1],
+ Memr[orval2], nver, width)
+ call me_apolygon (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval2], Memr[orval1], Memr[orval2], nver)
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ }
+
+ case RG_POINT:
+ O_LEN(o) = IM_LEN(RG_PMIM(rg),1)
+ O_TYPE(o) = TY_BOOL
+ if (nargs == 4) {
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_point (Memi[O_VALP(args[1])], Memi[O_VALP(args[2])],
+ Memi[O_VALP(o)], O_LEN(o), Memr[rval1+2], Memr[rval1+3])
+ } else if (nargs == 2) {
+ call malloc (ix, O_LEN(o), TY_INT)
+ call malloc (iy, O_LEN(o), TY_INT)
+ do i = 1, O_LEN(o)
+ Memi[ix+i-1] = i
+ call amovki (RG_OPMV(rg,2), Memi[iy], O_LEN(o))
+ call malloc (O_VALP(o), O_LEN(o), TY_INT)
+ call me_point (Memi[ix], Memi[iy], Memi[O_VALP(o)], O_LEN(o),
+ Memr[rval1], Memr[rval1+1])
+ call mfree (ix, TY_INT)
+ call mfree (iy, TY_INT)
+ } else {
+ O_TYPE(o) = ERR
+ }
+ default:
+ O_TYPE(o) = ERR
+ }
+
+ call sfree (sp)
+end
+
generated by cgit (git 2.34.1) at 2025-09-20 12:46:57 -0400