Пример #1
0
static int writePC33(bor_pc_t *pc, int fd)
{
    FILE *fout;
    bor_pc_it_t pcit;
    bor_vec3_t *v;

    fout = fdopen(fd, "w");
    if (!fout)
        return -1;

    // first print dimensions
    fprintf(fout, "3\n");

    // then write number of points
    fprintf(fout, "%d\n", (int)borPCLen(pc));

    // and write all points
    borPCItInit(&pcit, (bor_pc_t *)pc);
    while (!borPCItEnd(&pcit)){
        v = (bor_vec3_t *)borPCItGet(&pcit);
        fprintf(fout, "%g %g %g\n", borVec3X(v), borVec3Y(v), borVec3Z(v));

        borPCItNext(&pcit);
    }

    fclose(fout);

    return 0;
}
Пример #2
0
int main(int argc, char *argv[])
{
    svo_gng_eu_params_t params;
    svo_gng_eu_ops_t ops;
    size_t size;
    bor_real_t aabb[30];

    if (argc < 4){
        fprintf(stderr, "Usage: %s dim file.pts max_nodes\n", argv[0]);
        return -1;
    }

    max_nodes = atoi(argv[3]);


    svoGNGEuParamsInit(&params);
    params.dim = atoi(argv[1]);
    params.nn.type = BOR_NN_GUG;
    params.nn.type = BOR_NN_VPTREE;
    params.nn.gug.num_cells = 0;
    params.nn.gug.max_dens = 0.1;
    params.nn.gug.expand_rate = 1.5;

    svoGNGEuOpsInit(&ops);
    ops.terminate = terminate;
    ops.input_signal = input_signal;
    ops.callback  = callback;
    ops.callback_period = 300;
    ops.data = NULL;

    pc = borPCNew(params.dim);
    size = borPCAddFromFile(pc, argv[2]);
    borPCAABB(pc, aabb);
    params.nn.gug.aabb = aabb;
    fprintf(stderr, "Added %d points from %s\n", (int)size, argv[2]);

    borPCPermutate(pc);
    borPCItInit(&pcit, pc);

    gng = svoGNGEuNew(&ops, &params);

    borTimerStart(&timer);
    svoGNGEuRun(gng);
    callback(NULL);
    fprintf(stderr, "\n");

    svoGNGEuDumpSVT(gng, stdout, NULL);

    svoGNGEuDel(gng);

    borPCDel(pc);

    return 0;
}
Пример #3
0
static const bor_vec_t *input_signal(void *data)
{
    const bor_vec_t *v;

    if (borPCItEnd(&pcit)){
        borPCPermutate(pc);
        borPCItInit(&pcit, pc);
    }
    v = borPCItGet(&pcit);
    borPCItNext(&pcit);
    return v;
}
Пример #4
0
static int pcContains(bor_pc_t *pc, const bor_vec3_t *v)
{
    bor_pc_it_t it;
    const bor_vec3_t *w;

    borPCItInit(&it, pc);
    while (!borPCItEnd(&it)){
        w = (bor_vec3_t *)borPCItGet(&it);
        if (borVec3Eq(w, v))
            return 1;

        borPCItNext(&it);
    }
    return 0;
}