inline __host__ __device__
gl8u compute_saliency(i_short2 p, I& input_, int n_, int fast_th_, const A&)
{
unsigned max_n = 0;
unsigned n_bright = 0;
unsigned n_dark = 0;
gl8u vp = input_(p);
unsigned sum_bright = 0;
unsigned sum_dark = 0;
for (int i = 0; i < 16; i++)
{
gl8u vn = input_(p + i_int2(arch_neighb2d<A>::get(circle_r3_h, circle_r3, i)));
unsigned char dist = ::abs(int(vn) - int(vp));
if (dist > fast_th_)
{
if (int(vn) >= int(vp))
{
n_bright++;
sum_bright += dist;
}
else
{
n_dark++;
sum_dark += dist;
}
}
}
max_n = std::max(n_dark, n_bright);
if (max_n < n_)
return 0;
else
return max(sum_bright, sum_dark);
}
int main(int argc, char** argv){
//int main(){
int i;
if(argc < 3) {printf("wrong input of arguments!\n format: input_file output_file\n"); return 2;}
freopen(argv[2], "w", stdout);
int n = get_length(argv[1]);
//int n = get_length("input.txt");
int **M = (int**)malloc(n*sizeof(int*));
int **D = (int**)malloc(n*sizeof(int*));
int **save = (int**)malloc(n*sizeof(int*));
for(i = 0; i < n; i++){
M[i] = (int*)malloc(n*sizeof(int));
D[i] = (int*)malloc(n*sizeof(int));
save[i] = (int*)malloc(n*sizeof(int));
}
int* R = (int*)malloc(n*sizeof(int));
int* S = (int*)malloc(n*sizeof(int));
input_(argv[1], save, n);
//input_("input.txt", save, n);
int al = check_data(save, n);
//output_(1,save,n);
if(al == 1) {printf("wrong data input\n"); free_all(save, M, D, R, S, n); return 2;}
int H[1];
//get_data_from_within(save, "output.txt");
int cur_pos[1];
int record[1];
record[0] = get_first_record(save, M, D, R, S, n, cur_pos, H);
if(record[0] == -1) {
return 1;
}
backtracking(save, M, D, R, S, n, record, H);
//printf("Got here!\n");
printf("%d\n", H[0] + V[record[0]].L);
make_cycle(record[0]);
free_all(save, M, D, R, S, n);
return 0;
}
inline __host__ __device__
gl8u compute_saliency(i_short2 p, I& input_, int n_, int fast_th_, const A&)
{
unsigned max_n = 0;
unsigned n = 0;
int status = 2;
gl8u vp = input_(p);
unsigned sum_bright = 0;
unsigned sum_dark = 0;
// if (n_ == 15)
// {
// int to_test[3] = {0, 4, 12, 0};
// for (int i = 0; i < 3; i++)
// {
// gl8u vn = input_(p + i_int2(arch_neighb2d<A>::get(circle_r3_h, circle_r3, to_test[i])));
// int sign = int(vn) > int(vp);
// unsigned char dist = ::abs(int(vn) - int(vp));
// if (dist > fast_th_)
// if (sign == status) n++;
// else
// {
// if (n > max_n)
// max_n = n;
// status = sign;
// n = 1;
// }
// else
// {
// if (n > max_n)
// max_n = n;
// status = 2;
// }
// }
// if (n < 3) return 0;
// }
if (n_ >= 9)
{
int to_test[6] = {0, 4, 8, 12, 0, 4};
int equals = 0;
for (int i = 0; i < 6; i++)
{
gl8u vn = input_(p + i_int2(arch_neighb2d<A>::get(circle_r3_h, circle_r3, to_test[i])));
int sign = int(vn) > int(vp);
unsigned char dist = ::abs(int(vn) - int(vp));
if (dist > fast_th_)
if (sign == status) { n++; }
else
{
if (n > max_n)
max_n = n;
status = sign;
n = 1;
}
else
{
if (n > max_n)
max_n = n;
status = 2;
equals++;
if (i < 4 && n_ >= 12 && equals >= 2) return 0;
}
}
if (n > max_n)
max_n = n;
if (n_ >= 12 && max_n < 3) return 0;
else if (n_ >= 8 && max_n < 2) return 0;
}
n = 0;
status = 2;
max_n = 0;
for (int i = 0; i < 16; i++)
{
gl8u vn = input_(p + i_int2(arch_neighb2d<A>::get(circle_r3_h, circle_r3, i)));
int sign = int(vn) > int(vp);
unsigned char dist = ::abs(int(vn) - int(vp));
if (dist > fast_th_)
{
if (sign == status) n++;
else
{
if (n > max_n)
max_n = n;
status = sign;
n = 1;
}
if (vn < vp)
sum_dark += dist;
else
sum_bright += dist;
}
else
{
if (n > max_n)
max_n = n;
status = 2;
}
}
if (n != 16 && status != 2)
{
int i = 0;
while (true)
{
gl8u vn = input_(p + i_int2(arch_neighb2d<A>::get(circle_r3_h, circle_r3, i)));
int sign = int(vn) > int(vp);
unsigned char dist = ::abs(int(vn) - int(vp));
if (dist <= fast_th_ || sign != status) break;
n++;
i++;
assert(i < 16);
}
}
if (n > max_n)
max_n = n;
if (max_n < n_)
return 0;
else
return max(sum_bright, sum_dark);
// return sum_bright;
}
void test_unicode()
{
lexertl::cmatch r_;
const char *i_ = "";
r_.clear();
r_.reset(i_, i_);
const char utf8_[] = "\xf0\x90\x8d\x86\xe6\x97\xa5\xd1\x88\x7f";
lexertl::basic_utf8_in_iterator<const char *, int> u8iter_(utf8_,
utf8_ + sizeof(utf8_));
int i = *u8iter_; // 0x10346
i = *++u8iter_; // 0x65e5
i = *u8iter_++; // 0x65e5
i = *u8iter_; // 0x0448
i = *++u8iter_; // 0x7f
const wchar_t utf16_[] = L"\xdbff\xdfff\xd801\xdc01\xd800\xdc00\xd7ff";
lexertl::basic_utf16_in_iterator<const wchar_t *, int> u16iter_(utf16_,
utf16_ + sizeof(utf16_) / sizeof(wchar_t));
i = *u16iter_; // 0x10ffff
i = *++u16iter_; // 0x10401
i = *u16iter_++; // 0x10401
i = *u16iter_; // 0x10000
i = *++u16iter_; // 0xd7ff
// Not all compilers have char32_t, so use int for now
lexertl::basic_rules<char, int> rules_(lexertl::icase);
lexertl::basic_state_machine<int> sm_;
const int in_[] = {0x393, ' ', 0x393, 0x398, ' ', 0x398,
'1', ' ', 'i', 'd', 0x41f, 0};
std::basic_string<int> input_(in_);
const int *iter_ = input_.c_str();
const int *end_ = iter_ + input_.size();
lexertl::match_results<const int *> results_(iter_, end_);
rules_.push("\\p{LC}[\\p{LC}0-9]*", 1);
lexertl::basic_generator<lexertl::basic_rules<char, int>,
lexertl::basic_state_machine<int> >::build(rules_, sm_);
#ifdef WIN32
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
DWORD dwBytesWritten = 0;
#endif
do
{
#ifdef WIN32
std::wstring str_;
#else
std::string str_;
#endif
lexertl::lookup(sm_, results_);
#ifdef WIN32
str_.assign(lexertl::basic_utf16_out_iterator<const int *>
(results_.start, results_.end),
lexertl::basic_utf16_out_iterator<const int *>
(results_.end, results_.end));
std::wcout << L"Id: " << results_.id << L", Token: '";
::WriteConsoleW(hStdOut, str_.c_str(), str_.size(), &dwBytesWritten, 0);
std::wcout << '\'' << std::endl;
#else
str_.assign(lexertl::basic_utf8_out_iterator<const int *>
(results_.start, results_.end),
lexertl::basic_utf8_out_iterator<const int *>
(results_.end, results_.end));
std::cout << "Id: " << results_.id << ", Token: '" <<
str_ << '\'' << std::endl;
#endif
} while (results_.id != 0);
}
