src/common/abitmap.cpp

#ifndef lint
static const char RCSid[] = "$Id$";
#endif
/*
 *  abitmap.cpp
 *  panlib
 *
 *  General bitmap class implementation
 *
 *  Created by gward on Wed Oct 31 2001.
 *  Copyright (c) 2022 Anyhere Software. All rights reserved.
 *
 */

#include <string.h>
#include <math.h>
#include "abitmap.h"

// Private workhorse bit copy function; handles overlaps but no length checks
static void
moveBits(uint32 *bdst, uint32 idst, const uint32 *bsrc, uint32 isrc, uint32 n)
{
        if (!n)
                return;
        bdst += idst >> 5; idst &= 0x1f;
        bsrc += isrc >> 5; isrc &= 0x1f;
        if ((bdst == bsrc) & (idst == isrc))
                return;
        uint32  sword[2];
        if (n <= 32) {                          // short string case
                sword[0] = bsrc[0];
                sword[1] = bsrc[isrc+n > 32];
                bsrc = sword;
                while (n--) {
                        *bdst &= ~(1 << idst);
                        *bdst |= ((*bsrc >> isrc) & 1) << idst;
                        if (++idst > 0x1f) { idst=0; ++bdst; }
                        if (++isrc > 0x1f) { isrc=0; ++bsrc; }
                }
                return;
        }
        const bool      reverse = (bdst==bsrc) ? (idst > isrc) : (bdst > bsrc);
        const int       boff = isrc-idst & 0x1f;
        const bool      woff = (isrc > idst);
        const bool      partstart = (idst != 0);
        const bool      partend = ((idst+n & 0x1f) != 0);
        const int       lastword = (idst+n) >> 5;
        uint32          mask;
                                // messy starting-word stuff
#define DO_FIRSTPART if (partstart) { \
                sword[0] = bsrc[0]; sword[1] = bsrc[1]; \
                bdst[0] &= mask = (1<<idst)-1; \
                if (boff) { \
                        bdst[0] |= sword[woff]<<(32-boff) & ~mask; \
                        if (woff) bdst[0] |= sword[0]>>boff & ~mask; \
                } else \
                        bdst[0] |= sword[0] & ~mask; \
        } else
                                // messy ending-word stuff
#define DO_LASTPART if (partend) { \
                mask = ~0 << (idst+n & 0x1f); \
                bool    beyond = (1<<(32-boff) & ~mask); \
                sword[0] = bsrc[lastword-1]; \
                if (!boff | woff | beyond) sword[1] = bsrc[lastword]; \
                bdst[lastword] &= mask; \
                if (boff) { \
                        bdst[lastword] |= (sword[woff]>>boff) & ~mask; \
                        if (beyond) \
                                bdst[lastword] |= (woff ? bsrc[lastword+1] : sword[1]) \
                                                        << (32-boff) & ~mask; \
                } else \
                        bdst[lastword] |= sword[1] & ~mask; \
        } else
        if (reverse)
                DO_LASTPART;
        else
                DO_FIRSTPART;
        if (boff) {                             // middle part (unaligned case)
                int     i;
                if (reverse) {
                        for (i = lastword; --i > 0; )
                                bdst[i] = bsrc[i+woff]<<(32-boff) | bsrc[i+woff-1]>>boff;
                        if (!partstart) {
                                bdst[0] = bsrc[woff]<<(32-boff);
                                if (woff) bdst[0] |= bsrc[0]>>boff;
                        }
                } else {
                        if (!partstart) {
                                bdst[0] = bsrc[woff]<<(32-boff);
                                if (woff) bdst[0] |= bsrc[0]>>boff;
                        }
                        for (i = 0; ++i < lastword; )
                                bdst[i] = bsrc[i+woff]<<(32-boff) | bsrc[i+woff-1]>>boff;
                }
        } else {                                // middle (aligned word case)
                memmove(bdst+partstart, bsrc+partstart,
                                (lastword-partstart)*sizeof(uint32));
        }
        if (reverse)
                DO_FIRSTPART;
        else
                DO_LASTPART;
#undef DO_FIRSTPART
#undef DO_LASTPART
}

// Create and clear a new bitmap
bool
ABitMap::NewBitMap(uint32 n, bool clrset)
{
        int32   onwords = bmlen();
        len = n;
        int32   nwords = bmlen();
        if (nwords != onwords) {
                delete [] bmap;
                if (nwords) bmap = new uint32 [nwords];
                else bmap = 0;
        }
        if (!nwords)
                return false;
        ClearBitMap(clrset);
        return true;
}

