// get the n'th [row, col, square] (dependent on group_nr)
set<gen_cell*>* gen_sudoku::getgroup(const uint n, const uint group_nr) const {
set<gen_cell*>* group = new set<gen_cell*>();
switch(group_nr){
case 0: getrow(n, group); break;
case 1: getcolumn(n, group); break;
case 2: getsquare(n, group); break;
}
return group;
}
int main(int ac, char **av)
{
int i;
t_list *start;
if (launchread(av, ac, &start) == -1)
{
free_all(start);
return (0);
}
i = getsquare(start);
if (i > 0)
{
while (!(algo(start, start, i)))
i++;
printmap(start, i);
}
free_all(start);
return (0);
}
// return a set of cells in the same square as cell (x,y)
void gen_sudoku::getsquare(const uint x, const uint y, set<gen_cell*>* group) const{
uint order = (uint)sqrt((double)num_digits);
uint sq_x = x / order;
uint sq_y = y / order;
getsquare(sq_y * order + sq_x, group);
}
void find_nearby_colors( int sr, int sg, int sb,
byte palette[256][3], byte candidates[256])
{
int mindist2_mas[256];
int minmaxdist2 = 1<<30;
memset(candidates, 0, 256);
int mr = sr + kStepSize / 2;
int mg = sg + kStepSize / 2;
int mb = sb + kStepSize / 2;
for ( int i = 0; i < 256; ++i ) {
int r, g, b;
r = palette[i][0];
g = palette[i][1];
b = palette[i][2];
int v = 0;
if ( inrange(r, sr, sr+kStepSize) ) {
v |= 1;
}
if ( inrange(g, sg, sg+kStepSize) ) {
v |= 2;
}
if ( inrange(b, sb, sb+kStepSize) ) {
v |= 4;
}
int mindist2 = 0;
switch ( v ) {
case 7:
mindist2 = 0;
break;
case 6:
mindist2 = getsquare(sr - r);
break;
case 5:
mindist2 = getsquare(sg - g);
break;
case 4:
mindist2 = getsquare(getmin(abs(sg - g), abs(sr - r)));
break;
case 3:
mindist2 = getsquare(sb - b);
break;
case 2:
mindist2 = getsquare(getmin(abs(sb - b), abs(sr - r)));
break;
case 1:
mindist2 = getsquare(getmin(abs(sb - b), abs(sg - g)));
break;
/* point case next */
default:
break;
};
int sign[3] = {0};
sign[0] = b >= mb ? 1 : -1; //blue
sign[1] = r >= mr ? 1 : -1; //red
sign[2] = ( g >= mg ) ^ ( r < mr ) ? 1 : -1; //green
if ( !v ) {
int near_r = mr + sign[1] * kStepSize / 2;
int near_g = mg + sign[2] * kStepSize / 2;
int near_b = mb + sign[0] * kStepSize / 2;
mindist2 = (near_r - r) * (near_r - r)
+ (near_g - g) * (near_g - g)
+ (near_b - b) * (near_b - b);
}
mindist2_mas[i] = mindist2;
int far_r = mr + -sign[1] * kStepSize / 2;
int far_g = mg + -sign[2] * kStepSize / 2;
int far_b = mb + -sign[0] * kStepSize / 2;
int maxdist2 = (far_r - r) * (far_r - r)
+ (far_g - g) * (far_g - g)
+ (far_b - b) * (far_b - b);
if ( maxdist2 < minmaxdist2 ) {
minmaxdist2 = maxdist2;
}
}
for ( int i = 0; i < 256; ++i ) {
if ( mindist2_mas[i] <= minmaxdist2 ) {
candidates[i] = mindist2_mas[i] <= minmaxdist2;
}
}
}
