void motion2(Eigen::Matrix3f &rot, Eigen::Vector3f &tr)
{
rot = Eigen::Matrix3f::Identity();
tr(0) = gen_random_float(0,0.2f);
tr(1) = gen_random_float(0,0.2f);
tr(2) = gen_random_float(0,0.2f);
}
void motion3(Eigen::Matrix3f &rot, Eigen::Vector3f &tr)
{
Eigen::Vector3f n;
n(0) = gen_random_float(-1,1);
n(1) = gen_random_float(-1,1);
n(2) = gen_random_float(-1,1);
n.normalize();
Eigen::AngleAxisf aa(gen_random_float(-0.02f,0.05f),n);
rot = aa.toRotationMatrix();
tr.fill(0);
}
///////////////////////////////////////////////////////////////////////
// Generate random string
std::string gen_rand_str(size_t len) {
auto randchar = []() -> char {
// const char charset[] =
// "0123456789"
// "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
// "abcdefghijklmnopqrstuvwxyz";
const char charset[] =
"0123456789"
"abcdefghijklmnopqrstuvwxyz";
// const size_t max_index = (sizeof(charset) - 1);
// return charset[rand() % max_index];
return charset[((int) std::floor(gen_random_float(0.0f, (float) sizeof(charset) - 1)))];
};
std::string str(len, 0);
std::generate_n(str.begin(), len, randchar);
return str;
}
void CliffordAttractor::constructConstants() {
// while (1) {
constVals.clear();
expressionX->constVals.clear();
expressionY->constVals.clear();
if (expressionZ) expressionZ->constVals.clear();
for (int i = 0; i < consts.size(); i++) {
constVals.push_back(gen_random_float(-PI, 3*PI));
}
for (int i = 0; i < expressionX->numConsts; i++)
expressionX->constVals.push_back( constVals[i] );
for (int i = 0; i < expressionY->numConsts; i++)
expressionY->constVals.push_back( constVals[i] );
if (expressionZ) {
for (int i = 0; i < expressionY->numConsts; i++)
expressionZ->constVals.push_back( constVals[i] );
}
/* Constants evaluation
double x = 0;
double y = 0;
int good = 100;
for (int i = 0; i < 100; i++) {
vector<double> vals{x,y};
double nx = expressionX->evaluate(vals);
double ny = expressionY->evaluate(vals);
double d = pow(x-nx, 2) + pow(y-ny, 2);
}*/
//}
}
std::vector<cob_3d_mapping_msgs::CurvedPolygon> generateRandomPlanes(const int N, const bool cors)
{
std::vector<cob_3d_mapping_msgs::CurvedPolygon> r;
for(int i=0; i<N; i++)
{
cob_3d_mapping_msgs::CurvedPolygon cp;
cp.ID = i;
cp.parameter[0] = gen_random_float(2.f, 4.f);
cp.parameter[1] = gen_random_float(-1.f,1.f);
cp.parameter[2] = 0;
cp.parameter[3] = gen_random_float(-1.f,1.f);
cp.parameter[4] = 0;
cp.parameter[5] = 0;
Eigen::Vector3f z,n,np;
z.fill(0);z(2)=1.f;
n=z;
n(0) = -cp.parameter[1];
n(1) = -cp.parameter[3];
n.normalize();
np = cp.parameter[0]*(z.dot(n))*n;
cob_3d_mapping_msgs::feature ft;
ft.ID = 1; //nearest point
ft.x = np(0);
ft.y = np(1);
ft.z = np(2);
cp.features.push_back(ft);
if(cors)
{
cob_3d_mapping_msgs::simalarity_score ss;
ss.ID = i;
ss.prob = 1.f;
cp.score.push_back(ss);
}
//outline
float size = gen_random_float(0.5f, 2.f)/10;
for(int j=0; j<10; j++)
{
cob_3d_mapping_msgs::polyline_point pt;
pt.edge_prob = 1;
pt.x = j*size;
pt.y = 0;
cp.polyline.push_back(pt);
pt.x = j*size;
pt.y = size*10;
cp.polyline.push_back(pt);
pt.y = j*size;
pt.x = 0;
cp.polyline.push_back(pt);
pt.y = j*size;
pt.x = size*10;
cp.polyline.push_back(pt);
}
r.push_back(cp);
}
return r;
}
int main(int argc, char** argv)
{
int args = 1;
#ifdef USE_OPENCL
if (argc < 10) {
#else
if (argc < 7) {
#endif
std::cout << "Not enough arguments" << std::endl;
system("pause");
return 1;
}
DIM = util::toInt(argv[args++]);
N = util::toInt(argv[args++]);
K = util::toInt(argv[args++]);
ITERATIONS = util::toInt(argv[args++]);
RUNS = util::toInt(argv[args++]);
#ifdef USE_OPENCL
AM_LWS = util::toInt(argv[args++]);
RP_LWS = util::toInt(argv[args++]);
CT_LWS = util::toInt(argv[args++]);
USE_ALL_DEVICES = util::toInt(argv[args++]);
#else
device_count = util::toInt(argv[args++]);
#endif
std::cout << "DIM = " << DIM << std::endl;
std::cout << "N = " << N << std::endl;
std::cout << "K = " << K << std::endl;
std::cout << "ITERATIONS = " << ITERATIONS << std::endl;
std::cout << "RUNS = " << RUNS << std::endl;
#ifdef USE_OPENCL
std::cout << "AM_LWS = " << AM_LWS << std::endl;
std::cout << "RP_LWS = " << RP_LWS << std::endl;
std::cout << "CT_LWS = " << CT_LWS << std::endl;
std::cout << "USE_ALL_DEVICES = " << USE_ALL_DEVICES << std::endl << std::endl;
#else
std::cout << "device_count = " << device_count << std::endl << std::endl;
#endif
#ifdef _WIN32
rng.seed();
srand(GetTickCount());
#else
rng.seed();
srand(getTimeMs());
#endif
u = boost::uniform_real<float>(0.0f, 1000000.0f);
gen = new boost::variate_generator<boost::mt19937&, boost::uniform_real<float> >(rng, u);
#ifdef USE_OPENCL
cl_int clError = CL_SUCCESS;
initCL();
for (int i = 0; i < clDevices.size(); ++i) {
clInputBuf.push_back(cl::Buffer(clContext, CL_MEM_READ_ONLY, N * DIM * sizeof(float), NULL, &clError));
if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;
clCentroidBuf.push_back(cl::Buffer(clContext, CL_MEM_READ_WRITE, K * DIM * sizeof(float), NULL, &clError));
if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;
clMappingBuf.push_back(cl::Buffer(clContext, CL_MEM_READ_WRITE, N * sizeof(int), NULL, &clError));
if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;
clReductionBuf.push_back(cl::Buffer(clContext, CL_MEM_WRITE_ONLY, N * sizeof(float), NULL, &clError));
if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;
clClusterAssignment[i].setArgs(clInputBuf[i](), clCentroidBuf[i](), clMappingBuf[i]());
clClusterReposition[i].setArgs(clInputBuf[i](), clMappingBuf[i](), clCentroidBuf[i]());
clClusterReposition_k[i].setArgs(clInputBuf[i](), clMappingBuf[i](), clCentroidBuf[i]());
//clClusterReposition_k_c[i].setArgs(clInputBuf[i](), clMappingBuf[i](), clCentroidBuf[i](), clConvergedBuf[i]());
clComputeCost[i].setArgs(clInputBuf[i](), clCentroidBuf[i](), clMappingBuf[i](), clReductionBuf[i]());
}
device_count = clDevices.size();
#endif
util::Clock clock;
clock.reset();
for (int i = 0; i < RUNS; ++i) {
mapping_list.push_back(NULL);
centroids_list.push_back(NULL);
cost_list.push_back(0.0f);
}
float* source = new float[N*DIM];
for (int i = 0; i < N*DIM; ++i)
source[i] = gen_random_float();
input_list.push_back(source);
for (int i = 1; i < device_count; ++i) {
float* copy = new float[N*DIM];
memcpy(copy, source, N*DIM*sizeof(float));
input_list.push_back(copy);
}
if (device_count > 1) {
boost::thread_group threads;
for (int i = 0; i < device_count; ++i) {
threads.create_thread(boost::bind(exec, i, true));
}
threads.join_all();
} else {
exec(0, false);
}
#ifdef USE_OPENCL
reduction_group.join_all();
#endif
int best_result = 0;
float best_cost = std::numeric_limits<float>::max();
for (int i = 0; i < RUNS; ++i) {
if (cost_list[i] < best_cost) {
best_cost = cost_list[i];
best_result = i;
}
}
FILE *out_fdesc = fopen("centroids.out", "wb");
fwrite((void*)centroids_list[best_result], K * DIM * sizeof(float), 1, out_fdesc);
fclose(out_fdesc);
out_fdesc = fopen("mapping.out", "wb");
fwrite((void*)mapping_list[best_result], N * sizeof(int), 1, out_fdesc);
fclose(out_fdesc);
std::cout << "Best result is " << best_result << std::endl;
for (int i = 0; i < device_count; ++i) {
delete[] input_list[i];
}
for (int i = 0; i < RUNS; ++i) {
delete[] mapping_list[i];
delete[] centroids_list[i];
}
float now = clock.get();
std::cout << "Total: " << now << std::endl;
system("pause");
return 0;
}