// Clear bitmap to given value
void
ABitMap::ClearBitMap(bool clrset)
{
        memset(bmap, clrset * 0xff, sizeof(uint32)*bmlen());
}

// Invert the entire bitmap
void
ABitMap::Invert()
{
        uint32 *        wp = bmap + bmlen();
        while (wp-- > bmap)
                *wp = ~*wp;
}

// Extract bitmap section
bool
ABitMap::GetBits(ABitMap *dp, uint32 i) const
{
        if (!dp | (dp == this))
                return false;
        if (i >= len)
                return false;
        if (!dp->len && !dp->NewBitMap(len-i))
                return false;
        if (!i & (dp->len == len)) {
                *dp = *this;
                return true;
        }
        uint32  n = dp->len;
        if (n > len-i)
                n = len-i;
        moveBits(dp->bmap, 0, bmap, i, n);
        return true;
}

// Overlay bitmap section (ignores bits past end)
bool
ABitMap::AssignBits(uint32 i, const ABitMap &src)
{
        if (!src.len)
                return true;
        if (!i & (src.len == len)) {
                *this = src;
                return true;
        }
        if (i >= len)
                return false;
        moveBits(bmap, i, src.bmap, 0, (len-i < src.len) ? len-i : src.len);
        return true;
}

// Apply operation to bitmap section
bool
ABitMap::OpBits(uint32 i, char op, const ABitMap &src)
{
        if (!src.len | !len)
                return false;
        if (op == '=')
                return AssignBits(i, src);
        ABitMap bits(src.len);
        if (!GetBits(&bits, i))
                return false;
        switch (op) {
        case '|':
                bits |= src;
                break;
        case '&':
                bits &= src;
                break;
        case '^':
                bits ^= src;
                break;
        case '-':
        case '>':
                bits -= src;
                break;
        case '<':
                bits.Invert();
                bits &= src;
                break;
        default:
                return false;
        }
        return AssignBits(i, bits);
}

// Clear bitmap section
void
ABitMap::ClearBits(uint32 i, uint32 n, bool clrset)
{
        if (i >= len)
                return;
        if (n >= len - i) {
                if (!i) {
                        ClearBitMap(clrset);
                        return;
                }
                n = len - i;
        } else if (!n)
                return;

        const uint32 * const    sectEnd = bmap + ((i+n)>>5);
        uint32 *                wp = bmap + (i>>5);
        if (wp == sectEnd) {            // single word clear?
                const uint32    bits = (~0 << (i & 0x1f) &
                                        (1 << (i+n & 0x1f)) - 1);
                if (clrset)
                        *wp |= bits;
                else
                        *wp &= ~bits;
                return;
        }
        const uint32            clrWord = clrset * ~0;
        if (i & 0x1f) {                 // partial first word?
                if (clrset)
                        *wp++ |= ~0 << (i & 0x1f);
                else
                        *wp++ &= (1 << (i & 0x1f)) - 1;
        }
        while (wp < sectEnd)            // central words
                *wp++ = clrWord;
        if (i+n & 0x1f) {               // partial last word?
                if (clrset)
                        *wp |= (1 << (i+n & 0x1f)) - 1;
                else
                        *wp &= ~0 << (i+n & 0x1f);
        }
}

// Total all bits set in bitmap
uint32
ABitMap::SumTotal(bool bit2cnt) const
{
        static char     bitCount[256];
        int             i;
        if (!bitCount[255]) {
                for (i = 256; --i; )
                        for (int bits = i; bits; bits >>= 1)
                                bitCount[i] += (bits & 1);
        }
        uint32                  count = 0;
        const unsigned char *   cp;
        cp = (const unsigned char *)(bmap + bmlen());
        if (len & 0x1f) {               // partial last word
                uint32          lastBits = WordV(len-1);
                lastBits &= (1<<(len&0x1f)) - 1;
                for (i = sizeof(uint32); i--; lastBits >>= 8)
                        count += bitCount[lastBits & 0xff];
                cp -= sizeof(uint32);
        }
        while (cp > (const unsigned char *)bmap)
                count += bitCount[*--cp];
        if (bit2cnt)
                return count;
        return len - count;
}

