Until now, I had been investigating ways to step back to brighter pixels for finding a good stage to stop the growth of the clump. However, a few days ago, while investigating another issue with Sepideh Eskandarlou, we discovered a very interesting potential solution:

We can derive the azimuthal angle of a pixel in a profile by looking at its four-connected neighbors: If we define 'dx' as the difference of value between the next and previous pixels in the horizontal (X) direction, and 'dy' similarly for the Y direction, we can obtain the azimuthal angle of the pixel by taking the 'atan2' of 'dy/dx'.

In the left image below, you can see a small point-source on the wing of a bright elliptical Sersic profile. and on the right, you can see how the output of the analysis above (done through simple kernels with 'arithmetic').



As you see from this image, as long as we are primarily influenced by the point source, we fully cover the range of azimuthal degrees (0 to 360). But once we reach the part where the main galaxy dominates, the range of azimuthal angles significantly decreases to one small interval.

By checking the interval of the azimuthal angles as layers are added, we should be able to constrain the border of the small object without eating too much of the wing of the bright one.

We can use bits in one integer (maybe 16bit) to keep track of the azimuthal coverage as we expand the clump. We should explore this...

Thanks a lot to Sepideh for the very productive discussion that lead to this.

When a clump falls on the gradient of a large object, in the current implementation of Segment, it will steal a large fraction of flux from the large object. The code below in the P.S can be put in a simple shell script to reproduce the problem.

P.S. Code to reproduce the problem.

# Parameters.
oversample=5
zeropoint=22
background=20

# Abort in case of an error.
set -e

# Make a build directory if it doesn't already exist.
if ! [ -d build ]; then mkdir build; fi

# Generate the catalog
cat=build/cat.txt
echo "1 0   0   2 3  2.8 0 1   5  5"  > $cat # PSF
echo "1 100 100 1 15 1   0 0.4 9  5" >> $cat # Galaxy
echo "1 110 100 4 0  0   0 0   13 0" >> $cat # Star

# Build an image and a convolution kernel.
psf=build/psf.fits
raw=build/raw.fits
astmkprof $cat --mergedsize=200,200 \
          --zeropoint=$zeropoint -o$raw \
          --oversample=$oversample
mv build/0_raw.fits $psf

# Convolve the image with the kernel.
conv=build/conv.fits
astconvolve $raw --kernel=$psf -o$conv

# Undersample the convolved image.
nonoise=build/no-noise.fits
astwarp $conv --centeroncorner --scale=1/$oversample \
        --output=$nonoise

# Add noise
noised=build/noised.fits
export GSL_RNG_SEED=1657794821
astarithmetic $nonoise $background $zeropoint \
              mag-to-counts mknoise-poisson \
              -o$noised --envseed

# Detect the signal
det=build/detected.fits
astnoisechisel $noised --tilesize=10,10 -o$det

# Segment the signal
seg=build/segment.fits
astsegment $det -o$seg