Vector<Vector<Vector2> > BitMap::clip_opaque_to_polygons(const Rect2 &p_rect, float p_epsilon) const {
Rect2i r = Rect2i(0, 0, width, height).clip(p_rect);
print_verbose("BitMap: Rect: " + r);
Point2i from;
Ref<BitMap> fill;
fill.instance();
fill->create(get_size());
Vector<Vector<Vector2> > polygons;
for (int i = r.position.y; i < r.position.y + r.size.height; i++) {
for (int j = r.position.x; j < r.position.x + r.size.width; j++) {
if (!fill->get_bit(Point2(j, i)) && get_bit(Point2(j, i))) {
Vector<Vector2> polygon = _march_square(r, Point2i(j, i));
print_verbose("BitMap: Pre reduce: " + itos(polygon.size()));
polygon = reduce(polygon, r, p_epsilon);
print_verbose("BitMap: Post reduce: " + itos(polygon.size()));
polygons.push_back(polygon);
fill_bits(this, fill, Point2i(j, i), r);
}
}
}
return polygons;
}
uint32_t make_new_subseqs(void)
{
uint32_t i, t_count;
assert(subseq_count == 0);
subseq_Q = 1;
m_low = n_min;
m_high = n_max;
subseq_count = seq_count;
SUBSEQ = xmalloc(subseq_count*sizeof(subseq_t));
for (i = 0, t_count = 0; i < seq_count; i++)
{
assert(SEQ[i].type == seq_none);
SUBSEQ[i].seq = i;
SUBSEQ[i].d = 0;
SUBSEQ[i].filter = 0;
SUBSEQ[i].mcount = n_max-n_min+1;
SUBSEQ[i].M = make_bitmap(SUBSEQ[i].mcount);
SUBSEQ[i].a = 1;
SUBSEQ[i].b = 0;
fill_bits(SUBSEQ[i].M,0,SUBSEQ[i].mcount-1);
SEQ[i].type = seq_bitmap;
t_count += SUBSEQ[i].mcount;
}
return t_count;
}
static int zreceive(tl_inflate_source* z, int n, unsigned int* dest)
{
if (z->num_bits < n)
CHECK(fill_bits(z));
*dest = z->code_buffer & ((1 << n) - 1);
z->code_buffer >>= n;
z->num_bits -= n;
return 0;
}
static int zhuffman_decode(tl_inflate_source* a, zhuffman* z, unsigned int* dest)
{
int b,s,k;
if (a->num_bits < 16)
CHECK(fill_bits(a));
b = z->fast[a->code_buffer & ZFAST_MASK];
if (b < 0xffff) {
s = z->size[b];
a->code_buffer >>= s;
a->num_bits -= s;
*dest = z->value[b];
return 0;
}
void init_prime_sieve(uint64_t pmax)
{
uint_fast32_t *sieve;
uint32_t low_prime_limit, max_low_primes, *low_primes, low_prime_count;
uint32_t sieve_index, max_prime, max_primes_in_table;
uint32_t p, minp, i, composite;
assert(primes_in_prime_table == 0);
pmax = MAX(MINIMUM_PMAX,pmax);
max_prime = sqrt(pmax)+1;
low_prime_limit = sqrt(max_prime)+1;
max_low_primes = primes_bound(low_prime_limit);
low_primes = xmalloc(max_low_primes * sizeof(uint32_t));
low_primes[0] = 3;
low_prime_count = 1;
for (p = 5; p < low_prime_limit; p += 2)
for (minp = 0; minp <= low_prime_count; minp++)
{
if (low_primes[minp] * low_primes[minp] > p)
{
low_primes[low_prime_count] = p;
low_prime_count++;
break;
}
if (p % low_primes[minp] == 0)
break;
}
assert(low_prime_count <= max_low_primes);
/* Divide max_prime by 2 to save memory, also because already know that
all even numbers in the sieve are composite. */
sieve = make_bitmap(max_prime/2);
fill_bits(sieve,1,max_prime/2-1);
for (i = 0; i < low_prime_count; i++)
{
/* Get the current low prime. Start sieving at 3x that prime since 1x
is prime and 2x is divisible by 2. sieve[1]=3, sieve[2]=5, etc. */
composite = 3*low_primes[i];
sieve_index = (composite-1)/2;
while (composite < max_prime)
{
/* composite will always be odd, so add 2*low_primes[i] */
clear_bit(sieve,sieve_index);
sieve_index += low_primes[i];
composite += 2*low_primes[i];
}
}
free(low_primes);
max_primes_in_table = primes_bound(max_prime);
prime_table = xmalloc(max_primes_in_table * sizeof(uint32_t));
for (i = first_bit(sieve); i < max_prime/2; i = next_bit(sieve,i+1))
{
/* Convert the value back to an actual prime. */
prime_table[primes_in_prime_table] = 2*i + 1;
primes_in_prime_table++;
}
assert(primes_in_prime_table <= max_primes_in_table);
free(sieve);
composite_table = xmalloc(primes_in_prime_table * sizeof(uint64_t));
}
void prime_sieve(uint64_t low_prime, uint64_t high_prime, void(*fun)(uint64_t),
uint32_t mod, const uint_fast32_t *map)
{
uint64_t composite, prime, low_end_of_range, candidate;
uint_fast32_t *sieve;
uint32_t sieve_index, i, j, k;
assert(primes_in_prime_table > 0);
if (low_prime <= prime_table[primes_in_prime_table-1])
{
/* Skip ahead to low_prime. A binary search would be faster. */
for (i = 0; prime_table[i] < low_prime; i++)
;
while (i < primes_in_prime_table)
{
if (mod == 0) /* Null filter */
for (j = MIN(i+PROGRESS_STEP/3,primes_in_prime_table); i < j; i++)
{
if (prime_table[i] > high_prime)
return;
check_events(prime_table[i]);
fun(prime_table[i]);
}
else if (map == NULL) /* Global GFN filter */
for (j = MIN(i+PROGRESS_STEP/3,primes_in_prime_table); i < j; i++)
{
if (prime_table[i] > high_prime)
return;
if (((uint_fast32_t)prime_table[i] & mod) == 0)
{
check_events(prime_table[i]);
fun(prime_table[i]);
}
}
else /* Global QR filter */
for (j = MIN(i+PROGRESS_STEP/3,primes_in_prime_table); i < j; i++)
{
if (prime_table[i] > high_prime)
return;
if (test_bit(map,prime_table[i]%mod))
{
check_events(prime_table[i]);
fun(prime_table[i]);
}
}
check_progress();
}
low_end_of_range = prime_table[primes_in_prime_table-1]+1;
}
else /* Set low_end_of_range to the greatest even number <= low_prime */
low_end_of_range = (low_prime | 1) - 1;
sieve = make_bitmap(RANGE_SIZE);
primes_used_in_range = 0;
while (low_end_of_range <= high_prime)
{
setup_sieve(low_end_of_range);
fill_bits(sieve,0,RANGE_SIZE-1);
for (i = 0; i < primes_used_in_range; i++)
{
prime = prime_table[i];
composite = composite_table[i];
sieve_index = (composite - low_end_of_range)/2;
while (composite < low_end_of_range + 2*RANGE_SIZE)
{
clear_bit(sieve,sieve_index);
sieve_index += prime;
composite += 2*prime;
}
composite_table[i] = composite;
}
k = MIN((high_prime-low_end_of_range+1)/2,RANGE_SIZE);
i = first_bit(sieve);
while (i < k)
{
if (mod == 0) /* Null filter */
for (j = MIN(i+PROGRESS_STEP,k); i < j; i = next_bit(sieve,i+1))
{
candidate = low_end_of_range + 2*i + 1;
check_events(candidate);
fun(candidate);
}
else if (map == NULL) /* Global GFN filter */
for (j = MIN(i+PROGRESS_STEP,k); i < j; i = next_bit(sieve,i+1))
{
candidate = low_end_of_range + 2*i + 1;
if (((uint_fast32_t)candidate & mod) == 0)
{
check_events(candidate);
fun(candidate);
}
}
else /* Global QR filter */
for (j = MIN(i+PROGRESS_STEP,k); i < j; i = next_bit(sieve,i+1))
{
candidate = low_end_of_range + 2*i + 1;
if (test_bit(map,candidate%mod))
{
check_events(candidate);
fun(candidate);
}
}
check_progress();
}
low_end_of_range += 2*RANGE_SIZE;
}
free(sieve);
}