// Return the next bit position matching val (or ABMend if no match)
uint32
ABitMap::Find(uint32 i, bool val) const
{
        const uint32    clrWord = !val * ~0;
        const uint32 *  wp = bmap + (i>>5);
        uint32          b = Bit(i);

        wp -= !(i & 0x1f);

        while (i < len) {
                if (!(i & 0x1f)) {
                        while (*++wp == clrWord)
                                if ((i += 0x20) >= len)
                                        return ABMend;
                        b = 1;
                }
                if (((*wp & b) != 0) == val)
                        return i;
                b <<= 1;
                ++i;
        }
        return ABMend;
}

// Shift bits downward in bitmap, zero fill
ABitMap &
ABitMap::operator>>=(uint32 nbits)
{
        if (!nbits)
                return *this;
        if (nbits >= len) {
                ClearBitMap();
                return *this;
        }
        moveBits(bmap, 0, bmap, nbits, len-nbits);
        ClearBits(len-nbits, nbits);
        return *this;
}

// Shift bits upwards in bitmap, zero fill
ABitMap &
ABitMap::operator<<=(uint32 nbits)
{
        if (!nbits)
                return *this;
        if (nbits >= len) {
                ClearBitMap();
                return *this;
        }
        moveBits(bmap, nbits, bmap, 0, len-nbits);
        ClearBits(0, nbits);
        return *this;
}

// Bitmap copy operator
ABitMap &
ABitMap::operator=(const ABitMap &src)
{
        if (this == &src)
                return *this;
        int32   nwords = src.bmlen();
        if (nwords != bmlen()) {
                delete [] bmap;
                if (nwords) bmap = new uint32 [nwords];
                else bmap = 0;
        }
        len = src.len;
        memcpy(bmap, src.bmap, nwords*sizeof(uint32));
        return *this;
}

// Bitmap OR-copy operator (reverts to copy for different size bitmaps)
ABitMap &
ABitMap::operator|=(const ABitMap &src)
{
        if (this == &src)
                return *this;
        if (len != src.len)
                return *this = src;
        const int32     nwords = bmlen();
        const uint32 *  owp = src.bmap + nwords;
        uint32 *        wp = bmap + nwords;
        while (wp > bmap)
                *--wp |= *--owp;
        return *this;
}

// Bitmap AND-assign operator (no effect for different size bitmaps)
ABitMap &
ABitMap::operator&=(const ABitMap &src)
{
        if (this == &src)
                return *this;
        if (len != src.len)
                return *this;
        const int32     nwords = bmlen();
        const uint32 *  owp = src.bmap + nwords;
        uint32 *        wp = bmap + nwords;
        while (wp > bmap)
                *--wp &= *--owp;
        return *this;
}

// Bitmap XOR-assign operator (no effect for different size bitmaps)
ABitMap &
ABitMap::operator^=(const ABitMap &src)
{
        if (this == &src) {
                ClearBitMap();
                return *this;
        }
        if (len != src.len)
                return *this;
        const int32     nwords = bmlen();
        const uint32 *  owp = src.bmap + nwords;
        uint32 *        wp = bmap + nwords;
        while (wp > bmap)
                *--wp ^= *--owp;
        return *this;
}

// Clear bits set in second bitmap
bool
ABitMap::ClearBitsFrom(const ABitMap &src)
{
        if (this == &src) {
                ClearBitMap();
                return true;
        }
        if (src.len != len)
                return false;
        uint32 *        wp = bmap + bmlen();
        const uint32 *  sp = src.bmap + src.bmlen();
        while (wp > bmap)
                *--wp &= ~*--sp;
        return true;
}

// Compare two bitmaps for equality
bool
ABitMap::operator==(const ABitMap &that) const
{
        if (this == &that)
                return true;
        if (len != that.len)
                return false;
        if (!len)
                return true;
        const int       nwords = len >> 5;
        const uint32 *  owp = that.bmap + nwords;
        const uint32 *  wp = bmap + nwords;
        if (len & 0x1f && (*--wp ^ *--owp) & (1<<(len&0x1f))-1)
                return false;
        while (wp > bmap)
                if (*--wp != *--owp)
                        return false;
        return true;
}

/*************** Run-length compander section ***************
 *  First bit is:
 *      0       => non-run
 *      1       => run
 *  Next N "0" bits indicate counter length-3, "1"-terminated:
 *      001     => e.g., 5-bit counter follows
 *  Next N+3 bits constitute counter M, with implied "1" in leftmost bit
 *      00001   => e.g., 33 run or non-run length
 *  Next bit is "0" for a run of M 0's, or "1" for a run of 1's,
 *  OR M bits of non-run data.
 *
 *  Example 1:  "00101101"      => "0 1 000 00101101"
 *  Example 2:  49 1's          => "1 001 10001 1"
 *  Example 3:  7326 0's        => "1 0000000001 110010011110 0"
 *
 *  Note that any run or non-run must span 8 bits or more in source, and
 *  will take up at least 6 encoded bits for a run and 13 for a non-run.
 *  Encoding a bitmap < 72 bits long is never a win, and < 8 is
 *  not possible.  A bitmap <= 64 bits in length will be passed as is.
 *  Decoding is trivial compared to logical constraints during encode.
 */

