int map_init()
{//map initialisation function. creates or defines multiple bitmap buffers
map_buffer=create_bitmap(mapbuffer_width_in_tiles * tile_width, mapbuffer_height_in_tiles * tile_width);
screen_buffer=create_bitmap(1024,768);
tile_buffer=load_bitmap("tiles.bmp",0);
menu_buffer=create_bitmap(100,768);
get_tiles();
return 0;
}
void getQ(double Q[ACTION_COUNT], float s[DECAY_COUNT], double weights[], unsigned int num_tilings, unsigned int memory_size) {
int tile_array[feature_count];
unsigned int i, j;
for (i = 0; i < ACTION_COUNT; i++) {
get_tiles(s, i, tile_array, num_tilings, memory_size);
Q[i] = 0;
for (j = 0; j < feature_count; j++) {
Q[i] += weights[tile_array[j]];
}
}
}
int main()
{
InputImageType::Pointer im = readImage<InputImageType>("C:/Users/arun/Research/Farsight/exe/bin/CF_1_inverted_bg_sub.tif");
FILE *fp = fopen("C:/Users/arun/Research/Farsight/exe/bin/seeds.txt","r");
//IteratorType initer(im,im->GetLargestPossibleRegion());
//initer.GoToBegin();
//
//for(;!initer.IsAtEnd(); ++initer)
//{
// initer.Set(transfer_function1(initer.Get()));
//}
//
//writeImage<InputImageType>(im,"C:/Users/arun/Research/Farsight/exe/bin/hp2_cropped2_filtered.tif");
//
//return 0;
typedef itk::SymmetricSecondRankTensor<double,3> HessianType;
typedef itk::Hessian3DToVesselnessMeasureImageFilter<float> MeasureType;
typedef itk::Image<HessianType,3> HessianImageType;
typedef itk::MultiScaleHessianBasedMeasureImageFilter< InputImageType, HessianImageType, FloatImageType> VesselnessFilterType;
std::vector<InputImageType::RegionType> in1,in2,out1,out2;
get_tiles(im->GetLargestPossibleRegion().GetSize(),1500,1500,1500,100,100,10,in1,in2,out1,out2);
InputImageType::Pointer om;
/*
om = InputImageType::New();
om->SetRegions(im->GetLargestPossibleRegion());
om->Allocate();
for(int counter = 0; counter < in1.size(); counter++)
{
InputImageType::Pointer imtile = InputImageType::New();//
imtile->SetRegions(in2[counter]);
imtile->Allocate();
in1[counter].Print(std::cout);
in2[counter].Print(std::cout);
IteratorType iter1(im,in1[counter]);
IteratorType iter2(imtile,in2[counter]);
for(iter1.GoToBegin(),iter2.GoToBegin();!iter1.IsAtEnd(); ++iter1,++iter2)
{
iter2.Set(iter1.Get());
}
VesselnessFilterType::Pointer vfilt = VesselnessFilterType::New();
MeasureType::Superclass::Pointer measure = MeasureType::New();
vfilt->SetInput(imtile);
vfilt->SetHessianToMeasureFilter((VesselnessFilterType::HessianToMeasureFilterType *)measure);
vfilt->SetSigmaMinimum(3.0);
vfilt->SetSigmaMaximum(5.0);
vfilt->SetNumberOfSigmaSteps(3);
vfilt->SetSigmaStepMethod(VesselnessFilterType::EquispacedSigmaSteps);
vfilt->Update();
FloatImageType::Pointer omtile = vfilt->GetOutput();
typedef itk::ImageRegionIterator<FloatImageType> FloatIteratorType;
FloatIteratorType iter3;
iter1 = IteratorType(om,out1[counter]);
iter3 = FloatIteratorType(omtile,out2[counter]);
for(iter1.GoToBegin(),iter3.GoToBegin();!iter1.IsAtEnd();++iter1,++iter3)
{
iter1.Set(iter3.Get());
}
}
writeImage<InputImageType>(om,"C:/Users/arun/Research/Farsight/exe/bin/vesselnesstest.tif");
*/
om = readImage<InputImageType>("C:/Users/arun/Research/Farsight/exe/bin/vesselnesstest.tif");
typedef itk::BinaryBallStructuringElement<InputImageType::PixelType,3> StructElementType;
typedef itk::GrayscaleDilateImageFilter<InputImageType,InputImageType,StructElementType> FilterType1;
FilterType1::Pointer minfilt = FilterType1::New();
minfilt->SetInput(om);
FilterType1::RadiusType radius;
radius[0] = 1;
radius[1] = 1;
radius[2] = 1;
StructElementType strel;
strel.SetRadius(radius);
minfilt->SetKernel(strel);
minfilt->Update();
InputImageType::Pointer seed_out = InputImageType::New();
seed_out->SetRegions(om->GetLargestPossibleRegion());
seed_out->Allocate();
seed_out->FillBuffer(0);
int thresh_value = 6;
int number_of_seeds = 200;
int tnum_seeds = 0;
typedef itk::ImageRegionIteratorWithIndex<InputImageType> IndexIteratorType;
IndexIteratorType it1(minfilt->GetOutput(),minfilt->GetOutput()->GetLargestPossibleRegion());
IteratorType it2(om,om->GetLargestPossibleRegion());
for(it2.GoToBegin();!it2.IsAtEnd(); ++it2)
{
if(it2.Get()>thresh_value)
tnum_seeds++;
}
printf("tnum_seeds = %d\n",tnum_seeds);
IteratorType it3(seed_out,seed_out->GetLargestPossibleRegion());
IteratorType it4(im,im->GetLargestPossibleRegion());
std::vector<mdl::fPoint3D> seeds;
seeds.clear();
/*for(it1.GoToBegin(),it2.GoToBegin(),it3.GoToBegin(),it4.GoToBegin();!it1.IsAtEnd();++it1,++it2,++it3,++it4)
{
if(it1.Get()==it2.Get() && it4.Get() > 150)
{
it3.Set(255);
InputImageType::IndexType index = it1.GetIndex();
mdl::fPoint3D seed1;
seed1.x = index[0];
seed1.y = index[1];
seed1.z = index[2];
seeds.push_back(seed1);
}
}*/
seeds.clear();
while(!feof(fp))
{
mdl::fPoint3D seed1;
fscanf(fp,"%f %f %f",&seed1.x,&seed1.y,&seed1.z);
if(feof(fp))
break;
seed1.x*=1;
seed1.y*=1;
seeds.push_back(seed1);
}
fclose(fp);
printf("Seeds.size = %d\n",seeds.size());
//scanf("%*d");
mdl::vtkFileHandler * fhd1 = new mdl::vtkFileHandler();
fhd1->SetNodes(&seeds);
std::vector<mdl::pairE> nullpairs;
fhd1->SetLines(&nullpairs);
std::string outFilename1 = "C:/Users/arun/Research/Farsight/exe/bin/mst_input.vtk";
fhd1->Write(outFilename1.c_str());
delete fhd1;
int edgeRange = 50;
int morphStrength = 0;
mdl::MST *mst = new mdl::MST( im );
mst->SetDebug(false);
mst->SetUseVoxelRounding(false);
mst->SetEdgeRange(edgeRange);
mst->SetPower(1);
mst->SetSkeletonPoints( &seeds );
// can choose different weight
//mst->CreateGraphAndMST(1);
mst->CreateGraphAndMST(5);
mst->ErodeAndDialateNodeDegree(morphStrength);
std::vector<mdl::fPoint3D> nodes = mst->GetNodes();
std::vector<mdl::pairE> bbpairs = mst->BackboneExtract();
delete mst;
std::cerr << "Saving\n";
//****************************************************************
// TREE WRITER
mdl::vtkFileHandler * fhd2 = new mdl::vtkFileHandler();
fhd2->SetNodes(&nodes);
fhd2->SetLines(&bbpairs);
std::string outFilename2 = "C:/Users/arun/Research/Farsight/exe/bin/mst_tree.vtk";
fhd2->Write(outFilename2.c_str());
delete fhd2;
scanf("%*d");
writeImage<InputImageType>(seed_out,"C:/Users/arun/Research/Farsight/exe/bin/seedimage.tif");
}
bool Reversi::make_move(string move){
//check size of move
//cout << "Making move!\n";
//cout << "size of move:" << sizeof(move) << endl;
if(move.size() != 2)
return false;
//check if user has chosen side
//cout << "Move sized correctly!\n";
//cout << "current player:" << current_player << endl;
if(current_player == 'n')
return false;
//split move into correct data types
//cout << "Player has been set!\n";
//cout << "Move string: " << move << endl;
Position current_move;
if(isalpha(move[0])) {
current_move.column = get_number_of_letter(move[0]);
current_move.row = move[1]-'0'-1;
}
else{
current_move.row = get_number_of_letter(move[0]);
current_move.column = move[1]-'0'-1;
}
//cout << "row: " << current_move.row << endl;
//cout << "column: " << current_move.column << endl;
// check if valid move
bool possible_move_check = false;
for(unsigned int i=0; i< available_moves.size(); i++)
if(available_moves[i].row == current_move.row && available_moves[i].column == current_move.column)
possible_move_check = true;
if(!possible_move_check)
return false;
//cout << "Move is valid!\n";
// save previous state
// only need to support 10 undos (20 total saved states)
if(previous_states.size() >= 20)
previous_states.pop_back();
previous_states.push_front({board, available_moves, white_score, black_score, current_player});
previous_move = move;
//check all directions
//if valid in a direction flip all appropriate tiles
vector<Position> all_positions;
vector<Position> temp_positions;
all_positions.push_back(current_move);
int x_step = 0;
int y_step = -1;
temp_positions = get_tiles(current_move, x_step, y_step); //check above
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
y_step = 1;
temp_positions = get_tiles(current_move, x_step, y_step); //check below
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
y_step = 0;
x_step = 1;
temp_positions = get_tiles(current_move, x_step, y_step); //check right
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
x_step = -1;
temp_positions = get_tiles(current_move, x_step, y_step); //check left
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
y_step = -1;
temp_positions = get_tiles(current_move, x_step, y_step); //check top left
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
x_step = 1;
temp_positions = get_tiles(current_move, x_step, y_step); //check top right
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
y_step = 1;
temp_positions = get_tiles(current_move, x_step, y_step); //check bottom right
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
x_step = -1;
temp_positions = get_tiles(current_move, x_step, y_step); //check bottom left
for(unsigned int i=0; i<temp_positions.size(); i++)
all_positions.push_back(temp_positions[i]);
for(unsigned int i=0; i<all_positions.size(); i++)
board[all_positions[i].row][all_positions[i].column] = current_player;
update_score();
toggle_player();
available_moves = get_available_moves();
if(available_moves.size() == 0 && !(is_game_over())) {
toggle_player();
available_moves = get_available_moves();
}
}
int main(int argc, char *argv[]) {
/* Initialize variables used by the Agent thread */
int p;
int a, aprime;
float s[DECAY_COUNT], sprime[DECAY_COUNT];
int reward;
int tile_array[feature_count];
unsigned int i;
double delta;
double Q[ACTION_COUNT];
// Learning parameters
double stepsize = 0.1 / (float) num_tilings;
double lambda = 0.9;
double gamma = 0.9;
struct sigaction act;
struct sigaction oldact;
act.sa_handler = endProgram;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGINT, &act, &oldact);
srand(0);
pthread_mutex_init(&pktNumMutex, NULL);
pthread_mutex_init(&actionMutex, NULL);
pthread_mutex_init(&rewardMusicMutex, NULL);
trajectoryFile.open("trajectory.txt");
if(!trajectoryFile.is_open())
printf("Trajectory file could not be opened.\n");
/* Set up variables used by individual policy components */
// --- begin initialize variables for Tians code
timeStep = 0;
leftCount=0, rightCount =0;
diff = 0;
actionToTake = 1;
count = 0;
alignPhase = 1;
notInRightMode = false;
// --- end initialize variables for Tians code
// --- begin initialize variables for Amirs code
cwTurn = 1;
// --- end initialize variables for Amirs code
// initialize weights
// first try to read the weight file and if there is no file, then initialize randomly
if(!read_weights(weights)){
for (i = 0; i < memory_size; i++) {
weights[i] = -100.0/num_tilings;
}
}
for (i = 0; i < memory_size; i++) {
e[i] = 0;
}
// Set up timing + packet number
p = pktNum;
// State based on IR byte
s[0] = redDecay;
s[1] = greenDecay;
s[2] = bumpDecay;
s[3] = leftDecay;
s[4] = rightDecay;
s[5] = forwardDecay;
s[6] = backwardDecay;
s[7] = stopDecay;
s[8] = chargeDecay;
a = sAPrime[p];//epsilonGreedy(weights, s, epsilon);
// Use a lock to ensure action is changed separately
pthread_mutex_lock( &actionMutex );
action = a; // sets up action to be taken by csp thread
pthread_mutex_unlock( &actionMutex );
prevPktNum = myPktNum;
// Main agent loop
while (TRUE) {
int rval = getNextPacket();
if (rval == -1) {
write_weights(weights);
printf("Complete! Weights saved to weights.txt. Ran %d episodes.", episode + 1);
break;
} else if (rval == 1) {
// Episode complete
for (i = 0; i < memory_size; i++) {
e[i] = 0;
}
episode++;
}
// Get the packet number
p = pktNum;
// Update decays
updateDecay(p, prevPktNum, myPktNum);
//printf("ir: %d\n", sIRbyte[p]);
// Reward of -1 per step
reward = -1;
// Determine the next observation
// TODO: Change this to new state representation
sprime[0] = redDecay;
sprime[1] = greenDecay;
sprime[2] = bumpDecay;
sprime[3] = leftDecay;
sprime[4] = rightDecay;
sprime[5] = forwardDecay;
sprime[6] = backwardDecay;
sprime[7] = stopDecay;
sprime[8] = chargeDecay;
aprime = sAPrime[p];//epsilonGreedy(weights, sprime, epsilon);
// Set action variable
pthread_mutex_lock( &actionMutex );
action = aprime; // sets up action to be taken by csp thread
pthread_mutex_unlock( &actionMutex );
// Get Q values
getQ(Q, s, weights, num_tilings, memory_size);
delta = reward - Q[a];
getQ(Q, sprime, weights, num_tilings, memory_size);
delta += gamma * Q[aprime];
// Update weights
get_tiles(s, a, tile_array, num_tilings, memory_size);
for (i = 0; i < feature_count; i++) {
e[tile_array[i]] = 1;
}
//printf("Docking: s a r s' a':%d %d %d %d %d\n", s, a, reward, sprime, aprime);
for (i = 0; i < memory_size; i++ ) {
weights[i] += stepsize * delta * e[i];
e[i] *= lambda;
}
// Decay sensor traces
performDecay();
for (i = 0; i < DECAY_COUNT; i++) {
s[i] = sprime[i];
}
a = aprime;
prevPktNum = myPktNum;
}
return 0;
}
Game
play_game(const Options& options, Rng& rng)
{
static const boost::regex re_url("^(?:http://)?([^/]+)(/.*)$");
HTTPConnection connection(options.server_name);
connection.proxy = options.proxy;
const PTree& initial_json = connection.get_initial_state_json(options);
//std::cout << initial_json;
boost::match_results<std::string::const_iterator> what;
if (!regex_search(initial_json.get<std::string>("playUrl"), what, re_url))
throw std::runtime_error("can't parse play url");
const std::string play_server_name(what[1].first, what[1].second);
const std::string play_end_point(what[2].first, what[2].second);
const std::string& view_url = initial_json.get<std::string>("viewUrl");
std::cout << "view game at " << view_url << std::endl;
double start_time = get_double_time();
if (options.collect_map) { // collect maps
const Tiles tiles = get_tiles(initial_json.get_child("game.board"));
const HashedPair<Tiles> hashed_tiles(tiles);
std::stringstream ss;
ss << "map_" << std::hex << hashed_tiles.hash << std::dec << ".txt";
std::cout << "saving " << ss.str() << std::endl;
std::ofstream handle(ss.str().c_str());
handle << hashed_tiles.value;
handle.close();
}
Game game(initial_json);
#if defined(BOTUCT) || defined(BOTMULTI)
Bot bot(game, options.uct_constant, options.max_mc_depth, rng);
#elif defined(BOTRANDOM)
Bot bot(game, rng);
#else
Bot bot(game);
#endif
#if defined(REPORTING)
Reports reports;
#endif
while (!game.is_finished())
{
OmpFlag continue_flag(true);
std::cout << std::endl;
std::cout << "======================================== " << clock_it(get_double_time() - start_time) << std::endl;
game.status(std::cout);
std::cout << "++++++++++++++++++++++++++++++++++++++++ " << clock_it(get_double_time() - start_time) << std::endl;
#if defined(REPORTING)
Report report_aa = bot.crunch_it_baby(game, continue_flag, start_time, TURN_DURATION);
report_aa.type = 1;
reports.push_back(report_aa);
#else
bot.crunch_it_baby(game, continue_flag, start_time, TURN_DURATION);
#endif
const Direction direction = bot.get_move(game);
std::cout << "bot direction " << direction << std::endl;
bot.advance_game(game, direction);
//game.status(std::cout);
std::cout << "---------------------------------------- " << clock_it(get_double_time() - start_time) << std::endl;
std::cout << "view game at " << view_url << std::endl;
PTree new_json;
double request_start_time;
double request_end_time;
#if defined(OPENMP_FOUND)
#pragma omp parallel sections default(shared) shared(new_json, request_end_time, request_start_time, continue_flag, play_end_point, play_server_name, start_time, bot, game)
{
#pragma omp section
#endif
{
request_start_time = get_double_time();
new_json = connection.get_new_state_json(play_end_point, direction);
request_end_time = get_double_time();
continue_flag.reset();
}
#if defined(OPENMP_FOUND)
#pragma omp section
{
#if defined(REPORTING)
Report report_bb = bot.crunch_it_baby(game, continue_flag, start_time, 4);
report_bb.type = 2;
reports.push_back(report_bb);
#else
bot.crunch_it_baby(game, continue_flag, start_time, 4);
#endif
}
}
#endif
game.state.update(new_json);
game.update(new_json);
std::cout << "request took " << clock_it(request_end_time-request_start_time) << std::endl;
//game.status(std::cout);
std::cout << "======================================== " << clock_it(get_double_time() - start_time) << std::endl;
start_time = get_double_time();
}
assert( game.is_finished() );
#if defined(REPORTING)
save_report_file(reports, "report.txt");
#endif
return game;
}
