diff ./acedetect.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/acedetect.h
1c1
< # ACEALL parameter structure.
---
> # ACEDETECT parameter structure.
3c3
< define	PAR_LEN		243		# Length of parameter structure
---
> define	PAR_LEN		229		# Length of parameter structure
5,24c5,19
< define	PAR_TASK	Memc[P2C($1)]	# Task name (19)
< define	PAR_IMLIST	Memi[$1+$2+9]	# List of images (2)
< define	PAR_BPMLIST	Memi[$1+$2+11]	# List of bad pixel masks (2)
< define	PAR_SKYLIST	Memi[$1+$2+13]	# List of skys (2)
< define	PAR_SIGLIST	Memi[$1+$2+15]	# List of sigmas (2)
< define	PAR_EXPLIST	Memi[$1+$2+17]	# List of sigmas (2)
< define	PAR_GAINLIST	Memi[$1+$2+19]	# List of measurement gain maps (2)
< define	PAR_SCALELIST	Memi[$1+$2+21]	# List of scales (2)
< define	PAR_SPTLLIST	Memi[$1+$2+23]	# List of spatial scales (2)
< define	PAR_OFFSET	Memc[P2C($1+26)] # Offsets for difference matching
< define	PAR_OMLIST	Memi[$1+126]	# List of object masks
< define	PAR_INCATLIST	Memi[$1+127]	# List of input catalogs
< define	PAR_OUTCATLIST	Memi[$1+128]	# List of output catalogs
< define	PAR_CATDEFLIST	Memi[$1+129]	# List of catalog definitions
< define	PAR_LOGLIST	Memi[$1+130]	# List of log files
< define	PAR_OUTSKYLIST	Memi[$1+131]	# List of output sky images
< define	PAR_OUTSIGLIST	Memi[$1+132]	# List of output sigma images
< define	PAR_NMAXREC	Memi[$1+133]	# Maximum number of output records
< define	PAR_VERBOSE	Memi[$1+134]	# Verbose?
< define	PAR_UPDATE	Memi[$1+135]	# Update headers?
---
> define	PAR_IMLIST	Memi[$1+$2-1]	# List of images (2)
> define	PAR_BPMLIST	Memi[$1+$2+1]	# List of bad pixel masks (2)
> define	PAR_SKYLIST	Memi[$1+$2+3]	# List of skys (2)
> define	PAR_SIGLIST	Memi[$1+$2+5]	# List of sigmas (2)
> define	PAR_EXPLIST	Memi[$1+$2+7]	# List of sigmas (2)
> define	PAR_GAINLIST	Memi[$1+$2+9]	# List of measurement gain maps (2)
> define	PAR_SCALELIST	Memi[$1+$2+11]	# List of scales (2)
> define	PAR_OMLIST	Memi[$1+14]	# List of object masks
> define	PAR_INCATLIST	Memi[$1+15]	# List of input catalogs
> define	PAR_OUTCATLIST	Memi[$1+16]	# List of output catalogs
> define	PAR_CATDEFLIST	Memi[$1+17]	# List of catalog definitions
> define	PAR_CATFILTER	Memc[P2C($1+18)] # Output catalog filter
> define	PAR_LOGLIST	Memi[$1+119]	# List of log files
> define	PAR_OUTSKYLIST	Memi[$1+120]	# List of output sky images
> define	PAR_OUTSIGLIST	Memi[$1+121]	# List of output sigma images
26,31c21,25
< define	PAR_SKY		Memi[$1+136]	# Sky parameters
< define	PAR_DET		Memi[$1+137]	# Detection parameters
< define	PAR_SPT		Memi[$1+138]	# Split parameters
< define	PAR_GRW		Memi[$1+139]	# Grow parameters
< define	PAR_EVL		Memi[$1+140]	# Evaluate parameters
< define	PAR_FLT		Memi[$1+141]	# Filter parameters
---
> define	PAR_SKY		Memi[$1+122]	# Sky parameters
> define	PAR_DET		Memi[$1+123]	# Detection parameters
> define	PAR_SPT		Memi[$1+124]	# Split parameters
> define	PAR_GRW		Memi[$1+125]	# Grow parameters
> define	PAR_EVL		Memi[$1+126]	# Evaluate parameters
33,34c27,28
< define	PAR_OMTYPE	Memi[$1+142]	# Output object mask type
< define	PAR_EXTNAMES	Memc[P2C($1+143)] # Extensions names
---
> define	PAR_OMTYPE	Memi[$1+127]	# Output object mask type
> define	PAR_EXTNAMES	Memc[P2C($1+128)] # Extensions names
diff ./ace.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/ace.h
4,10c4,9
< define	MASK_NUM	000777777B	# Mask number
< define	MASK_GRW	001000000B	# Grow pixel
< define	MASK_SPLIT	002000000B	# Split flag
< define	MASK_BNDRY	004000000B	# Boundary flag
< define	MASK_BP		010000000B	# Bad pixel
< define	MASK_BPFLAG	020000000B	# Bad pixel flag
< define	MASK_DARK	040000000B	# Dark flag
---
> define	MASK_NUM	0017777777B	# Mask number
> define	MASK_BP		0020000000B	# Bad pixel
> define	MASK_BPFLAG	0040000000B	# Bad pixel flag
> define	MASK_BNDRY	0100000000B	# Boundary flag
> define	MASK_SPLIT	0200000000B	# Split flag
> define	MASK_DARK	0400000000B	# Dark flag
16,17d14
< define	MNOTGRW		(andi($1,MASK_GRW)==0)
< define	MGRW		(andi($1,MASK_GRW)!=0)
30,31c27,28
< define	OM_TYPES		"|boolean|numbers|all|bboolean|bnumbers|"
< define	OM_BOOL		1	# Boolean (0=sky, 1=object+bad+grow)
---
> define	OM_TYPES		"|boolean|numbers|colors|all|"
> define	OM_BOOL		1	# Boolean (0=sky, 1=object+bad)
33,35c30,31
< define	OM_ALL		3	# All values
< define	OM_BBOOL	4	# Boolean (0=sky, 1=object+bad+grow)
< define	OM_BONUM	5	# Object number only
---
> define	OM_COLORS	3	# Bad=1, Objects=2-9
> define	OM_ALL		4	# All values
diff ./acematch.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/acematch.h
1c1
< # CATMATCH.H -- Catalog information required by the task.
---
> # ACEXYMATCH.H -- Catalog information required by the task.
11,16c11,16
< define	ACM_RA		RECD($1,ID_RA)
< define	ACM_DEC		RECD($1,ID_DEC)
< define	ACM_MAG		RECD($1,ID_MAG)
< define	ACM_X		RECD($1,ID_X)
< define	ACM_Y		RECD($1,ID_Y)
< define	ACM_PTR		RECI($1,ID_PTR)
---
> define	XYM_RA		RECD($1,ID_RA)
> define	XYM_DEC		RECD($1,ID_DEC)
> define	XYM_MAG		RECD($1,ID_MAG)
> define	XYM_X		RECD($1,ID_X)
> define	XYM_Y		RECD($1,ID_Y)
> define	XYM_PTR		RECI($1,ID_PTR)
diff ./acesetwcs.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/acesetwcs.h
3,6c3,6
< define	ID_RA		 0 # d hr %.2f		/ X world coordinate
< define	ID_DEC		 2 # d deg %.2f		/ Y world coordinate
< define	ID_X		 4 # r pixels %.2f	/ X aperture coordinate
< define	ID_Y		 5 # r pixels %.2f	/ Y aperture coordinate
---
> define	ID_WX		 0 # d pixels %.2h	/ X world coordinate
> define	ID_WY		 2 # d pixels %.2h	/ Y world coordinate
> define	ID_PX		 4 # d pixels %.2f	/ X aperture coordinate
> define	ID_PY		 5 # d pixels %.2f	/ Y aperture coordinate
8,11c8,11
< define	OBJ_RA		RECD($1,ID_RA)		# X world coordinate
< define	OBJ_DEC		RECD($1,ID_DEC)		# Y world coordinate
< define	OBJ_X		RECR($1,ID_X)		# X aperture coordinate
< define	OBJ_Y		RECR($1,ID_Y)		# Y aperture coordinate
---
> define	OBJ_WX		RECD($1,ID_WX)		# X world coordinate
> define	OBJ_WY		RECD($1,ID_WY)		# Y world coordinate
> define	OBJ_PX		RECD($1,ID_PX)		# X aperture coordinate
> define	OBJ_PY		RECD($1,ID_PY)		# Y aperture coordinate
diff ./bndry.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/bndry.x
13c13
< int	i, c, c1, c2, l, nc, nl, num, numc, bndryval, bndryvalg, val, vallast
---
> int	i, c, c1, c2, l, nc, nl, num, numc, bndryval, val, vallast
15c15
< int	numg, num1l, num1c, num1r, num3l, num3c, num3r
---
> int	num1l, num1c, num1r, num3l, num3c, num3r
137c137
< 		bndryval = MSETFLAG(num,MASK_BNDRY)
---
> 		bndryval = MSETFLAG (num, MASK_BNDRY)
154,162c154,160
< 		    numg = MUNSETFLAG(num,MASK_BP+MASK_GRW)
< 		    bndryvalg = MUNSETFLAG(bndryval,MASK_BP+MASK_GRW)
< 		    num1l = MUNSETFLAG(Memi[buf1+c-1],MASK_BP+MASK_GRW)
< 		    num1c = MUNSETFLAG(Memi[buf1+c],MASK_BP+MASK_GRW)
< 		    num1r = MUNSETFLAG(Memi[buf1+c+1],MASK_BP+MASK_GRW)
< 		    num3l = MUNSETFLAG(Memi[buf3+c-1],MASK_BP+MASK_GRW)
< 		    num3c = MUNSETFLAG(Memi[buf3+c],MASK_BP+MASK_GRW)
< 		    num3r = MUNSETFLAG(Memi[buf3+c+1],MASK_BP+MASK_GRW)
< 		    if (num3l != numg)
---
> 		    num1l = MUNSETFLAG(Memi[buf1+c-1],MASK_BP)
> 		    num1c = MUNSETFLAG(Memi[buf1+c],MASK_BP)
> 		    num1r = MUNSETFLAG(Memi[buf1+c+1],MASK_BP)
> 		    num3l = MUNSETFLAG(Memi[buf3+c-1],MASK_BP)
> 		    num3c = MUNSETFLAG(Memi[buf3+c],MASK_BP)
> 		    num3r = MUNSETFLAG(Memi[buf3+c+1],MASK_BP)
> 		    if (num3l != num)
164c162
< 		    else if (num3c != numg)
---
> 		    else if (num3c != num)
166c164
< 		    else if (num3r != numg)
---
> 		    else if (num3r != num)
168c166
< 		    else if (num1l != numg && num1l != bndryvalg)
---
> 		    else if (num1l != num && num1l != bndryval)
170c168
< 		    else if (num1c != numg && num1c != bndryvalg)
---
> 		    else if (num1c != num && num1c != bndryval)
172c170
< 		    else if (num1r != numg && num1r != bndryvalg)
---
> 		    else if (num1r != num && num1r != bndryval)
206a205
> 
diff ./cat.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/cat.h
36c36
< define	ENTRY_LEN	96			# Length of entry structure
---
> define	ENTRY_LEN	95			# Length of entry structure
diff ./catshape.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/catshape.x
5d4
< include	<aceobjs1.h>
40,41c39,40
< 	x2 = OBJ_XX(obj)
< 	y2 = OBJ_YY(obj)
---
> 	x2 = OBJ_X2(obj)
> 	y2 = OBJ_Y2(obj)
66,67c65
< 	r = sqrt (r2 / 2)
< 	#r = sqrt (r2)
---
> 	r = sqrt (PI * r2 / 4)
diff ./convolve.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/convolve.x
6,7c6,7
< # CONVOLVE -- Get a line of data possibly convolved.  Also get the unconvolved
< # data, the sky data, the sky sigma data, and exposure map data.
---
> # ODCNV -- Get a line of data possibly convolved.  Also get the unconvolved
> # data, the sky data, and the sky sigma data.
14,15c14
< 	line, cnv, scnv, indata, bp, cnvdata, scnvdata, skydata, sigdata,
< 	expdata, cnvwt, logfd, verbose)
---
> 	line, cnv, indata, bp, cnvdata, skydata, sigdata, expdata, cnvwt, logfd)
29d27
< int	scnv		#I Convolve sky?
33d30
< pointer	scnvdata	#O Pointer to possibly convolved sky data
39d35
< int	verbose		#I Verbose level
42c38
< real	wts, wts1, wts2, asumr()
---
> real	wts, wts1
46,48c42
< pointer	kernel, sym, symbuf, symwts
< pointer bpbuf, bpwts, wtsl, scales
< pointer	buf, buf2, buf3
---
> pointer	kernel, sym, symbuf, symwts, buf, buf2, buf3, bpbuf, bpwts, wtsl, scales
50,51c44,45
< data	bpbuf/NULL/, bpwts/NULL/, wtsl/NULL/, scales/NULL/
< data	buf/NULL/, buf2/NULL/, buf3/NULL/
---
> data	buf/NULL/, buf2/NULL/, buf3/NULL/, bpbuf/NULL/, bpwts/NULL/
> data	wtsl/NULL/, scales/NULL/
56,62d49
< 	if (scnv == YES) {
< 	    call convolves (in, bpm, sky, sig, exp, bpval, bpdet, bpflg,
< 		offset, scale, line, cnv, scnv, indata, bp, cnvdata, scnvdata,
< 		skydata, sigdata, expdata, cnvwt, logfd, verbose)
< 	    return
< 	}
< 
68,69c55
< 	    call cnvgline1 (line, offset, in, bpm, indata,
< 	        bp, bpval, bpdet, bpflg)
---
> 	    call cnvgline1 (line, offset, in, bpm, indata, bp, bpval, bpdet, bpflg)
78,79d63
< 	    scnvdata = skydata[1]
< 
83c67
< 	# Free memory and reinitialize.
---
> 	# Free memory.
155c139
< 	    call cnvparse (cnv, kernel, nx, ny, i, logfd, verbose)
---
> 	    call cnvparse (cnv, kernel, nx, ny, logfd)
162,170d145
< 	    wts1 = 0; wts2 = 0; kptr = kernel
< 	    do i = 1, nx*ny {
< 		wts = Memr[kptr]
< 	        wts1 = wts1 + wts
< 		wts2 = wts2 + wts * wts
< 		kptr = kptr + 1
< 	    }
< 	    cnvwt = wts1 / sqrt (wts2)
< 
174c149
< 		wts1 = 0.
---
> 		wts = 0.
177c152
< 			wts1 = 0.
---
> 			wts = 0.
180,181c155,156
< 		    if (wts1 == 0.)
< 			wts1 = Memr[kptr+k] / Memr[kernel+k]
---
> 		    if (wts == 0.)
> 			wts = Memr[kptr+k] / Memr[kernel+k]
183,184c158,159
< 			wts2 = Memr[kptr+k] / Memr[kernel+k]
< 			if (!fp_equalr (wts1, wts2))
---
> 			wts1 = Memr[kptr+k] / Memr[kernel+k]
> 			if (!fp_equalr (wts, wts1))
188,189c163,164
< 		if (wts1 != 0. && fp_equalr (wts1, wts2)) {
< 		    Memr[scales+i-1] = wts1
---
> 		if (wts != 0. && fp_equalr (wts, wts1)) {
> 		    Memr[scales+i-1] = wts
194c169
< 	    wts1 = 0
---
> 	    wts = 0
197c172
< 		wts2 = 0.
---
> 		wts1 = 0.
199c174
< 		    wts2 = wts2 + Memr[kptr]
---
> 		    wts1 = wts1 + Memr[kptr]
202,212c177,184
< 		wts2 = wts2 * Memr[scales+i-1]
< 		Memr[wtsl+i-1] = wts2
< 		wts1 = wts1 + wts2
< 	    }
< 	    if (wts1 != 0.) {
< 		call adivkr (Memr[wtsl], wts1, Memr[wtsl], ny)
< 		call adivkr (Memr[kernel], wts1, Memr[kernel], nx*ny)
< 	    }
< 	    wts1 = asumr (Memr[kernel], nx) * asumr(Memr[scales],ny)
< 	    if (wts1 > 0)
< 		call adivkr (Memr[scales], wts1, Memr[scales], ny)
---
> 		Memr[wtsl+i-1] = wts1
> 		wts = wts + wts1
> 	    }
> 	    if (wts != 0.) {
> 		call adivkr (Memr[wtsl], wts, Memr[wtsl], ny)
> 		call adivkr (Memr[kernel], wts, Memr[kernel], nx*ny)
> 	    }
> 	    cnvwt = sqrt (wts)
376,806d347
< 	scnvdata = skydata[1]
< end
< 
< 
< # CONVOLVES -- Get a line of convolved data.  Also get the unconvolved
< # data, the sky data, sigma data, and exposure data.
< #
< # This routine must be called sequentially starting with the first line.
< # It is initialized when the first line.  Memory is freed by using a final
< # call with a line of zero.
< 
< procedure convolves (in, bpm, sky, sig, exp, bpval, bpdet, bpflg, offset, scale,
< 	line, cnv, scnv, indata, bp, cnvdata, scnvdata, skydata, sigdata,
< 	expdata, cnvwt, logfd, verbose)
< 
< pointer	in[2]		#I Image pointers
< pointer	bpm[2]		#I BPM pointer
< pointer	sky[2]		#I Sky map
< pointer	sig[2]		#I Sigma map
< pointer	exp[2]		#I Exposure map
< int	bpval		#I Output bad pixel value
< int	bpdet		#I Detection bad pixel ranges
< int	bpflg		#I Flag bad pixel ranges
< int	offset[2]	#I Offsets
< real	scale[2]	#I Image scales
< int	line		#I Line
< char	cnv[ARB]	#I Convolution string
< int	scnv		#I Convolve sky?
< pointer	indata[2]	#O Pointers to unconvolved image data
< pointer	bp		#O Bad pixel data
< pointer	cnvdata		#O Pointer to convolved image data
< pointer	scnvdata	#O Pointer to convolved sky data
< pointer	skydata[2]	#O Pointer to sky data
< pointer	sigdata[2]	#O Pointer to sigma data corrected by exposure map
< pointer	expdata[2]	#O Pointer to exposure map data
< real	cnvwt		#O Weight for convolved sigma
< int	logfd		#I Logfile
< int	verbose		#I Verbose level
< 
< int	i, j, k,  nx, ny, nx2, ny2, nc, nl, mode, off
< real	wts, wts1, wts2, asumr()
< pointer	bpm2, kptr, ptr, sptr, symptr, symwptr
< bool	dobpm, overlap, fp_equalr()
< 
< pointer	kernel, sym, symbuf, symwts
< pointer bpbuf, bpwts, wtsl, scales
< pointer	buf, buf2, buf3
< pointer	sbuf, sbuf2, sbuf3
< pointer	sigbuf, sigbuf2
< pointer	ebuf, ebuf2
< data	kernel/NULL/, sym/NULL/, symbuf/NULL/, symwts/NULL/
< data	bpbuf/NULL/, bpwts/NULL/, wtsl/NULL/, scales/NULL/
< data	buf/NULL/, buf2/NULL/, buf3/NULL/
< data	sbuf/NULL/, sbuf2/NULL/, sbuf3/NULL/
< data	sigbuf/NULL/, sigbuf2/NULL/
< data	ebuf/NULL/, ebuf2/NULL/
< 
< errchk	cnvparse, cnvgline2
< 
< begin
< 	# If no convolution.
< 	if (cnv[1] == EOS) {
< 	    if (line == 0)
< 		return
< 
< 	    call cnvgline1 (line, offset, in, bpm, indata,
< 	        bp, bpval, bpdet, bpflg)
< 	    call cnvgline2 (line, offset, in, sky, sig, exp, skydata,
< 		sigdata, expdata)
< 	    cnvwt = 1
< 	    if (in[2] == NULL)
< 		cnvdata = indata[1]
< 	    else
< 		call asubr_scale (Memr[indata[1]], scale[1],
< 		    Memr[indata[2]], scale[2], Memr[cnvdata], IM_LEN(in[1],1))
< 	    scnvdata = skydata[1]
< 
< 	    return
< 	}
< 
< 	# Free memory and initialize.
< 	if (line == 0) {
< 	    if (symbuf != NULL) {
< 		do i = 0, ARB {
< 		    ptr = Memi[symbuf+i]
< 		    if (ptr == -1)
< 			break
< 		    call mfree (ptr, TY_REAL)
< 		}
< 	    }
< 	    if (symwts != NULL) {
< 		do i = 0, ARB {
< 		    ptr = Memi[symwts+i]
< 		    if (ptr == -1)
< 			break
< 		    call mfree (ptr, TY_REAL)
< 		}
< 	    }
< 	    call mfree (scnvdata, TY_REAL)
< 	    call mfree (scales, TY_REAL)
< 	    call mfree (wtsl, TY_REAL)
< 	    call mfree (kernel, TY_REAL)
< 	    call mfree (scales, TY_REAL)
< 	    call mfree (sym, TY_INT)
< 	    call mfree (symbuf, TY_POINTER)
< 	    call mfree (symwts, TY_POINTER)
< 	    call mfree (buf, TY_REAL)
< 	    call mfree (buf2, TY_REAL)
< 	    call mfree (buf3, TY_REAL)
< 	    call mfree (bpbuf, TY_REAL)
< 	    call mfree (bpwts, TY_REAL)
< 	    call mfree (sbuf, TY_REAL)
< 	    call mfree (sbuf2, TY_REAL)
< 	    call mfree (sbuf3, TY_REAL)
< 	    call mfree (sigbuf, TY_REAL)
< 	    call mfree (ebuf, TY_REAL)
< 
< 	    return
< 	}
< 
< 	# Initialize by getting the kernel coefficients, setting the
< 	# image I/O buffers using a scrolling array, and allocate memory.
< 
< 	if (line == 1 || buf == NULL) {
< 	    if (buf != NULL) {
< 		if (symbuf != NULL) {
< 		    do i = 0, ARB {
< 			ptr = Memi[symbuf+i]
< 			if (ptr == -1)
< 			    break
< 			call mfree (ptr, TY_REAL)
< 		    }
< 		}
< 		if (symwts != NULL) {
< 		    do i = 0, ARB {
< 			ptr = Memi[symwts+i]
< 			if (ptr == -1)
< 			    break
< 			call mfree (ptr, TY_REAL)
< 		    }
< 		}
< 		call mfree (scnvdata, TY_REAL)
< 		call mfree (scales, TY_REAL)
< 		call mfree (wtsl, TY_REAL)
< 		call mfree (kernel, TY_REAL)
< 		call mfree (scales, TY_REAL)
< 		call mfree (sym, TY_INT)
< 		call mfree (symbuf, TY_POINTER)
< 		call mfree (symwts, TY_POINTER)
< 		call mfree (buf, TY_REAL)
< 		call mfree (buf2, TY_REAL)
< 		call mfree (buf3, TY_REAL)
< 		call mfree (bpbuf, TY_REAL)
< 		call mfree (bpwts, TY_REAL)
< 		call mfree (sbuf, TY_REAL)
< 		call mfree (sbuf2, TY_REAL)
< 		call mfree (sbuf3, TY_REAL)
< 		call mfree (sigbuf, TY_REAL)
< 		call mfree (ebuf, TY_REAL)
< 	    }
< 
< 	    nc = IM_LEN(in[1],1)
< 	    nl = IM_LEN(in[1],2)
< 
< 	    call cnvparse (cnv, kernel, nx, ny, i, logfd, verbose)
< 	    nx2 = nx / 2
< 	    ny2 = ny / 2
< 	    call malloc (scnvdata, nc, TY_REAL)
< 	    call malloc (scales, ny, TY_REAL)
< 	    call calloc (wtsl, ny, TY_REAL)
< 	    call amovkr (1., Memr[scales], ny)
< 
< 	    wts1 = 0; wts2 = 0; kptr = kernel
< 	    do i = 1, nx*ny {
< 		wts = Memr[kptr]
< 	        wts1 = wts1 + wts
< 		wts2 = wts2 + wts * wts
< 		kptr = kptr + 1
< 	    }
< 	    cnvwt = wts1 / sqrt (wts2)
< 
< 	    # Check for lines which are simple scalings of the first line.
< 	    do i = 2, ny {
< 		kptr = kernel + (i - 1) * nx
< 		wts1 = 0.
< 		do k = 0, nx-1 {
< 		    if (Memr[kptr+k] == 0. || Memr[kernel+k] == 0.) {
< 			wts1 = 0.
< 			break
< 		    }
< 		    if (wts1 == 0.)
< 			wts1 = Memr[kptr+k] / Memr[kernel+k]
< 		    else {
< 			wts2 = Memr[kptr+k] / Memr[kernel+k]
< 			if (!fp_equalr (wts1, wts2))
< 			    break
< 		    }
< 		}
< 		if (wts1 != 0. && fp_equalr (wts1, wts2)) {
< 		    Memr[scales+i-1] = wts1
< 		    call amovr (Memr[kernel], Memr[kptr], nx)
< 		}
< 	    }
< 
< 	    wts1 = 0
< 	    do i = 1, ny {
< 		kptr = kernel + (i - 1) * nx
< 		wts2 = 0.
< 		do j = 1, nx {
< 		    wts2 = wts2 + Memr[kptr]
< 		    kptr = kptr + 1
< 		}
< 		wts2 = wts2 * Memr[scales+i-1]
< 		Memr[wtsl+i-1] = wts2
< 		wts1 = wts1 + wts2
< 	    }
< 	    if (wts1 != 0.) {
< 		call adivkr (Memr[wtsl], wts1, Memr[wtsl], ny)
< 		call adivkr (Memr[kernel], wts1, Memr[kernel], nx*ny)
< 	    }
< 	    wts1 = asumr (Memr[kernel], nx) * asumr(Memr[scales],ny)
< 	    if (wts1 > 0)
< 		call adivkr (Memr[scales], wts1, Memr[scales], ny)
< 
< 	    if (in[2] == NULL)
< 		bpm2 = NULL
< 	    else
< 		bpm2 = bpm[2] 
< 	    if (bpm[1] == NULL && bpm2 == NULL)
< 		dobpm = false
< 	    else
< 		dobpm = true
< 	    if (dobpm) {
< 		call malloc (bpbuf, nc*ny, TY_REAL)
< 		call malloc (bpwts, nc, TY_REAL)
< 		call calloc (symwts, ny*ny+1, TY_POINTER)
< 		Memi[symwts+ny*ny] = -1
< 	    }
< 
< 	    # Check for any line symmetries in the kernel.
< 	    call malloc (sym, ny, TY_INT)
< 	    call calloc (symbuf, ny*ny+1, TY_POINTER)
< 	    Memi[symbuf+ny*ny] = -1
< 	    do i = ny, 1, -1 {
< 		kptr = kernel + (i - 1) * nx
< 		do j = ny, 1, -1 {
< 		    ptr = kernel + (j - 1) * nx
< 		    do k = 0, nx-1 {
< 			if (Memr[kptr+k] != Memr[ptr+k])
< 			    break
< 		    }
< 		    if (k == nx) {
< 			Memi[sym+i-1] = j
< 			break
< 		    }
< 		}
< 	    }
< 	    do i = ny, 1, -1 {
< 		k = 0
< 		do j = ny, 1, -1
< 		    if (Memi[sym+j-1] == i)
< 			k = k + 1
< 		if (k == 1)
< 		    Memi[sym+i-1] = 0
< 	    }
< 
< 	    call malloc (buf, nc*ny, TY_REAL)
< 	    call malloc (sbuf, nc*ny, TY_REAL)
< 	    call malloc (sigbuf, nc*ny, TY_REAL)
< 	    call malloc (ebuf, nc*ny, TY_REAL)
< 	    if (in[2] != NULL) {
< 		call malloc (buf2, nc*ny, TY_REAL)
< 		call malloc (buf3, nc*ny, TY_REAL)
< 		call malloc (sbuf2, nc*ny, TY_REAL)
< 		call malloc (sbuf3, nc*ny, TY_REAL)
< 		call malloc (sigbuf2, nc*ny, TY_REAL)
< 		call malloc (ebuf2, nc*ny, TY_REAL)
< 	    }
< 
< 	    if (in[2] != NULL) {
< 		overlap = true
< 		if (1-offset[1] < 1 || nc-offset[1] > IM_LEN(in[2],1))
< 		    overlap = false
< 		if (1-offset[2] < 1 || nl-offset[2] > IM_LEN(in[2],2))
< 		    overlap = false
< 	    }
< 	    do i = 1, ny {
< 		call cnvgline1 (i, offset, in, bpm, indata, bp, bpval,
< 		    bpdet, bpflg)
< 		call cnvgline2 (i, offset, in, sky, sig, exp, skydata, sigdata,
< 		   expdata)
< 		off = mod (i, ny) * nc
< 		call amovr (Memr[indata[1]], Memr[buf+off], nc)
< 		call amovr (Memr[skydata[1]], Memr[sbuf+off], nc)
< 		call amovr (Memr[sigdata[1]], Memr[sigbuf+off], nc)
< 		call amovr (Memr[expdata[1]], Memr[ebuf+off], nc)
< 		if (in[2] != NULL) {
< 		    call amovr (Memr[indata[2]], Memr[buf2+off], nc)
< 		    call amovr (Memr[sigdata[2]], Memr[sigbuf2+off], nc)
< 		    call amovr (Memr[expdata[2]], Memr[ebuf2+off], nc)
< 		    call asubr_scale (Memr[buf+off], scale[1],
< 			Memr[buf2+off], scale[2], Memr[buf3+off], nc)
< 		}
< 		if (dobpm)
< 		    call amovi (Memi[bp], Memi[bpbuf+off], nc)
< 	    }
< 	}
< 
< 	# Get new line.
< 	j = line +  ny2
< 	if (j > ny && j <= nl) {
< 	    call cnvgline1 (j, offset, in, bpm, indata, bp, bpval, bpdet, bpflg)
< 	    call cnvgline2 (j, offset, in, sky, sig, exp, skydata, sigdata,
< 	       expdata)
< 	    off = mod (j, ny) * nc
< 	    call amovr (Memr[indata[1]], Memr[buf+off], nc)
< 	    call amovr (Memr[skydata[1]], Memr[sbuf+off], nc)
< 	    call amovr (Memr[sigdata[1]], Memr[sigbuf+off], nc)
< 	    call amovr (Memr[expdata[1]], Memr[ebuf+off], nc)
< 	    if (in[2] != NULL) {
< 		call amovr (Memr[indata[2]], Memr[buf2+off], nc)
< 		call asubr_scale (Memr[buf+off], scale[1],
< 		    Memr[buf2+off], scale[2], Memr[buf3+off], nc)
< 		call amovr (Memr[skydata[2]], Memr[sbuf2+off], nc)
< 		call amovr (Memr[sigdata[2]], Memr[sigbuf2+off], nc)
< 		call amovr (Memr[expdata[2]], Memr[ebuf2+off], nc)
< 		call asubr_scale (Memr[sbuf+off], scale[1],
< 		    Memr[sbuf2+off], scale[2], Memr[sbuf3+off], nc)
< 	    }
< 	    if (dobpm) {
< 		ptr = bpbuf + off
< 		call amovi (Memi[bp], Memi[ptr], nc)
< 	    }
< 	}
< 
< 	# Compute the convolution vector with boundary reflection.
< 	# Save and reuse lines with the same kernel weights apart
< 	# from a scale factor.
< 
< 	kptr = kernel
< 	call aclrr (Memr[cnvdata], nc)
< 	call aclrr (Memr[scnvdata], nc)
< 	if (dobpm)
< 	    call aclrr (Memr[bpwts], nc)
< 	do i = 1, ny {
< 	    j = line + i - ny2 - 1
< 	    if (j < 1)
< 		j = 2 - j
< 	    else if (j > nl)
< 		j = 2 * nl - j
< 	    off = mod (j, ny) * nc
< 	    if (in[2] == NULL) {
< 		ptr = buf
< 		sptr = sbuf
< 	    } else {
< 		ptr = buf3
< 		sptr = sbuf3
< 	    }
< 	    k = Memi[sym+i-1]
< 	    if (k == 0) {
< 		mode = 1
< 		symptr = ptr
< 		symwptr = bpwts
< 	    } else {
< 		if (k == i)
< 		    mode = 2
< 		else
< 		    mode = 3
< 		symptr = Memi[symbuf+(k-1)*ny+mod(j,ny)]
< 		if (symptr == NULL) {
< 		    call malloc (symptr, nc, TY_REAL)
< 		    Memi[symbuf+(k-1)*ny+mod(j,ny)] = symptr
< 		    mode = 2
< 		}
< 		if (dobpm) {
< 		    symwptr = Memi[symwts+(k-1)*ny+mod(j,ny)]
< 		    if (symwptr == NULL) {
< 			call malloc (symwptr, nc, TY_REAL)
< 			Memi[symwts+(k-1)*ny+mod(j,ny)] = symwptr
< 		    }
< 		}
< 	    }
< 	    if (dobpm) {
< 		call convolve2 (Memr[ptr+off], Memr[cnvdata], Memr[symptr],
< 		    nc, Memr[kptr], Memr[scales+i-1], nx, Memi[bpbuf+off],
< 		    Memr[wtsl+i-1], Memr[bpwts], Memr[symwptr], mode)
< 		call convolve2 (Memr[sptr+off], Memr[scnvdata], Memr[symptr],
< 		    nc, Memr[kptr], Memr[scales+i-1], nx, Memi[bpbuf+off],
< 		    Memr[wtsl+i-1], Memr[bpwts], Memr[symwptr], mode)
< 	    } else {
< 		call convolve1 (Memr[ptr+off], Memr[cnvdata], Memr[symptr],
< 		    nc, Memr[kptr], Memr[scales+i-1], nx, mode)
< 		call convolve1 (Memr[sptr+off], Memr[scnvdata], Memr[symptr],
< 		    nc, Memr[kptr], Memr[scales+i-1], nx, mode)
< 	    }
< 	    kptr = kptr + nx
< 	}
< 	if (dobpm) {
< 	    do i = 0, nc-1 {
< 		if (Memr[bpwts+i] != 0.) {
< 		    Memr[cnvdata+i] = Memr[cnvdata+i] / Memr[bpwts+i]
< 		    Memr[scnvdata+i] = Memr[scnvdata+i] / Memr[bpwts+i]
< 		}
< 	    }
< 	}
< 
< 	# Set the output vectors.
< 	off = mod (line, ny) * nc
< 	indata[1] = buf + off 
< 	skydata[1] = sbuf + off 
< 	sigdata[1] = sigbuf + off 
< 	expdata[1] = ebuf + off 
< 	if (dobpm) {
< 	    if (bpm2 == NULL)
< 		bp = bpbuf + off
< 	    else
< 		call amovi (Memi[bpbuf+off], Memi[bp], nc)
< 	}
< 	if (in[2] != NULL) {
< 	    if (overlap) {
< 		indata[2] = buf2 + off
< 		skydata[2] = sbuf2 + off
< 		sigdata[2] = sigbuf2 + off
< 		expdata[2] = ebuf2 + off
< 	    } else {
< 		call amovr (Memr[buf2+off], Memr[indata[2]], nc)
< 		call amovr (Memr[sbuf2+off], Memr[skydata[2]], nc)
< 		call amovr (Memr[sigbuf2+off], Memr[sigdata[2]], nc)
< 		call amovr (Memr[ebuf2+off], Memr[expdata[2]], nc)
< 	    }
< 	}
807a349
> 	
810c352
< # CONVOLVE1 --  One dimensional convolution with boundary reflection.
---
> # ODCNV1 --  One dimensional convolution with boundary reflection.
908c450
< # CONVOLVE2 --  One dimensional convolution with boundary reflection & masking.
---
> # ODCNV2 --  One dimensional convolution with boundary reflection and masking.
1090c632
< int	nl1, nl2, loff, l2
---
> int	i, j, nl1, nl2, loff, l2
1151c693
< 	    call amovki (1, Memi[bp], nc1)
---
> 	    call amovi (1, Memi[bp], nc1)
1344c886
< procedure cnvparse (cnvstr, kernel, nx, ny, scnv, logfd, verbose)
---
> procedure cnvparse (cnvstr, kernel, nx, ny, logfd)
1349d890
< int	scnv			#O Convolve sky?
1351d891
< int	verbose			#I Verbose level
1362c902,903
< 	# Determine if the sky should be convolved.
---
> 	kernel = NULL
> 
1365,1371d905
< 	if (strncmp (cnvstr[ip], "sky", 3) == 0) {
< 	    scnv = YES
< 	    ip = ip + 3
< 	    for (;IS_WHITE(cnvstr[ip]); ip=ip+1)
< 		;
< 	} else
< 	    scnv = NO
1373,1374d906
< 	# Parse the convolution function.
< 	kernel = NULL
1376d907
< 	    scnv = NO
1491,1494c1022
< 	    if (scnv == YES)
< 		call fprintf (logfd, "    Convolution for input and sky:\n")
< 	    else
< 		call fprintf (logfd, "    Convolution:\n")
---
> 	    call fprintf (logfd, "    Convolution:\n")
1505,1520c1033
< 	if (verbose > 1) {
< 	    ptr = kernel
< 	    if (scnv == YES)
< 		call printf ("    Convolution for input and sky:\n")
< 	    else
< 		call printf ("    Convolution:\n")
< 	    do j = 1, ny {
< 		call printf ("     ")
< 		do i = 1, nx {
< 		    call printf (" %7.3g")
< 			call pargr (Memr[ptr])
< 		    ptr = ptr + 1
< 		}
< 		call printf ("\n")
< 	    }
< 	}
---
> 
diff ./detect.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/detect.h
4c4
< define	DET_LEN		(64+2*DET_BPLEN)	# Length of parameter structure
---
> define	DET_LEN		(62+2*DET_BPLEN)	# Length of parameter structure
8,22c8,20
< define	DET_SCNV	Memi[$1+51]	# Convovle sky?
< define	DET_HSIG	Memr[$1+52]	# High detection sigma
< define	DET_LSIG	Memr[$1+53]	# Low detection sigma
< define	DET_HDETECT	Memi[$1+54]	# Detect above sky?
< define	DET_LDETECT	Memi[$1+55]	# Detect below sky?
< define	DET_NEIGHBORS	Memi[$1+56]	# Neighbor type
< define	DET_MINPIX	Memi[$1+57]	# Minimum number of pixels
< define	DET_SIGAVG	Memr[$1+58]	# Minimum average above sky in sigma
< define	DET_SIGPEAK	Memr[$1+59]	# Minimum peak above sky in sigma
< define	DET_FRAC2	Memr[$1+60]	# Fraction of difference relative to 2
< define	DET_BPVAL	Memi[$1+61]	# Output bad pixel value
< define	DET_SKB		Memi[$1+62]	# Parameters for sky update
< define	DET_UPDSKY	Memi[$1+63]	# Update sky?
< define	DET_BPDET	Memi[$1+64]		# BP ranges
< define	DET_BPFLG	Memi[$1+64+DET_BPLEN]	# BP ranges
---
> define	DET_HSIG	Memr[$1+51]	# High detection sigma
> define	DET_LSIG	Memr[$1+52]	# Low detection sigma
> define	DET_HDETECT	Memi[$1+53]	# Detect above sky?
> define	DET_LDETECT	Memi[$1+54]	# Detect below sky?
> define	DET_NEIGHBORS	Memi[$1+55]	# Neighbor type
> define	DET_MINPIX	Memi[$1+56]	# Minimum number of pixels
> define	DET_SIGAVG	Memr[$1+57]	# Minimum average above sky in sigma
> define	DET_SIGPEAK	Memr[$1+58]	# Minimum peak above sky in sigma
> define	DET_FRAC2	Memr[$1+59]	# Fraction of difference relative to 2
> define	DET_BPVAL	Memi[$1+60]	# Output bad pixel value
> define	DET_SKB		Memi[$1+61]	# Parameters for sky update
> define	DET_BPDET	Memi[$1+62]		# BP ranges
> define	DET_BPFLG	Memi[$1+62+DET_BPLEN]	# BP ranges
diff ./detect.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/detect.x
3a4
> include	"ace.h"
7,8d7
< include	<aceobjs1.h>
< include	"ace.h"
11d9
< include	"sky.h"
21c19
< procedure detect (det, sky, spt, dosky, dosig, skyname, signame, im, bpm,
---
> procedure detect (det, spt, dosky, dosig, skyname, signame, im, bpm,
23c21
< 	logfd, verbose, cat)
---
> 	logfd, cat)
26d23
< pointer	sky			#I Sky parameter structure
42,43c39
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
---
> int	logfd			#I Verbose?
48d43
< int	scnv			# Convolve sky?
62c57
< pointer	indata[2], bp, skydata[2], sigdata[2], expdata[2], cnvdata, scnvdata
---
> pointer	indata[2], bp, skydata[2], sigdata[2], expdata[2], cnvdata
66a62
> 
84,87d79
< 	if (im[2] == NULL)
< 	    scnv = SKY_SCNV(sky)
< 	else
< 	    scnv = NO
168,169d159
< 	if (verbose > 1)
< 	    call printf ("  Detect objects:\n")
183,186c173,175
< 		bpval, DET_BPDET(det), DET_BPFLG(det), offset,
< 		scale, l, Memc[cnv], scnv, indata, bp, cnvdata, scnvdata,
< 		skydata, sigdata, expdata, cnvwt, logfd, verbose)
< 
---
> 	        bpval, DET_BPDET(det), DET_BPFLG(det), offset,
> 		scale, l, Memc[cnv], indata, bp, cnvdata, skydata,
> 		sigdata, expdata, cnvwt, logfd)
188c177,178
< 	    call detect1 (det, spt, skb, Memr[indata[1]], Memr[scnvdata],
---
> 
> 	    call detect1 (det, spt, skb, Memr[indata[1]], Memr[skydata[1]],
205,206c195,196
< 	    scale, 0, Memc[cnv], scnv, indata, bp, cnvdata, scnvdata,
< 	    skydata, sigdata, expdata, cnvwt, logfd, verbose)
---
> 	    scale, 0, Memc[cnv], indata, bp, cnvdata, skydata,
> 	    sigdata, expdata, cnvwt, logfd)
213c203
< 	call drenum (det, out, Memi[ids], Memi[objs], nobjs, CAT_RECLEN(cat))
---
> 	call drenum (det, out, Memi[ids], Memi[objs], nobjs)
245,248d234
< 	if (verbose > 1) {
< 	    call printf ("    %d objects detected\n")
< 		call pargi (nobjs - NUMSTART + 1)
< 	}
252c238
< 	        skymap, sigmap, logfd, verbose)
---
> 	        skymap, sigmap, logfd)
608c594
< 	    OBJ_ISIGAV(obj) = 0.
---
> 	    OBJ_ISIGAVG2(obj) = 0.
629c615
< 		OBJ_ISIGAV(obj) = OBJ_ISIGAV(obj) + OBJ_ISIGAV(obj1)
---
> 		OBJ_ISIGAVG2(obj) = OBJ_ISIGAVG2(obj) + OBJ_ISIGAVG2(obj1)
659,660c645,646
< 	#OBJ_ISIGAV(obj) = OBJ_ISIGAV(obj) + (data2 - sky2) / sigma2
< 	OBJ_ISIGAV(obj) = OBJ_ISIGAV(obj) + (data2 - sky2) / sigma
---
> 	#OBJ_ISIGAVG2(obj) = OBJ_ISIGAVG2(obj) + (data2 - sky2) / sigma2
> 	OBJ_ISIGAVG2(obj) = OBJ_ISIGAVG2(obj) + (data2 - sky2) / sigma
666c652
< procedure drenum (det, out, ids, objs, nobjs, objlen)
---
> procedure drenum (det, out, ids, objs, nobjs)
673d658
< int	objlen		#I Length of object record
711,712c696,697
< 	    OBJ_ISIGAV(obj) = OBJ_ISIGAV(obj) / rval
< 	    if (OBJ_ISIGAVG(obj) < frac * OBJ_ISIGAV(obj)) {
---
> 	    OBJ_ISIGAVG2(obj) = OBJ_ISIGAVG2(obj) / rval
> 	    if (OBJ_ISIGAVG(obj) < frac * OBJ_ISIGAVG2(obj)) {
744c729
< 	    call newobj (obj, objlen)
---
> 	    call newobj (obj)
800c785
< procedure newobj (obj, objlen)
---
> procedure newobj (obj)
803d787
< int	objlen		#I Length of object record
809c793
< 	call realloc (obj, objlen, TY_STRUCT)
---
> 	call realloc (obj, OBJ_LEN, TY_STRUCT)
814,816c798
< 	OBJ_XPEAK(obj) = INDEFR
< 	OBJ_YPEAK(obj) = INDEFR
< 	OBJ_GWFLUX(obj) = INDEFR
---
> 	OBJ_FCORE(obj) = INDEFR
819,825c801,804
< 	OBJ_X(obj) = INDEFR
< 	OBJ_Y(obj) = INDEFR
< 	OBJ_XX(obj) = INDEFR
< 	OBJ_YY(obj) = INDEFR
< 	OBJ_XY(obj) = INDEFR
< 	OBJ_EAELLIP(obj) = INDEFR
< 	OBJ_EATHETA(obj) = INDEFR
---
> 	OBJ_X1(obj) = INDEFR
> 	OBJ_Y1(obj) = INDEFR
> 	OBJ_WX(obj) = INDEFD
> 	OBJ_WY(obj) = INDEFD
diff ./evaluate.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/evaluate.h
4c4
< define	EVL_LEN		102			# Parameters structure length
---
> define	EVL_LEN		51			# Parameters structure length
7,9d6
< define	EVL_ORDER	Memc[P2C($1)+$2+50]	# Order expression
< define	EVL_GWTSIG	Memr[$1+100]		# Sigma for stellar flux wt
< define	EVL_GWTNSIG	Memr[$1+101]		# Number of sig for centroids
diff ./evaluate.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/evaluate.x
2,3d1
< include	<mach.h>
< include	<evvexpr.h>
10d7
< include	<aceobjs1.h>
13,14d9
< include	"eaflux.h"
< include	"gwt.h"
28a24,32
> #
> # The structure of this routine has up to three passes depending on which
> # centers are defined.  If the aperture centers are defined then only one
> # pass is needed.  If they are not defined and the peak centers are defined
> # then two passes are needed with the aperture centers first computed based
> # on a core centroid.  If the peak centers are also not defined then three
> # passes are needed; 1) compute the peak center, 2) compute the aperture
> # center based on the core centroid, and 3) evaluate the quantities that
> # depend on the aperture center.
30,31c34
< procedure evaluate (evl, cat, im, om, skymap, sigmap, gainmap, expmap,
< 	sptlmap, logfd, verbose)
---
> procedure evaluate (evl, cat, im, om, skymap, sigmap, gainmap, expmap, logfd)
41,49c44,48
< pointer	sptlmap			#I Spatial scale map
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
< 
< bool	grw, bndry
< bool	dogwt, docaf, doeaf
< int	i, j, n, c, l, nc, nl, c1, c2, nummax, num, nobjsap, fw_nbins, nstar
< real	x, x2, y, y2, r, s, s2, f, f2, wt, s2x, s2y, dfw, rstar
< real	val, sky, pval, ssig, sptl
---
> int	logfd			#I Logfile
> 
> bool	newpeaks, newaps, bndry
> int	i, j, n, c, l, nc, nl, c1, c2, nummax, num, nobjsap, fw_nbins
> real	x, x2, y, y2, r, s, s2, f, f2, wt, val, sky, pval, ssig, s2x, s2y, dfw
51,55c50,54
< pointer	stp, sym, objs, obj, rlptr, gwts, gwt, eafs, eaf, o
< pointer	data, skydata, ssigdata, gaindata, expdata, sigdata, sptldata
< pointer	sp, order, str, v, rl, ivals, xmin, ymin
< pointer	sum_f1, sum_f2, sum_s2x, sum_s2y
< pointer	stars, fw_norm, sum_fw, fw_bins
---
> pointer	objs, obj, rlptr
> pointer	data, skydata, ssigdata, gaindata, expdata, sigdata
> pointer	sp, v, rl, nthresh, sum_f2, sum_s2x, sum_s2y, dopeaks, doaps
> pointer	fw_norm, sum_fw, fw_bins
> pointer	hdr
60,64c59
< pointer	stfind(), catexpr()
< errchk	salloc, evgdata, gwt_ginit, gwt_init, eaf_ginit, eaf_init
< extern	compare()
< 
< int	iter
---
> errchk	salloc, evgdata
68,69c63,65
< 	call salloc (order, SZ_LINE, TY_CHAR)
< 	call salloc (str, SZ_LINE, TY_CHAR)
---
> 
> 	if (logfd != NULL)
> 	    call fprintf (logfd, "  Evaluate objects:\n")
72,73d67
< 	# The magnitude zero point may be defined by the parameter
< 	# file, the image header, or the catalog header.
86,98d79
< 	call strcpy (EVL_ORDER(evl,1), Memc[order], SZ_LINE)
< 
< 	# Print log information.
< 	if (logfd != NULL) {
< 	    call fprintf (logfd, "  Evaluate objects:\n")
< 	    call fprintf (logfd, "    magzero = %g\n")
< 		call pargr (magzero)
< 	}
< 	if (verbose > 1) {
< 	    call printf ("  Evaluate objects:\n")
< 	    call printf ("    magzero = %g\n")
< 		call pargr (magzero)
< 	}
101,110d81
< 	expdata = NULL
< 	gaindata = NULL
< 	sptldata = NULL; sptl = 1.
< 	stars = NULL
< 
< 	call evgdata (0, im, skymap, sigmap, gainmap, expmap,
< 	    sptlmap, data, skydata, ssigdata, gaindata,
< 	    expdata, sigdata, sptldata)
< 
< 	stp = CAT_STP(cat)
126,128c97,99
< 	call salloc (ivals, nummax, TY_INT)
< 	call salloc (xmin, nummax, TY_INT)
< 	call salloc (ymin, nummax, TY_INT)
---
> 	call salloc (dopeaks, nummax, TY_SHORT)
> 	call salloc (doaps, nummax, TY_SHORT)
> 	call salloc (nthresh, nummax, TY_INT)
130d100
< 	call salloc (sum_f1, nummax, TY_REAL)
136c106
< 	call aclri (Memi[ivals], nummax)
---
> 	call aclri (Memi[nthresh], nummax)
138d107
< 	call aclrr (Memr[sum_f1], nummax)
151,152c120,121
< 	# Initialize.
< 	j = 0; l = 0
---
> 	# Initialize values for accumulation or checking.
> 	newpeaks = false; newaps = false
153a123,125
> 	    Mems[dopeaks+i] = NO
> 	    Mems[doaps+i] = NO
> 
157,158c129
< 	    if (OBJ_FLAG(obj,DARK) == 'D') {
< 	        l = l + 1
---
> 	    if (OBJ_FLAG(obj,DARK) == 'D')
160d130
< 	    }
162,165c132,137
< 	    j = j + 1
< 	    OBJ_ORDER(obj) = j
< 
< 	    OBJ_PEAK(obj) = 0.
---
> 	    # Parameters related to the peak value and center.
> 	    if (IS_INDEFR(OBJ_PEAK(obj))) {
> 		newpeaks = true
> 	        Mems[dopeaks+i] = YES
> 		OBJ_PEAK(obj) = 0.
> 	    }
167,175c139,151
< 	    # Parameters related to the moments.
< 	    OBJ_X(obj) = 0.
< 	    OBJ_Y(obj) = 0.
< 	    OBJ_XX(obj) = 0.
< 	    OBJ_YY(obj) = 0.
< 	    OBJ_XY(obj) = 0.
< 	    OBJ_XVAR(obj) = 0.
< 	    OBJ_YVAR(obj) = 0.
< 	    OBJ_XYCOV(obj) = 0.
---
> 	    # Parameters related to aperture center.
> 	    if (IS_INDEFR(OBJ_FCORE(obj))) {
> 		newaps = true
> 	        Mems[doaps+i] = YES
> 		OBJ_FCORE(obj) = 0.
> 		OBJ_XAP(obj) = 0.
> 		OBJ_YAP(obj) = 0.
> 	    }
> 	    OBJ_R(obj) = 0.
> 	    OBJ_RI2(obj) = 0.
> 	    OBJ_FWHM(obj) = 0.
> 	    do j = ID_APFLUX, ID_APFLUX9
> 	        RECR(obj,j) = INDEFR
178,184d153
< 	    OBJ_FCORE(obj) = INDEFR
< 	    OBJ_GWFLUX(obj) = INDEFR
< 	    OBJ_FWHM(obj) = 0.
< 	    OBJ_R(obj) = 0.
< 	    OBJ_RII(obj) = 0.
< 	    do j = 0, 9
< 	        OBJ_CAFLUX(obj,j) = INDEFR
188c157,161
< 	    OBJ_EAR(obj,0) = INDEFR
---
> 	    OBJ_X1(obj) = 0.
> 	    OBJ_Y1(obj) = 0.
> 	    OBJ_X2(obj) = 0.
> 	    OBJ_Y2(obj) = 0.
> 	    OBJ_XY(obj) = 0.
192c165
< 	    OBJ_ISIGAV(obj) = INDEFR
---
> 	    OBJ_ISIGAVG2(obj) = INDEFR
194,204c167,169
< 	}
< 	if (l > 0 && Memc[order] == EOS) {
< 	    do i = NUMSTART-1, nummax-1 {
< 		obj = Memi[objs+i]
< 		if (obj == NULL)
< 		    next
< 		if (OBJ_FLAG(obj,DARK) == 'D') {
< 		    j = j + 1
< 		    OBJ_ORDER(obj) = j
< 		}
< 	    }
---
> 	    OBJ_XVAR(obj) = 0.
> 	    OBJ_YVAR(obj) = 0.
> 	    OBJ_XYCOV(obj) = 0.
207,218d171
< 	# Set flag for aperture fluxes.
< 	docaf = false; doeaf = false
< 	sym = stfind (stp, "CAFLUX_0")
< 	if (ENTRY_EVAL(sym) == YES)
< 	    docaf = (ENTRY_EVAL(sym) == YES)
< 	sym = stfind (stp, "EAR_0")
< 	if (ENTRY_EVAL(sym) == YES)
< 	    doeaf = (ENTRY_EVAL(sym) == YES)
< 	sym = stfind (stp, "EAFLUX_0")
< 	if (ENTRY_EVAL(sym) == YES)
< 	    doeaf = (ENTRY_EVAL(sym) == YES)
< 
221,222c174,179
< 	# Compute parameters that do not depend on a source center.
< 	# Compute peak position and unweighted centroid.
---
> 	# Compute all parameters that do not depend on a source center.
> 	# Compute parameters for sources with defined centers.
> 	# Compute those centers that can be computed in this pass.
> 
> 	# Check and initialze aperture fluxes.
> 	call evapinit (cat, nobjsap)
230a188,192
> 	    # Do circular aperture photometry.
> 	    if (nobjsap > 0)
> 		call evapeval (l, im, skymap, sigmap, gainmap, expmap,
> 		    data, skydata, ssigdata, gaindata, expdata, sigdata)
> 
255,256c217
< 			    sptlmap, data, skydata, ssigdata, gaindata,
< 			    expdata, sigdata, sptldata)
---
> 			    data, skydata, ssigdata, gaindata, expdata, sigdata)
263,264d223
< 			Memi[xmin+num] = c1
< 			Memi[ymin+num] = l
266c225
< 			OBJ_XMAX(obj) = c2
---
> 			OBJ_XMAX(obj) = c1
270,273d228
< 		    } else {
< 		        OBJ_XMIN(obj) = min (OBJ_XMIN(obj), c1)
< 		        OBJ_XMAX(obj) = min (OBJ_XMAX(obj), c2)
< 			OBJ_YMAX(obj) = l
286,287c241,288
< 			x = c - Memi[xmin+num]
< 			y = l - Memi[ymin+num]
---
> 			# Do things concerning the peak pixel.
> 			if (Mems[dopeaks+num] == YES) {
> 			    if (pval < val) {
> 				OBJ_PEAK(obj) = val
> 				OBJ_XPEAK(obj) = c
> 				OBJ_YPEAK(obj) = l
> 			    }
> 			} else {
> 			    if (!newpeaks && Mems[doaps+num] == YES) {
> 				r = sqrt ((c - OBJ_XPEAK(obj)) ** 2 +
> 				    (l - OBJ_YPEAK(obj)) ** 2)
> 				if (r <= RCORE) {
> 				    OBJ_FCORE(obj) = OBJ_FCORE(obj) + val
> 				    OBJ_XAP(obj) = OBJ_XAP(obj) + c * val
> 				    OBJ_YAP(obj) = OBJ_YAP(obj) + l * val
> 				}
> 			    }
> 			}
> 
> 			# Do things concerning aperture center.
> 			if (!newaps) {
> 			    r = sqrt ((c - OBJ_XAP(obj)) ** 2 +
> 			        (l - OBJ_YAP(obj)) ** 2)
> 
> 			    if (pval > 0.) {
> 				x = val / pval
> 				if (x > FW_I1 && x < FW_I2) {
> 				    j = int ((x - FW_I1) / dfw) 
> 				    y = r / Memr[fw_norm+j]
> 				    wt = (1 - 2 * abs (x - 0.5)) / sqrt(y)
> 				    OBJ_FWHM(obj) = OBJ_FWHM(obj) + y * wt
> 				    Memr[sum_fw+num] = Memr[sum_fw+num] + wt
> 				    if (y > FW_BIN1 && y < FW_BIN2) {
> 					j = 1 + (y-FW_BIN1)/FW_BINWIDTH
> 					Memr[fw_bins+j] = Memr[fw_bins+j] + wt
> 				    } else
> 					Memr[fw_bins] = Memr[fw_bins] + wt
> 				}
> 			    }
> 
> 			    OBJ_R(obj) = OBJ_R(obj) + r * val
> 			    OBJ_RI2(obj) = OBJ_RI2(obj) + r * f2
> 			    Memr[sum_f2+num] = Memr[sum_f2+num] + f2
> 			}
> 
> 			# Do other evaluations.
> 			x = c - OBJ_XMIN(obj)
> 			y = l - OBJ_YMIN(obj)
292,297d292
< 			if (OBJ_PEAK(obj) < val) {
< 			    OBJ_PEAK(obj) = val
< 			    OBJ_XPEAK(obj) = c
< 			    OBJ_YPEAK(obj) = l
< 			}
< 
304c299
< 			    Memi[ivals+num] = Memi[ivals+num] + 1
---
> 			    Memi[nthresh+num] = Memi[nthresh+num] + 1
310,312c305,308
< 			Memr[sum_f1+num] = Memr[sum_f1+num] + val
< 			OBJ_X(obj) = OBJ_X(obj) + x * val
< 			OBJ_XX(obj) = OBJ_XX(obj) + x2 * val
---
> 			OBJ_XMIN(obj) = min (OBJ_XMIN(obj), c)
> 			OBJ_XMAX(obj) = max (OBJ_XMAX(obj), c)
> 			OBJ_X1(obj) = OBJ_X1(obj) + x * val
> 			OBJ_X2(obj) = OBJ_X2(obj) + x2 * val
316,317c312,315
< 			OBJ_Y(obj) = OBJ_Y(obj) + y * val
< 			OBJ_YY(obj) = OBJ_YY(obj) + y2 * val
---
> 			OBJ_YMIN(obj) = min (OBJ_YMIN(obj), l)
> 			OBJ_YMAX(obj) = max (OBJ_YMAX(obj), l)
> 			OBJ_Y1(obj) = OBJ_Y1(obj) + y * val
> 			OBJ_Y2(obj) = OBJ_Y2(obj) + y2 * val
324,326d321
< 			Memr[sum_s2x+num] = s2x
< 			Memr[sum_s2y+num] = s2y
< 
329a325
> 
330a327,328
> 		    Memr[sum_s2x+num] = s2x
> 		    Memr[sum_s2y+num] = s2y
346,351d343
< 	    if (n == 0) {
< 	        call mfree (Memi[objs+i], TY_STRUCT)
< 		next
< 	    }
< 	    if (OBJ_NDETECT(obj) == 0)
< 	        OBJ_NDETECT(obj) = n
354,357c346,380
< 	    # I don't think this can ever happen.
< 	    if (OBJ_PEAK(obj) == 0.) {
< 		OBJ_XPEAK(obj) = (OBJ_XMAX(obj) + OBJ_XMIN(obj)) / 2.
< 		OBJ_YPEAK(obj) = (OBJ_YMAX(obj) + OBJ_YMIN(obj)) / 2.
---
> 	    if (Mems[dopeaks+i] == YES) {
> 		# I don't think OBJ_PEAK can ever be less than or equal to zero.
> 		if (OBJ_PEAK(obj) == 0.) {
> 		    OBJ_XPEAK(obj) = (OBJ_XMAX(obj) + OBJ_XMIN(obj)) / 2.
> 		    OBJ_YPEAK(obj) = (OBJ_YMAX(obj) + OBJ_YMIN(obj)) / 2.
> 		}
> 
> 	    } else if (!newpeaks && Mems[doaps+i] == YES) {
> 		if (OBJ_FCORE(obj) > 0.) {
> 		    OBJ_XAP(obj) = OBJ_XAP(obj) / OBJ_FCORE(obj)
> 		    OBJ_YAP(obj) = OBJ_YAP(obj) / OBJ_FCORE(obj)
> 		} else {
> 		    OBJ_XAP(obj) = OBJ_XPEAK(obj)
> 		    OBJ_YAP(obj) = OBJ_YPEAK(obj)
> 		}
> 
> 	    } else if (!newaps) {
> 		x = Memr[sum_fw+i]
> 		if (x > 0.) {
> 		    fwhm = fwhm + OBJ_FWHM(obj)
> 		    nfwhm = nfwhm + x
> 		    OBJ_FWHM(obj) = OBJ_FWHM(obj) / x
> 		} else
> 		    OBJ_FWHM(obj) = INDEFR
> 
> 		if (f > 0)
> 		    OBJ_R(obj) = OBJ_R(obj) / f
> 		else
> 		    OBJ_R(obj) = INDEFR
> 
> 		f2 = Memr[sum_f2+i]
> 		if (f2 > 0)
> 		    OBJ_RI2(obj) = SQRTOF2 * OBJ_RI2(obj) / f2
> 		else
> 		    OBJ_RI2(obj) = INDEFR
360d382
< 	    f = Memr[sum_f1+i]
362,366d383
< 		x = OBJ_X(obj) / f
< 		y = OBJ_Y(obj) / f
< 		OBJ_X(obj) = x + Memi[xmin+i]
< 		OBJ_Y(obj) = y + Memi[ymin+i]
< 
367a385
> 		x = OBJ_X1(obj) / f
371c389,390
< 		OBJ_XX(obj) = OBJ_XX(obj) / f - x * x
---
> 		OBJ_X1(obj) = x + OBJ_XMIN(obj)
> 		OBJ_X2(obj) = OBJ_X2(obj) / f - x * x
375c394,396
< 		OBJ_YY(obj) = OBJ_YY(obj) / f - y * y
---
> 		y = OBJ_Y1(obj) / f
> 		OBJ_Y1(obj) = y + OBJ_YMIN(obj)
> 		OBJ_Y2(obj) = OBJ_Y2(obj) / f - y * y
382,392d402
< 
< 		if (OBJ_XX(obj) < 0.01 || OBJ_YY(obj) < 0.01) {
< 		    #OBJ_X(obj) = INDEFR
< 		    OBJ_XX(obj) = INDEFR
< 		    OBJ_XVAR(obj) = INDEFR
< 		    #OBJ_Y(obj) = INDEFR
< 		    OBJ_YY(obj) = INDEFR
< 		    OBJ_YVAR(obj) = INDEFR
< 		    OBJ_XY(obj) = INDEFR
< 		    OBJ_XYCOV(obj) = INDEFR
< 		}
394,395c404,405
< 		OBJ_X(obj) = INDEFR
< 		OBJ_XX(obj) = INDEFR
---
> 		OBJ_X1(obj) = INDEFR
> 		OBJ_X2(obj) = INDEFR
397,398c407,408
< 		OBJ_Y(obj) = INDEFR
< 		OBJ_YY(obj) = INDEFR
---
> 		OBJ_Y1(obj) = INDEFR
> 		OBJ_Y2(obj) = INDEFR
405,409c415,416
< 	    if (IS_INDEFR(OBJ_X(obj)) || IS_INDEFR(OBJ_Y(obj))) {
< 	        OBJ_X(obj) = OBJ_XPEAK(obj); OBJ_Y(obj) = OBJ_YPEAK(obj)
< 	    }
< 	    if (Memi[ivals+i] > 0)
< 		OBJ_THRESH(obj) = OBJ_THRESH(obj) / Memi[ivals+i]
---
> 	    if (Memi[nthresh+i] > 0)
> 		OBJ_THRESH(obj) = OBJ_THRESH(obj) / Memi[nthresh+i]
418a426,427
> 	call evapfree ()
> 
421,438c430,431
< 	# Given the unweighted moments we determine the weighted moments and
< 	# set the aperture center.
< 
< 	if (IS_INDEFR(EVL_GWTSIG(evl))) {
< 	    if (stars == NULL) {
< 		stars = ivals
< 		call evl_findstars (cat, Memi[stars], nstar, rstar, s,
< 		    20, 10, Memr[sum_fw])
< 	    }
< 	    if (IS_INDEFR(rstar))
< 		call gwt_ginit (cat, EVL_GWTSIG(evl),
< 		    EVL_GWTNSIG(evl), 3, gwts, NULL, 0)
< 	    else
< 		call gwt_ginit (cat, rstar/SQRTOF2,
< 		    EVL_GWTNSIG(evl), 3, gwts, NULL, 0)
< 	} else
< 	    call gwt_ginit (cat, EVL_GWTSIG(evl),
< 		EVL_GWTNSIG(evl), 3, gwts, logfd, verbose)
---
> 	# If aperture centers were not defined we can now find the aperture
> 	# center from the peak just measured.
440,441c433
< 	call amovkr (1., Memr[sum_f1], nummax)
< 	do iter = 1, 10 {
---
> 	if (newaps && newpeaks) { 
443d434
< 	    dogwt = false
462,464d452
< 		    grw = MGRW(Memi[rlptr+2])
< 		    if (Memr[sum_f1+num] < 0.05)
< 			next
466c454
< 		    # Do all unevaluated objects and their parents.
---
> 		    # Compute aperture center.
472a461,464
> 			if (Mems[doaps+num] == NO) {
> 			    num = OBJ_PNUM(obj) - 1
> 			    next
> 			}
476,477c468,469
< 				expmap, sptlmap, data, skydata, ssigdata,
< 				gaindata, expdata, sigdata, sptldata)
---
> 				expmap, data, skydata, ssigdata, gaindata,
> 				expdata, sigdata)
482,483d473
< 			    if (sptldata != NULL)
< 				sptl = Memr[sptldata+c-1]
485,489c475,480
< 			    gwt = GWTS_GWT(gwts,num)
< 			    if (gwt == 0) {
< 				call gwt_init (gwts, gwt, OBJ_X(obj),
< 				    OBJ_Y(obj), OBJ_XX(obj), OBJ_YY(obj))
< 				GWTS_GWT(gwts,num) = gwt
---
> 			    r = sqrt ((c - OBJ_XPEAK(obj)) ** 2 +
> 				(l - OBJ_YPEAK(obj)) ** 2)
> 			    if (r <= RCORE) {
> 				OBJ_FCORE(obj) = OBJ_FCORE(obj) + val
> 				OBJ_XAP(obj) = OBJ_XAP(obj) + c * val
> 				OBJ_YAP(obj) = OBJ_YAP(obj) + l * val
491,492c482
< 			    if (gwt > 0)
< 				call gwt_accum (gwts, gwt, c, l, val, grw, sptl)
---
> 
498,526d487
< 
< 		# Deallocate memory for weighted moment measurements.
< 		rlptr = rl
< 		do i = 2, Memi[rl] {
< 		    rlptr = rlptr + 3
< 		    num = MNUM(Memi[rlptr+2]) - 1
< 		    obj = Memi[objs+num]
< 		    if (obj == NULL)
< 			break
< 		    if (l != OBJ_YMAX(obj))
< 			next
< 		    gwt = GWTS_GWT(gwts,num)
< 		    if (gwt > 0) {
< 			call gwt_done (gwts, gwt, x, y, OBJ_XX(obj),
< 			    OBJ_YY(obj), OBJ_XY(obj), OBJ_FCORE(obj),
< 			    OBJ_GWFLUX(obj))
< 			GWTS_GWT(gwts,num) = gwt
< 
< #if (iter == 1) {
< #OBJ_XVAR(obj) = OBJ_X(obj)
< #OBJ_YVAR(obj) = OBJ_Y(obj)
< #}
< 			OBJ_X(obj) = OBJ_X(obj) + x
< 			OBJ_Y(obj) = OBJ_Y(obj) + y
< 			Memr[sum_f1+num] = sqrt (x*x+y*y)
< 			if (Memr[sum_f1+num] > 0.05)
< 			    dogwt = true
< 		    }
< 		}
528d488
< 	}
530,538c490,493
< 	call gwt_gdone (cat, gwts)
< 	
< 	# Check and set final positions and core flux.
< 	do i = NUMSTART-1, nummax-1 {
< 	    obj = Memi[objs+i]
< 	    if (obj == NULL)
< 		next
< 	    if (OBJ_FLAG(obj,DARK) == 'D')
< 		next
---
> 	    # Finish up the evaluations.
> 	    do i = NUMSTART-1, nummax-1 {
> 	        if (Mems[doaps+i] == NO)
> 		    next
540,550c495,504
< 	    if (IS_INDEFR(OBJ_FCORE(obj)))
< 		OBJ_FCORE(obj) = OBJ_PEAK(obj)
< 	    if (IS_INDEFR(OBJ_X(obj)) || IS_INDEFR(OBJ_Y(obj))) {
< 		OBJ_X(obj) = OBJ_XPEAK(obj); OBJ_Y(obj) = OBJ_YPEAK(obj)
< 	    }
< 	    if (IS_INDEFR(OBJ_XAP(obj)) || IS_INDEFR(OBJ_YAP(obj))) {
< 		OBJ_XAP(obj) = OBJ_X(obj); OBJ_YAP(obj) = OBJ_Y(obj)
< 	    }
< 	    if (abs(OBJ_XAP(obj)-OBJ_X(obj))>5. ||
< 	        abs(OBJ_YAP(obj)-OBJ_Y(obj))>5.) {
< 		OBJ_XAP(obj) = OBJ_X(obj); OBJ_YAP(obj) = OBJ_Y(obj)
---
> 		obj = Memi[objs+i]
> 		if (obj == NULL)
> 		    next
> 		if (OBJ_FCORE(obj) > 0.) {
> 		    OBJ_XAP(obj) = OBJ_XAP(obj) / OBJ_FCORE(obj)
> 		    OBJ_YAP(obj) = OBJ_YAP(obj) / OBJ_FCORE(obj)
> 		} else {
> 		    OBJ_XAP(obj) = OBJ_XPEAK(obj)
> 		    OBJ_YAP(obj) = OBJ_YPEAK(obj)
> 		}
556c510
< 	# Compute FWHM and aperture fluxes (if requested).
---
> 	# If aperture centers were defined in pass1 or pass2 apply them.
558,569c512,513
< 	if (docaf) {
< 	    if (stars == NULL) {
< 		stars = ivals
< 		call evl_findstars (cat, Memi[stars], nstar, rstar, s,
< 		    20, 10, Memr[sum_fw])
< 	    }
< 	    call caf_init (cat, nobjsap, 2*rstar/SQRTOF2, logfd, verbose)
< 	}
< 	if (doeaf)
< 	    call eaf_ginit (cat, eafs)
< 	else
< 	    eafs = NULL
---
> 	if (newaps) {
> 	    call evapinit (cat, nobjsap)
571,573c515,517
< 	Memi[v] = 1
< 	do l = 1, nl {
< 	    Memi[v+1] = l
---
> 	    Memi[v] = 1
> 	    do l = 1, nl {
> 		Memi[v+1] = l
575,576c519,520
< 	    # Note the data is read the first time it is needed.
< 	    data = NULL
---
> 		# Note the data is read the first time it is needed.
> 		data = NULL
578,583c522,526
< 	    # Do circular aperture photometry.  Check nobjsap to avoid
< 	    # subroutine call.
< 	    if (docaf && nobjsap > 0)
< 		call caf_eval (l, im, skymap, sigmap, gainmap, expmap,
< 		    sptlmap, data, skydata, ssigdata, gaindata, expdata,
< 		    sigdata, sptldata)
---
> 		# Do circular aperture photometry.  Check nobjsap to avoid
> 		# subroutine call.
> 		if (nobjsap > 0)
> 		    call evapeval (l, im, skymap, sigmap, gainmap, expmap,
> 			data, skydata, ssigdata, gaindata, expdata, sigdata)
585,588c528,531
< 	    # Check if there are any object regions in this line.
< 	    if (!pm_linenotempty (om, Memi[v]))
< 		next
< 	    call pmglri (om, Memi[v], Memi[rl], 0, nc, 0)
---
> 		# Check if there are any object regions in this line.
> 		if (!pm_linenotempty (om, Memi[v]))
> 		    next
> 		call pmglri (om, Memi[v], Memi[rl], 0, nc, 0)
590,597c533,539
< 	    # Go through pixels which are parts of objects.
< 	    rlptr = rl
< 	    do i = 2, Memi[rl] {
< 		rlptr = rlptr + 3
< 		c1 = Memi[rlptr]
< 		c2 = c1 + Memi[rlptr+1] - 1
< 		num = MNUM(Memi[rlptr+2]) - 1
< 		grw = MGRW(Memi[rlptr+2])
---
> 		# Go through pixels which are parts of objects.
> 		rlptr = rl
> 		do i = 2, Memi[rl] {
> 		    rlptr = rlptr + 3
> 		    c1 = Memi[rlptr]
> 		    c2 = c1 + Memi[rlptr+1] - 1
> 		    num = MNUM(Memi[rlptr+2]) - 1
599,605c541,551
< 		# Do all unevaluated objects and their parents.
< 		while (num >= NUMSTART-1) {
< 		    obj = Memi[objs+num]
< 		    if (obj == NULL)
< 			break
< 		    if (OBJ_FLAG(obj,DARK) == 'D')
< 			break
---
> 		    # Do all unevaluated objects and their parents.
> 		    while (num >= NUMSTART-1) {
> 			obj = Memi[objs+num]
> 			if (obj == NULL)
> 			    break
> 			if (OBJ_FLAG(obj,DARK) == 'D')
> 			    break
> 			if (Mems[doaps+num] == NO) {
> 			    num = OBJ_PNUM(obj) - 1
> 			    next
> 			}
607,610c553,556
< 		    if (data == NULL)
< 			call evgdata (l, im, skymap, sigmap, gainmap,
< 			    expmap, sptlmap, data, skydata, ssigdata,
< 			    gaindata, expdata, sigdata, sptldata)
---
> 			if (data == NULL)
> 			    call evgdata (l, im, skymap, sigmap, gainmap,
> 				expmap, data, skydata, ssigdata, gaindata,
> 				expdata, sigdata)
612,615c558,562
< 		    pval = OBJ_PEAK(obj)
< 		    do c = c1, c2 {
< 			sky = Memr[skydata+c-1]
< 			val = Memr[data+c-1] - sky
---
> 			pval = OBJ_PEAK(obj)
> 			do c = c1, c2 {
> 			    sky = Memr[skydata+c-1]
> 			    val = Memr[data+c-1] - sky
> 			    f2 = val * val
617,618c564,565
< 			f2 = val * val
< 			r = sqrt ((c - OBJ_X(obj)) ** 2 + (l - OBJ_Y(obj)) ** 2)
---
> 			    r = sqrt ((c - OBJ_XAP(obj)) ** 2 +
> 				(l - OBJ_YAP(obj)) ** 2)
620,637c567,580
< 			if (pval > 0. && r > 0.) {
< 			    x = val / pval
< 			    if (x > FW_I1 && x < FW_I2) {
< 				j = int ((x - FW_I1) / dfw) 
< 				y = r / Memr[fw_norm+j]
< 				wt = (1 - 2 * abs (x - 0.5)) /
< 				    sqrt(y)
< 				OBJ_FWHM(obj) =
< 				    OBJ_FWHM(obj) + y * wt
< 				Memr[sum_fw+num] =
< 				    Memr[sum_fw+num]+wt
< 				if (y > FW_BIN1 && y < FW_BIN2) {
< 				    j = 1 + (y-FW_BIN1)/FW_BINWIDTH
< 				    Memr[fw_bins+j] =
< 					Memr[fw_bins+j]+wt
< 				} else
< 				    Memr[fw_bins] =
< 					Memr[fw_bins]+wt
---
> 			    if (pval > 0. && r > 0.) {
> 				x = val / pval
> 				if (x > FW_I1 && x < FW_I2) {
> 				    j = int ((x - FW_I1) / dfw) 
> 				    y = r / Memr[fw_norm+j]
> 				    wt = (1 - 2 * abs (x - 0.5)) / sqrt(y)
> 				    OBJ_FWHM(obj) = OBJ_FWHM(obj) + y * wt
> 				    Memr[sum_fw+num] = Memr[sum_fw+num] + wt
> 				    if (y > FW_BIN1 && y < FW_BIN2) {
> 					j = 1 + (y-FW_BIN1)/FW_BINWIDTH
> 					Memr[fw_bins+j] = Memr[fw_bins+j] + wt
> 				    } else
> 					Memr[fw_bins] = Memr[fw_bins] + wt
> 				}
639d581
< 			}
641,652c583,585
< 			OBJ_R(obj) = OBJ_R(obj) + r * val
< 			OBJ_RII(obj) = OBJ_RII(obj) + r * f2
< 			Memr[sum_f2+num] = Memr[sum_f2+num] + f2
< 
< 			if (eafs != NULL) {
< 			    eaf = EAFS_EAF(eafs,num)
< 			    if (eaf == 0) {
< 				call eaf_init (eaf, obj)
< 				EAFS_EAF(eafs,num) = eaf
< 			    }
< 			    if (eaf > 0)
< 				call eaf_accum (eaf, obj, c, l, val)
---
> 			    OBJ_R(obj) = OBJ_R(obj) + r * val
> 			    OBJ_RI2(obj) = OBJ_RI2(obj) + r * f2
> 			    Memr[sum_f2+num] = Memr[sum_f2+num] + f2
654,658d586
< 		    }
< 
< 		    num = OBJ_PNUM(obj) - 1
< 		}
< 	    }
660,676c588
< 	    # Deallocate memory.
< 	    if (eafs != NULL) {
< 		rlptr = rl
< 		do i = 2, Memi[rl] {
< 		    rlptr = rlptr + 3
< 		    num = MNUM(Memi[rlptr+2]) - 1
< 		    obj = Memi[objs+num]
< 		    if (obj == NULL)
< 			break
< 		    if (l != OBJ_YMAX(obj))
< 			next
< 		    if (eafs != NULL) {
< 			eaf = EAFS_EAF(eafs,num)
< 			if (eaf > 0) {
< 			    call eaf_done (eafs, eaf, obj)
< 			    EAFS_EAF(eafs,num) = eaf
< 			}
---
> 			num = OBJ_PNUM(obj) - 1
680,688d591
< 	}
< 
< 	# Finish up the evaluations.
< 	do i = NUMSTART-1, nummax-1 {
< 	    obj = Memi[objs+i]
< 	    if (obj == NULL)
< 		next
< 	    if (OBJ_FLAG(obj,DARK) == 'D')
< 		next
690,696c593,596
< 	    x = Memr[sum_fw+i]
< 	    if (x > 0.) {
< 		fwhm = fwhm + OBJ_FWHM(obj)
< 		nfwhm = nfwhm + x
< 		OBJ_FWHM(obj) = OBJ_FWHM(obj) / x
< 	    } else
< 		OBJ_FWHM(obj) = INDEFR
---
> 	    # Finish up the evaluations.
> 	    do i = NUMSTART-1, nummax-1 {
> 		if (Mems[doaps+i] == NO)
> 		    next
698,702c598,602
< 	    f = OBJ_FLUX(obj)
< 	    if (f > 0.)
< 		OBJ_R(obj) = OBJ_R(obj) / f
< 	    else
< 		OBJ_R(obj) = INDEFR
---
> 		obj = Memi[objs+i]
> 		if (obj == NULL)
> 		    next
> 		if (OBJ_FLAG(obj,DARK) == 'D')
> 		    next
704,708c604,616
< 	    f2 = Memr[sum_f2+i]
< 	    if (f2 > 0.)
< 		OBJ_RII(obj) = SQRTOF2 * OBJ_RII(obj) / f2
< 	    else
< 		OBJ_RII(obj) = INDEFR
---
> 		x = Memr[sum_fw+i]
> 		if (x > 0.) {
> 		    fwhm = fwhm + OBJ_FWHM(obj)
> 		    nfwhm = nfwhm + x
> 		    OBJ_FWHM(obj) = OBJ_FWHM(obj) / x
> 		} else
> 		    OBJ_FWHM(obj) = INDEFR
> 
> 		f = OBJ_FLUX(obj)
> 		if (f > 0.)
> 		    OBJ_R(obj) = OBJ_R(obj) / f
> 		else
> 		    OBJ_R(obj) = INDEFR
710,711c618,623
< 	    if (IS_INDEFR(OBJ_FCORE(obj)))
< 		OBJ_FCORE(obj) = OBJ_PEAK(obj)
---
> 		f2 = Memr[sum_f2+i]
> 		if (f2 > 0.)
> 		    OBJ_RI2(obj) = SQRTOF2 * OBJ_RI2(obj) / f2
> 		else
> 		    OBJ_RI2(obj) = INDEFR
> 	    }
714,720c626
< 	if (docaf)
< 	    call caf_free ()
< 	if (eafs != NULL)
< 	    call eaf_gdone (cat, eafs)
< 
< 	# Set apportioned fluxes.
< 	call evapportion (cat, Memr[sum_s2x])
---
> 	call evapfree ()
724,788d629
< 	# Identify stars.
< 	if (stars == NULL)
< 	    call evl_findstars (cat, Memi[stars], nstar, rstar, s,
< 		20, 10, Memr[sum_fw])
< 
< 	# Adjust zero points.
< 	if (IS_INDEFR(magzero) && docaf) {
< 	    # Set aperture corrections for fixed aperture fluxes.
< 	    f = 0.; f2 = 0.
< 	    do i = 0, nstar-1 {
< 		obj = Memi[stars+i]
< 		if (IS_INDEFR(OBJ_GWFLUX(obj)) ||
< 		    IS_INDEFR(OBJ_FRACFLUX(obj)) || OBJ_GWFLUX(obj) <= 0.)
< 		    next
< 		f = f + OBJ_FCORE(obj) * OBJ_FRACFLUX(obj) / OBJ_GWFLUX(obj)
< 		f2 = f2 + OBJ_FCORE(obj)
< 	    }
< 	    if (f2 > 0) {
< 		f = f / f2
< 		do i = NUMSTART-1, nummax-1 {
< 		    obj = Memi[objs+i]
< 		    if (obj == NULL)
< 			next
< 		    if (IS_INDEFR(OBJ_GWFLUX(obj)))
< 			next
< 		    OBJ_GWFLUX(obj) = f * OBJ_GWFLUX(obj)
< 		}
< 		call catputr (cat, "GWMAGZ", -2.5*log10(f))
< 	    }
< 	    if (docaf) {
< 		do j = 0, 9 {
< 		    call sprintf (Memc[str], SZ_LINE, "CAFLUX_%d")
< 		        call pargi (j)
< 		    sym = stfind (stp, Memc[str])
< 		    if (ENTRY_EVAL(sym) == NO)
< 		        break
< 		    f = 0.; f2 = 0.
< 		    do i = 0, nstar-1 {
< 			obj = Memi[stars+i]
< 			if (IS_INDEFR(OBJ_CAFLUX(obj,j)) ||
< 			    IS_INDEFR(OBJ_FRACFLUX(obj)) ||
< 			    OBJ_CAFLUX(obj,j) <= 0.)
< 			    next
< 			f = f + OBJ_FCORE(obj) * OBJ_FRACFLUX(obj) /
< 			    OBJ_CAFLUX(obj,j)
< 			f2 = f2 + OBJ_FCORE(obj)
< 		    }
< 		    if (f2 > 0) {
< 			f = f / f2
< 			do i = NUMSTART-1, nummax-1 {
< 			    obj = Memi[objs+i]
< 			    if (obj == NULL)
< 				next
< 			    if (IS_INDEFR(OBJ_CAFLUX(obj,j)))
< 				next
< 			    OBJ_CAFLUX(obj,j) = f * OBJ_CAFLUX(obj,j)
< 			}
< 			call sprintf (Memc[str], SZ_LINE, "CAMAGZ%d")
< 			    call pargi (j)
< 			call catputr (cat, Memc[str], -2.5*log10(f))
< 		    }
< 		}
< 	    }
< 	}
< 
811,812c652,658
< 	if (!IS_INDEFR(fwhm))
< 	    call catputr (cat, "FWHM", fwhm)
---
> 	if (!IS_INDEFR(fwhm)) {
>             hdr = CAT_OHDR(cat)
>             if (hdr == NULL)
>                 hdr = CAT_IHDR(cat)
> 	    if (hdr != NULL)
> 		call imaddr (hdr, "FWHM", fwhm)
> 	}
814,833c660,758
< 	# Set sort index if requested.
< 	if (Memc[order] != EOS) {
< 	    do i = 0, nummax-NUMSTART+1 {
< 		obj = Memi[objs+i+NUMSTART-1]
< 		if (obj == NULL)
< 		    next
< 		OBJ_ORDER(obj) = i
< 		Memr[sum_fw+i] = MAX_REAL
< 		if (OBJ_FLAG(obj,DARK) == 'D')
< 		    next
< 		ifnoerr (o = catexpr (Memc[order], cat, obj)) {
< 		    switch (O_TYPE(o)) {
< 		    case TY_BOOL, TY_INT:
< 		        Memr[sum_fw+i] = O_VALI(o)
< 		    case TY_REAL:
< 		        Memr[sum_fw+i] = O_VALR(o)
< 		    case TY_DOUBLE:
< 		        Memr[sum_fw+i] = O_VALD(o)
< 		    }
< 		    call evvfree (o)
---
> 	# Set apportioned fluxes.
> 	call evapportion (cat, Memr[sum_s2x])
> 
> 	# Set WCS coordinates.
> 	call evalwcs (cat, im)
> 
> 	call sfree (sp)
> end
> 
> 
> # EVAPINIT -- Initialize aperture photometry.  nobjsap will signal whether
> # there are any aperture fluxes requested.
> 
> procedure evapinit (cat, nobjsap)
> 
> pointer	cat			#I Catalog
> int	nobjsap			#O Number of objects for aperture evaluation
> 
> bool	doobj
> int	i, j, nummax
> pointer	tbl, stp, sym, obj, sthead(), stnext()
> 
> int	ycompare()
> extern	ycompare
> errchk	calloc, malloc
> 
> int	nobjs			# Number of objects to evaluate
> int	naps			# Number of apertures per object
> real	rmax			# Maximum aperture radius
> pointer	r2aps			# Array of aperture radii squared (ptr)
> pointer	ysort			# Array of Y sorted object number indices (ptr)
> int	ystart			# Index of first object to consider
> pointer	objs			# Array of object structure (ptr)
> int	ids			# Array of entry ids
> common	/evapcom/ nobjs, naps, rmax, r2aps, ysort, ystart, objs, ids
> 
> begin
> 	nobjsap = 0
> 	nobjs = 0
> 	naps = 0
> 	ids = NULL
> 	r2aps = NULL
> 	ysort = NULL
> 
> 	tbl = CAT_OUTTBL(cat)
> 	if (tbl == NULL)
> 	    return
> 	stp = TBL_STP(tbl)
> 
> 	# Determine number of apertures.
> 	naps = 0
> 	for (sym=sthead(stp); sym!=NULL; sym=stnext(stp,sym)) {
> 	    if (ENTRY_ID(sym) < ID_APFLUX || ENTRY_ID(sym) > ID_APFLUX9)
> 		next
> 	    naps = naps + 1
> 	}
> 	if (naps == 0)
> 	    return
> 
> 	objs = CAT_RECS(cat)
> 	nummax = CAT_NUMMAX(cat)
> 
> 	# Allocate memory.
> 	call malloc (ids, naps, TY_INT)
> 	call malloc (r2aps, naps, TY_REAL)
> 	call malloc (ysort, nummax, TY_INT)
> 
> 	# Get the maximum radius since that will define the line
> 	# limits needed for each object.  Compute array of radius squared
> 	# for the apertures.  Pixels are checked for being in the aperture
> 	# in r^2 to avoid square roots.
> 	rmax = 0.
> 	naps = 0
> 	for (sym=sthead(stp); sym!=NULL; sym=stnext(stp,sym)) {
> 	    if (ENTRY_ID(sym) < ID_APFLUX || ENTRY_ID(sym) > ID_APFLUX9)
> 		next
> 	    Memi[ids+naps] = ENTRY_ID(sym)
> 	    Memr[r2aps+naps] = ENTRY_RAP(sym) ** 2
> 	    rmax = max (ENTRY_RAP(sym), rmax)
> 	    naps = naps + 1
> 	}
> 
> 	# For the objects create a sorted index array by YAP so that we
> 	# can quickly find objects which include a particular line in
> 	# their apertures.
> 
> 	do i = NUMSTART-1, nummax-1 {
> 	    obj = Memi[objs+i]
> 	    if (obj == NULL)
> 		next
> 	    if (OBJ_FLAG(obj,DARK) == 'D')
> 	        next
> 	    if (IS_INDEFR(OBJ_FCORE(obj)))
> 	        next
> 	    doobj = false
> 	    do j = 0, naps-1 {
> 		if (IS_INDEFR(RECR(obj,Memi[ids+j]))) {
> 		    doobj = true
> 		    RECR(obj,Memi[ids+j]) = 0.
836,845c761,763
< 	    call gqsort (Memi[objs+NUMSTART-1], nummax-NUMSTART+1, compare,
< 		sum_fw)
< 	    j = 0
< 	    do i = 0, nummax-1 {
< 	        #obj = Memi[objs+Memi[ivals+i]]
< 	        obj = Memi[objs+i]
< 		if (obj == NULL)
< 		    next
< 		j = j + 1
< 		OBJ_ORDER(obj) = j
---
> 	    if (doobj) {
> 		Memi[ysort+nobjsap] = i
> 		nobjsap = nobjsap + 1
847a766,772
> 	ystart = 1
> 	nobjs = nobjsap
> 
> 	if (nobjsap == 0)
> 	    call evapfree ()
> 	else if (nobjsap > 1)
> 	    call gqsort (Memi[ysort], nobjsap, ycompare, objs)
849d773
< 	call sfree (sp)
853,855c777
< # COMPARE -- Compare values of two objects for sorting.
< 
< int procedure compare (vals, i1, i2)
---
> # EVAPFREE -- Free aperture photometry memory.
857,859c779
< pointer	vals			#I Pointer to array of sort values
< int	i1			#I Index of first object to compare
< int	i2			#I Index of second object to compare
---
> procedure evapfree ()
861c781,789
< int	j1, j2
---
> int	nobjs			# Number of objects to evaluate
> int	naps			# Number of apertures per object
> real	rmax			# Maximum aperture radius
> pointer	r2aps			# Array of aperture radii squared (ptr)
> pointer	ysort			# Array of Y sorted object number indices (ptr)
> int	ystart			# Index of first object to consider
> pointer	objs			# Array of object structure (ptr)
> int	ids			# Array of entry ids
> common	/evapcom/ nobjs, naps, rmax, r2aps, ysort, ystart, objs, ids
864,869c792,795
< 	if (i1 == i2)
< 	    return (0)
< 	else if (i2 == NULL)
< 	    return (-1)
< 	else if (i1 == NULL)
< 	    return (1)
---
> 	call mfree (ids, TY_INT)
> 	call mfree (r2aps, TY_REAL)
> 	call mfree (ysort, TY_INT)
> end
871,872d796
< 	j1 = OBJ_ORDER(i1)
< 	j2 = OBJ_ORDER(i2)
874,879c798,870
< 	if (Memr[vals+j1] < Memr[vals+j2])
< 	    return (-1)
< 	else if (Memr[vals+j1] > Memr[vals+j2])
< 	    return (1)
< 	else
< 	    return (0)
---
> # EVAPEVAL -- Do circular aperture photometry.  Maintain i1 as the
> # first entry in the sorted index array to be considered.  All
> # earlier entries will have all aperture lines less than the
> # current line.  Break on the first object whose minimum aperture
> # line is greater than the current line.
> 
> procedure evapeval (l, im, skymap, sigmap, gainmap, expmap, data, skydata,
> 	ssigdata, gaindata, expdata, sigdata)
> 
> int	l			#I Line
> pointer	im			#I Image
> pointer	skymap			#I Sky map
> pointer	sigmap			#I Sigma map
> pointer	gainmap			#I Gain map
> pointer	expmap			#I Exposure map
> pointer	data			#O Image data
> pointer	skydata			#O Sky data
> pointer	ssigdata		#O Sky sigma data
> pointer	gaindata		#O Gain data
> pointer	expdata			#O Exposure data
> pointer	sigdata			#O Total sigma data
> 
> int	i, j, id, nc, c
> real	x, y, l2, r2, val, sky
> pointer	obj
> 
> int	nobjs			# Number of objects to evaluate
> int	naps			# Number of apertures per object
> real	rmax			# Maximum aperture radius
> pointer	r2aps			# Array of aperture radii squared (ptr)
> pointer	ysort			# Array of Y sorted object number indices (ptr)
> int	ystart			# Index of first object to consider
> pointer	objs			# Array of object structure (ptr)
> int	ids			# Array of entry ids
> common	/evapcom/ nobjs, naps, rmax, r2aps, ysort, ystart, objs, ids
> 
> begin
> 	nc = IM_LEN(im,1)
> 	do i = ystart, nobjs {
> 	    obj = Memi[objs+Memi[ysort+i-1]]
> 	    if (IS_INDEFR(OBJ_FCORE(obj)))
> 	        next
> 
> 	    y = OBJ_YAP(obj)
> 	    if (y - rmax > l)
> 		break
> 	    if (y + rmax < l) {
> 		ystart = ystart + 1
> 		next
> 	    }
> 	    x = OBJ_XAP(obj)
> 	    if (data == NULL)
> 		call evgdata (l, im, skymap, sigmap, gainmap, expmap,
> 		    data, skydata, ssigdata, gaindata, expdata, sigdata)
> 
> 	    # Accumulate data within in the apertures using the r^2
> 	    # values.  Currently partial pixels are not considered and
> 	    # errors are not evaluated.
> 	    # Note that bad pixels or object overlaps are not excluded
> 	    # in the apertures.
> 	    l2 = (l - y) ** 2
> 	    do c = max (0, int(x-rmax)), min (nc, int(x+rmax+1)) {
> 		r2 = (c - x) ** 2 + l2
> 		do j = 0, naps-1 {
> 		    if (r2 < Memr[r2aps+j]) {
> 			val = Memr[data+c-1]
> 			sky = Memr[skydata+c-1]
> 			id = Memi[ids+j]
> 			RECR(obj,id) = RECR(obj,id) + (val - sky)
> 		    }
> 		}
> 	    }
> 	}
960c951
< # EVL_FINDSTARS -- Find stars as the lower bound of the moment radii.
---
> # EVALWCS -- Set WCS coordinates.
962c953
< procedure evl_findstars (cat, stars, nstar, r, s, nmin, nit, work)
---
> procedure evalwcs (cat, im)
964,975c955,956
< pointer	cat				#I Catalog
< pointer	stars[ARB]			#O Array of stars (>= CAT_NUMMAX)
< int	nstar				#O Number of stars
< real	r				#O Average moment radius
< real	s				#O Sigma of moment radius
< int	nmin				#I Minimum number of stars
< int	nit				#I Maximum number of iterations
< real	work[ARB]			#O Work array (>= CAT_NUMMAX)
< 
< int	i, j, k, nummax
< real	isigavg
< pointer	objs, obj
---
> pointer	cat			#I Catalog structure
> pointer	im			#I IMIO pointer
977c958,962
< int	awvgr()
---
> int	i
> double	xscale, yscale
> pointer	sp, str, mw, ctw, ctp, objs, obj, mw_openim(), mw_sctran()
> bool	streq()
> errchk	mw_openim
980,1001c965,966
< 	    objs = CAT_RECS(cat)
< 	    nummax = CAT_NUMMAX(cat)
< 
< 	    # Preselect brighter, single, objects with measured moment radius.
< 	    nstar = 0
< 	    for (isigavg=50.; nstar>nmin||isigavg<20.; isigavg=isigavg-10.) {
< 		nstar = 0
< 		do i = NUMSTART-1, nummax-1 {
< 		    obj = Memi[objs+i]
< 		    if (obj == NULL)
< 			next
< 		    if (OBJ_ISIGAVG(obj) < isigavg || IS_INDEFR(OBJ_XX(obj)) ||
< 			IS_INDEFR(OBJ_YY(obj)))
< 			next
< 		    if (OBJ_FLAG(obj,DARK) == 'D' || OBJ_FLAG(obj,SPLIT) == 'M')
< 			next
< 		    nstar = nstar + 1
< 		    stars[nstar] = obj
< 		    work[nstar] = sqrt (OBJ_XX(obj) + OBJ_YY(obj))
< 		}
< 		if (nstar == 0)
< 		    next
---
> 	call smark (sp)
> 	call salloc (str, SZ_FNAME, TY_CHAR)
1003,1012c968,982
< 		# Do asymmetric sigma clipping.
< 		j = awvgr (work, nstar, r, s, 0., 0.)
< 		if (IS_INDEFR(r) || IS_INDEFR(s))
< 		    next
< 		do i = 1, nit {
< 		    k = awvgr (work, nstar, r, s, r-3*s, r+s)
< 		    if (k == j || k == 0 || IS_INDEFR(r) || IS_INDEFR(s))
< 			break
< 		    j = k
< 		}
---
> 	mw = mw_openim (im)
> 	ctw = mw_sctran (mw, "logical", "world", 03B)
> 	ctp = mw_sctran (mw, "logical", "physical", 03B)
> 
> 	# Set conversion.
> 	xscale = 1.
> 	yscale = 1.
> 	ifnoerr (call mw_gwattrs (mw, 1, "axtype", Memc[str], SZ_FNAME)) {
> 	    if (streq (Memc[str], "ra"))
> 	        xscale = 15.
> 	}
> 	ifnoerr (call mw_gwattrs (mw, 2, "axtype", Memc[str], SZ_FNAME)) {
> 	    if (streq (Memc[str], "ra"))
> 	        yscale = 15.
> 	}
1014,1025c984,1000
< 		# Eliminate rejected objects and flag those accepted.
< 		if (IS_INDEFR(r) || IS_INDEFR(s))
< 		    next
< 		r = r - s; s = 2 * s
< 		j = nstar
< 		nstar = 0
< 		do i = 1, j {
< 		    if (abs (work[i] - r) > s)
< 			next
< 		    nstar = nstar + 1
< 		    stars[nstar] = stars[i]
< 		}
---
> 	objs = CAT_RECS(cat)
> 	do i = NUMSTART-1, CAT_NUMMAX(cat)-1 {
> 	    obj = Memi[objs+i]
> 	    if (obj == NULL)
> 		next
> 	    if (IS_INDEFR(OBJ_XAP(obj)) || IS_INDEFR(OBJ_YAP(obj))) {
> 		OBJ_WX(obj) = INDEFD
> 		OBJ_WY(obj) = INDEFD
> 		OBJ_PX(obj) = INDEFD
> 		OBJ_PY(obj) = INDEFD
> 	    } else {
> 		call mw_c2trand (ctw, double(OBJ_XAP(obj)),
> 		    double(OBJ_YAP(obj)), OBJ_WX(obj), OBJ_WY(obj))
> 		OBJ_WX(obj) = OBJ_WX(obj) / xscale
> 		OBJ_WY(obj) = OBJ_WY(obj) / yscale
> 		call mw_c2trand (ctp, double(OBJ_XAP(obj)),
> 		    double(OBJ_YAP(obj)), OBJ_PX(obj), OBJ_PY(obj))
1026a1002
> 	}
1028,1034c1004,1028
< 	    # Finish up.
< 	    do i = 1, nstar
< 		OBJ_FLAG(stars[i],RCLIP) = 'R'
< 	    if (nstar == 0) {
< 	        r = INDEFR
< 		s = INDEFR
< 	    }
---
> 	call mw_ctfree (ctw)
> 	call mw_ctfree (ctp)
> 	call mw_close (mw)
> end
> 
> 
> # YCOMPARE -- Compare Y values of two objects for sorting.
> 
> int procedure ycompare (objs, i1, i2)
> 
> pointer	objs			#I Pointer to array of objects
> int	i1			#I Index of first object to compare
> int	i2			#I Index of second object to compare
> 
> real	y1, y2
> 
> begin
> 	y1 = OBJ_YAP(Memi[objs+i1])
> 	y2 = OBJ_YAP(Memi[objs+i2])
> 	if (y1 < y2)
> 	    return (-1)
> 	else if (y1 > y2)
> 	    return (1)
> 	else
> 	    return (0)
1040,1041c1034,1035
< procedure evgdata (l, im, skymap, sigmap, gainmap, expmap, sptlmap,
< 	data, skydata, ssigdata, gaindata, expdata, sigdata, sptldata)
---
> procedure evgdata (l, im, skymap, sigmap, gainmap, expmap, data, skydata,
> 	ssigdata, gaindata, expdata, sigdata)
1049d1042
< pointer	sptlmap			#I Spatial scale map
1056d1048
< pointer	sptldata		#O Spatial scale data
1058,1060c1050,1051
< int	i, nc
< real	sptlnorm, asumr()
< pointer	ptr, imgl2r(), map_glr()
---
> int	nc
> pointer	imgl2r(), map_glr()
1064,1078d1054
< 	# Initialize if line is zero.
< 	if (l == 0) {
< 	    sptlnorm = 1
< 	    if (sptlmap == NULL)
< 	        return
< 	    iferr (call map_geti (sptlmap, "im", ptr))
< 	        return
< 	    sptlnorm = 0
< 	    nc = IM_LEN(ptr,1)
< 	    do i = 1, IM_LEN(ptr,2)
< 	        sptlnorm = sptlnorm + asumr (Memr[imgl2r(ptr,i)], nc) / nc
< 	    sptlnorm = sptlnorm / IM_LEN(ptr,2)
< 	    return
< 	}
< 
1102,1106d1077
< 	if (sptlmap != NULL) {
< 	    sptldata = map_glr (sptlmap, l, READ_ONLY)
< 	    if (sptlnorm != 1.)
< 		call adivkr (Memr[sptldata], sptlnorm, Memr[sptldata], nc)
< 	}
diff ./filter.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/filter.x
4d3
< include	<aceobjs1.h>
9,10c8
< pointer	incat			# Input catalog name
< pointer	outcat			# Output catalog name
---
> pointer	catalog			#I Catalog name
18,19c16
< 	call salloc (icat, SZ_FNAME, TY_CHAR)
< 	call salloc (ocat, SZ_FNAME, TY_CHAR)
---
> 	call salloc (catalog, SZ_FNAME, TY_CHAR)
22,23c19
< 	call clgstr ("icatalog", Memc[icat], SZ_FNAME)
< 	call clgstr ("ocatalog", Memc[ocat], SZ_FNAME)
---
> 	call clgstr ("catalog", Memc[catalog], SZ_FNAME)
26,37c22,24
< 	# Open catalogs.
< 	call catopen (cat, Memc[icat], Memc[ocat], "", "", NULL, 1)
< 	call catwrecs (cat, Memc[filt], INDEFI)
< 
< 	# Loop through records.
< 	do i = 1, CAT_NRECS(cat) {
< 	    rec = CAT_REC(cat,i)
< 	    if (!filter (cat, rec, filt))
< 	        next
< 	    if (rec == NULL)
< 	        next
< 	for (rec=cathead(icat); rec!=NULL; rec=catnext(icat,obj)) {
---
> 	call catopen (cat, Memc[catalog], Memc[catalog], "")
> 
> 	for (obj=cathead(cat); obj!=NULL; obj=catnext(cat,obj)) {
42c29
< 	call catclose (cat, NO)
---
> 	call catclose (cat)
diff ./grow.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/grow.x
6d5
< include	<aceobjs1.h>
10c9
< procedure grow (grw, cat, objmask, logfd, verbose)
---
> procedure grow (grw, cat, objmask, logfd)
15,16c14
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
---
> int	logfd			#I Logfile
41,45d38
< 	if (verbose > 1) {
< 	    call printf ("  Grow objects: ngrow = %d, agrow = %g\n")
< 		call pargi (ngrow)
< 		call pargr (agrow)
< 	}
142c135
< int	i, j, n, id, id0, id1, num1, andi(), ori()
---
> int	i, j, n, id, id0, id1, num1, andi()
288,289c281
< 		#out[i] = id
< 		out[i] = MSETFLAG(id,MASK_GRW)
---
> 		out[i] = id
309c301
< int	i, j, n, id, id0, id1, num1, andi(), ori()
---
> int	i, j, n, id, id0, id1, num1, andi()
523,524c515
< 		#out[i] = id
< 		out[i] = MSETFLAG(id,MASK_GRW)
---
> 		out[i] = id
660,661c651
< 		#out[1] = id
< 		out[1] = MSETFLAG(id,MASK_GRW)
---
> 		out[1] = id
798,799c788
< 		#out[nc] = id
< 		out[nc] = MSETFLAG(id,MASK_GRW)
---
> 		out[nc] = id
818c807
< int	i, j, n, id, id0, id1, num1, andi(), ori()
---
> int	i, j, n, id, id0, id1, num1, andi()
964,965c953
< 		#out[i] = id
< 		out[i] = MSETFLAG(id,MASK_GRW)
---
> 		out[i] = id
diff ./mapio.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/mapio.x
291d290
< bool	streq()
300,305d298
< 	case MAP_CONST:
< 	    if (streq (param, "interp"))
< 	       val = NO
< 	    else
< 		call error (1,
< 		    "map_geti: parameter does not apply to constant map")
351d343
< int	ival
353c345
< errchk	mim_seti, mgs_seti
---
> errchk	mim_seti(), mgs_seti
356,358d347
< 	if (map == NULL)
< 	    return
< 
363,369c352,354
< 	    if (streq (param, "sample")) {
< 		call mim_geti (MAP_MAP(map), "interp", ival)
< 		if (ival == YES)
< 		    MAP_SAMPLE(map) = max (1, val)
< 		else
< 		    MAP_SAMPLE(map) = 1
< 	    } else
---
> 	    if (streq (param, "sample"))
> 		MAP_SAMPLE(map) = max (1, val)
> 	    else
391,393d375
< 	if (map == NULL)
< 	    return
< 
416,418d397
< 	if (map == NULL)
< 	    return
< 
diff ./mim.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/mim.x
222c222
< int	strlen(), btoi(), imaccf()
---
> int	strlen(), btoi()
233c233
< 	    mim = NULL; im = NULL; mw = NULL; interp = false; rotate = false
---
> 	    mim = NULL; im = NULL; mw = NULL
245,247d244
< 	    if (nc != ncref || nl != nlref)
< 	        interp = true
< 
249,273c246
< 	    # coordinates.  If there are no logical WCS keywords in the map
< 	    # match the reference WCS.
< 
< 	    if (imaccf(im,"ltm1_1")==NO && imaccf(im,"ltm1_2")==NO) {
< 		mw = mw_openim (im)
< 
< 	        call aclrd (lt, 6)
< 		lt[1] = (nc - 1.) / (ncref - 1.)
< 		lt[4] = (nl - 1.) / (nlref - 1.)
< 		lt[5] = 1 - lt[1]
< 		lt[6] = 1 - lt[1]
< 	    } else {
< 		ptr = mw_openim (refim); mw = ptr 
< 		call mw_gltermd (mw, lt, lt[5], 2)
< 		call mw_close (mw)
< 		mw = mw_openim (im)
< 		call mw_gltermd (mw, ltin, ltin[5], 2)
< 
< 		# Combine lterms.
< 		call mw_invertd (lt, ltref, 2)
< 		call mw_mmuld (ltref, ltin, lt, 2)
< 		call mw_vmuld (lt, lt[5], lt[5], 2)
< 		lt[5] = ltin[5] - lt[5]
< 		lt[6] = ltin[6] - lt[6]
< 	    }
---
> 	    # coordinates.
274a248,260
> 	    ptr = mw_openim (refim); mw = ptr 
> 	    call mw_gltermd (mw, lt, lt[5], 2)
> 	    call mw_close (mw)
> 
> 	    mw = mw_openim (im)
> 	    call mw_gltermd (mw, ltin, ltin[5], 2)
> 
> 	    # Combine lterms.
> 	    call mw_invertd (lt, ltref, 2)
> 	    call mw_mmuld (ltref, ltin, lt, 2)
> 	    call mw_vmuld (lt, lt[5], lt[5], 2)
> 	    lt[5] = ltin[5] - lt[5]
> 	    lt[6] = ltin[6] - lt[6]
278a265
> 	    interp = false
287a275,276
> 	    else
> 		rotate = false
461,463c450
< 	if (streq (param, "im"))
< 	    val = MIM_IM(mim)
< 	else if (streq (param, "msitype"))
---
> 	if (streq (param, "msitype"))
471,472d457
< 	else if (streq (param, "interp"))
< 	    val = MIM_INTERP(mim)
diff ./mkpkg /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/mkpkg
2a3
> $call	lace
12,16c13
< 	$update libpkg.a
< 	$call ace
< 	;
< 
< ace:
---
> 	$checkout x_ace.o acebin$
18,19c15,17
< 	$link	x_ace.o libpkg.a -lacecat -lnfe -lds -lgsurfit -lcurfit \
< 	    -lxtools -liminterp -lnlfit -lslalib -o xx_ace.e
---
> 	$link	x_ace.o -lace -lacecat -lds -lgsurfit -lcurfit \
> 	    -lxtools -liminterp -lslalib -o xx_ace.e
> 	$checkin x_ace.o acebin$
23,28c21
< 	$move	xx_ace.e nfebin$x_ace.e
< 	$copy	aceall nfebin$aceall
< 	$copy	acecatalog nfebin$acecatalog
< 	$copy	acediff nfebin$acediff
< 	$copy	aceevaluate nfebin$aceevaluate
< 	$copy	acesegment nfebin$acesegment
---
> 	$move	xx_ace.e acebin$x_ace.e
31,44c24,27
< host:
< 	$ifolder (txt.x: lib/aceobjs.h, lib/catdef.dat, aceall.par, \
< 	    acecatalog.par, acediff.par, aceevaluate.par, acesegment.par, \
< 	    acefocus.h)
< 	    !rm -f txt.x
< 	    !txtcompile lib/aceobjs.h txt.x f_acestruct
< 	    !txtcompile lib/catdef.dat txt.x f_catdef
< 	    !txtcompile aceall.par txt.x p_aceall
< 	    !txtcompile acecatalog.par txt.x p_acecatalog
< 	    !txtcompile acediff.par txt.x p_acediff
< 	    !txtcompile aceevaluate.par txt.x p_aceevaluate
< 	    !txtcompile acesegment.par txt.x p_acesegment
< 	    !txtcompile acefocus.h txt.x f_acefocus
< 	$endif
---
> lace:
> 	$checkout libace.a acebin$
> 	$update libace.a
> 	$checkin libace.a acebin$
47,58c30
< libpkg.a:
< 	@stf
< 
< 	$call host
< 	txt.x
< 
< 	ace.x		ace.h acedetect.h detect.h filter.h <acecat.h>\
< 			<acecat1.h> <aceobjs.h> <error.h> <fset.h> <imhdr.h>\
< 			<imset.h> <pmset.h>
< 	acefunc.x	<acecat.h> <aceobjs.h>
< 	acemulticat.x	acedetect.h filter.h <fset.h> <acecat.h> <aceobjs.h>
< 	aceoffsets.x	<imset.h>
---
> libace.a:
60d31
< 	afn.x
62,70c33,41
< 	caflux.x	<acecat.h> <acecat1.h> <aceobjs.h> <imhdr.h>
< 	catshape.x	<acecat.h> <acecat1.h> <aceobjs.h> <math.h>
< 	convolve.x	ace.h <ctype.h> <imhdr.h>
< 	detect.x	ace.h detect.h sky.h skyblock.h split.h <acecat.h>\
< 			<acecat1.h> <aceobjs.h> <imhdr.h> <mach.h> <pmset.h>
< 	eaflux.x	eaflux.h <acecat.h> <acecat1.h> <aceobjs.h>
< 	evaluate.x	ace.h eaflux.h evaluate.h gwt.h <acecat.h> <acecat1.h>\
< 			<aceobjs.h> <error.h> <imhdr.h> <math.h> <pmset.h>
< 	grow.x		ace.h grow.h <acecat.h> <acecat1.h> <aceobjs.h>\
---
> 	catfunc.x	<acecat.h> <aceobjs.h>
> 	catshape.x	<acecat1.h> <acecat.h> <aceobjs.h> <math.h>
> 	convolve.x	<ctype.h> <imhdr.h>
> 	detect.x	<acecat1.h> <acecat.h> ace.h <aceobjs.h> detect.h\
> 			<imhdr.h> <mach.h> <pmset.h> skyblock.h split.h
> 	evaluate.x	<acecat1.h> <acecat.h> ace.h <aceobjs.h> <error.h>\
> 			evaluate.h <imhdr.h> <pmset.h>
> 	filter.x	ace.h <aceobjs.h> <evvexpr.h>
> 	grow.x		<acecat1.h> <acecat.h> ace.h <aceobjs.h> grow.h\
72d42
< 	gwt.x		gwt.h <acecat.h> <acecat1.h> <aceobjs.h>
75,76c45,46
< 	mgs.x		<error.h> <imio.h> <math/gsurfit.h> <imhdr.h>
< 	mim.x		<error.h> <imset.h> <math/iminterp.h> <imhdr.h>
---
> 	mgs.x		<error.h> <imhdr.h> <imio.h> <math/gsurfit.h>
> 	mim.x		<error.h> <imhdr.h> <imset.h> <math/iminterp.h>
78,88c48,53
< 	omcat.x		ace.h <acecat.h> <acecat1.h> <aceobjs.h> <imhdr.h>\
< 			<pmset.h>
< 	omwrite.x	ace.h filter.h <acecat.h> <acecat1.h> <aceobjs.h>\
< 			<imhdr.h> <pmset.h>
< 	pars.x		detect.h evaluate.h grow.h sky.h skyblock.h skyfit.h\
< 			split.h filter.h <ctype.h> <math/curfit.h>\
< 			<math/gsurfit.h>
< 	sky.x		sky.h <error.h>
< 	skyblock.x	skyblock.h <ctype.h> <error.h> <imhdr.h> <imset.h>\
< 			<mach.h>
< 	skyfit.x	skyfit.h <imhdr.h> <math/curfit.h> <math/gsurfit.h>
---
> 	omwrite.x	ace.h <imhdr.h> <pmset.h>
> 	pars.x		<ctype.h> detect.h evaluate.h grow.h <math/curfit.h>\
> 			<math/gsurfit.h> skyblock.h skyfit.h sky.h split.h
> 	skyblock.x	<ctype.h> <error.h> <imhdr.h> <imset.h> <mach.h>\
> 			skyblock.h
> 	skyfit.x	<imhdr.h> <math/curfit.h> <math/gsurfit.h> skyfit.h
90,104c55,71
< 	split.x		ace.h split.h <acecat.h> <acecat1.h> <aceobjs.h>\
< 			<mach.h> <pmset.h>
< 	t_acefocus.x	acefocus.h stf/starfocus.h <acecat.h> <mach.h>
< 	t_acematch.x	acematch.h <acecat.h> <error.h> <fset.h> <imhdr.h>\
< 			<mach.h> <math.h>
< 	t_acecopy.x	<acecat.h> <error.h>
< 	t_ace.x		ace.h acedetect.h filter.h
< 	t_acedisplay.x	display.h gwindow.h <ctype.h> <error.h> <imhdr.h>\
< 			<imset.h> <mach.h> <pmset.h> <imhdr.h> <imset.h> <mach.h>
< 	t_acegeomap.x	acematch.h <acecat.h> <error.h> <fset.h> <imhdr.h>\
< 			<mach.h> <math.h>
< 	t_acesetwcs.x	acesetwcs.h <acecat.h> <imhdr.h> <math.h>\
< 			<math/gsurfit.h> <mwset.h> <pkg/skywcs.h>
< 	#t_imext.x	<ctype.h> <error.h> <imhdr.h> <imset.h> <mach.h>
< 	#t_mscext.x	<error.h> <imhdr.h> <imset.h>
---
> 	sky.x		<error.h> sky.h
> 	split.x		<acecat1.h> <acecat.h> ace.h <aceobjs.h> <mach.h>\
> 			<pmset.h> split.h
> 	t_acecatmatch.x	<error.h> <fset.h> <mach.h> <math.h> <imhdr.h>\
> 			<acecat.h> acecatmatch.h
> 	t_acecopy.x	<error.h> <acecat.h>
> 	t_acedetect.x	<acecat1.h> <acecat.h> acedetect.h ace.h <aceobjs.h>\
> 			<error.h> <fset.h> <imhdr.h> <imset.h> <pmset.h>
> 	t_acedisplay.x	<ctype.h> display.h <error.h> gwindow.h <imhdr.h>\
> 			<imhdr.h> <imset.h> <imset.h> <mach.h> <mach.h>\
> 			<pmset.h>
> 	t_acegeomap.x	<acecat.h> acematch.h <error.h> <imhdr.h> <mach.h>\
> 			<math.h>
> 	t_acesetwcs.x	<imhdr.h> <math.h> <mwset.h> <math/gsurfit.h>\
> 			<pkg/skywcs.h>
> 	t_imext.x	<ctype.h> <error.h> <imhdr.h> <imset.h> <mach.h>
> 	t_mscext.x	<error.h> <imhdr.h> <imset.h>
105a73,75
> 	xtmaskname.x	
> 	#xtpmmap.x	<ctype.h> <error.h> <imhdr.h> <imset.h> <mach.h>\
> 	#		<mwset.h> <pmset.h>
diff ./noisemodel.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/noisemodel.x
20c20
< real	f, s, g, e, elast, sqrte
---
> real	e, elast, sqrte
23,26c23,24
< 	g = gain[1]
< 	e = exp[1]
< 	if (IS_INDEFR(e)) {
< 	    if (IS_INDEFR(g))
---
> 	if (IS_INDEFR(exp[1])) {
> 	    if (IS_INDEFR(gain[1]))
29,37c27,29
< 		do i = 1, npix {
< 		    f = image[i] - sky[i]
< 		    s = sig[i] * sig[i]
< 		    g = gain[i]
< 		    if (g <= 0.)
< 		        sigma[i] = sig[i]
< 		    else
< 			sigma[i] = sqrt (s + max (-0.5 * s, f / g))
< 		}
---
> 		do i = 1, npix
> 		    sigma[i] = sqrt (sig[i] * sig[1] +
> 			(image[i] - sky[i]) / gain[i])
39c31
< 	} else if (IS_INDEFR(g)) {
---
> 	} else if (IS_INDEFR(gain[1])) {
43c35
< 		if (e <= 0.) {
---
> 		if (e == 0.) {
54d45
< 	    elast = INDEFR
56,58d46
< 		f = image[i] - sky[i]
< 		s = sig[i] * sig[i]
< 		g = gain[i]
60,73c48,51
< 		if (e <= 0.) {
< 		    if (g <= 0.)
< 		        sigma[i] = sig[i]
< 		    else
< 			sigma[i] = sqrt (s + max (-0.5 * s, f / g))
< 		} else {
< 		    if (e != elast) {
< 			sqrte = sqrt (e)
< 			elast = e
< 		    }
< 		    if (g <= 0.)
< 			sigma[i] = sig[i] / sqrte
< 		    else
< 			sigma[i] = sqrt (s + max (-0.5 * s, f / g)) / sqrte
---
> 		if (e == 0.) {
> 		    sigma[i] = sqrt (sig[i] * sig[i] +
> 			(image[i] - sky[i]) / gain[i])
> 		    next
74a53,54
> 		sigma[i] = sqrt ((sig[i] * sig[i] +
> 		    (image[i] - sky[i]) / gain[i]) / e)
diff ./omwrite.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/omwrite.x
6d5
< include	<aceobjs1.h>
8d6
< include	"filter.h"
11,12c9
< procedure omwrite (pm, fname, flt, omtype, refim, cat, catalog, objid,
< 	update, logfd, verbose)
---
> procedure omwrite (pm, fname, filt, omtype, refim, cat, catalog, objid, logfd)
16c13
< pointer	flt		#I Filter parameters
---
> char	filt[ARB]	#I Filter
22d18
< int	update		#I Update image header
24d19
< int	verbose		#I Verbose level
26c21
< int	i, j, k, nc, nl, id, nummax
---
> int	i, j, k, nc, nl, stridxs(), andi()
28,29c23
< pointer	sp, str, im, buf, recs, rec, nums, sym
< 
---
> pointer	sp, str, im, buf, recs, rec, nums, immap(), impl2i()
31,32d24
< int	stridxs(), andi()
< pointer	immap(), impl2i(), stfind()
47,70d38
< 	
< 	if (update == YES)
< 	    call imastr (refim, "OBJMASK", Memc[str])
< 	if (pm == NULL)
< 	    return
< 
< 	# Check catalog for mask number field.
< 	id = INDEFI
< 	if (cat != NULL && flt != NULL) {
< 	    sym = stfind (CAT_STP(cat), FLT_NUM(flt))
< 	    if (sym == NULL) {
< 	        call sprintf (Memc[str], SZ_LINE,
< 		    "Mask number catalog field not found (%s)")
< 		    call pargstr (FLT_NUM(flt))
< 	        call error (1, Memc[str])
< 	    }
< 	    if (ENTRY_TYPE(sym) != TY_INT) {
< 	        call sprintf (Memc[str], SZ_LINE,
< 		    "Mask number catalog field not integer (%s)")
< 		    call pargstr (FLT_NUM(flt))
< 	        call error (1, Memc[str])
< 	    }
< 	    id = ENTRY_ID(sym)
< 	}
76,79d43
< 	if (verbose > 1) {
< 	    call printf ("  Write object mask: %s\n")
< 		call pargstr (Memc[str])
< 	}
88c52
< 	if (IS_INDEFI(id)) {
---
> 	if (filt[1] == EOS) {
90c54
< 	    case OM_BOOL, OM_BBOOL:
---
> 	    case OM_BOOL:
95,100d58
< 		    if (omtype == OM_BBOOL) {
< 			do j = buf, buf+nc-1 {
< 			    if (Memi[j] >= NUMSTART && MNOTBNDRY(Memi[j]))
< 				Memi[j] = 0
< 			}
< 		    }
103c61
< 	    case OM_ONUM, OM_BONUM:
---
> 	    case OM_ONUM:
108,113d65
< 		    if (omtype == OM_BONUM) {
< 			do j = buf, buf+nc-1 {
< 			    if (Memi[j] >= NUMSTART && MNOTBNDRY(Memi[j]))
< 				Memi[j] = 0
< 			}
< 		    }
116a69,84
> 	    case OM_COLORS:
> 		do i = 1, nl {
> 		    v[2] = i
> 		    buf = impl2i (im, i)
> 		    call pmglpi (pm, v, Memi[buf], 0, nc, PIX_SRC)
> 		    do j = buf, buf+nc-1 {
> 			k = MNUM(Memi[j])
> 			if (k > 0) {
> 			    if (k < NUMSTART)
> 				k = 1
> 			    else
> 				k = mod (k, 8) + 2
> 			}
> 			Memi[j] = k
> 		    }
> 		}
124d91
< 	    nummax = CAT_NUMMAX(cat)
125a93,94
> 	    call salloc (nums, CAT_NUMMAX(cat)+1, TY_SHORT)
> 	    call aclrs (Mems[nums], CAT_NUMMAX(cat)+1)
127,128c96,97
< 		rec = Memi[recs+i]
< 		if (rec == NULL)
---
> 	        rec = Memi[recs+i]
> 	        if (rec == NULL)
130,146c99,100
< 		if (!filter (cat, rec, FLT_FILTER(flt)))
< 		    next
< 		nummax = max (nummax, RECI(rec,id))
< 	    }
< 
< 	    call salloc (nums, nummax+1, TY_SHORT)
< 	    call aclrs (Mems[nums], nummax+1)
< 	    do i = 0, CAT_NRECS(cat)-1 {
< 		rec = Memi[recs+i]
< 		if (rec == NULL)
< 		    next
< 		if (!filter (cat, rec, FLT_FILTER(flt)))
< 		    next
< 		k = RECI(rec,id)
< 		if (k < 1 || k > nummax)
< 		    next
< 		Mems[nums+k] = 1
---
> 		if (filter (cat, rec, filt))
> 		    Mems[nums+OBJ_NUM(rec)] = 1
155,156c109,110
< 		    if (k > nummax || Mems[nums+k] == 0)
< 			Memi[j] = 0
---
> 		    if (Mems[nums+k] == 0)
> 		        Memi[j] = 0
159,165c113
< 		case OM_BOOL, OM_BBOOL:
< 		    if (omtype == OM_BBOOL) {
< 			do j = buf, buf+nc-1 {
< 			    if (Memi[j] >= NUMSTART && MNOTBNDRY(Memi[j]))
< 				Memi[j] = 0
< 			}
< 		    }
---
> 		case OM_BOOL:
167,173c115
< 		case OM_ONUM, OM_BONUM:
< 		    if (omtype == OM_BONUM) {
< 			do j = buf, buf+nc-1 {
< 			    if (Memi[j] >= NUMSTART && MNOTBNDRY(Memi[j]))
< 				Memi[j] = 0
< 			}
< 		    }
---
> 		case OM_ONUM:
175a118,128
> 		case OM_COLORS:
> 		    do j = buf, buf+nc-1 {
> 			k = MNUM(Memi[j])
> 			if (k > 0) {
> 			    if (k < NUMSTART)
> 				k = 1
> 			    else
> 				k = mod (k, 8) + 2
> 			}
> 			Memi[j] = k
> 		    }
184,185d136
< 	iferr (call imdelf (im, "OBJMASK"))
< 	    ;
191,204c142
< 	# Add the mask type for other programs to use.
< 	switch (omtype) {
< 	case OM_BOOL:
< 	    call imastr (im, "OMTYPE", "boolean")
< 	case OM_ONUM:
< 	    call imastr (im, "OMTYPE", "numbers")
< 	case OM_ALL:
< 	    call imastr (im, "OMTYPE", "all")
< 	case OM_BBOOL:
< 	    call imastr (im, "OMTYPE", "bboolean")
< 	case OM_BONUM:
< 	    call imastr (im, "OMTYPE", "bonum")
< 	}
< 
---
> 	call imastr (refim, "OBJMASK", Memc[str])
diff ./pars.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/pars.x
11d10
< include	"filter.h"
32c31
< 	case 'a', 'o':
---
> 	case 'o':
38,61c37,39
< #	    call clgpseta (pp, "skytype", SKY_STR(pars), SKY_STRLEN)
< #	    SKY_TYPE(pars) = strdic (SKY_STR(pars), SKY_STR(pars), SKY_STRLEN,
< #		SKY_TYPES)
< 	    if (option[1] == 'a') {
< 		call clgpseta (pp, "skyotype", SKY_STR(pars), SKY_STRLEN)
< 		SKY_OTYPE(pars) = strdic (SKY_STR(pars), SKY_STR(pars),
< 		    SKY_STRLEN, SKY_OTYPES)
< 	    } else
< 		SKY_OTYPE(pars) = SKY_OSKY
< 	    call clcpset (pp)
< 
< 	    call skb_pars (option, pset, SKY_SKB(pars))
< 	    if (SKY_SKB(pars) == NULL)
< 		SKY_TYPE(pars) = SKY_FIT
< 	    else
< 		SKY_TYPE(pars) = SKY_BLOCK
< 	case 't':
< 	    if (pars == NULL)
< 		return
< 
< 	    pp = clopset (pset)
< 	    call clgpseta (pp, "skyotype", SKY_STR(pars), SKY_STRLEN)
< 	    SKY_OTYPE(pars) = strdic (SKY_STR(pars), SKY_STR(pars), SKY_STRLEN,
< 		SKY_OTYPES)
---
> 	    call clgpseta (pp, "skytype", SKY_STR(pars), SKY_STRLEN)
> 	    SKY_TYPE(pars) = strdic (SKY_STR(pars), SKY_STR(pars), SKY_STRLEN,
> 		SKY_TYPES)
91c69
< 	case 'a', 'o':
---
> 	case 'o':
139c117
< 	case 'a', 'o':
---
> 	case 'o':
146d123
< 	    SKB_BLKSIZE(pars) = clgpseti (pp, "blksize")
147a125
> 	    SKB_BLKSIZE(pars) = clgpseti (pp, "blksize")
179,181d156
< 	    SKB_AVSKY(pars) = INDEFR
< 	    SKB_AVSIG(pars) = INDEFR
< 
183,185d157
< 
< 	    if (SKB_BLKSIZE(pars) == 0 || SKB_BLKSTEP(pars) == 0)
< 	        call mfree (pars, TY_STRUCT)
218c190
< 	case 'a', 'o', 'd':
---
> 	case 'o':
251,255c223,264
< 	    if (clgpsetb (pp, "updatesky")) {
< 	        DET_UPDSKY(pars) = YES
< 		#call skb_pars ("open", pset, DET_SKB(pars))
< 	    } else
< 	        DET_UPDSKY(pars) = NO
---
> 	    if (clgpsetb (pp, "updatesky"))
> 		call skb_pars ("open", pset, DET_SKB(pars))
> 
> 	    # Check convolution kernel.
> 	    for (cp=DET_CNV(pars); IS_WHITE(Memc[cp]); cp=cp+1)
> 		;
> 	    call strcpy (Memc[cp], Memc[DET_CNV(pars)], DET_STRLEN)
> 	    if (Memc[DET_CNV(pars)] != EOS) {
> 		call cnvparse (Memc[DET_CNV(pars)], ptr, i, j, NULL)
> 		call mfree (ptr, TY_REAL)
> 		if (i == 1 && j == 1)
> 		    Memc[DET_CNV(pars)] = EOS
> 	    }
> 
> 	    call clcpset (pp)
> 	case 'd':
> 	    if (pars != NULL)
> 		return
> 	    call calloc (pars, DET_LEN, TY_STRUCT)
> 
> 	    pp = clopset (pset)
> 
> 	    call clgpseta (pp, "bpdetect", Memc[DET_CNV(pars)], DET_STRLEN)
> 	    if (decode_ranges (Memc[DET_CNV(pars)], DET_BPDET(pars), DET_NBP,
> 	        i) == ERR)
> 		call error (1, "Error parsing 'bpdetect' parameter")
> 	    call clgpseta (pp, "bpflag", Memc[DET_CNV(pars)], DET_STRLEN)
> 	    if (decode_ranges (Memc[DET_CNV(pars)], DET_BPFLG(pars), DET_NBP,
> 	        i) == ERR)
> 		call error (1, "Error parsing 'bpflag' parameter")
> 	    call clgpseta (pp, "convolve", Memc[DET_CNV(pars)], DET_STRLEN)
> 	    DET_HSIG(pars) = clgpsetr (pp, "hsigma")
> 	    DET_LSIG(pars) = clgpsetr (pp, "lsigma")
> 	    DET_HDETECT(pars) = btoi (clgpsetb (pp, "hdetect"))
> 	    DET_LDETECT(pars) = btoi (clgpsetb (pp, "ldetect"))
> 	    DET_NEIGHBORS(pars) = clgpseti (pp, "neighbors")
> 	    DET_MINPIX(pars) = clgpseti (pp, "minpix")
> 	    DET_SIGAVG(pars) = clgpsetr (pp, "sigavg")
> 	    DET_SIGPEAK(pars) = clgpsetr (pp, "sigmax")
> 	    DET_BPVAL(pars) = clgpseti (pp, "bpval")
> 	    if (clgpsetb (pp, "updatesky"))
> 		call skb_pars ("open", pset, DET_SKB(pars))
262,263c271
< 		call cnvparse (Memc[DET_CNV(pars)], ptr, i, j,
< 		    DET_SCNV(pars), NULL, 0)
---
> 		call cnvparse (Memc[DET_CNV(pars)], ptr, i, j, NULL)
265c273
< 		if (i == 1 && j == 1) {
---
> 		if (i == 1 && j == 1)
267,268d274
< 		    DET_SCNV(pars) = NO
< 		}
272,273c278
< 	    if (option[1] == 'a' || option[1] == 'd')
< 		DET_FRAC2(pars) = clgpsetr (pp, "rfrac")
---
> 	    DET_FRAC2(pars) = clgpsetr (pp, "rfrac")
276,278d280
< 
< 	    if (DET_HDETECT(pars) == NO && DET_LDETECT(pars) == NO)
< 	        call mfree (pars, TY_STRUCT)
307c309
< 	case 'a', 'o':
---
> 	case 'o':
326,328d327
< 
< 	    if (SPT_SPLITSTEP(pars) <= 0.)
< 	        call mfree (pars, TY_STRUCT)
354c353
< 	case 'a', 'o':
---
> 	case 'o':
363,365d361
< 
< 	    if (GRW_NGROW(pars) <= 0 && GRW_AGROW(pars) <= 0.)
< 	        call mfree (pars, TY_STRUCT)
381c377
< int	i
---
> int	i, nowhite(), ctor()
385,386d380
< int	ctor(), nowhite()
< real	clgetr()
393c387
< 	case 'a', 'o':
---
> 	case 'o':
407,440d400
< 	    EVL_GWTSIG(pars) = clgetr ("gwtsig")
< 	    EVL_GWTNSIG(pars) = clgetr ("gwtnsig")
< 	    call clgpseta (pp, "order", EVL_ORDER(pars,1), EVL_STRLEN)
< 	    call clcpset (pp)
< 	case 'c':
< 	    call mfree (pars, TY_STRUCT)
< 	}
< end
< 
< 
< # FLT_PARS -- Filter parameters.
< 
< procedure flt_pars (option, pset, pars)
< 
< char	option[ARB]		#I Option
< char	pset[ARB]		#I Pset
< pointer	pars			#U Parameter structure
< 
< pointer	pp
< 
< pointer	clopset()
< 
< errchk	calloc
< 
< begin
< 	switch (option[1]) {
< 	case 'a', 'o':
< 	    if (pars != NULL)
< 		return
< 	    call calloc (pars, FLT_LEN, TY_STRUCT)
< 
< 	    pp = clopset (pset)
< 	    call clgpseta (pp, "catfilter", FLT_FILTER(pars), FLT_STRLEN)
< 	    call strcpy ("NUM", FLT_NUM(pars), FLT_NUMLEN)
diff ./skyblock.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/skyblock.h
14c14
< define	SKB_LEN			84	# Sky block structure length
---
> define	SKB_LEN			82	# Sky block structure length
51,54d50
< 
< # The following are computed for each image.
< define	SKB_AVSKY	Memr[$1+82]	# Mean sky
< define	SKB_AVSIG	Memr[$1+83]	# Mean sigma
diff ./skyblock.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/skyblock.x
14c14
< 	skymap, sigmap, logfd, verbose)
---
> 	skymap, sigmap, logfd)
26,27c26
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
---
> int	logfd			#I Verbose?
32c31
< pointer	sp, cnv, cnvdata, scnvdata, bp
---
> pointer	sp, cnv, cnvdata, bp
40,45d38
< 	# Set parameters if not set in a previous call or set externally.
< 	if (skb == NULL)
< 	    call skb_pars ("open", "", skb)
< 	if (skb == NULL)
< 	    return
< 
59,67c52,55
< 	if (verbose > 1) {
< 	    if (dosky && dosig)
< 		call printf (
< 		    "    Determine sky and sigma by block statistics:\n")
< 	    else if (dosky)
< 		call printf ("    Determine sky by block statistics:\n")
< 	    else
< 		call printf ("    Determine sigma by block statistics:\n")
< 	}
---
> 
> 	# Set parameters if not set in a previous call or set externally.
> 	if (skb == NULL)
> 	    call skb_pars ("open", "", skb)
71c59
< 	call skb_iminit (skb, in, expmap, blkstep, logfd, verbose)
---
> 	call skb_iminit (skb, in, expmap, blkstep, logfd)
100,101c88,89
< 	        0, 1., l, Memc[cnv], NO, indata, bp, cnvdata, scnvdata, skydata,
< 		sigdata, expdata, cnvwt, logfd, verbose)
---
> 	        0, 1., l, Memc[cnv], indata, bp, cnvdata, skydata,
> 		sigdata, expdata, cnvwt, logfd)
108,109c96,97
< 	    0, 1., 0, Memc[cnv], NO, indata, bp, cnvdata, scnvdata, skydata,
< 	    sigdata, expdata, cnvwt, logfd, verbose)
---
> 	    0, 1., 0, Memc[cnv], indata, bp, cnvdata, skydata,
> 	    sigdata, expdata, cnvwt, logfd)
113c101
< 	    skymap, sigmap, logfd, verbose)
---
> 	    skymap, sigmap, logfd)
123c111
< procedure skb_iminit (skb, im, expmap, blkstep, logfd, verbose)
---
> procedure skb_iminit (skb, im, expmap, blkstep, logfd)
130d117
< int	verbose			#I Verbose level
212,229d198
< 	if (verbose > 1) {
< 	    call printf ("      Number of blocks: %d %d\n")
< 	        call pargi (SKB_NCBLK(skb))
< 	        call pargi (SKB_NLBLK(skb))
< 	    call printf ("      Number of pixels per block: %d %d\n")
< 	        call pargi (SKB_NCPIX(skb))
< 	        call pargi (SKB_NLPIX(skb))
< 	    call printf ("      Number of subblocks: %d %d\n")
< 	        call pargi (SKB_NCSBLK(skb))
< 	        call pargi (SKB_NLSBLK(skb))
< 	    call printf ("      Number of pixels per subblock: %d %d\n")
< 	        call pargi (SKB_NCSPIX(skb))
< 	        call pargi (SKB_NLSPIX(skb))
< 	    if (blkstep > 1) {
< 		call printf ("      Line sampling step: %d\n")
< 		    call pargi (blkstep)
< 	    }
< 	}
520c489
< 	skymap, sigmap, logfd, verbose)
---
> 	skymap, sigmap, logfd)
531d499
< int	verbose			#I Verbose level
533d500
< int	nav
548c515
< 		    SKB_NLSPIX(skb), 0., SKB_AVSKY(skb), nav, NULL, 0)
---
> 		    SKB_NLSPIX(skb), 0., NULL)
557c524
< 		    SKB_NLSPIX(skb), 0., SKB_AVSKY(skb), nav, NULL, 0)
---
> 		    SKB_NLSPIX(skb), 0., NULL)
570c537
< 		    SKB_NLPIX(skb), INDEFR, SKB_AVSKY(skb), nav, NULL, 0)
---
> 		    SKB_NLPIX(skb), INDEFR, NULL)
575c542
< 		    SKB_NLPIX(skb), INDEFR, SKB_AVSKY(skb), nav, logfd, verbose)
---
> 		    SKB_NLPIX(skb), INDEFR, logfd)
594c561
< 		    SKB_NLSPIX(skb), 0., SKB_AVSIG(skb), nav, NULL, 0)
---
> 		    SKB_NLSPIX(skb), 0., NULL)
603c570
< 		    SKB_NLSPIX(skb), 0., SKB_AVSIG(skb), nav, NULL, 0)
---
> 		    SKB_NLSPIX(skb), 0., NULL)
616c583
< 		    SKB_NLPIX(skb), INDEFR, SKB_AVSIG(skb), nav, NULL, 0)
---
> 		    SKB_NLPIX(skb), INDEFR, NULL)
621c588
< 		    SKB_NLPIX(skb), INDEFR, SKB_AVSIG(skb), nav, logfd, verbose)
---
> 		    SKB_NLPIX(skb), INDEFR, logfd)
838,839c805
< procedure skb_wmap (name, imref, data, ncblk, nlblk, ncpix, nlpix,
< 	blank, av, nav, logfd, verbose)
---
> procedure skb_wmap (name, imref, data, ncblk, nlblk, ncpix, nlpix, blank, logfd)
847,848d812
< real	av			#O Average value
< int	nav			#O Number in average
850d813
< int	verbose			#I Verbose level
857c820
< errchk	immap, imrename, imaddr
---
> errchk	immap, imrename
869,870d831
< 	av = 0.; nav = 0
< 
895c856
< 		if (logfd != NULL || verbose > 1) {
---
> 		if (logfd != NULL) {
902,909c863,864
< 		    if (logfd != NULL) {
< 			call fprintf (logfd, "    Write sky map: %s\n")
< 			    call pargstr (Memc[str])
< 		    }
< 		    if (verbose > 1) {
< 			call printf ("    Write sky map: %s\n")
< 			    call pargstr (Memc[str])
< 		    }
---
> 		    call fprintf (logfd, "    Write sky map: %s\n")
> 			call pargstr (Memc[str])
931,936d885
< 		    do j = 1, ncblk {
< 			if (IS_INDEFR(Memr[buf+j-1]))
< 			    next
< 			av = av + Memr[buf+j-1]
< 			nav = nav + 1
< 		    }
949c898
< 		if (logfd != NULL || verbose > 1) {
---
> 		if (logfd != NULL) {
956,963c905,906
< 		    if (logfd != NULL) {
< 			call fprintf (logfd, "    Update sky map: %s\n")
< 			    call pargstr (Memc[str])
< 		    }
< 		    if (verbose > 1) {
< 			call printf ("    Update sky map: %s\n")
< 			    call pargstr (Memc[str])
< 		    }
---
> 		    call fprintf (logfd, "    Update sky map: %s\n")
> 			call pargstr (Memc[str])
978,983d920
< 		    do j = 1, ncblk {
< 			if (IS_INDEFR(Memr[buf+j-1]))
< 			    next
< 			av = av + Memr[buf+j-1]
< 			nav = nav + 1
< 		    }
989,993d925
< 	if (nav > 0)
< 	    av = av / nav
< 	else
< 	    av = INDEFR
< 
996,998c928
< 	if (im != NULL) {
< 	    if (nav > 0)
< 		call imaddr (im, "MEAN", av)
---
> 	if (im != NULL)
1000d929
< 	}
diff ./skyfit.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/skyfit.x
23c23
< 	skymap, sigmap, logfd, verbose)
---
> 	skymap, sigmap, logfd)
35,36c35
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
---
> int	logfd			#I Verbose?
94c93
< 		call fprintf (logfd, "    Determine sigma by constant fit:\n")
---
> 		call fprintf (logfd, "    Determine sigma by surface fit:\n")
116,141d114
< 	if (verbose > 1) {
< 	    if (dosky && dosig)
< 		call printf ("    Determine sky and sigma by surface fits:\n")
< 	    else if (dosky)
< 		call printf ("    Determine sky by surface fit:\n")
< 	    else
< 		call printf ("    Determine sigma by constant fit:\n")
< 	    call printf ("      start line = %d, end line = %d, step = %.1f\n")
< 		call pargi (l1)
< 		call pargi (l2)
< 		call pargr (step)
< 	    call printf ("      xorder = %d, yorder = %d, xterms = %s\n")
< 		call pargi (xorder)
< 		call pargi (yorder)
< 		switch (xterms) {
< 		case GS_XNONE:
< 		    call pargstr ("none")
< 		case GS_XFULL:
< 		    call pargstr ("full")
< 		case GS_XHALF:
< 		    call pargstr ("half")
< 		}
< 	    call printf ("      hclip = %g, lclip = %g\n")
< 		call pargr (hclip)
< 		call pargr (lclip)
< 	}
223a197
> ptr = imgl2r(im,l)
diff ./sky.h /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/sky.h
1c1
< # Sky parameter structure
---
> # Grow parameter structure
3c3
< define	SKY_LEN		10		# Length of parameter structure
---
> define	SKY_LEN		8		# Length of parameter structure
7,11c7,10
< define	SKY_OTYPE	Memi[$1+1]	# Type of output sky
< define	SKY_SCNV	Memi[$1+2]	# Convolve sky?
< define	SKY_SKF		Memi[$1+3]	# Sky fit parameters
< define	SKY_SKB		Memi[$1+4]	# Sky block parameters
< define	SKY_STR		Memc[P2C($1+5)]	# String
---
> define	SKY_SKF		Memi[$1+1]	# Sky fit parameters
> define	SKY_SKB		Memi[$1+2]	# Sky block parameters
> define	SKY_STR		Memc[P2C($1+3)]	# String
> 
16,19d14
< 
< define	SKY_OTYPES	"|subsky|sky|"
< define	SKY_OSUB	1		# Output sky subtracted image
< define	SKY_OSKY	2		# Output sky image
diff ./skyimages.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/skyimages.x
3,4d2
< include	"sky.h"
< include	"skyblock.h"
7c5
< # SKYIMAGES -- Write out sky or sky subtracted images.
---
> # SKYIMAGES -- Write out sky images.
9,10c7
< procedure skyimages (par, outsky, outsig, im, skymap, sigmap, gainmap,
< 	expmap, logfd, verbose)
---
> procedure skyimages (outsky, outsig, im, skymap, sigmap, gainmap, expmap, logfd)
12d8
< pointer	par			#I Sky parameters
21d16
< int	verbose			#I Verbose level
26d20
< int	imaccess()
28c22
< errchk	immap, imgl2r, map_glr, imaddr
---
> errchk	immap, map_glr
31,32c25,26
< 	# Return if no output is needed.
< 	if (outsky[1] == EOS && outsig[1] == EOS || im == NULL)
---
> 	# Return no output is needed.
> 	if (outsky[1] == EOS && outsig[1] == EOS)
35,39d28
< 	if (outsky[1] != EOS && imaccess(outsky,0)==YES)
< 	    call error (1, "Output sky image already exists")
< 	if (outsig[1] != EOS && imaccess(outsig[1],0)==YES)
< 	    call error (1, "Output sky sigma image already exists")
< 
44,50c33,34
< 		switch (SKY_OTYPE(par)) {
< 		case SKY_OSUB:
< 		    call fprintf (logfd, " sky subtracted = %s")
< 		default:
< 		    call fprintf (logfd, " sky = %s")
< 		}
< 		call pargstr (outsky)
---
> 		call fprintf (logfd, " sky = %s")
> 		    call pargstr (outsky)
58,74d41
< 	if (verbose > 1) {
< 	    call printf ("  Output sky images:")
< 	    if (outsky[1] != EOS) {
< 		switch (SKY_OTYPE(par)) {
< 		case SKY_OSUB:
< 		    call printf (" sky subtracted = %s")
< 		default:
< 		    call printf (" sky = %s")
< 		}
< 		call pargstr (outsky)
< 	    }
< 	    if (outsig[1] != EOS) {
< 		call printf (" sigma = %s")
< 		    call pargstr (outsig)
< 	    }
< 	    call printf ("\n")
< 	}
80c47
< 	    if (outsky[1] != EOS && skymap != NULL) {
---
> 	    if (outsky[1] != EOS) {
84c51
< 	    if (outsig[1] != EOS && sigmap != NULL) {
---
> 	    if (outsig[1] != EOS) {
97,103c64
< 		    switch (SKY_OTYPE(par)) {
< 		    case SKY_OSUB:
< 			call asubr (Memr[imgl2r(im,l)], Memr[skydata],
< 			    Memr[impl2r(skyim,l)], nc)
< 		    default:
< 			call amovr (Memr[skydata], Memr[impl2r(skyim,l)], nc)
< 		    }
---
> 		    call amovr (Memr[skydata], Memr[impl2r(skyim,l)], nc)
140,144c101
< 	    if (skyim != NULL) {
< 	        if (!IS_INDEFR(SKB_AVSKY(SKY_SKB(par)))) {
< 		    if (SKY_OTYPE(par) == SKY_OSKY)
< 		        call imaddr (skyim, "MEAN", SKB_AVSKY(SKY_SKB(par)))
< 		}
---
> 	    if (skyim != NULL)
146,151c103
< 	    }
< 	    if (sigim != NULL) {
< 	        if (!IS_INDEFR(SKB_AVSIG(SKY_SKB(par)))) {
< 		    if (SKY_OTYPE(par) == SKY_OSKY)
< 		        call imaddr (skyim, "MEAN", SKB_AVSIG(SKY_SKB(par)))
< 		}
---
> 	    if (sigim != NULL)
153d104
< 	    }
diff ./sky.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/sky.x
3d2
< include	"skyblock.h"
28c27
< 	skyout, sigout, dosky, dosig, logfd, verbose)
---
> 	dosky, dosig, logfd)
38,39d36
< bool	skyout			#I Need sky?
< bool	sigout			#I Need sigma?
42,43c39
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
---
> int	logfd			#I Verbose?
45d40
< int	ival
47c42
< pointer	sp, intro, namesky, namesig
---
> pointer	sp, namesky, namesig
50d44
< real	imgetr()
56d49
< 	call salloc (intro, SZ_FNAME, TY_CHAR)
60,61c53,54
< 	call strcpy ("  Set sky and sigma:\n", Memc[intro])
< 
---
> 	if (logfd != NULL)
> 	    call fprintf (logfd, "  Set sky and sigma:\n")
71,106c64,70
< 	    if (skymap != NULL) {
< 		call map_geti (skymap, "im", ival)
< 		iferr (SKB_AVSKY(SKY_SKB(par)) = imgetr (ival, "MEAN"))
< 		    SKB_AVSKY(SKY_SKB(par)) = INDEFR
< 	        call map_geti (skymap, "interp", ival)
< 		if (ival == NO)
< 		    #SKY_SCNV(par) = YES
< 		    SKY_SCNV(par) = NO
< 	    }
< 	    if (skymap != NULL) {
< 		if (logfd != NULL) {
< 		    call fprintf (logfd, Memc[intro])
< 		    ifnoerr (call map_getr (skymap, "constant", rval)) {
< 			call fprintf (logfd, "    Use constant input sky: %g\n")
< 			    call pargr (rval)
< 		    } else if (SKY_SCNV(par) == YES) {
< 			call fprintf (logfd,
< 			    "    Use convolved input sky: %s\n")
< 			    call pargstr (skyname)
< 		    } else {
< 			call fprintf (logfd, "    Use input sky: %s\n")
< 			    call pargstr (skyname)
< 		    }
< 		}
< 		if (verbose > 1) {
< 		    call printf (Memc[intro])
< 		    ifnoerr (call map_getr (skymap, "constant", rval)) {
< 			call printf ("    Use constant input sky: %g\n")
< 			    call pargr (rval)
< 		    } else if (SKY_SCNV(par) == YES) {
< 			call printf ("    Use convolved input sky: %s\n")
< 			    call pargstr (skyname)
< 		    } else {
< 			call printf ("    Use input sky: %s\n")
< 			    call pargstr (skyname)
< 		    }
---
> 	    if (logfd != NULL && skymap != NULL) {
> 		ifnoerr (call map_getr (skymap, "constant", rval)) {
> 		    call fprintf (logfd, "    Use constant input sky: %g\n")
> 			call pargr (rval)
> 		} else {
> 		    call fprintf (logfd, "    Use input sky: %s\n")
> 			call pargstr (skyname)
108,109d71
< 		if (logfd != NULL || verbose > 1)
< 		    Memc[intro] = EOS
112,115c74
< 	if (skyout)
< 	    dosky = (skymap == NULL)
< 	else
< 	    dosky = false
---
> 	dosky = (skymap == NULL)
125,150c84,90
< 	    if (sigmap != NULL) {
< 		call map_geti (skymap, "im", ival)
< 		iferr (SKB_AVSKY(SKY_SKB(par)) = imgetr (ival, "MEAN"))
< 		    SKB_AVSKY(SKY_SKB(par)) = INDEFR
< 	    }
< 	    if (sigmap != NULL) {
< 		if (logfd != NULL) {
< 		    call fprintf (logfd, Memc[intro])
< 		    ifnoerr (call map_getr (sigmap, "constant", rval)) {
< 			call fprintf (logfd,
< 			    "    Use constant input sigma: %g\n")
< 			    call pargr (rval)
< 		    } else {
< 			call fprintf (logfd, "    Use input sigma: %s\n")
< 			    call pargstr (signame)
< 		    }
< 		}
< 		if (verbose > 1) {
< 		    call printf (Memc[intro])
< 		    ifnoerr (call map_getr (sigmap, "constant", rval)) {
< 			call printf ("    Use constant input sigma: %g\n")
< 			    call pargr (rval)
< 		    } else {
< 			call printf ("    Use input sigma: %s\n")
< 			    call pargstr (signame)
< 		    }
---
> 	    if (logfd != NULL && sigmap != NULL) {
> 		ifnoerr (call map_getr (sigmap, "constant", rval)) {
> 		    call fprintf (logfd, "    Use constant input sigma: %g\n")
> 			call pargr (rval)
> 		} else {
> 		    call fprintf (logfd, "    Use input sigma: %s\n")
> 			call pargstr (signame)
152,153d91
< 		if (logfd != NULL || verbose > 1)
< 		    Memc[intro] = EOS
156,159c94
< 	if (dosky || sigout)
< 	    dosig = (sigmap == NULL)
< 	else
< 	    dosig = false
---
> 	dosig = (sigmap == NULL)
163,168d97
< 	    if (logfd != NULL)
< 		call fprintf (logfd, Memc[intro])
< 	    if (verbose > 1)
< 		call printf (Memc[intro])
< 	    Memc[intro] = EOS
< 
175c104
< 		    skyname, signame, skymap, sigmap, logfd, verbose)
---
> 		    skyname, signame, skymap, sigmap, logfd)
178c107
< 		    "", "", skymap, sigmap, logfd, verbose)
---
> 		    "", "", skymap, sigmap, logfd)
182c111
< 		    skyname, signame, skymap, sigmap, logfd, verbose)
---
> 		    skyname, signame, skymap, sigmap, logfd)
diff ./split.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/split.x
7d6
< include	<aceobjs1.h>
15c14
< procedure split (spt, cat, objmask, siglevel, siglevels, logfd, verbose)
---
> procedure split (spt, cat, objmask, siglevel, siglevels, logfd)
22,23c21
< int	logfd			#I Log FD
< int	verbose			#I Verbose level
---
> int	logfd			#I Logfile
55,56d52
< 	if (spt == NULL)
< 	    return
73,76d68
< 	if (verbose > 1) {
< 	    call printf ("  Split objects: sminpix = %d\n")
< 		call pargi (sminpix)
< 	}
251c243
< 		    nsobjs, CAT_RECLEN(cat), dminpix, sigavg, sigmax)
---
> 		    nsobjs, dminpix, sigavg, sigmax)
254c246
< 		    nsobjs, CAT_RECLEN(cat), sminpix, ssigavg, ssigmax)
---
> 		    nsobjs, sminpix, ssigavg, ssigmax)
418c410
< procedure srenum (cat, om, sm, ids, sobjs, nsobjs, objlen, minpix,
---
> procedure srenum (cat, om, sm, ids, sobjs, nsobjs, minpix,
427d418
< int	objlen			#I Object record length
524c515
< 	    call newobj (obj, objlen)
---
> 	    call newobj (obj)
diff ./t_acecopy.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/t_acecopy.x
77c77
< 		    "", NULL, 1)
---
> 		    "", NULL)
105c105
< 		call catclose (cat, NO)
---
> 		call catclose (cat)
diff ./t_acegeomap.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/t_acegeomap.x
7c7
< include	"acematch.h"
---
> include	"acecatmatch.h"
9c9
< define	STRUCTDEF	"acesrc$acematch.h"
---
> define	STRUCTDEF	"ace$src/acecatmatch.h"
128c128
< 			        "", STRUCTDEF, NULL, 1)
---
> 			        "", STRUCTDEF, NULL)
131c131
< 			        "", STRUCTDEF, NULL, 1)
---
> 			        "", STRUCTDEF, NULL)
161c161
< 		    call catclose (Memi[cat+i], NO)
---
> 		    call catclose (Memi[cat+i])
198c198
< 		call catopen (cat, catname, catname, catdef, STRUCTDEF, NULL, 1)
---
> 		call catopen (cat, catname, catname, catdef, STRUCTDEF, NULL)
200c200
< 		call catopen (cat, catname, "", catdef, STRUCTDEF, NULL, 1)
---
> 		call catopen (cat, catname, "", catdef, STRUCTDEF, NULL)
diff ./t_acesetwcs.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/t_acesetwcs.x
9c9
< define	STRUCTDEF	"acesrc$acesetwcs.h"
---
> define	STRUCTDEF	"ace$src/acesetwcs.h"
32c32
< pointer	cat, dt, im, coo, tcoo, mw, sx1, sy1, sx2, sy2, ptr
---
> pointer	cat, dt, im, coo, tcoo, mw, sx1, sy1, sx2, sy2
37d36
< int	catrrec()
142c141
< 		   STRUCTDEF, NULL, 1)
---
> 		   "", NULL)
144c143
< 	        call catopen (cat, Memc[catalog], "", "", "", NULL, 1)
---
> 	        call catopen (cat, Memc[catalog], "", "", "", NULL)
152c151
< 		call catclose (cat, NO)
---
> 		call catclose (cat)
259,267c258,260
< 	        # First check if all fields are present.
< 		if (catrrec (cat, ptr, 1) != 4)
< 		    call eprintf ( "WARNING: Missing fields for evaluation\n")
< 		else {
< 		    call catrrecs (cat, "", -1)
< 		    call cc_catwcs (cat, im)
< 		    call catwrecs (cat, "", INDEFI)
< 		}
< 		call mfree (ptr, TY_STRUCT)
---
> 		call catrrecs (cat, "", -1)
> 		call cc_catwcs (cat, im)
> 		call catwrecs (cat, "")
271c264
< 	    call catclose (cat, NO)
---
> 	    call catclose (cat)
582c575
< 	    call printf ("    Ra/Dec logical axes: %d  %d\n")
---
> 	    call printf ("    Ra/Dec logical image axes: %d  %d\n")
584c577
< 	    call printf ("    Long/Lat logical axes: %d  %d\n")
---
> 	    call printf ("    Long/Lat logical image axes: %d  %d\n")
1432,1435c1425,1427
< 	    if (IS_INDEFR(OBJ_X(obj)) || IS_INDEFR(OBJ_Y(obj))) {
< 		#OBJ_RA(obj) = INDEFD
< 		#OBJ_DEC(obj) = INDEFD
< 		;
---
> 	    if (IS_INDEFD(OBJ_PX(obj)) || IS_INDEFD(OBJ_PY(obj))) {
> 		OBJ_WX(obj) = INDEFD
> 		OBJ_WY(obj) = INDEFD
1437,1440c1429,1432
< 		call mw_c2trand (ctw, double(OBJ_X(obj)),
< 		    double(OBJ_Y(obj)), OBJ_RA(obj), OBJ_DEC(obj))
< 		OBJ_RA(obj) = OBJ_RA(obj) / xscale
< 		OBJ_DEC(obj) = OBJ_DEC(obj) / yscale
---
> 		call mw_c2trand (ctw, OBJ_PX(obj), OBJ_PY(obj),
> 		    OBJ_WX(obj), OBJ_WY(obj))
> 		OBJ_WX(obj) = OBJ_WX(obj) / xscale
> 		OBJ_WY(obj) = OBJ_WY(obj) / yscale
diff ./t_acexymatch.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/t_acexymatch.x
8c8
< define	STRUCTDEF	"acesrc$acematch.h"
---
> define	STRUCTDEF	"ace$src/acematch.h"
129c129
< 		        Memc[icatdef], STRUCTDEF, NULL, 1)
---
> 		        Memc[icatdef], STRUCTDEF, NULL)
161c161
< 		call catopen (newcat, "", Memc[mcat], "", STRUCTDEF, NULL, 1)
---
> 		call catopen (newcat, "", Memc[mcat], "", STRUCTDEF, NULL)
163c163
< 		call catclose (newcat, NO)
---
> 		call catclose (newcat)
168,169c168,169
< 		call catclose (Memi[cat2+i-1], NO)
< 		call catclose (Memi[cat1+i-1], NO)
---
> 		call catclose (Memi[cat2+i-1])
> 		call catclose (Memi[cat1+i-1])
284c284
< 	    call catopen (cat, catname, "", catdef, STRUCTDEF, NULL, 1)
---
> 	    call catopen (cat, catname, "", catdef, STRUCTDEF, NULL)
diff ./test.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/test.x
5c5,8
< pointer	cat
---
> int	i, j
> int	axno[2], axval[2]
> double	x, y, r, d, ltv[2], ltm[2,2], r[2]
> pointer	im, mw, ctlw, ctwl, immap(), mw_openim(), mw_sctran()
8c11,81
< 	call catopen (cat, "", "junk", "catdef.dat", "lib/aceobjs.h", NULL, 3)
---
> 	im = immap ("test", READ_ONLY, 0)
> 	mw = mw_openim (im)
> 
> 
> 	x = 1
> 	y = 1000
> 	ctlw = mw_sctran (mw, "logical", "world", 3)
> 	call mw_c2trand (ctlw, x, y, d, r)
> 	call mw_ctfree (ctlw)
> 	call printf ("%.1f %.1f %.2H %.1h\n")
> 	    call pargd (x)
> 	    call pargd (y)
> 	    call pargd (r)
> 	    call pargd (d)
> 
> #	call mw_gaxmap (mw, axno, axval, 2)
> #	axno[1] = 2
> #	axno[2] = 1
> #	call mw_saxmap (mw, axno, axval, 2)
> #	call mw_gltermd (mw, ltm, ltv, 2)
> #	x = ltv[1]
> #	ltv[1] = ltv[2]
> #	ltv[2] = x
> #	x = ltm[1,1]
> #	ltm[1,1] = ltm[1,2]
> #	ltm[1,2] = x
> #	x = ltm[2,2]
> #	ltm[2,2] = ltm[2,1]
> #	ltm[2,1] = x
> #	call mw_sltermd (mw, ltm, ltv, 2)
> 	
> 	call mw_swattrs (mw, 1, "axtype", "ra")
> 	call mw_swattrs (mw, 2, "axtype", "dec")
> 
> 	call mw_gwtermd (mw, r, ltv, ltm, 2)
> #	x = r[1]
> #	r[1] = r[2]
> #	r[2] = x
> 	x = ltv[1]
> 	ltv[1] = ltv[2]
> 	ltv[2] = x
> 	x = ltm[1,1]
> 	ltm[1,1] = ltm[1,2]
> 	ltm[1,2] = x
> 	x = ltm[2,2]
> 	ltm[2,2] = ltm[2,1]
> 	ltm[2,1] = x
> 	call mw_swtermd (mw, r, ltv, ltm, 2)
> 
> 	x = 1
> 	y = 1000
> 	ctlw = mw_sctran (mw, "logical", "world", 3)
> 	call mw_c2trand (ctlw, x, y, r, d)
> 	call mw_ctfree (ctlw)
> 	call printf ("%.1f %.1f %.2H %.1h\n")
> 	    call pargd (x)
> 	    call pargd (y)
> 	    call pargd (r)
> 	    call pargd (d)
> 
> 	ctwl = mw_sctran (mw, "world", "logical", 3)
> 	call mw_c2trand (ctwl, r, d, x, y)
> 	call mw_ctfree (ctwl)
> 	call printf ("%.1f %.1f %.2H %.1h\n")
> 	    call pargd (x)
> 	    call pargd (y)
> 	    call pargd (r)
> 	    call pargd (d)
> 
> 	call mw_close (mw)
> 	call imunmap (im)
diff ./t_mefmerge.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/t_mefmerge.x
80c80
< 		    "", NULL, 1)
---
> 		    "", NULL)
128c128
< 		call catclose (cat, NO)
---
> 		call catclose (cat)
diff ./x_ace.x /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/x_ace.x
1,2c1
< task	aceall = t_aceall,
< 	acecatalog = t_acecatalog,
---
> task	acecatmatch = t_acecatmatch,
4,7c3,7
< 	acediff = t_acediff,
< 	aceevaluate = t_aceevaluate,
< 	acefilter = t_acefilter,
< 	acefocus = t_acefocus,
---
> 	detect = t_acedetect,
> 	diffdetect = t_diffdetect,
> 	evaluate = t_aceevaluate,
> 	overlay = t_acedisplay,
> 	skyimages = t_acesky,
9,10d8
< 	acematch = t_acematch,
< 	acesegment = t_acesegment,

Common subdirectories: ./acetools and /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src/acetools

Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: acecatmatch.h
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: acecatmatch.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: catfunc.x
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: detect.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: diffdetect.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: evaluate.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: objmasks1.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: objmasks.cl
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: objmasks.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: overlay.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: skyimages.par
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: t_acecatmatch.x
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: t_acedetect.x
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: xtmaskname.x
Only in /pipedevn/pipeline/valdes/V1.0/MarioSrc/lib/ace/src: xtpmmap.x

Only in .: aceall
Only in .: aceall.par
Only in .: acecatalog
Only in .: acecatalog.par
Only in .: acedemo
Only in .: acediff
Only in .: acediff.par
Only in .: aceevaluate
Only in .: aceevaluate.par
Only in .: acefilter.par
Only in .: acefocus.h
Only in .: acefocus.key
Only in .: acefocus.par
Only in .: acefunc.x
Only in .: acematch.par
Only in .: acemulticat.x
Only in .: aceoffsets.x
Only in .: acesegment
Only in .: acesegment.par
Only in .: acetvmark.cl
Only in .: ace.x
Only in .: ace.xBAK
Only in .: afn.x
Only in .: awvgr.x
Only in .: BAK
Only in .: caflux.x
Only in .: catdef.dat
Only in .: convolveNEW.x
Only in .: .cvsignore
Only in .: diff
Only in .: doc
Only in .: eaflux.h
Only in .: eaflux.x
Only in .: evaluate.xALT
Only in .: filter.h
Only in .: foo
Only in .: gwt.h
Only in .: gwt.hBAK1
Only in .: gwt.x
Only in .: gwt.xBAK1
Only in .: impmmapo.x
Only in .: lib
Only in .: libpkg.a
Only in .: mom.x
Only in .: omcat.x
Only in .: overlay.cl
Only in .: starfocus.h
Only in .: stf
Only in .: t_acefocus.x
Only in .: t_acematch.x
Only in .: t_ace.x
Only in .: txt.x
Only in .: x_ace.o