#define RLEmagic        0x1700A9A5      // magic number (32-bits)
#define MinCntB         3               // minimum counter length
#define MinCnt          (1<<MinCntB)    // minimum encodable bit sequence

// Get original bitmap length if RLE (or 0)
uint32
ABitMap::RLength() const
{
        if (bmlen() < 3 || bmap[0] != RLEmagic) return 0;
        return bmap[1];
}

// Compress into a run-length encoded bitmap
bool
ABitMap::GetRLE(ABitMap *rlep) const
{
        if (!rlep)
                return false;
        if (RLength())                  // already encoded?
                return false;
        if (len <= 64) {                // don't bother?
                *rlep = *this;
                return len;
        }
                                        // create draft bitmap
        ABitMap tmap(len + len/50 + 128);
        tmap.bmap[0] = RLEmagic;        // mark as RLE
        tmap.bmap[1] = len;             // record original length
        uint32  i=0, o=64;              // encode bits
        while (i < len) {
                uint32  cnt, cbex;
                uint32  start = i++;    // check for usable run
                if (!Find(&i, !Check(start)))
                        i = len;
                else if (i > len - MinCnt)
                        i = len - MinCnt;

                if (i >= start + MinCnt) {
                        tmap.Set(o++);  // encode a run
                        cnt = (i - start)>>MinCntB;
                        cbex = MinCntB; // counter width
                        while (cnt > 1) {
                                o++;
                                cbex++;
                                cnt >>= 1;
                        }
                        tmap.Set(o++);  // 1 terminator, then count
                        cnt = i - start;
                        while (cbex-- > 0) {
                                if (cnt & 1<<cbex) tmap.Set(o);
                                ++o;
                        }               // followed by repeat bit
                        if (Check(start))
                                tmap.Set(o);
                        ++o;
                        continue;       // move on to next
                }
                i = start + MinCnt;     // else encode non-run
                if (i + MinCnt > len)
                        i = len;        // non-run to end
                while (i < len) {       // stop at next useful run
                        bool    cand = Check(i);
                        uint32  candStart = i;
                        while (++i < len && Check(i) == cand)
                                if (i - candStart > 2*(2+MinCntB)+1) {
                                        i = candStart;
                                        candStart = ABMend;
                                        break;
                                }
                        if (candStart == ABMend)
                                break;  // found run worth stopping for
                }
                o++;                    // encode our non-run
                cnt = (i - start)>>MinCntB;
                if (!cnt)
                        goto calamity;  // should never occur!
                cbex = MinCntB;         // counter width
                while (cnt > 1) {
                        o++;
                        cbex++;
                        cnt >>= 1;
                }
                tmap.Set(o++);          // 1 terminator, then count
                cnt = i - start;
                while (cbex-- > 0) {
                        if (cnt & 1<<cbex) tmap.Set(o);
                        ++o;
                }                       // finally, copy bit data
                if (o + cnt > tmap.len)
                        goto calamity;  // over-ran temp buffer!
                moveBits(tmap.bmap, o, bmap, start, cnt);
                o += cnt;               // onwards...
        }
                                        // copy to right-sized array
        if (rlep->NewBitMap(o) && tmap.GetBits(rlep, 0))
                return true;
calamity:               // XXX should really speak up if we get here!
        return false;
}

// Reconstitute bits from RLE encoding
bool
ABitMap::SetFromRLE(const ABitMap &rle)
{
        if (rle.len <= 64) {            // never was encoded?
                *this = rle;
                return len;
        }
        if (&rle == this) {             // cuidado!
                ABitMap         tmap;
                return tmap.Take(this) && SetFromRLE(tmap);
        }
        if (!NewBitMap(rle.RLength()))  // start from 0's
                return false;
        uint32  i=64, o=0;              // decode bits
        while (i < rle.len) {
                bool    isrun = rle.Check(i++);
                int     cntlen = MinCntB;
                while (!rle.Check(i++)) cntlen++;
                if (cntlen > 31)
                        return false;
                uint32  rlen = 1;       // get output count
                while (cntlen--)
                        rlen = (rlen<<1) + rle.Check(i++);
                if (!isrun) {           // copy bits
                        if ((i+rlen > rle.len) | (o+rlen > len))
                                return false;
                        moveBits(bmap, o, rle.bmap, i, rlen);
                        i += rlen;
                } else if (rle.Check(i++))
                        ClearBits(o, rlen, true);

                if ((o += rlen) >= len) // advance output index
                        break;
        }
        return (i == rle.len) & (o == len);
}

