void
trace4(char *msg1, char *msg2, char *msg3, char *msg4)
{
if (msg1) {
char buf[PIPE_MAX];
buf[0] = 0;
bufcat(buf, sizeof buf, msg1);
if (msg2)
buf2cat(buf, sizeof buf, ": ", msg2);
trace3(buf, msg3, msg4);
} else
trace3(msg2, msg3, msg4);
}
void onClick2(int button, int state, int mx, int my)
{
if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
int CurrWindowWidth=glutGet(GLUT_WINDOW_WIDTH);
int CurrWindowHeight=glutGet(GLUT_WINDOW_HEIGHT);
switch(pointer)
{
case 0:
base_radius = 20;
xi = mx;
yi = CurrWindowHeight - my;
drawFilledBlob(xi, yi, base_radius);
b1.pushreq=true;
pointer = 1;
break;
default:
xf = mx;
yf = CurrWindowHeight - my;
if(xf == xi && yf == yi)
{
base_radius += 1;
drawFilledBlob(xi, yi, base_radius);
b1.pushreq=true;
}
else
{
blobs b;
b.radius = base_radius;
if(base_radius > b1.max)
b1.max=base_radius;
if(base_radius < b1.min)
b1.min=base_radius;
trace3(base_radius, b1.min, b1.max);
b1.bv.push_back(b);
b1.pushreq=false;
pointer = 0;
}
break;
}
}
}
int main(int argc, char** argv)
{
size_t size=1<<5;
if(argc>1) size=1<<atoi(argv[1]);
size_t ne=size*size/8 + 1;
boost::mt19937 rng;
if(argc>2){
rng.seed(atoi(argv[2]));
}
typedef bald_t G;
bald_t g;
boost::generate_random_graph(g, size, ne, rng);
size_t e=boost::num_edges(g);
size_t n=boost::num_vertices(g);
std::cout << "generated " << e << " edges, " << n << " vertices\n";
BOOST_AUTO(EE, boost::edges(g));
for(;EE.first!=EE.second; ++EE.first){
auto s=boost::source(*EE.first, g);
auto t=boost::target(*EE.first, g);
if(!boost::edge(t, s, g).second){
boost::add_edge(t, s, g);
}
}
// boost::add_edge(0,1,g);
e=boost::num_edges(g);
std::cout << "symmetric " << e << " edges\n";
unsigned i=0;
BOOST_AUTO(E, boost::edges(g));
for(;E.first!=E.second; ++E.first){
++i;
std::cout << boost::source(*E.first, g) << " -- " <<
boost::target(*E.first, g) << "\n";
if(i==5) break;
}
std::deque<unsigned long > iso;
BOOST_AUTO(V, boost::vertices(g));
for(;V.first!=V.second; ++V.first){
if(boost::out_degree(*V.first, g)){
}else{
iso.push_back(*V.first);
}
}
#ifdef REMOVE_ISOLATED
// no longer necessary.
for(auto i: iso){
boost::remove_vertex(i, g);
}
#endif
n = boost::num_vertices(g);
V=boost::vertices(g);
for(;V.first!=V.second; ++V.first){
assert(*V.first<n);
// assert(boost::out_degree(*V.first,g));
}
std::cout << "tagged " << iso.size() <<"\n";
i = 0;
// boost md does not like cliques.
trace3("clique check", n, e, size);
if((n*(n-1u)) == boost::num_edges(g)){ untested();
exit(0);
}else{
itested();
}
std::vector<int> inverse_perm(n, 0);
std::vector<int> supernode_sizes(n, 1);
BOOST_AUTO(id, boost::get(boost::vertex_index, g));
std::vector<int> degree(n, 0);
std::vector<int> io(n, 0);
std::vector<int> o(n, 0);
G h(g);
assert(boost::num_edges(g)==boost::num_edges(g));
// assert(n + iso.size() == size);
/*
* (Graph& g,
* DegreeMap degree,
* InversePermutationMap inverse_perm,
* PermutationMap perm,
* SuperNodeMap supernode_size,
* int delta,
* VertexIndexMap vertex_index_map)
*/
unsigned ub=-1;
unsigned w =
#ifndef HAVE_MINDEGREE_FORK
0;
itested();
#endif
boost::minimum_degree_ordering
(g,
boost::make_iterator_property_map(°ree[0], id, degree[0]),
&io[0],
&o[0],
boost::make_iterator_property_map(&supernode_sizes[0], id, supernode_sizes[0]),
0,
id
#ifdef HAVE_MINDEGREE_FORK
, ub
#endif
);
typename treedec::graph_traits<G>::treedec_type t;
g = h; // restore
int status;
#ifdef TRY_INEFFICIENT_VARIANT
treedec::ordering_to_treedec(g, o, t ); // can kill g!
h=g; // restore
status = treedec::check_treedec(g,t);
std::cout << "bagsize " << treedec::get_bagsize(t) << " status " << status <<"\n";
std::cout << "same as bagsize! " << w <<"\n";
assert(w == treedec::get_bagsize(t)); /// checks if BMD works!
#endif
treedec::draft::vec_ordering_to_tree(g, o, t );
status=treedec::check_treedec(g, t);
if (!status) std::cout << "treedec is valid!!\n";
std::cout << "bagsize " << treedec::get_bagsize(t) << " status " << status <<"\n";
std::cout << "boost_minDegree_ordering said " << w << "\n";
assert(!status);
if(w != treedec::get_bagsize(t)){
}
assert(w == treedec::get_bagsize(t));
}
VOID parseXFileData(ID3DXFileData* lpXFileData, INT depth)
{
if(lpXFileData == NULL || lpXFileData->IsReference())
{
return;
}
SIZE_T nameSize;
CHAR* lpName;
if(FAILED(lpXFileData->GetName(NULL, &nameSize)))
{
return;
}
lpName = new CHAR[nameSize];
if(FAILED(lpXFileData->GetName(lpName, &nameSize)))
{
delete []lpName;
return;
}
CHAR* lpTab = NULL;
if(depth > 0)
{
lpTab = new CHAR[depth + 1];
for (INT depthIndex = 0; depthIndex < depth; ++depthIndex)
{
lpTab[depthIndex] = ' ';
}
lpTab[depth] = '\0';
}
GUID guid;
if(FAILED(lpXFileData->GetType(&guid)))
{
delete []lpName;
delete []lpTab;
return;
}
char* tmpl =
guid == TID_D3DRMFrame ? "Frame" :
guid == TID_D3DRMFrameTransformMatrix ? "FrameTransformMatrix" :
guid == TID_D3DRMMeshMaterialList ? "MeshMaterialList" :
guid == TID_D3DRMMeshTextureCoords ? "MeshTextureCoords" :
guid == TID_D3DRMMeshNormals ? "MeshNormal" :
guid == TID_D3DRMMesh ? "Mesh" :
guid == TID_D3DRMMaterial ? "Material" :
guid == TID_D3DRMTextureFilename ? "TextureFilename" : NULL;
trace2("%s%s", lpTab == NULL ? "" : lpTab,"---------------------------------------------------\n");
trace3("%sname:%s, tmpl:%s\n", lpTab == NULL ? "" : lpTab, lpName, tmpl == NULL ? "" : tmpl);
delete []lpName;
delete []lpTab;
SIZE_T numChildren;
if(FAILED(lpXFileData->GetChildren(&numChildren)))
{
return;
}
for (SIZE_T i = 0; i < numChildren; ++i)
{
ID3DXFileData* lpXFileSubData;
if(FAILED(lpXFileData->GetChild(i, &lpXFileSubData)))
{
return;
}
parseXFileData(lpXFileSubData, depth + 1);
lpXFileSubData->Release();
}
}
matrix_3x3_t m3i=inv3(m3);
print_util_print_matrix(print_util_get_debug_stream(), m3i.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_3x3_t m3_=mmul3(m3, m3i);
m3_=mmul3(m3, inv3(m3));
print_util_print_matrix(print_util_get_debug_stream(), m3_.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_4x4_t m4={.v={{1, 2, 3, 4},{2,4,2, 4},{4,3,2,1}, {5,6,7,5}}};
print_util_print_matrix(print_util_get_debug_stream(), m4.v[0], 4, 4, 2); print_util_dbg_print("\n");
matrix_4x4_t m4t=trans4(m4);
print_util_print_matrix(print_util_get_debug_stream(), m4t.v[0], 4, 4, 2); print_util_dbg_print("\n");
matrix_4x4_t m4i=inv4(m4);
print_util_print_matrix(print_util_get_debug_stream(), m4i.v[0], 4, 4, 2); print_util_dbg_print("\n");
matrix_4x4_t m4_=mmul4(m4, m4i);
print_util_print_matrix(print_util_get_debug_stream(), m4_.v[0], 4, 4, 2); print_util_dbg_print("\n");
vector_3_t v1={.v={2,4,7}};
print_util_print_matrix(print_util_get_debug_stream(), v1.v, 1, 3, 2); print_util_dbg_print("\n");
print_util_dbg_print("squared Norm m3: "); print_util_dbg_putfloat(sqr_f_norm3(m3), 4);print_util_dbg_print("\n");
print_util_dbg_print("trace m3: "); print_util_dbg_putfloat(trace3(m3), 4);print_util_dbg_print("\n");
print_util_dbg_print("residual |MxM^{-1} - I| "); print_util_dbg_putfloat(sqr_f_norm3(msub3(mmul3(m3, inv3(m3)), ident_3x3)), 10);print_util_dbg_print("\n");
return true;
}
