void mepp_component_CGAL_Example_plugin::draw_connections(Viewer* viewer, int frame_i, int frame_j)
{
#if (1)
PolyhedronPtr pMesh_i = viewer->getScenePtr()->get_polyhedron(frame_i);
PolyhedronPtr pMesh_j = viewer->getScenePtr()->get_polyhedron(frame_j);
int nbp_i = pMesh_i->size_of_vertices();
int nbp_j = pMesh_j->size_of_vertices();
if (nbp_i == nbp_j)
{
glLineWidth(2);
glColor3f(1., 0., 0.);
Vertex_iterator pVertex_i = NULL;
Vertex_iterator pVertex_j = NULL;
for (pVertex_i = pMesh_i->vertices_begin(), pVertex_j = pMesh_j->vertices_begin(); pVertex_i != pMesh_i->vertices_end(); pVertex_i++, pVertex_j++)
{
Vec pi(pVertex_i->point().x(), pVertex_i->point().y(), pVertex_i->point().z());
Vec pj(pVertex_j->point().x(), pVertex_j->point().y(), pVertex_j->point().z());
draw_link(viewer, frame_i, frame_j, pi, pj);
}
}
#endif
}
bool Print(const RichText& text, const Rect& page, int currentpage, const char *name)
{
PrinterJob pj(name);
pj.CurrentPage(currentpage);
pj.PageCount(text.GetHeight(page).page + 1);
pj.Landscape(page.GetWidth() > page.GetHeight());
if(pj.Execute()) {
Print(pj, text, page, pj.GetPages());
return true;
}
return false;
}
Vector2f computeError(int i, Matrix3f X, MatrixXf Z){
Vector3f pi(1, 1, 1);
Vector3f pj(1, 1, 1);
for(int j=0; j<2; j++){
pi(j, 0) = Z(j, i);
pj(j, 0) = Z(j+2, i);
}
Vector3f efull = X*pi - pj;
Vector2f e;
e(0,0) = efull(0,0);
e(1,0) = efull(1,0);
return e;
}
inline uint256 HashAxiom(const T1 pbegin, const T1 pend)
{
int R = 2;
int N = 65536;
std::vector<uint256> M(N);
static unsigned char pblank[1];
pblank[0] = 0;
sph_shabal256_context ctx_shabal;
uint256 hash1;
sph_shabal256_init(&ctx_shabal);
sph_shabal256 (&ctx_shabal, (pbegin == pend ? pblank : static_cast<const void*>(&pbegin[0])), (pend - pbegin) * sizeof(pbegin[0]));
sph_shabal256_close(&ctx_shabal, static_cast<void*>(&hash1));
M[0] = hash1;
for(int i = 1; i < N; i++)
{
sph_shabal256_init(&ctx_shabal);
sph_shabal256 (&ctx_shabal, (unsigned char*)&M[i - 1], sizeof(M[i - 1]));
sph_shabal256_close(&ctx_shabal, static_cast<void*>((unsigned char*)&M[i]));
}
for(int r = 1; r < R; r ++)
{
for(int b = 0; b < N; b++)
{
int p = (b - 1 + N) % N;
int q = M[p].GetInt() % (N - 1);
int j = (b + q) % N;
std::vector<uint256> pj(2);
pj[0] = M[p];
pj[1] = M[j];
sph_shabal256_init(&ctx_shabal);
sph_shabal256 (&ctx_shabal, (unsigned char*)&pj[0], 2 * sizeof(pj[0]));
sph_shabal256_close(&ctx_shabal, static_cast<void*>((unsigned char*)&M[b]));
}
}
return M[N - 1];
}
ATOOLS::Vec4D_Vector Combine
(const Cluster_Amplitude &l,int i,int j,int k,const ATOOLS::Flavour &mo)
{
Mass_Selector *p_ms=ampl.MS();
if (i>j) std::swap<int>(i,j);
Vec4D_Vector after(ampl.Legs().size()-1);
double mb2(0.0);
if (i<2) {
mb2=ampl.Leg(1-i)->Mom().Abs2();
double mfb2(p_ms->Mass2(ampl.Leg(1-i)->Flav()));
if ((mfb2==0.0 && IsZero(mb2,1.0e-6)) || IsEqual(mb2,mfb2,1.0e-6)) mb2=mfb2;
}
Vec4D pi(ampl.Leg(i)->Mom()), pj(ampl.Leg(j)->Mom());
Vec4D pk(ampl.Leg(k)->Mom()), pb(i<2?ampl.Leg(1-i)->Mom():Vec4D());
double mi2=pi.Abs2(), mfi2=p_ms->Mass2(ampl.Leg(i)->Flav());
double mj2=pj.Abs2(), mfj2=p_ms->Mass2(ampl.Leg(j)->Flav());
double mk2=pk.Abs2(), mfk2=p_ms->Mass2(ampl.Leg(k)->Flav());
if ((mfi2==0.0 && IsZero(mi2,1.0e-6)) || IsEqual(mi2,mfi2,1.0e-6)) mi2=mfi2;
if ((mfj2==0.0 && IsZero(mj2,1.0e-6)) || IsEqual(mj2,mfj2,1.0e-6)) mj2=mfj2;
if ((mfk2==0.0 && IsZero(mk2,1.0e-6)) || IsEqual(mk2,mfk2,1.0e-6)) mk2=mfk2;
double mij2=p_ms->Mass2(mo);
Kin_Args lt;
if (i>1) {
if (k>1) lt=ClusterFFDipole(mi2,mj2,mij2,mk2,pi,pj,pk,2);
else lt=ClusterFIDipole(mi2,mj2,mij2,mk2,pi,pj,-pk,2);
if ((k==0 && lt.m_pk[3]<0.0) ||
(k==1 && lt.m_pk[3]>0.0) || lt.m_pk[0]<0.0) return Vec4D_Vector();
}
else {
if (k>1) {
lt=ClusterIFDipole(mi2,mj2,mij2,mk2,mb2,-pi,pj,pk,-pb,2);
}
else lt=ClusterIIDipole(mi2,mj2,mij2,mk2,-pi,pj,-pk,2);
if ((i==0 && lt.m_pi[3]<0.0) ||
(i==1 && lt.m_pi[3]>0.0) || lt.m_pi[0]<0.0) return Vec4D_Vector();
}
if (lt.m_stat<0) return Vec4D_Vector();
for (size_t l(0), m(0);m<ampl.Legs().size();++m) {
if (m==(size_t)j) continue;
if (m==(size_t)i) after[l]=i>1?lt.m_pi:-lt.m_pi;
else if (m==(size_t)k) after[l]=k>1?lt.m_pk:-lt.m_pk;
else after[l]=lt.m_lam*ampl.Leg(m)->Mom();
++l;
}
return after;
}
void Polyhedron_triangulation::extract_CAT()
{
std::for_each(cat_cells.begin(), cat_cells.end(), std::mem_fun_ref(&std::list<CAT_facet>::clear));
int *tetra_vtx_ptr = tetra_mesh.tetrahedronlist;
int *marker = tetra_mesh.pointmarkerlist;
REAL *pnt_tbl = tetra_mesh.pointlist;
std::function<Point_3(int)> cgal_pnt = [=](int idx) { return Point_3(pnt_tbl[idx*3], pnt_tbl[idx*3+1], pnt_tbl[idx*3+2]); };
for (int i = 0; i < tetra_mesh.numberoftetrahedra; i++, tetra_vtx_ptr += 4)
{
std::set<int> group_no;
std::multimap<int, int> group_no_vidx;
typedef std::multimap<int, int>::const_iterator Iter;
for (int j = 0; j < 4; j++)
{
int vid = tetra_vtx_ptr[j];
int gid = marker[vid];
group_no.insert(gid);
group_no_vidx.insert(std::make_pair(gid, vid));
}
if (group_no.size() == 2)
{
std::set<int>::const_iterator gid0 = group_no.begin(), gid1 = group_no.begin();
++gid1;
if (group_no_vidx.count(*gid0) == 1 && group_no_vidx.count(*gid1) == 3)
{
std::pair<Iter, Iter> i0 = group_no_vidx.equal_range(*gid0);
std::pair<Iter, Iter> i1 = group_no_vidx.equal_range(*gid1);
std::list<Point_3> mid_tri;
for (Iter it = i1.first; it != i1.second; ++it)
mid_tri.push_back(CGAL::midpoint(cgal_pnt(i0.first->second), cgal_pnt(it->second)));
if (*gid0 >= 0)
cat_cells[*gid0].push_back(CAT_facet(cgal_pnt(i0.first->second), mid_tri));
if (*gid1 >= 0)
for (Iter it = i1.first; it != i1.second; ++it)
cat_cells[*gid1].push_back(CAT_facet(cgal_pnt(it->second), mid_tri));
}
else if (group_no_vidx.count(*gid0) == 3 && group_no_vidx.count(*gid1) == 1)
{
std::pair<Iter, Iter> i0 = group_no_vidx.equal_range(*gid0);
std::pair<Iter, Iter> i1 = group_no_vidx.equal_range(*gid1);
std::list<Point_3> mid_tri;
for (Iter it = i0.first; it != i0.second; ++it)
mid_tri.push_back(CGAL::midpoint(cgal_pnt(i1.first->second), cgal_pnt(it->second)));
if (*gid1 >= 0)
cat_cells[*gid1].push_back(CAT_facet(cgal_pnt(i1.first->second), mid_tri));
if (*gid0 >= 0)
for (Iter it = i0.first; it != i0.second; ++it)
cat_cells[*gid0].push_back(CAT_facet(cgal_pnt(it->second), mid_tri));
}
else
{
std::pair<Iter, Iter> i0 = group_no_vidx.equal_range(*gid0);
std::pair<Iter, Iter> i1 = group_no_vidx.equal_range(*gid1);
Iter it = i0.first;
Point_3 p00(cgal_pnt(it->second));
++it;
Point_3 p01(cgal_pnt(it->second));
it = i1.first;
Point_3 p10(cgal_pnt(it->second));
++it;
Point_3 p11(cgal_pnt(it->second));
Point_3 midpnt[4] = {CGAL::midpoint(p00, p10), CGAL::midpoint(p00, p11), CGAL::midpoint(p01, p10), CGAL::midpoint(p01, p11)};
std::list<Point_3> mid_pm; // the middle parallelogram
mid_pm.push_back(midpnt[0]);
mid_pm.push_back(midpnt[1]);
if (Vector_3(midpnt[0], midpnt[1])*Vector_3(midpnt[2], midpnt[3]) < 0)
{
mid_pm.push_back(midpnt[2]);
mid_pm.push_back(midpnt[3]);
}
else
{
mid_pm.push_back(midpnt[3]);
mid_pm.push_back(midpnt[2]);
}
if (*gid0 >= 0)
{
cat_cells[*gid0].push_back(CAT_facet(p00, mid_pm));
cat_cells[*gid0].push_back(CAT_facet(p01, mid_pm));
}
if (*gid1 >= 0)
{
cat_cells[*gid1].push_back(CAT_facet(p10, mid_pm));
cat_cells[*gid1].push_back(CAT_facet(p11, mid_pm));
}
}
}
else if (group_no.size() == 3)
{
// the two vertices in the same group
int smgp[2];
// the two vertices in the other two different groups
int dfgp[2];
int gi, gj, gk;
std::vector< std::pair<int, int> > tmpv(group_no_vidx.begin(), group_no_vidx.end());
if (tmpv[0].first == tmpv[1].first)
{
smgp[0] = tmpv[0].second; smgp[1] = tmpv[1].second; gi = tmpv[0].first;
dfgp[0] = tmpv[2].second; dfgp[1] = tmpv[3].second; gj = tmpv[2].first; gk = tmpv[3].first;
}
else if (tmpv[1].first == tmpv[2].first)
{
smgp[0] = tmpv[1].second; smgp[1] = tmpv[2].second; gi = tmpv[1].first;
dfgp[0] = tmpv[0].second; dfgp[1] = tmpv[3].second; gj = tmpv[0].first; gk = tmpv[3].first;
}
else
{
smgp[0] = tmpv[2].second; smgp[1] = tmpv[3].second; gi = tmpv[2].first;
dfgp[0] = tmpv[0].second; dfgp[1] = tmpv[1].second; gj = tmpv[0].first; gk = tmpv[1].first;
}
Point_3 pi[2] = {cgal_pnt(smgp[0]), cgal_pnt(smgp[1])};
Point_3 pj(cgal_pnt(dfgp[0])), pk(cgal_pnt(dfgp[1]));
Point_3 tri_cent[2] = {CGAL::centroid(pi[0], pj, pk), CGAL::centroid(pi[1], pj, pk)};
Point_3 edge_mid[5] = {CGAL::midpoint(pi[0], pj), CGAL::midpoint(pi[0], pk),
CGAL::midpoint(pi[1], pj), CGAL::midpoint(pi[1], pk),
CGAL::midpoint(pj, pk)};
//std::list<Point_3> quad_i0i1j, quad_i0i1k, tri_i0i1jk;
std::array<Point_3, 4> quad_i0i1j = {edge_mid[0], edge_mid[2], tri_cent[1], tri_cent[0]};
std::array<Point_3, 4> quad_i0i1k = {edge_mid[1], edge_mid[3], tri_cent[1], tri_cent[0]};
std::array<Point_3, 3> tri_i0i1jk = {edge_mid[4], tri_cent[1], tri_cent[0]};
if (gi >= 0)
{
cat_cells[gi].push_back(CAT_facet(pi[0], quad_i0i1j.begin(), quad_i0i1j.end()));
cat_cells[gi].push_back(CAT_facet(pi[0], quad_i0i1k.begin(), quad_i0i1k.end()));
cat_cells[gi].push_back(CAT_facet(pi[1], quad_i0i1j.begin(), quad_i0i1j.end()));
cat_cells[gi].push_back(CAT_facet(pi[1], quad_i0i1k.begin(), quad_i0i1k.end()));
}
if (gj >= 0)
{
cat_cells[gj].push_back(CAT_facet(pj, quad_i0i1j.begin(), quad_i0i1j.end()));
cat_cells[gj].push_back(CAT_facet(pj, tri_i0i1jk.begin(), tri_i0i1jk.end()));
}
if (gk >= 0)
{
cat_cells[gk].push_back(CAT_facet(pk, quad_i0i1k.begin(), quad_i0i1k.end()));
cat_cells[gk].push_back(CAT_facet(pk, tri_i0i1jk.begin(), tri_i0i1jk.end()));
}
}
else if (group_no.size() == 4)
{
std::array<Point_3, 4> vs;
std::array<int, 4> groupid;
for (int j = 0; j < 4; j++)
{
vs[j] = cgal_pnt(tetra_vtx_ptr[j]);
groupid[j] = marker[tetra_vtx_ptr[j]];
}
Point_3 tetra_cent = CGAL::centroid(vs.begin(), vs.end(), CGAL::Dimension_tag<0>());
for (int j = 0; j < 4; j++)
{
if (groupid[j] < 0)
continue;
for (int k = 0; k < 4; k++)
{
if (j == k)
continue;
for (int l = 0; l < 4; l++)
{
if (l == j || l == k)
continue;
Point_3 mpnt = CGAL::midpoint(vs[j], vs[k]);
int m;
for (m = 0; m < 4; m++)
if (m != j && m != k && m != l)
break;
Point_3 tri_cent[2] = { CGAL::centroid(vs[j], vs[k], vs[l]), CGAL::centroid(vs[j], vs[k], vs[m]) };
std::list<Point_3> tri;
tri.push_back(mpnt);
tri.push_back(tri_cent[0]);
tri.push_back(tri_cent[1]);
cat_cells[groupid[j]].push_back(CAT_facet(vs[j], tri));
tri.pop_front();
tri.push_back(tetra_cent);
cat_cells[groupid[j]].push_back(CAT_facet(vs[j], tri));
}
}
}
}
}
}
int main(){
initAndLoad(cv::Mat::eye(4,4,CV_32F), cv::Mat::eye(4,4,CV_32F), &vidRecord, &wcSkeletons, "map000000_aoto4_edit/video/", true);
zeroWorldCoordinateSkeletons(cv::Mat::eye(4,4,CV_32F), &vidRecord, &wcSkeletons);
setCameraMatrixTexture(KINECT::loadCameraParameters());
setCameraMatrixScene(KINECT::loadCameraParameters());
cylinderBody.Load("map000000-custCB/");
cv::namedWindow("rgb");
cv::namedWindow("3d", CV_GUI_NORMAL);
cv::setMouseCallback("3d", onMouse);
frame=0;
angle_y = 0;
angle_x = 0;
trans = cv::Mat::eye(4,4,CV_32F);
calculateSkeletonOffsetPoints(vidRecord, wcSkeletons, cylinderBody);
boundingBoxLerp = cv::Rect (0,0,WIDTH,HEIGHT);
lc = generateLerpCorners(boundingBoxLerp);
while(true){
cv::Mat tex_ = uncrop(vidRecord[frame].videoFrame);
cv::Mat tex(tex_.size(), CV_8UC4, cv::Scalar(255,255,255,255));
int from_to[] = { 0,0, 1,1, 2,2};
cv::mixChannels(&tex_,1,&tex,1,from_to,3);
cv::Mat _3d(HEIGHT, WIDTH, CV_8UC4, cv::Scalar(0,0,0,255));
cv::Vec3f sCenter = calcSkeleCenter(vidRecord[frame].kinectPoints);
trans = getTranslationMatrix(sCenter) * mat3_to_mat4(getRotationMatrix(cv::Vec3f(0,1,0), angle_y)) * mat3_to_mat4(getRotationMatrix(cv::Vec3f(1,0,0), angle_x)) * getTranslationMatrix(-sCenter);
ghostdraw_parallel(frame, cv::Mat::eye(4,4,CV_32F), vidRecord, wcSkeletons, cylinderBody, Limbrary(), tex, cv::Mat(), GD_CYL);
ghostdraw_parallel(frame, trans, vidRecord, wcSkeletons, cylinderBody, Limbrary(), _3d, cv::Mat(), GD_CYL);
cv::Scalar goodColor(50, 200, 250);
cv::Scalar badColor(20, 20, 250);
for(int joint=0;joint<NUMJOINTS;++joint)
{
cv::Scalar color;
if (wcSkeletons[frame].states[joint] < 1)
color = badColor;
else
color = goodColor;
{
cv::Vec3f jv = mat_to_vec3(wcSkeletons[frame].points.col(joint));
cv::Vec2f jv2 = mat4_to_vec2(getCameraMatrixScene() * vec3_to_mat4(jv));
cv::Point pj(jv2(0), jv2(1));
cv::circle(tex,pj,2,color,-1);
}
{
cv::Vec3f jv = mat_to_vec3(trans * wcSkeletons[frame].points.col(joint));
cv::Vec2f jv2 = mat4_to_vec2(getCameraMatrixScene() * vec3_to_mat4(jv));
cv::Point pj(jv2(0), jv2(1));
cv::circle(_3d,pj,3,color,-1);
}
}
std::stringstream frameSS;
frameSS << frame;
cv::putText(tex, frameSS.str(), cv::Point(30, 30), CV_FONT_HERSHEY_PLAIN, 2, cv::Scalar(0, 255, 0), 3);
cv::putText(_3d, frameSS.str(), cv::Point(30, 30), CV_FONT_HERSHEY_PLAIN, 2, cv::Scalar(255, 0, 255), 3);
cv::imshow("rgb", tex);
cv::imshow("3d", _3d);
char in = cv::waitKey(10);
switch(in){
case 'q':
return 0;
case 'z':
--frame;
while(vidRecord[frame].videoFrame.mat.empty()){
--frame;
}
if(frame < 0) frame = 0;
break;
case 'x':
++frame;
if (frame >= vidRecord.size()) frame = vidRecord.size() - 1;
while(vidRecord[frame].videoFrame.mat.empty()){
++frame;
if (frame >= vidRecord.size()) frame = vidRecord.size() - 1;
}
break;
case 'd':
if (lastjoint != -1){
if (wcSkeletons[frame].states[lastjoint] < 1){
wcSkeletons[frame].states[lastjoint] = 1;
}
else{
wcSkeletons[frame].states[lastjoint] = 0.5;
}
}
case 'r':
angle_y = 0;
angle_x = 0;
break;
case 'c':
alljoints = !alljoints;
break;
case 's':
for(int i=0;i<vidRecord.size();++i){
vidRecord[i].kinectPoints = wcSkeletons[i];
//if(!vidRecord[i].cam2World.empty())
//{
// vidRecord[i].kinectPoints.points = vidRecord[i].cam2World.inv() * vidRecord[i].kinectPoints.points;
//}
}
SaveVideo(&vidRecord, getCameraMatrixScene(), "map000000_aoto4_edit/video/");
break;
}
}
}
void onMouse(int e, int x, int y, int, void *){
switch (e)
{
case cv::EVENT_LBUTTONDOWN:
start.x = x;
start.y = y;
prev = start;
mousedn = true;
rmousedn = false;
break;
case cv::EVENT_LBUTTONUP:
mousedn = false;
rmousedn = false;
break;
case cv::EVENT_MOUSEMOVE:
if(mousedn){
cv::Point curr(x,y);
angle_y += (curr.x - prev.x)/180.*CV_PI;
angle_x += (curr.y - prev.y)/180.*CV_PI;
prev = curr;
}
else if(rmousedn){
if(!alljoints){
if(cjoint != -1){
cv::Vec3f ray = lerpPoint(x,y,boundingBoxLerp,lc);
cv::Vec3f newPos = vectorProject(mat_to_vec3(trans * wcSkeletons[frame].points.col(cjoint)), ray);
cv::Mat(trans.inv() * vec3_to_mat4(newPos)).copyTo(wcSkeletons[frame].points.col(cjoint));
calculateSkeletonOffsetPoints(vidRecord, wcSkeletons, cylinderBody);
}
}else{
if(cjoint != -1){
cv::Vec3f ray = lerpPoint(x,y,boundingBoxLerp,lc);
cv::Vec3f newPosProj = vectorProject(mat_to_vec3(trans * wcSkeletons[frame].points.col(cjoint)), ray);
cv::Mat newPos = trans.inv() * vec3_to_mat4(newPosProj);
cv::Mat oldPos = wcSkeletons[frame].points.col(cjoint);
cv::Mat diff = newPos - oldPos;
newPos.copyTo(wcSkeletons[frame].points.col(cjoint));
for(int joint = 0; joint < NUMJOINTS; ++joint){
if(joint != cjoint){
cv::Mat newPosCopyTransform = wcSkeletons[frame].points.col(joint) + diff;
newPosCopyTransform.copyTo(wcSkeletons[frame].points.col(joint));
}
}
calculateSkeletonOffsetPoints(vidRecord, wcSkeletons, cylinderBody);
}
}
}
break;
case cv::EVENT_RBUTTONDOWN:
{
mousedn = false;
rmousedn = true;
cv::Point curr(x,y);
float cdist=10000;
cjoint=-1;
for(int joint=0;joint<NUMJOINTS;++joint)
{
cv::Vec3f jv = mat_to_vec3(trans * wcSkeletons[frame].points.col(joint));
cv::Vec2f jv2 = mat4_to_vec2(getCameraMatrixScene() * vec3_to_mat4(jv));
cv::Point pj(jv2(0), jv2(1));
float dist = cv::norm(curr-pj);
if(dist < cdist && dist < 10){
cdist = dist;
cjoint = joint;
}
}
lastjoint = cjoint;
break;
}
case cv::EVENT_RBUTTONUP:
{
mousedn = false;
rmousedn = false;
cjoint = -1;
}
default:
break;
}
}
GraphExample(void)
: prog()
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, node_count(512)
, edge_count(0)
, cam_path(make_cam_path_cps())
, tgt_path(make_tgt_path_cps())
{
std::srand(std::time(0));
// Vertex shader
VertexShader vs;
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" Position;"
" gl_PointSize = 4.0 * gl_Position.w / gl_Position.z;"
"}"
);
// compile it
vs.Compile();
// Fragment shader
FragmentShader fs;
// set the fragment shader source
fs.Source(
"#version 330\n"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(0.0, 0.0, 0.0, 1.0);"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the cube
graph.Bind();
std::vector<GLfloat> positions(node_count * 3);
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
GLuint k = 0;
for(GLuint p=0; p!=node_count; ++p)
{
positions[k++] = nrand() *120.0;
positions[k++] = nrand() * 5.0;
positions[k++] = nrand() *120.0;
}
assert(k == positions.size());
// upload the data
Buffer::Data(Buffer::Target::Array, positions);
// setup the vertex attribs array for the vertices
VertexAttribArray vert_attr(prog, "Position");
vert_attr.Setup(3, DataType::Float).Enable();
}
// bind the VBO for cube edge indices
edges.Bind(Buffer::Target::ElementArray);
{
std::vector<GLuint> edge_data;
edge_data.reserve(node_count * 6);
for(GLuint i=0; i!=node_count; ++i)
{
Vec3f pi(
positions[i*3+0],
positions[i*3+1],
positions[i*3+2]
);
float min_dist = 1000.0f;
GLuint m = i;
for(GLuint j=i+1; j!=node_count; ++j)
{
Vec3f pj(
positions[j*3+0],
positions[j*3+1],
positions[j*3+2]
);
float dist = Distance(pi, pj);
if(min_dist > 1.0 && min_dist > dist)
{
min_dist = dist;
m = j;
}
}
min_dist *= 2.0f;
GLuint done = 0;
for(GLuint j=i+1; j!=node_count; ++j)
{
Vec3f pj(
positions[j*3+0],
positions[j*3+1],
positions[j*3+2]
);
float dist = Distance(pi, pj);
if(min_dist > dist)
{
float x = dist/min_dist;
if(std::pow(nrand(), 2.0) >= x)
{
edge_data.push_back(i);
edge_data.push_back(j);
++done;
}
}
}
if(done == 0)
{
if(i != m)
{
edge_data.push_back(i);
edge_data.push_back(m);
}
}
}
Buffer::Data(Buffer::Target::ElementArray, edge_data);
assert(edge_data.size() % 2 == 0);
edge_count = edge_data.size();
positions.clear();
}
//
gl.ClearColor(0.9f, 0.9f, 0.8f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::LineSmooth);
gl.Enable(Capability::ProgramPointSize);
gl.Enable(Capability::Blend);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::OneMinusSrcAlpha);
}
TEST_F(RoStrTest, compact2) {
str r = compact(file_read(pj("fix/test_compact")));
}