/*************** 2-D bitmap section ***************/

// Reconstitute bits from RLE encoding (size must match)
bool
ABitMap2::SetFromRLE(int w, int h, const ABitMap &rle)
{
        uint32  orig_len = rle.RLength();

        if ((w <= 0) | (h <= 0) | (orig_len != (uint32)w*h))
                return false;

        if (!ABitMap::SetFromRLE(rle))
                return false;

        width = w; height = h;
        return true;
}

// Extract bitmap section, true if some overlap
bool
ABitMap2::GetRect(ABitMap2 *dp, int sx, int sy) const
{
        if (!dp | (dp == this))
                return false;
        if ((sx >= width) | (sy >= height))
                return false;
        if (dp->width <= 0 && !dp->NewBitMap(width-sx, height-sy))
                return false;
        if (!sx & !sy & (dp->width == width) & (dp->height == height)) {
                *dp = *this;
                return true;
        }
        int             dx=0, dy=0;
        if (sx < 0) {
                if ((dx = -sx) >= dp->width) return false;
                sx = 0;
        }
        if (sy < 0) {
                if ((dy = -sy) >= dp->height) return false;
                sy = 0;
        }
        const int       rowwidth = (dp->width-dx > width-sx) ? width-sx : dp->width-dx;
        int             rowcount = (dp->height-dy > height-sy) ? height-sy : dp->height-dy;
        if ((rowwidth == width) & (width == dp->width))
                moveBits(dp->base(), dp->width*dy, base(), width*sy, rowwidth*rowcount);
        else
                while (rowcount--)
                        moveBits(dp->base(), dp->width*dy++ + dx,
                                        base(), width*sy++ + sx, rowwidth);
        return true;    
}

// Assign bitmap section (ignores anything past edges)
bool
ABitMap2::AssignRect(int dx, int dy, const ABitMap2 &src)
{
        if (src.width <= 0)
                return true;
        if ((dx >= width) | (dy >= height))
                return false;
        if (!dx & !dy && (src.width == width) & (src.height == height)) {
                *this = src;
                return true;
        }
        int             sx=0, sy=0;
        int             w=src.width, h=src.height;
        if (dx < 0) {
                if ((sx = -dx) >= w) return false;
                dx = 0; w -= sx;
        }
        if (dy < 0) {
                if ((sy = -dy) >= h) return false;
                dy = 0; h -= sy;
        }
        if (dx+w > width) w = width - dx;
        if (dy+h > height) h = height - dy;
        if ((w <= 0) | (h <= 0))
                return false;
        if ((w == width) & (width == src.width))
                moveBits(base(), width*dy, src.base(), src.width*sy, w*h);
        else
                while (h--)
                        moveBits(base(), width*dy++ + dx,
                                        src.base(), src.width*sy++ + sx, w);
        return true;
}

// Apply operation to bitmap section
bool
ABitMap2::OpRect(int dx, int dy, char op, const ABitMap2 &src)
{
        if ((src.width <= 0) | (width <= 0))
                return false;
        if (op == '=')
                return AssignRect(dx, dy, src);
        ABitMap2        rbits(src.width, src.height);
        if (!GetRect(&rbits, dx, dy))
                return false;
        switch (op) {
        case '|':
                rbits |= src;
                break;
        case '&':
                rbits &= src;
                break;
        case '^':
                rbits ^= src;
                break;
        case '-':
        case '>':
                rbits -= src;
                break;
        case '<':
                rbits.Invert();
                rbits &= src;
                break;
        default:
                return false;
        }
        return AssignRect(dx, dy, rbits);
}

// Clear a rectangle
void
ABitMap2::ClearRect(int x, int y, int w, int h, bool clrset)
{
        if (x < 0) { w += x; x = 0; }
        if (y < 0) { h += y; y = 0; }
        if (w > width - x)
                w = width - x;
        if (w <= 0)
                return;
        if (h > height - y)
                h = height - y;
        if (h <= 0)
                return;
        if (w == width)                 // contiguous case
                ClearBits(y*width, h*width, clrset);
        else
                while (h--)             // discontiguous
                        ClearBits(bmi(x,y++), w, clrset);
}

