AvlIndex AvlNode::balance(AvlIndex tree)
{
int balance, lh, rh;
balance = get_balance(tree);
if (balance < -1)
{
balance = get_balance(AVLNODE(tree)->left);
if (balance > 0)
tree = left_right(tree);
else
tree = left_left(tree);
}
else if (balance > 1)
{
balance = get_balance(AVLNODE(tree)->right);
if (balance < 0)
tree = right_left(tree);
else
tree = right_right(tree);
}
lh = node_height(AVLNODE(tree)->left);
rh = node_height(AVLNODE(tree)->right);
AVLNODE(tree)->height = (lh > rh ? lh : rh) + 1;
return tree;
}
int Mv_management::get_dir(int i)
{
if (data->vcEvents[i].vcPage[0].Movement_type==0)//do not move
return(5);
if (data->vcEvents[i].vcPage[0].Movement_type==1)// random
{
return(random_move( i));
}
if (data->vcEvents[i].vcPage[0].Movement_type==2)// up down
{
return(up_down(i));
}
if (data->vcEvents[i].vcPage[0].Movement_type==3)// left right
{
return(left_right(i));
}
if (data->vcEvents[i].vcPage[0].Movement_type==4)// go to the hero
{
return(to_hero(i));
}
if (data->vcEvents[i].vcPage[0].Movement_type==5)// run frome the hero
{
return(escape_hero(i));
}
if (data->vcEvents[i].vcPage[0].Movement_type==6)// use the stack
{
return(custom(i));
}
return(5);
}
bool
voir(t_cli *c, t_msg UNUSED(*msg))
{
int i;
char *buffer;
ERR(PINK"[%s], client %d from team '%s'\n"WHITE,
__func__, c->sock.fd, c->team->name);
i = 0;
if (!(buffer = malloc(VOIR_BUFFER_SIZE)))
return (perror("malloc()"), false);
*buffer = '\0';
g_i = &i;
g_buffer = buffer;
print_str_to_buffer("{");
if (c->direction == UP || c->direction == DOWN)
up_down(c);
else
left_right(c);
print_str_to_buffer("}\n");
enqueue_msg(c, buffer);
free(buffer);
return (true);
}
void loop_it(t_tout *tout)
{
unsigned long key;
int refresh;
while ((key = 0) || (read(0, &key, 6)) != 0)
{
refresh = 1;
if (key == KEY_ESCAPE || key == 'q')
abort_exit(0);
else if (key == KEY_SPACE)
select_deselect(tout);
else if (key == KEY_ENTER)
print_white(tout);
else if (key == KEY_UP || key == KEY_DOWN)
up_down(tout, key);
else if (key == KEY_LEFT || key == KEY_RIGHT)
left_right(tout, key);
else if (key == KEY_BACKSPACE || key == KEY_DELETE)
remove_word(tout);
else
refresh = 0;
if (refresh)
refresh_screen(0);
}
}
int totalNQueens(int n) {
vector<bool> cols(n, true);
vector<bool> left_right(2*n-1, true);
vector<bool> right_left(2*n-1, true);
int count = 0;
solveNQueens(0, cols, left_right, right_left, count);
return count;
}
/* balance the tree */
struct avl_node* balance(struct avl_node *node)
{
int diff;
diff = difference(node); /* get height difference of left and right subtrees */
if(diff > 1) /* tree is imbalanced to the left */
{
if(difference(node->left) > 0)
node = right(node); /* single right rotation fixes it */
else
node = left_right(node); /* negative balance: left-right rotation fixes it */
}
else if(diff < -1) /* tree is imbalanced to the right */
{
if(difference(node->right) > 0)
node = right_left(node); /* positive balance: right-left rotation fixes it */
else
node = left(node); /* single left rotation fixes it */
}
return node;
}
void defineGameMap()
{
VALUE cCollisionType = defClass<CollisionType>("CollisionType");
defMethod(cCollisionType, "initialize", CollisionType_initialize, -1);
defMethod(cCollisionType, "left", CollisionType_left, 0);
defMethod(cCollisionType, "right", CollisionType_right, 0);
defMethod(cCollisionType, "up", CollisionType_up, 0);
defMethod(cCollisionType, "down", CollisionType_down, 0);
defMethod(cCollisionType, "content", CollisionType_content, 0);
defMethod(cCollisionType, "left=", CollisionType_setLeft, 1);
defMethod(cCollisionType, "right=", CollisionType_setRight, 1);
defMethod(cCollisionType, "up=", CollisionType_setUp, 1);
defMethod(cCollisionType, "down=", CollisionType_setDown, 1);
defMethod(cCollisionType, "content=", CollisionType_setContent, 1);
VALUE cTile = defClass<GameMap::Tile>("Tile");
defMethod(cTile, "initialize", GameMap_Tile_initialize, -1);
defMethod(cTile, "x", Tile_x, 0);
defMethod(cTile, "y", Tile_y, 0);
defMethod(cTile, "tileset", Tile_tileset, 0);
defMethod(cTile, "tileX", Tile_tileX, 0);
defMethod(cTile, "tileY", Tile_tileY, 0);
defMethod(cTile, "type", Tile_type, 0);
defMethod(cTile, "x=", Tile_setX, 1);
defMethod(cTile, "y=", Tile_setY, 1);
defMethod(cTile, "tileset=", Tile_setTileset, 1);
defMethod(cTile, "tileX=", Tile_setTileX, 1);
defMethod(cTile, "tileY=", Tile_setTileY, 1);
defMethod(cTile, "type=", Tile_setType, 1);
VALUE cMap = defClass<GameMap>("GameMap", "Drawable");
defMethod(cMap, "initialize", GameMap_initialize, -1);
defMethod(cMap, "addTileset", GameMap_addTileset, 1);
defMethod(cMap, "setTileSize", GameMap_setTileSize, 2);
defMethod(cMap, "tileWidth", GameMap_tileWidth, 0);
defMethod(cMap, "tileHeight", GameMap_tileHeight, 0);
defMethod(cMap, "collisionH=", GameMap_setCollisionH, 1);
defMethod(cMap, "collisionH", GameMap_collisionH, 0);
defMethod(cMap, "absToRel", GameMap_absToRel, 2);
defMethod(cMap, "relToAbs", GameMap_relToAbs, 2);
defMethod(cMap, "centerOn", GameMap_centerOn, 2);
defMethod(cMap, "addElem", GameMap_addElem, -1);
defMethod(cMap, "<<", GameMap_push, 1);
defMethod(cMap, "clear", GameMap_clear, 0);
defMethod(cMap, "clearTiles", GameMap_clearTiles, 0);
defMethod(cMap, "clear_between", GameMap_clearBetween, 0);
defMethod(cMap, "tiles", GameMap_tiles, 0);
defMethod(cMap, "tilesets", GameMap_tilesets, 0);
defMethod(cMap, "each_tile", GameMap_each_tile, 0);
defMethod(cMap, "each_tileset", GameMap_each_tileset, 0);
defMethod(cMap, "reject_tiles", GameMap_reject_tiles, 0);
defMethod(cMap, "addBetween", GameMap_addBetween, 1);
defAlias(cMap, "addTileset", "add_tileset");
defAlias(cMap, "setTileSize", "set_tile_size");
defAlias(cMap, "tileWidth", "tile_width");
defAlias(cMap, "tileHeight", "tile_height");
defAlias(cMap, "collisionH", "collision_h");
defAlias(cMap, "collisionH=", "collision_h=");
defAlias(cMap, "absToRel", "abs2rel");
defAlias(cMap, "relToAbs", "rel2abs");
defAlias(cMap, "centerOn", "center_on");
defAlias(cMap, "addElem", "add_elem");
defAlias(cMap, "clearTiles", "clear_tiles");
CollisionType full(true, false, false, false, false);
CollisionType left(false, true, false, false, false);
CollisionType right(false, false, true, false, false);
CollisionType up(false, false, false, true, false);
CollisionType down(false, false, false, false, true);
CollisionType no(false, false, false, false, false);
CollisionType left_right(false, true, true, false, false);
CollisionType left_up(false, true, false, true, false);
CollisionType left_down(false, true, false, false, true);
CollisionType right_up(false, false, true, true, false);
CollisionType right_down(false, false, true, false, true);
CollisionType up_down(false, false, false, true, true);
/*
Document-const: COL_FULL
Joyau::CollisionType.new(true, false, false, false, false): Collision with
everything.
*/
/*
Document-const: COL_LEFT
Joyau::CollisionType.new(false, true, false, false, false): Collision with
the left side.
*/
/*
Document-const: COL_RIGHT
Joyau::CollisionType.new(false, false, true, false, false): Collision with
the right side.
*/
/*
Document-const: COL_UP
Joyau::CollisionType.new(false, false, false, true, false): Collision with
the upper side.
*/
/*
Document-const: COL_DOWN
Joyau::CollisionType.new(false, false, false, false, true): Collision with
the downer side.
*/
/*
Document-const: COL_NO
Joyau::CollisionType.new(false, false, false, false, false): Collision
with nothing.
*/
/*
Document-const: COL_LEFT_RIGHT
Joyau::CollisionType.new(false, true, true, false, false): Collision with
the left and right sides.
*/
/*
Document-const: COL_LEFT_UP
Joyau::CollisionType.new(false, true, false, true, false): Collision with
the left and the upper sides.
*/
/*
Document-const: COL_LEFT_DOWN
Joyau::CollisionType.new(false, true, false, false, true): Collision with
the left and the downer sides.
*/
/*
Document-const: COL_RIGHT_UP
Joyau::CollisionType.new(false, false, true, true, false): Collision with
the right and the upper sides.
*/
/*
Document-const: COL_RIGHT_DOWN
Joyau::CollisionType.new(false, false, true, false, true): Collision with
the right and the downer sides.
*/
/*
Document-const: COL_UP_DOWN
Joyau::CollisionType.new(false, false, false, true, true): Collision with
the upper and the downer sides.
*/
defConst(cMap, "COL_FULL", createObject(cCollisionType, full));
defConst(cMap, "COL_LEFT", createObject(cCollisionType, left));
defConst(cMap, "COL_RIGHT", createObject(cCollisionType, right));
defConst(cMap, "COL_UP", createObject(cCollisionType, up));
defConst(cMap, "COL_DOWN", createObject(cCollisionType, down));
defConst(cMap, "COL_NO", createObject(cCollisionType, no));
defConst(cMap, "COL_LEFT_RIGHT", createObject(cCollisionType, left_right));
defConst(cMap, "COL_LEFT_UP", createObject(cCollisionType, left_up));
defConst(cMap, "COL_LEFT_DOWN", createObject(cCollisionType, left_down));
defConst(cMap, "COL_RIGHT_UP", createObject(cCollisionType, right_up));
defConst(cMap, "COL_RIGHT_DOWN", createObject(cCollisionType, right_down));
defConst(cMap, "COL_UP_DOWN", createObject(cCollisionType, up_down));
}
int main(int argc, char* argv[])
{
int max_disparity = DEFAULT_MAX_DISPARITY, min_disparity = DEFAULT_MIN_DISPARITY,
x_window_size = DEFAULT_WINDOW_SIZE, y_window_size = DEFAULT_WINDOW_SIZE,
x_tx_win_size = DEFAULT_TX_WINDOW_SIZE, y_tx_win_size = DEFAULT_TX_WINDOW_SIZE, i,
border_x, border_y;
double *scores;
char basefile[50], outname[50];
FILE *leftfp, *rightfp, *outfile, *lrfile;
struct pgm left_image, right_image, disp1;
struct DISP disparity, left_disparity, lr_valid_left, lr_valid_right;
pixel *right_rank, *left_rank;
int offset = 0, lr = 0;
enum match_type match = SAD;
if (argc < 2) {
perror ("Usage: match [-d min_disparity max_disparity] [-m SAD | SSD | NCC | ZSAD | ZSSD | ZNCC | RANK | CENSUS] [-w x_window_size y_window_size] [-t x_tx_win_size y_tx_win_size] [-lr] <base-file> <outputfile>");
return (1);
}
/* process optional args */
for (i = 1; i < argc - 2; i++) {
if (strcasecmp (argv[i], "-w") == 0) {
x_window_size = atoi (argv[++i]);
y_window_size = atoi (argv[++i]);
} else if (strcasecmp (argv[i], "-t") == 0) {
x_tx_win_size = atoi (argv[++i]);
y_tx_win_size = atoi (argv[++i]);
} else if (strcasecmp (argv[i], "-o") == 0) {
offset = atoi (argv[++i]);
} else if (strcasecmp (argv[i], "-lr") == 0) {
lr = 1;
} else if (strcasecmp (argv[i], "-d") == 0) {
min_disparity = atoi (argv[++i]);
if (min_disparity < MIN_ALLOWED_DISPARITY)
min_disparity = MIN_ALLOWED_DISPARITY;
max_disparity = atoi (argv[++i]);
if (max_disparity > MAX_ALLOWED_DISPARITY)
max_disparity = MAX_ALLOWED_DISPARITY;
} else if (strcasecmp (argv[i], "-m") == 0) {
i++;
if (strcasecmp (argv[i], "SAD") == 0)
match = SAD;
else if (strcasecmp (argv[i], "SSD") == 0)
match = SSD;
else if (strcasecmp (argv[i], "NCC") == 0)
match = NCC;
else if (strcasecmp (argv[i], "ZSAD") == 0)
match = ZSAD;
else if (strcasecmp (argv[i], "ZSSD") == 0)
match = ZSSD;
else if (strcasecmp (argv[i], "ZNCC") == 0)
match = ZNCC;
else if (strcasecmp (argv[i], "RANK") == 0)
match = RANK;
else if (strcasecmp (argv[i], "CENSUS") == 0)
match = CENSUS;
else {
perror ("Usage: match [-d max_disparity] [-m SAD | SSD | NCC | ZSAD | ZSSD | ZNCC | RANK] [-w x_window_size y_window_size] [-t x_tx_win_size y_tx_win_size] <base-file> <outputfile>");
return (1);
}
} else {
perror ("Usage: match [-d max_disparity] [-m SAD | SSD | NCC | ZSAD | ZSSD | ZNCC | RANK] [-w x_window_size y_window_size] [-t x_tx_win_size y-tx_win_size] <base-file> <outputfile>");
return (1);
} /* if */
} /* for */
/* Open left image file */
strcpy (basefile, argv[i]);
if ((leftfp = fopen (strcat (basefile, "-l.pgm"), "r")) == NULL) {
perror ("Cannot open file for reading");
return (2);
}
/* Open right image file */
strcpy (basefile, argv[i]);
if ((rightfp = fopen (strcat (basefile, "-r.pgm"), "r")) == NULL) {
perror ("Cannot open file for reading");
return (2);
}
/* Open output file for writing */
strcpy (outname, argv[i+1]);
if ((outfile = fopen (strcat (outname, ".pgm"), "w")) == NULL) {
perror ("Cannot open file for writing");
return (3);
}
/* Open output file for writing */
strcpy (outname, argv[i+1]);
if ((lrfile = fopen (strcat (outname, "_lr.pgm"), "w")) == NULL) {
perror ("Cannot open file for writing");
return (3);
}
if ((read_pgm (leftfp, &left_image) == 0) && (read_pgm (rightfp, &right_image) == 0)) {
if ((left_image.width != right_image.width) || (left_image.height != right_image.height)) {
perror ("Images different sizes");
return (4);
}
disparity.width = left_image.width;
disparity.height = left_image.height;
disparity.max_grey = left_image.max_grey;
if ((disparity.bitmap = (signed char*) calloc (disparity.width * disparity.height, 1)) == NULL) {
perror ("Not enough memory");
return (5);
}
if ((scores = (double*) calloc (disparity.width * disparity.height, sizeof(double))) == NULL) {
perror ("Not enough memory");
return (5);
}
if (lr) {
lr_valid_left.width = lr_valid_right.width = left_disparity.width = left_image.width;
lr_valid_left.height = lr_valid_right.height = left_disparity.height = left_image.height;
lr_valid_left.max_grey = lr_valid_right.max_grey = left_disparity.max_grey = left_image.max_grey;
if ((left_disparity.bitmap = (signed char*) calloc (left_disparity.width * left_disparity.height, 1)) == NULL) {
perror ("Not enough memory");
return (5);
}
if ((lr_valid_right.bitmap = (signed char*) calloc (lr_valid_right.width * lr_valid_right.height, 1)) == NULL) {
perror ("Not enough memory");
return (5);
}
if ((lr_valid_left.bitmap = (signed char*) calloc (lr_valid_left.width * lr_valid_left.height, 1)) == NULL) {
perror ("Not enough memory");
return (5);
}
} /* left_right */
switch (match) {
case (SAD):
puts ("SAD");
match_SAD_right (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_image.bitmap, right_image.bitmap, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2;
border_y = y_window_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
case (SSD):
puts ("SSD");
match_SSD_right (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_image.bitmap, right_image.bitmap, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2;
border_y = y_window_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
case (NCC):
puts ("NCC");
match_NCC_right (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_image.bitmap, right_image.bitmap, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2;
border_y = y_window_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
case(ZSAD):
puts ("ZSAD");
match_ZSAD_right (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_image.bitmap, right_image.bitmap, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2;
border_y = y_window_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
case (ZSSD):
puts ("ZSSD");
match_ZSSD_right (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_image.bitmap, right_image.bitmap, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2;
border_y = y_window_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
case (ZNCC):
puts ("ZNCC");
match_ZNCC_right (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_image.bitmap, right_image.bitmap, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2;
border_y = y_window_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
case (RANK):
puts ("RANK");
if (((right_rank = (pixel*) calloc (disparity.width * disparity.height, 1)) == NULL) ||
((left_rank = (pixel*) calloc (disparity.width * disparity.height, 1)) == NULL)) {
perror ("Not enough memory");
return (5);
}
rank_transform (right_image.bitmap, x_tx_win_size, y_tx_win_size, right_image.width, right_image.height, right_rank);
rank_transform (left_image.bitmap, x_tx_win_size, y_tx_win_size, left_image.width, left_image.height, left_rank);
match_SAD_right (left_rank, right_rank, disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_rank, right_rank, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2 + x_tx_win_size / 2;
border_y = y_window_size / 2 + y_tx_win_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
free (right_rank);
free (left_rank);
break;
case (CENSUS):
puts ("CENSUS");
CENSUS_RIGHT (left_image.bitmap, right_image.bitmap, disparity.bitmap, scores, left_image.width,
left_image.height, x_tx_win_size, y_tx_win_size, x_window_size, y_window_size, min_disparity, max_disparity);
if (lr) {
match_SAD_left (left_rank, right_rank, left_disparity.bitmap, scores, left_image.width,
left_image.height, x_window_size, y_window_size, min_disparity, max_disparity);
border_x = x_window_size / 2 + x_tx_win_size / 2;
border_y = y_window_size / 2 + y_tx_win_size / 2;
left_right (left_disparity.bitmap, disparity.bitmap, lr_valid_left.bitmap, lr_valid_right.bitmap,
left_image.width, left_image.height, border_x, border_y);
}
break;
} /* switch */
/* Copy disparity to unsigned char and write to file */
disp1.width = disparity.width;
disp1.height = disparity.height;
disp1.max_grey = disparity.max_grey;
disp1.bitmap = (unsigned char*) calloc (disp1.width*disp1.height,sizeof(unsigned char));
for (i=0; i<disp1.height*disp1.width; i++)
*(disp1.bitmap+i) = *(disparity.bitmap+i) + min_disparity;
write_pgm_binary (outfile, &disp1);
/* Copy lr information to unsigned char and write to file */
disp1.width = lr_valid_right.width;
disp1.height = lr_valid_right.height;
disp1.max_grey = lr_valid_right.max_grey;
for (i = 0; i < disp1.height*disp1.width; i++)
*(disp1.bitmap+i) = *(lr_valid_right.bitmap+i) * 255;
write_pgm_binary (lrfile, &disp1);
free (left_image.bitmap);
free (right_image.bitmap);
free (disparity.bitmap);
free (disp1.bitmap);
free (scores);
if (lr) {
free (left_disparity.bitmap);
free (lr_valid_left.bitmap);
free (lr_valid_right.bitmap);
}
} /* if */
fclose (leftfp);
fclose (rightfp);
fclose (outfile);
fclose (lrfile);
return (0);
} /* main */
