void GenerateSeq(const unsigned int &i, int &numSteps)
{
//std::cout << i << std::endl;
if(i==1)
{
return;
}
++numSteps;
if((i&1)==0){
return GenerateSeq(i/2,numSteps);
}
return GenerateSeq(3*i+1,numSteps);
}
bool FFAnalyzer::SeqPrint()
{
FF_analyzer_.Start();
Init();
/* printing */
/* set pillars as starting edges */
PrintPillars();
/* split layers */
/* label stores layer index of each dual node */
int layer_size = ptr_frame_->SizeOfLayer();
layers_.clear();
layers_.resize(layer_size);
for (int i = 0; i < Nd_; i++)
{
WF_edge *e = ptr_frame_->GetEdge(ptr_wholegraph_->e_orig_id(i));
layers_[e->Layer()].push_back(e);
}
for (int l = 0; l < layer_size; l++)
{
printf("Size of layer %d is %d\n", l + 1, layers_[l].size());
}
/* print starting from the first layer */
bool bSuccess = true;
for (int l = 0; l < layer_size; l++)
{
/*
* Nl: number of dual verts in current layer
* h : head for printing queue of the layer
* t : tail for printing queue of the layer
*/
int Nl = layers_[l].size();
int h = print_queue_.size();
int t;
if (l == 0)
{
t = Nl;
}
else
{
t = h + Nl;
}
if (debug_)
{
printf(">>>layer %d is in processing, intial head index %d, tail index %d\n",
l + 1, h, t);
}
if (h == t)
{
continue;
}
/* max_z_ and min_z_ in current layer */
min_z_ = 1e20;
max_z_ = -min_z_;
for (int i = 0; i < Nl; i++)
{
WF_edge *e = layers_[l][i];
point u = e->pvert_->Position();
point v = e->ppair_->pvert_->Position();
min_z_ = min(min_z_, (double)min(u.z(), v.z()));
max_z_ = max(max_z_, (double)max(u.z(), v.z()));
}
if (!GenerateSeq(l, h, t))
{
if (debug_)
{
printf("...all possible start edge at layer %d has been tried but no feasible sequence is obtained.\n",
l + 1);
}
bSuccess = false;
break;
}
}
if (fileout_)
{
//WriteLayerQueue();
//WriteRenderPath();
}
FF_analyzer_.Stop();
return bSuccess;
}
bool FFAnalyzer::GenerateSeq(int l, int h, int t)
{
/* last edge */
assert(h != 0); // there must be pillars
WF_edge *ei = print_queue_[h - 1];
if (debug_)
{
printf("---searching edge #%d in layer %d, head %d, (tail %d)\n",
ei->ID() / 2, l + 1, h, t);
}
/* exit */
if (h == t)
{
if (debug_)
{
printf("***searching at layer %d finishes.\n", l + 1);
}
return true;
}
/* next choice */
multimap<double, WF_edge*> choice;
multimap<double, WF_edge*>::iterator it;
/* next edge in current layer */
int Nl = layers_[l].size();
for (int j = 0; j < Nl; j++)
{
WF_edge *ej = layers_[l][j];
/* cost weight */
double cost = GenerateCost(ei, ej);
if (cost != -1)
{
choice.insert(pair<double, WF_edge*>(cost, ej));
}
}
/* ranked by weight */
for (it = choice.begin(); it != choice.end(); it++)
{
WF_edge *ej = it->second;
print_queue_.push_back(ej);
/* update printed subgraph */
UpdateStructure(ej);
/* update collision */
vector<vector<lld>> tmp_angle(3);
UpdateStateMap(ej, tmp_angle);
if (debug_)
{
printf("^^^choose edge #%d in layer %d with cost %lf\n",
ej->ID() / 2, l + 1, it->first);
printf("^^^entering next searching state.\n");
}
if (GenerateSeq(l, h + 1, t))
{
return true;
}
RecoverStateMap(ej, tmp_angle);
RecoverStructure(ej);
print_queue_.pop_back();
}
if (debug_)
{
printf("---searching at layer %d, head %d, (tail %d) ended.\n", l + 1, h, t);
}
return false;
}
