Feature octogon(int side, int)
{
// total number of rows is side * 3
// top segment has side - 1 sections that increase by 2 each time
// segment 2 has identitical sides offset 0 length side + 2*(side-1)
// segment 3 has side -1 seconds, inverse of section 1
EdgeList edges;
side /= 3;
if (side < 2) side = 2;
for (auto i = 0; i < side - 1; i++)
{
edges.push_back({side-1-i,side+i*2});
}
for (auto i = 0; i < side; i++)
{
edges.push_back({0,side+2*(side-1)});
}
for (auto i = side - 2; i >= 0; i--)
{
edges.push_back({side-1-i,side+i*2});
}
return Feature(edges);
}
void PolyMesh::findEdgeList( Edge* e, EdgeList& elist0, EdgeList& elist1 )
{
osg::Vec3 v0=(*e)[0], v1=(*e)[1];
for ( EdgeMap::iterator itr=_edges.begin(); itr!=_edges.end(); ++itr )
{
if ( e==itr->second ) continue;
if ( equivalent(itr->first.first,v0) || equivalent(itr->first.second,v0) )
elist0.push_back( itr->second );
else if ( equivalent(itr->first.first,v1) || equivalent(itr->first.second,v1) )
elist1.push_back( itr->second );
}
}
void EdgeCollector::getBoundaryEdgeList(EdgeList & el)
{
for (EdgeSet::iterator it = _edgeSet.begin(), end = _edgeSet.end(); it != end; ++it)
{
if ((*it)->isBoundaryEdge()) el.push_back(*it);
}
}
GPUGraph readDimacs(char* filename){
FILE * fd = fopen(filename,"r");
printf("reading file %s ...\n",filename);
char buf[1024];
uint64_t edges, nodes;
EdgeList v;
std::vector<int> weights;
while(fgets(buf,sizeof(buf),fd)){
if(buf[0]=='c') continue;
if(buf[0]=='p'){
//read nodes and edges
char s;
//p sp nodes edges
sscanf(buf,"%c %c%c %lu %lu\n", &s,&s,&s, &nodes, &edges);
printf("edges:%lu, nodes:%lu\n",edges,nodes);
}
if(buf[0]=='a'){
char s;
uint64_t src,dst,wgt;
sscanf(buf,"%c %lu %lu %lu\n", &s,&src, &dst, &wgt);
v.push_back(Edge(src-1,dst-1));
weights.push_back((int)wgt);
}
}
fclose(fd);
return GPUGraph(v,weights);
}
static void FindEdges(const HitData &Hit, const GLIX &HitGlix, const IIX &IntervalIndex)
{
int *QueryMatches;
int *TargetMatches;
const int QueryMatchCount = IntervalIndex.LookupGlobal(Hit.QueryFrom, Hit.QueryTo, &QueryMatches);
const int TargetMatchCount = IntervalIndex.LookupGlobal(Hit.TargetFrom, Hit.TargetTo, &TargetMatches);
const int MatchCount = QueryMatchCount + TargetMatchCount;
int *Matches = all(int, MatchCount);
memcpy(Matches, QueryMatches, QueryMatchCount*sizeof(int));
memcpy(Matches + QueryMatchCount, TargetMatches, TargetMatchCount*sizeof(int));
for (int i = 0; i < MatchCount; ++i)
{
const int m = Matches[i];
if (m < 0 || m > CandCount)
Quit("m=%d count=%d", m, CandCount);
}
for (int i = 0; i < MatchCount; ++i)
{
const int CandIndex1 = Matches[i];
for (int j = 0; j < i; ++j)
{
const int CandIndex2 = Matches[j];
if (IsEdge(HitGlix, Hit, CandIndex1, CandIndex2))
{
EdgeData Edge;
Edge.Node1 = CandIndex1;
Edge.Node2 = CandIndex2;
Edge.Rev = Hit.Rev;
Edges.push_back(Edge);
}
}
}
}
void Graph::linkTo(Graph::node_ptr a, Graph::node_ptr b)
{
Edge edge = {a, b, 0};
edges.push_back(edge);
a->edges.push_back(&edges.back());
}
Feature diamond(int rows, int)
{
// the offset starts at rows
// the rows are (i+1)*2 -1 wide
EdgeList edges;
for (auto i = 0; i < rows / 2; i++)
{
edges.push_back({rows/2-i-1,(i+1)*2-1});
}
// bottom half of diamond
for (auto i = rows / 2 - 1; i >= 0; i--)
{
edges.push_back({rows / 2 - i - 1,(i+1)*2-1});
}
return Feature(edges);
}
void PolyMesh::findEdgeList( osg::Vec3 p, EdgeList& elist )
{
for ( EdgeMap::iterator itr=_edges.begin(); itr!=_edges.end(); ++itr )
{
if ( equivalent(itr->first.first,p) || equivalent(itr->first.second,p) )
elist.push_back( itr->second );
}
}
Feature triangle(int rows, int)
{
EdgeList edges;
for (auto i = 0; i < rows; i++)
{
edges.push_back({rows-i-1,(i+1)*2-1});
}
return Feature(edges);
}
Feature trapezium(int top, int height)
{
EdgeList edges;
for (auto i = 0; i < height; i++)
{
edges.push_back({top-1-i,top+i*2});
}
return Feature(edges);
}
Feature rectangle(int width, int height)
{
EdgeList edges;
for (auto i = 0; i < height; i++)
{
edges.push_back({0,width});
}
return Feature(edges);
}
void PolyMesh::findEdgeList( Face* f, EdgeList& elist )
{
unsigned int size = f->_pts.size();
for ( unsigned int i=0; i<size; ++i )
{
Edge* edge = getEdge( (*f)[i%size], (*f)[(i+1)%size], _edges );
if ( edge ) elist.push_back( edge );
}
}
static void FindSuperFamEdges(FamList &Fams, EdgeList &Edges)
{
const int FamCount = (int) Fams.size();
// Allocate triangular array Related[i][j], value is true
// iff families i and j are related (i.e., there is a local
// alignment between some member of i and some member of j).
const int TriangleSize = (FamCount*(FamCount - 1))/2;
bool *Related = all(bool, TriangleSize);
zero(Related, bool, TriangleSize);
for (PtrFamList p = Fams.begin(); p != Fams.end(); ++p)
{
FamData *Fam = *p;
for (PtrFamData q = Fam->begin(); q != Fam->end(); ++q)
{
FamMemberData &FamMember = *q;
int PileIndex = FamMember.PileIndex;
const PileData &Pile = Piles[PileIndex];
const int FamIndex = Pile.FamIndex;
if (-1 == FamIndex)
continue;
const int ImageCount = Pile.ImageCount;
for (int ImageIndex = 0; ImageIndex < ImageCount; ++ImageIndex)
{
const PileImageData &Image = Pile.Images[ImageIndex];
const int PartnerPileIndex = Image.SIPile;
if (PartnerPileIndex == PileIndex)
continue;
const PileData &PartnerPile = Piles[PartnerPileIndex];
const int PartnerFamIndex = PartnerPile.FamIndex;
if (-1 == PartnerFamIndex || PartnerFamIndex == FamIndex)
continue;
const int Index = TriangleSubscript(FamCount, FamIndex, PartnerFamIndex);
assert(Index >- 0 && Index < TriangleSize);
Related[Index] = true;
}
}
}
Edges.clear();
for (int i = 0; i < FamCount; ++i)
for (int j = i + 1; j < FamCount; ++j)
{
const int Index = TriangleSubscript(FamCount, i, j);
if (Related[Index])
{
// Log("R %d %d\n", i, j);
EdgeData Edge;
Edge.Node1 = i;
Edge.Node2 = j;
Edge.Rev = false;
Edges.push_back(Edge);
}
}
}
static void AddEdges(EdgeList &Edges, PILE_INDEX_TYPE PileIndex,
PILE_INDEX_TYPE Partners[], bool PartnersRev[], int PartnerCount)
{
EdgeCount += PartnerCount;
for (int i = 0; i < PartnerCount; ++i)
{
int PileIndex2 = Partners[i];
EdgeData Edge;
Edge.Node1 = PileIndex;
Edge.Node2 = PileIndex2;
Edge.Rev = PartnersRev[i];
Edges.push_back(Edge);
}
}
inline
Polyhedron<ScalarParam>*
Polyhedron<ScalarParam>::clip(
const typename Polyhedron<ScalarParam>::Plane& plane) const
{
typedef Misc::HashTable<Card,void> IndexSet;
typedef Misc::HashTable<Card,Card> IndexMapper;
/* Find the indices of all half edges that intersect the plane: */
IndexMapper indexMapper(101);
Card nextIndex=0;
Card numIntersectedEdges=0;
Card intersectedEdgeIndex=0;
IndexSet ioEdges(17);
Card numEdges=edges.size();
for(Card i=0;i<numEdges;++i)
{
/* Get the plane distance of start and end points of edge i: */
Scalar d0=plane.calcDistance(edges[i].start);
Scalar d1=plane.calcDistance(edges[edges[i].next].start);
/* Classify the edge: */
if(d0<Scalar(0)&&d1<Scalar(0))
{
/* Keep the edge: */
indexMapper.setEntry(typename IndexMapper::Entry(i,nextIndex));
++nextIndex;
}
else if(d0<Scalar(0)||d1<Scalar(0))
{
/* Keep the edge: */
indexMapper.setEntry(typename IndexMapper::Entry(i,nextIndex));
++nextIndex;
if(d0<Scalar(0))
{
/* Mark the edge as intersected: */
++numIntersectedEdges;
intersectedEdgeIndex=i;
}
else
{
/* Mark the edge as the opposite of an intersected edge: */
ioEdges.setEntry(typename IndexSet::Entry(i));
}
}
}
/* Remember the number of retained edges: */
Card newNumEdges=nextIndex;
/* Check for trivial cases: */
if(newNumEdges==0)
return new Polyhedron; // Return an empty polyhedron
else if(numIntersectedEdges==0)
return new Polyhedron(*this); // Return an identical copy of the polyhedron
/* Sort the list of intersected edges to form a loop: */
IndexMapper newFaceEdges(17);
EdgeList newFace;
while(newFace.size()<numIntersectedEdges)
{
Edge newEdge;
/* Calculate the new edge's starting point: */
const Point& p0=edges[intersectedEdgeIndex].start;
Scalar d0=plane.calcDistance(p0);
const Point& p1=edges[edges[intersectedEdgeIndex].next].start;
Scalar d1=plane.calcDistance(p1);
newEdge.start=Geometry::affineCombination(p0,p1,(Scalar(0)-d0)/(d1-d0));
/* Find the next intersected edge around the same face as the current last edge: */
Card edgeIndex;
for(edgeIndex=edges[intersectedEdgeIndex].next;!ioEdges.isEntry(edgeIndex);edgeIndex=edges[edgeIndex].next)
;
newEdge.next=indexMapper.getEntry(edgeIndex).getDest();
newEdge.opposite=newNumEdges+numIntersectedEdges+newFace.size();
/* Store the index of the new face edge: */
newFaceEdges.setEntry(IndexMapper::Entry(intersectedEdgeIndex,newFace.size()));
/* Store the new face edge: */
newFace.push_back(newEdge);
/* Go to the next intersected face: */
intersectedEdgeIndex=edges[edgeIndex].opposite;
}
/* Create the result polyhedron: */
Polyhedron* result=new Polyhedron;
/* Create the edges of the result polyhedron: */
for(Card i=0;i<numEdges;++i)
{
/* Get the plane distance of start and end points of edge i: */
Scalar d0=plane.calcDistance(edges[i].start);
Scalar d1=plane.calcDistance(edges[edges[i].next].start);
/* Classify the edge: */
if(d0<Scalar(0)&&d1<Scalar(0))
{
/*****************************************************************
If an edge is completely inside, its opposite edge must be as
well, and its next edge must at least be partially inside.
Therefore, indexMapper will contain the new indices for both
edges.
*****************************************************************/
/* Keep the edge: */
result->edges.push_back(Edge(edges[i].start,indexMapper.getEntry(edges[i].next).getDest(),indexMapper.getEntry(edges[i].opposite).getDest()));
}
else if(d0<Scalar(0))
{
/*****************************************************************
If an edge's start point is inside, its opposite edge's index will
be contained in indexMapper, and its next edge is a new face edge
whose index can be calculated from newFaceEdges.
*****************************************************************/
/* Find the index of the next edge from the new face loop: */
Card next=newNumEdges+newFaceEdges.getEntry(i).getDest();
/* Retain the edge: */
result->edges.push_back(Edge(edges[i].start,next,indexMapper.getEntry(edges[i].opposite).getDest()));
}
else if(d1<Scalar(0))
{
/*****************************************************************
If an edge's end point is inside, its start point must be
calculated by clipping, and its next edge and opposite edge will
both be contained in indexMapper.
*****************************************************************/
/* Calculate the new start point: */
Point newStart=Geometry::affineCombination(edges[edges[i].next].start,edges[i].start,(Scalar(0)-d1)/(d0-d1));
/* Retain the clipped edge: */
result->edges.push_back(Edge(newStart,indexMapper.getEntry(edges[i].next).getDest(),indexMapper.getEntry(edges[i].opposite).getDest()));
}
}
/* Add the closing edges for all clipped faces to the polyhedron: */
for(typename EdgeList::const_iterator nfIt=newFace.begin();nfIt!=newFace.end();++nfIt)
result->edges.push_back(*nfIt);
/* Add the edges of the closing face to the polyhedron: */
for(Card i=0;i<newFace.size();++i)
{
Edge newEdge;
newEdge.start=newFace[(i+1)%newFace.size()].start;
newEdge.next=newNumEdges+numIntersectedEdges+(i+newFace.size()-1)%newFace.size();
newEdge.opposite=newNumEdges+i;
result->edges.push_back(newEdge);
}
// DEBUGGING
// result->check();
return result;
}
int main(int argc, char **argv)
{
int i, j, k,nodes = 0,prev_nodes = 0;
srand(time(0));
const int max_t = atoi(argv[1]);
cout << max_t << endl;
//const int max_n = 100;
// const int max_m = max_n * (max_n - 1) / 2;
typedef pair<int, int> EdgePair;
typedef std::list<EdgePair> EdgeList;
for(int s = 0; s < max_t; ++s)
{
EdgeList edges;
cout << endl;
nodes = 0;
const int ranks = MIN_RANKS
+ (rand () % (MAX_RANKS - MIN_RANKS + 1));
// printf ("digraph {\n");
for (i = 0; i < ranks; i++)
{
/* New nodes of 'higher' rank than all nodes generated till now. */
int new_nodes = MIN_PER_RANK
+ (rand () % (MAX_PER_RANK - MIN_PER_RANK + 1));
/* Edges from old nodes ('nodes') to new ones ('new_nodes'). */
for (j = prev_nodes; j < nodes; j++)
for (k = 0; k < new_nodes; k++)
if ( (rand () % 100) < PERCENT)
{
edges.push_back(make_pair(j, k + nodes));
}
//cout << j << " " << k + nodes << endl;
// printf ("%d %d\n", j, k + nodes); /* An Edge. */
prev_nodes = nodes;
nodes += new_nodes; /* Accumulate into old node set. */
}
cout << nodes << " " << edges.size() << endl;
cout << 0;
set<int> generated;
for(i = 1; i < nodes; ++i)
{
int v = rand() % 1000 + 1;
while(generated.find(v) != generated.end())
v = rand() % 1000 + 1;
cout << " " << v;
generated.insert(v);
}
cout << endl;
EdgeList::const_iterator edge = edges.begin();
for(i = 0; i < edges.size(); ++i)
{
cout << edge->first << " " << edge->second << endl;
++edge;
}
}
return 0;
}
static void FindPyramids(int PileIndex)
{
const TanPile &Pile = Piles[PileIndex];
const int HitCount = Pile.HitCount;
if (HitCount < MIN_HIT_COUNT)
return;
EdgeList Edges;
EdgeData Edge;
Edge.Rev = false;
const HitData *Hits = Pile.Hits;
for (int HitIndex1 = 0; HitIndex1 < HitCount; ++HitIndex1)
{
const HitData &Hit1 = Hits[HitIndex1];
Edge.Node1 = HitIndex1;
for (int HitIndex2 = 0; HitIndex2 < HitIndex1; ++HitIndex2)
{
const HitData &Hit2 = Hits[HitIndex2];
if (TandemPair(Hit1, Hit2))
{
Edge.Node2 = HitIndex2;
Edges.push_back(Edge);
}
}
}
FamList Fams;
FindConnectedComponents(Edges, Fams, MIN_HIT_COUNT);
if (0 == Fams.size())
return;
GFFRecord Rec;
Rec.Source = "piler";
Rec.Feature = "hit";
Rec.Score = 0;
Rec.Frame = -1;
Rec.SeqName = Pile.Label;
for (PtrFamList p = Fams.begin(); p != Fams.end(); ++p)
{
FamData *Fam = *p;
if (0 != fMotif)
InferMotif(PyramidIndex, Pile, Fam);
LogPyramid(PyramidIndex, Pile, Fam);
int PyramidFrom = -1;
int PyramidTo = -1;
for (PtrFamData q = Fam->begin(); q != Fam->end(); ++q)
{
FamMemberData &FamMember = *q;
int HitIndex = FamMember.PileIndex;
if (HitIndex < 0 || HitIndex >= Pile.HitCount)
Quit("Hit index out of range");
const HitData &Hit = Pile.Hits[HitIndex];
char s[1024];
sprintf(s, "Target %s %d %d ; Pile %d ; Pyramid %d",
Pile.Label,
Hit.TargetFrom + 1,
Hit.TargetTo + 1,
PileIndex,
PyramidIndex);
Rec.Strand = (Hit.Rev ? '-' : '+');
Rec.Start = Hit.QueryFrom + 1;
Rec.End = Hit.QueryTo + 1;
Rec.Attrs = s;
WriteGFFRecord(fOut, Rec);
if (PyramidFrom == -1)
PyramidFrom = min(Hit.QueryFrom, Hit.TargetFrom);
else
PyramidFrom = min3(PyramidFrom, Hit.QueryFrom, Hit.TargetFrom);
if (PyramidTo == -1)
PyramidTo = max(Hit.QueryTo, Hit.TargetTo);
else
PyramidTo = max3(PyramidTo, Hit.QueryTo, Hit.TargetTo);
}
WritePyramid(PyramidIndex, Pile.Label, PyramidFrom, PyramidTo);
++PyramidIndex;
}
}
int buildTreeWidthDecomposition(Graph& g, GenericTree& twd, vector<set<int> >& nodedirectory){//return the max_bag_size of this decomposition
set<VertexDegreePair,VertexDegreePairComp> DegreeRank;//first is degree; second is vertex id;
vector<int> DegreeList(g.num_vertices(),0);
int max_bag_size=-1;
for(int i=0; i<g.num_vertices(); i++){
int current_degree=g.get_degree(i);
DegreeRank.insert(VertexDegreePair(i, current_degree));
DegreeList[i]=current_degree;
}
while(DegreeRank.size()>0){
set<VertexDegreePair,VertexDegreePairComp>::iterator minDegreeVertex=DegreeRank.begin();
DegreeRank.erase(DegreeRank.begin());
int current_vertexID=minDegreeVertex->first;
//build treenode
nodedirectory.push_back(set<int>());
int current_nodeID=nodedirectory.size()-1;
nodedirectory.back().insert(current_vertexID);
for(EdgeList::iterator vit=g.get_neighbors(current_vertexID).begin(); vit<g.get_neighbors(current_vertexID).end(); vit++){
nodedirectory.back().insert(*vit);
g[*vit].nodes.push_back(current_nodeID);
//update on graph
EdgeList::iterator iit=g.get_neighbors(current_vertexID).begin();
EdgeList::iterator jit=g.get_neighbors(*vit).begin();
EdgeList combined;
while(iit<g.get_neighbors(current_vertexID).end() && jit<g.get_neighbors(*vit).end()){
//It is assumed that a vertex itself does not appear in its adjacent list and the adjacent list is in ascending order.
if(*iit==*vit){
iit++;
continue;
}else if (*jit==current_vertexID){
jit++;
continue;
}
if(*iit<*jit){
combined.push_back(*iit);
iit++;
}else if(*iit>*jit){
combined.push_back(*jit);
jit++;
}else{//implies *iit==*jit
combined.push_back(*iit);
iit++;
jit++;
}
}
if(iit<g.get_neighbors(current_vertexID).end() && jit<g.get_neighbors(*vit).end()){
cout<<"Internal Logic Error. Exit."<<endl;
exit(-1);
}
for(; iit<g.get_neighbors(current_vertexID).end(); iit++){
if(*iit!=*vit)
combined.push_back(*iit);
}
for(; jit<g.get_neighbors(*vit).end(); jit++){
if(*jit!=current_vertexID)
combined.push_back(*jit);
}
g.get_neighbors(*vit)=combined;
//update on graph done
//update on nodes
vector<int> reduced;
vector<int>::iterator itern=g[*vit].nodes.begin();
vector<int>::iterator jtern=g[current_vertexID].nodes.begin();
while(itern<g[*vit].nodes.end() && jtern<g[current_vertexID].nodes.end()){
if(*itern<*jtern){
reduced.push_back(*itern);
itern++;
}
else if (*itern>*jtern){
jtern++;
}
else{//implies *itern==*jtern
itern++;
jtern++;
}
}
for(; itern<g[*vit].nodes.end(); itern++)
reduced.push_back(*itern);
g[*vit].nodes=reduced;
//update on nodes done
//other update
set<VertexDegreePair,VertexDegreePairComp>::iterator fit=DegreeRank.find(VertexDegreePair(*vit, DegreeList[*vit]));
DegreeRank.erase(fit);
DegreeRank.insert(VertexDegreePair(*vit, g.get_degree(*vit)));
DegreeList[*vit]=g.get_degree(*vit);
//other update done
}
max_bag_size=int(nodedirectory.back().size())>max_bag_size? int(nodedirectory.back().size()) : max_bag_size;
//build treenode done
//build decomposition tree
twd.addNode(twd.num_nodes());
for(vector<int>::iterator nit=g[current_vertexID].nodes.begin(); nit<g[current_vertexID].nodes.end(); nit++){
twd.addEdge(current_nodeID, *nit);//current_nodeID shall always be larger than *nit;
twd.addEdge(*nit, current_nodeID);
}
//build decomposition tree done
//clear deleted vertex
g[current_vertexID].nodes.clear();
g.get_neighbors(current_vertexID).clear();
//clear deleted vertex
}
return max_bag_size;
}
