void runTest()
{
NeuralGasNetwork* myNet = new NeuralGasNetwork(
2,
NODE_CHANGE_RATE,
NODE_NEIGHBOR_CHANGE_RATE,
LOCAL_DECREASE_RATE,
GLOBAL_DECREASE_RATE,
AGE_MAX,
TIME_BETWEEN_ADDING_NODES);
int i = 0;
while (myNet->nodes.size() < 100 && i < 15000)
{
if (i%500 == 0)
cout << "Iteration " << i << endl;
myNet->iterate(generateTestData());
++i;
}
LabelGraphNodes(myNet);
//Now train the perceptron classifer
PerceptronClassifier* myClassifier = new PerceptronClassifier(myNet,
2,
2);
for (unsigned int i = 0; i != 100; ++i)
{
vector<double> testData = generateTestData();
if (testData[0] > 0.5)
myClassifier->train_GNG_Perceptron(testData, 1);
else
myClassifier->train_GNG_Perceptron(testData, 0);
}
while (1)
{
double t1;
double t2;
cin >> t1 >> t2;
vector<double> testVec = { t1, t2 };
int k = myNet->findNearest(testVec);
cout << "GNG Classifcation: " << myNet->nodes[k]->classification << endl;
cout << "GNG Error: " << myNet->nodes[k]->getEuclidianDistance(testVec) << endl;
myClassifier->printOutput(testVec);
}
}
virtual void SetUp()
{
// generate a pointcloud
generateTestData();
// setup ROS
ros::NodeHandle n("~");
pub_cloud_ = n.advertise<sensor_msgs::PointCloud2>("output", 1);
pub_even_indices_ = n.advertise<pcl_msgs::PointIndices>("output/even_indices", 1);
pub_odd_indices_ = n.advertise<pcl_msgs::PointIndices>("output/odd_indices", 1);
sub_even_result_ = n.subscribe("input/even_result", 1, &ExtractIndicesTest::evenCallback, this);
sub_odd_result_ = n.subscribe("input/odd_result", 1, &ExtractIndicesTest::oddCallback, this);
sub_even_organized_result_ = n.subscribe("input/even_organized_result", 1,
&ExtractIndicesTest::evenOrganizedCallback, this);
sub_odd_organized_result_ = n.subscribe("input/odd_organized_result",
1, &ExtractIndicesTest::oddOrganizedCallback, this);
// wait until
ros::Time start_time = ros::Time::now();
while (!isReady()) {
publishData();
ros::spinOnce();
ros::Duration(0.5).sleep();
}
ros::Time end_time = ros::Time::now();
ROS_INFO("took %f sec to retrieve result", (end_time - start_time).toSec());
}
double doExec() {
if (!loadTestData()) {
std::cerr << "Failed to load test data" << std::endl;
return -1;
}
//
// Start solution testing
//
double score = 0, sse;
int scenario = 0;
for (int i = 0; i < subsetsNum; i++) {
scenario = i % 3;
generateTestData(scenario, i);
VD res = test->predict(0, scenario, DTrain, DTest);
Assert(groundTruth.size() == res.size(), "Expected results count not equal to found. Expected: %lu, but found: %lu", groundTruth.size(), res.size());
sse = 0;
for (int j = 0; j < res.size(); j++) {
double e = res[j] - groundTruth[j];
sse += e * e;
}
// calculate score
double s = 1000000 * fmax(0, 1.0 - sse/sse0);
Printf("%i.) Score = %f, sse: %f, sse0: %f\n", i, s, sse, sse0);
score += s;
}
return score / subsetsNum;
}
OCL_TEST_P(FastNlMeansDenoising_hsep, Mat)
{
for (int j = 0; j < test_loop_times; j++)
{
generateTestData();
OCL_OFF(cv::fastNlMeansDenoising(src_roi, dst_roi, h, templateWindowSize, searchWindowSize, normType));
OCL_ON(cv::fastNlMeansDenoising(usrc_roi, udst_roi, h, templateWindowSize, searchWindowSize, normType));
OCL_EXPECT_MATS_NEAR(dst, 1);
}
}
void performTest(int channelsIn, int channelsOut, int code, double threshold = 1e-3)
{
for (int j = 0; j < test_loop_times; j++)
{
generateTestData(channelsIn, channelsOut);
OCL_OFF(cv::cvtColor(src_roi, dst_roi, code, channelsOut));
OCL_ON(cv::cvtColor(usrc_roi, udst_roi, code, channelsOut));
Near(threshold);
}
}
//================================================================================================================================================================
int main()
{
auto elements = generateTestData(std::pow(10, 4));
size_t key = -1; // an element which is never found
std::unique_ptr<basicsearching::ISearch> linearSearch = std::make_unique<basicsearching::LinearSearch>();
std::unique_ptr<basicsearching::ISearch> binarySearch = std::make_unique<basicsearching::BinarySearch>();
testSearchAlgorithm("LinearSearch", linearSearch, elements, key);
std::cout << std::endl << "-----------";
testSearchAlgorithm("BinarySearch", binarySearch, elements, key);
std::cout << std::endl;
return 0;
}
void runTest()
{
//Get the platforms
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
//Create a context
cl_context_properties cps[3] = {CL_CONTEXT_PLATFORM,
(cl_context_properties)(*platforms.begin())(), 0};
cl::Context context = cl::Context(CL_DEVICE_TYPE_GPU, cps);
//Create and build the program
cl::Program opencl_gngNetworkProgram;
opencl_gngNetworkProgram = createProgram(context, "opencl_gng_network.cl");
//Create the command queue from the first device in context
cl::CommandQueue queue;
queue = cl::CommandQueue(context, context.getInfo<CL_CONTEXT_DEVICES>()[0], CL_QUEUE_PROFILING_ENABLE);
GPU_parallel_gng::NeuralGasNetworkHost* myNet = new GPU_parallel_gng::NeuralGasNetworkHost(
2,
NODE_CHANGE_RATE,
NODE_NEIGHBOR_CHANGE_RATE,
LOCAL_DECREASE_RATE,
GLOBAL_DECREASE_RATE,
AGE_MAX,
TIME_BETWEEN_ADDING_NODES,
context,
opencl_gngNetworkProgram,
queue);
for (int i = 0; i != 50000; ++i)
{
if (i%500 == 0)
cout << "iteration: " << i << endl;
vector<float> dataPoint = generateTestData();
myNet->iterateNetwork(dataPoint, queue);
}
myNet->foo(queue);
CPU_serial_gng::NeuralGasNetwork* cpuNet = convert_to_cpu_gng(*myNet->gngNetwork);
CPU_serial_gng::LabelGraphNodes(cpuNet);
}
OCL_TEST_F(SphericalWarperTest, Mat)
{
for (int j = 0; j < test_loop_times; j++)
{
generateTestData();
Ptr<WarperCreator> creator = makePtr<SphericalWarper>();
Ptr<detail::RotationWarper> warper = creator->create(2.0);
OCL_OFF(warper->buildMaps(src.size(), K, R, xmap, ymap));
OCL_ON(warper->buildMaps(usrc.size(), K, R, uxmap, uymap));
OCL_OFF(warper->warp(src, K, R, INTER_LINEAR, BORDER_REPLICATE, dst));
OCL_ON(warper->warp(usrc, K, R, INTER_LINEAR, BORDER_REPLICATE, udst));
Near(1e-4);
}
}
void testCMarginBuffer()
{
const int64_t cols = 23;
const int64_t rows = 54;
const int64_t numPixels = cols * rows;
const int64_t numElements = (cols + 2 * margin) * (rows + 2 * margin);
CMarginBuffer2D<margin> buffer1(cols, rows);
EXPECT_EQ(cols, buffer1.cols());
EXPECT_EQ(rows, buffer1.rows());
EXPECT_EQ(numPixels, buffer1.numPixels());
EXPECT_EQ(numElements, buffer1.numElements());
// generate test data
generateTestData(buffer1);
// check the data in the buffer
for (int64_t y = 0; y < rows; ++y)
{
for (int64_t x = 0; x < cols; ++x)
{
EXPECT_EQ(Complex(std::sin(static_cast<Real>(y)), static_cast<Real>(x)),
buffer1.pixel(x, y));
}
}
// create a compatible buffer
auto buffer2 = buffer1.createCompatibleBuffer();
EXPECT_EQ(cols, buffer1.cols());
EXPECT_EQ(rows, buffer2.rows());
EXPECT_EQ(numPixels, buffer2.numPixels());
EXPECT_EQ(numElements, buffer2.numElements());
EXPECT_TRUE(buffer1.compatible(buffer2));
EXPECT_TRUE(buffer2.compatible(buffer1));
// copy the data in the new buffer
buffer2.assign(buffer1);
// clear the first buffer
const Complex clearValue(42.0, -8.0);
buffer1.setValue(clearValue);
// check the data in the first buffer
for (int64_t y = 0; y < rows; ++y)
for (int64_t x = 0; x < cols; ++x)
EXPECT_EQ(clearValue, buffer1.pixel(x, y));
// check the data in the second buffer
for (int64_t y = 0; y < rows; ++y)
{
for (int64_t x = 0; x < cols; ++x)
{
EXPECT_EQ(Complex(std::sin(static_cast<Real>(y)), static_cast<Real>(x)),
buffer2.pixel(x, y));
}
}
// test addAssign
buffer1.setValue(Complex(1.0, -1.0));
generateTestData(buffer2);
buffer1 += buffer2;
for (int64_t y = 0; y < rows; ++y)
{
for (int64_t x = 0; x < cols; ++x)
{
EXPECT_EQ(Complex(std::sin(static_cast<Real>(y)) + R(1.0),
static_cast<Real>(x) - R(1.0)),
buffer1.pixel(x, y));
}
}
// test multiplyAssign(CMarginBuffer)
buffer1.setValue(Complex(1.0, -1.0));
generateTestData(buffer2);
buffer1 *= buffer2;
for (int64_t y = 0; y < rows; ++y)
{
for (int64_t x = 0; x < cols; ++x)
{
EXPECT_EQ(Complex(std::sin(static_cast<Real>(y)) + static_cast<Real>(x),
-std::sin(static_cast<Real>(y)) + static_cast<Real>(x)),
buffer1.pixel(x, y));
}
}
// test multiplyAssign(Complex)
generateTestData(buffer1);
buffer1 *= Complex(1.0, -1.0);
for (int64_t y = 0; y < rows; ++y)
{
for (int64_t x = 0; x < cols; ++x)
{
EXPECT_EQ(Complex(std::sin(static_cast<Real>(y)) + static_cast<Real>(x),
-std::sin(static_cast<Real>(y)) + static_cast<Real>(x)),
buffer1.pixel(x, y));
}
}
// test multiplyAssign(Real)
generateTestData(buffer1);
buffer1 *= 5.0;
for (int64_t y = 0; y < rows; ++y)
{
for (int64_t x = 0; x < cols; ++x)
{
EXPECT_EQ(Complex(std::sin(static_cast<Real>(y)) * R(5.0),
static_cast<Real>(x) * R(5.0)),
buffer1.pixel(x, y));
}
}
// create a third buffer
const Complex initialValue(-49.0, 7.0);
CMarginBuffer2D<margin> buffer3(cols + 1, rows, initialValue);
EXPECT_FALSE(buffer3.compatible(buffer1));
EXPECT_FALSE(buffer1.compatible(buffer3));
for (int64_t y = 0; y < rows; ++y)
for (int64_t x = 0; x < cols; ++x)
EXPECT_EQ(initialValue, buffer3.pixel(x, y));
std::mt19937 generator;
std::uniform_real_distribution<Real> distribution(0.0, Math::twoPi);
for (int64_t y = 0; y < rows; ++y)
for (int64_t x = 0; x < cols + 1; ++x)
buffer3.pixel(x, y) = fromArg(distribution(generator));
EXPECT_EQ(buffer3.numPixels(), buffer3.absSqrReduce());
// todo: test multiplyAssign
// todo: test info
}
/*********************************************
per-frame logic goes here
**********************************************/
void App::updateMain(){
//Get the mouse pointer pos in screen space
SDL_GetMouseState(&iMouseX, &iMouseY);
//Throw away any bad frames
if(fTimeScale == infinity || fTimeScale == 0.0f){
return;
}
float fCamSpeed = fTimeScale * 10.0f;
float fDragScale = 0.05f;
if (!this->bGlobalDisableKeyMovement) {
//Right button means we reset rotation and such
//NOTE: I did have this as 'both left and right at once', which seemed
//to make more sense, but it doesn't work great on systems that map this
//to middle-mouse
if(mouseDown(3)){
resetCam();
}
//Rotation for the wall
/*
float camTime = fUptime * 0.1f;
float fRotateSpeed = fCamSpeed;
fRot[1] += fRotateSpeed;
fRot[0] = (sinf(camTime) * 5);
fCameraY = cosf(camTime) * 5;
fZoom = (sinf(camTime) * 15) + 27;
*/
//LOG("%f, %f\n", fRot[1], fZoom);
//fZoom = -10;
//Keyboard rotation
if(keyDown(SDLK_RSHIFT) || keyDown(SDLK_LSHIFT)){
fCamSpeed *= 10;
}
if(keyDown(SDLK_LEFT)) fRot[1] -= fCamSpeed;
if(keyDown(SDLK_RIGHT)) fRot[1] += fCamSpeed;
if(keyDown(SDLK_UP)) fRot[0] -= fCamSpeed;
if(keyDown(SDLK_DOWN)) fRot[0] += fCamSpeed;
if(keyDown(SDLK_w)) {
fCameraZ -= fCamSpeed;
//fRot[0] = 0.0; fRot[1] = 0.0; fRot[2] = 0.0;
fLookZ -= fCamSpeed;
}
if(keyDown(SDLK_s)) {
fCameraZ += fCamSpeed;
//fRot[0] = 0.0; fRot[1] = 0.0; fRot[2] = 0.0;
fLookZ += fCamSpeed;
}
if(keyDown(SDLK_a)) {
fCameraX -= fCamSpeed;
fLookX -= fCamSpeed;
}
if(keyDown(SDLK_d)) {
fCameraX += fCamSpeed;
fLookX += fCamSpeed;
}
if(keyDown(SDLK_SPACE)) resetCam();
//If we're actively dragging with the mouse
if(bDrag){
//Figure out the drag vectors and stuff
Vector2 drag = getMouse();
Vector2 diff = (dragStart - drag) * fDragScale;
//Left mouse button means we modify the rotation
if(mouseDown(1)){
fRot[1] -= diff.x;
fRot[0] -= diff.y;
}
//Middle mouse means we modify the zoom
else if(mouseDown(2)){
fZoom += diff.y;
}
dragVel = diff;
dragStart = getMouse();
}else{
//fRot[1] -= dragVel.x;
//fRot[0] -= dragVel.y;
}
}
updateSocket();
//Hack! The shader system doesn't really play nice with the banner, so
//we disable it here.
if(!isConnected()){
if(ps()->getType() <= PARTICLE_SYSTEM_POINTSPRITES)
generateTestData();
else
fGUITimeout = 1.0f;
}
mParticleSystem->update();
}