// Get bounds of assigned region
bool
ABitMap2::GetBoundRect(int xymin[2], int wh[2], bool val) const
{
        int     x=0, y=0;

        if (!xymin | !wh)
                return false;
        if (!Find(&x, &y, val)) {
                xymin[0] = xymin[1] = wh[0] = wh[1] = 0;
                return false;
        }
        xymin[0] = x; xymin[1] = y;
        int     xymax[2] = {x, y};
        do {
                if (x < xymin[0]) xymin[0] = x;
                xymax[1] = y;

                if (Check(width-1, y) == val) {
                        xymax[0] = width-1;
                        x = 0; ++y;
                        continue;
                }
                if (++x < xymax[0]) x = xymax[0];
                Find(&x, &y, !val);     // never false after above Check()
                if (x-1 > xymax[0]) xymax[0] = x-1;
        } while (Find(&x, &y, val));

        wh[0] = xymax[0] - xymin[0] + 1;
        wh[1] = xymax[1] - xymin[1] + 1;
        return true;
}

// Shift bitmap image right-left and down-up, filling as indicated
void
ABitMap2::Shift(int dx, int dy, int fill)
{
        int     adx = (dx > 0) ? dx : -dx;
        int     ady = (dy > 0) ? dy : -dy;
        if ((adx >= width) | (ady >= height)) {
                if (fill >= 0)
                        ClearBitMap(fill);
                return;
        }
        int     bitshift = dy*width + dx;
        if (bitshift > 0)               // shift underlying bits
                operator<<=(bitshift);
        else if (bitshift < 0)
                operator>>=(-bitshift);
        else
                return;
        if (fill < 0)                   // no fill -- we're done
                return;
        int     hmarg[4];               // new horizontal margin
        hmarg[0] = (dx < 0) ? width-adx : 0;
        hmarg[1] = (dy > 0) ? dy : 0;
        hmarg[2] = adx;
        hmarg[3] = height - ady;
        if (fill) {                     // fill corner with 1's
                ClearRect(hmarg[0], hmarg[1], hmarg[2], hmarg[3], true);
                ClearRect(0, (dy < 0) ? height-ady : 0, width, ady, true);
        } else {                        // fill side with 0's
                ClearRect(hmarg[0], hmarg[1]-1, hmarg[2], hmarg[3]+2);
        }
}

static inline int
iSqrt(double x)
{
        if (x <= 0) return 0;
        return int(sqrt(x) + .5);
}

// Dilate (or erode) selection by given radius
void
ABitMap2::Expand(double rad, bool val)
{
        if (rad < 0) {
                rad = -rad;
                val = !val;
        }
        if ((width <= 0) | (rad < 1))
                return;
                                        // check what we have here
        int             xyorg[2], wh[2];
        if (!GetBoundRect(xyorg, wh, val))
                return;                 // empty bitmap!
        const int       wh_orig[2] = {width, height};
        const int       irad = int(rad+.5);
                                        // optimize if >= 3/4 empty
        if ((width >= 128) & (height >= 128) &&
                                ((wh[0] += irad<<1) <= width>>1) &
                                ((wh[1] += irad<<1) <= height>>1)) {
                ABitMap2        subRgn(wh[0], wh[1], !val);
                GetRect(&subRgn, xyorg[0] -= irad, xyorg[1] -= irad);
                Take(&subRgn);          // work with subregion
        }
                                        // copy original pattern
        ABitMap2        origMap = *this;
                                        // stamp out larger one
        for (int y = -irad; y <= irad; y++) {
                const int       spanRad = iSqrt(rad*rad - y*y);
                for (int x = -spanRad; x <= spanRad; x++) {
                        if (!x & !y) continue;
                        ABitMap2        stamp = origMap;
                        stamp.Shift(x, y, !val);
                        if (val)
                                *this |= stamp;
                        else
                                *this &= stamp;
                }
        }
        if ((width == wh_orig[0]) & (height == wh_orig[1]))
                return;
                                        // restore original dimensions
        origMap.NewBitMap(wh_orig[0], wh_orig[1], !val) &&
                origMap.AssignRect(xyorg[0], xyorg[1], *this) &&
                Take(&origMap);
}
Revision:	2.2
Committed:	Sat Aug 24 23:25:24 2024 UTC (8 months, 1 week ago) by greg
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.1:	+3 -0 lines
Log Message:	chore: Added RCS tags to files