static void
na_newedge(graph *g1, int m1, int n1, boolean dolabel)
/* Make all graphs by non-adjacent edge addition. */
{
int n2,m2;
int v1,v2,w1,w2;
set *sv1,*sw1;
graph *gq;
#if MAXN
graph h[MAXN*MAXM];
grapg g2[MAXN*MAXM];
#else
DYNALLSTAT(graph,h,h_sz);
DYNALLSTAT(graph,g2,g2_sz);
#endif
n2 = n1 + 2;
m2 = (n2 + WORDSIZE - 1) / WORDSIZE;
if (m2 < m1) m2 = m1;
#if !MAXN
DYNALLOC2(graph,g2,g2_sz,m2,n2,"newedgeg");
if (dolabel) DYNALLOC2(graph,h,h_sz,m2,n2,"newedgeg");
#endif
for (v1 = 0, sv1 = g1; v1 < n1-3; ++v1, sv1 += m1)
for (w1 = v1+1, sw1 = sv1 + m1; w1 < n1-1; ++w1, sw1 += m1)
{
for (v2 = v1; (v2 = nextelement(sv1,m1,v2)) >= 0; )
for (w2 = w1; (w2 = nextelement(sw1,m1,w2)) >= 0; )
{
if (v2 == w1 || v2 == w2) continue;
newedge(g1,m1,n1,v1,v2,w1,w2,g2,m2);
gq = g2;
if (dolabel)
{
fcanonise(g2,m2,n2,h,NULL,FALSE); /* FIXME (loops) */
gq = h;
}
if (outcode == SPARSE6) writes6(outfile,gq,m2,n2);
else writeg6(outfile,gq,m2,n2);
++nout;
}
}
}
void add_jobs(Puzzle *puz, Solution *sol, int except, Cell *cell,
int depth, bit_type *old)
{
dir_t k;
line_t i, j;
int lwork, rwork;
/* While probing, we OR all bits set into our scratchpad. These values
* should not be probed on later during this sequence.
*/
if (probing)
fbit_or(propad(cell),cell->bit);
if (!maylinesolve) return;
for (k= 0; k < puz->nset; k++)
if (k != except)
{
i= cell->line[k];
j= cell->index[k];
/* We only add the job only if either the saved left or right
* solution for the line has been invalidated.
*/
if (VL || WL(puz->clue[k][i]))
printf ("L: CHECK OLD SOLN FOR %s %d CELL %d\n",
CLUENAME(puz->type,k),i,j);
lwork= left_check(&puz->clue[k][i], j, cell->bit);
rwork= right_check(&puz->clue[k][i], j, cell->bit);
if (lwork || rwork)
{
add_job(puz, k, i, depth,
newedge(puz, sol->line[k][i], j, old, cell->bit) );
if (!VJ && WL(puz->clue[k][i]))
dump_jobs(stdout,puz);
}
}
}
void TwoDSceneXMLParser::loadSpringForces( rapidxml::xml_node<>* node, TwoDScene& twodscene )
{
assert( node != NULL );
// Extract the edge the force acts across
int forcenum = 0;
for( rapidxml::xml_node<>* nd = node->first_node("springforce"); nd; nd = nd->next_sibling("springforce") )
{
int edge = -1;
if( nd->first_attribute("edge") )
{
std::string attribute(nd->first_attribute("edge")->value());
if( !stringutils::extractFromString(attribute,edge) )
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse value of edge attribute for springforce " << forcenum << ". Value must be integer. Exiting." << std::endl;
exit(1);
}
}
else
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse value of edge attribute for springforce " << forcenum << ". Exiting." << std::endl;
exit(1);
}
std::pair<int,int> newedge(twodscene.getEdge(edge));
// Extract the spring stiffness
scalar k = std::numeric_limits<scalar>::signaling_NaN();
if( nd->first_attribute("k") )
{
std::string attribute(nd->first_attribute("k")->value());
if( !stringutils::extractFromString(attribute,k) )
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse value of k attribute for springforce " << forcenum << ". Value must be numeric. Exiting." << std::endl;
exit(1);
}
}
else
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse k attribute for springforce " << forcenum << ". Exiting." << std::endl;
exit(1);
}
// Extract the spring rest length
scalar l0 = std::numeric_limits<scalar>::signaling_NaN();
if( nd->first_attribute("l0") )
{
std::string attribute(nd->first_attribute("l0")->value());
if( !stringutils::extractFromString(attribute,l0) )
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse value of l0 attribute for springforce " << forcenum << ". Value must be numeric. Exiting." << std::endl;
exit(1);
}
}
else
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse l0 attribute for springforce " << forcenum << ". Exiting." << std::endl;
exit(1);
}
// Extract the optional damping coefficient
scalar b = 0.0;
if( nd->first_attribute("b") )
{
std::string attribute(nd->first_attribute("b")->value());
if( !stringutils::extractFromString(attribute,b) )
{
std::cerr << "\033[31;1mERROR IN XMLSCENEPARSER:\033[m Failed to parse value of b attribute for springforce " << forcenum << ". Value must be numeric. Exiting." << std::endl;
exit(1);
}
}
//std::cout << "Springforce: " << forcenum << " i: " << newedge.first << " j: " << newedge.second << " k: " << k << " l0: " << l0 << std::endl;
twodscene.insertForce(new SpringForce(newedge,k,l0,b));
++forcenum;
}
//SpringForce( const std::pair<int,int>& endpoints, const scalar& k, const scalar& l0 )
}
void contour(double levels[],
int nlevels,
struct Map_info Map,
DCELL ** z, struct Cell_head Cell, int n_cut)
{
int nrow, ncol; /* number of rows and columns in current region */
int startrow, startcol; /* start row and col of current line */
int n, i, j; /* loop counters */
double level; /* current contour level */
char **hit; /* array of flags--1 if Cell has been hit; */
/* 0 if Cell is still to be checked */
struct line_pnts *Points;
struct line_cats *Cats;
int outside; /* 1 if line is exiting region; 0 otherwise */
struct cell current;
int p1, p2; /* indexes to end points of cell edges */
int ncrossing; /* number of found crossing */
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nrow = Cell.rows;
ncol = Cell.cols;
hit = (char **)G_malloc((nrow - 1) * sizeof(char *));
for (i = 0; i < nrow - 1; i++)
hit[i] = (char *)G_malloc((ncol - 1) * sizeof(char));
ncrossing = 0;
G_message(_n("Writing vector contour (one level)...",
"Writing vector contours (total levels %d)...", nlevels), nlevels);
for (n = 0; n < nlevels; n++) {
level = levels[n];
G_percent(n+1, nlevels, 2); /* print progress */
/* initialize hit array */
for (i = 0; i < nrow - 1; i++) {
for (j = 0; j < ncol - 1; j++) {
hit[i][j] = 0;
}
}
/* check each cell of top and bottom borders */
for (startrow = 0; startrow < nrow; startrow += (nrow - 2)) {
for (startcol = 0; startcol <= ncol - 2; startcol++) {
/* look for starting point of new line */
if (!hit[startrow][startcol]) {
current.r = startrow;
current.c = startcol;
outside = getnewcell(¤t, nrow, ncol, z);
/* is this top or bottom? */
if (startrow == 0) /* top */
current.edge = 0;
else /* bottom edge */
current.edge = 2;
p1 = current.edge;
p2 = current.edge + 1;
if (checkedge(current.z[p1], current.z[p2], level)) {
getpoint(¤t, level, Cell, Points);
/* while not off an edge, follow line */
while (!outside) {
hit[current.r][current.c] +=
findcrossing(¤t, level, Cell, Points,
&ncrossing);
newedge(¤t);
outside = getnewcell(¤t, nrow, ncol, z);
}
if ((n_cut <= 0) || ((Points->n_points) > n_cut)) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, n + 1);
Vect_write_line(&Map, GV_LINE, Points, Cats);
}
Vect_reset_line(Points);
} /* if checkedge */
} /* if ! hit */
} /* for columns */
} /* for rows */
/* check right and left borders (each row of first and last column) */
for (startcol = 0; startcol < ncol; startcol += (ncol - 2)) {
for (startrow = 0; startrow <= nrow - 2; startrow++) {
/* look for starting point of new line */
if (!hit[startrow][startcol]) {
current.r = startrow;
current.c = startcol;
outside = getnewcell(¤t, nrow, ncol, z);
/* is this left or right edge? */
if (startcol == 0) /* left */
current.edge = 3;
else /* right edge */
current.edge = 1;
p1 = current.edge;
p2 = (current.edge + 1) % 4;
if (checkedge(current.z[p1], current.z[p2], level)) {
getpoint(¤t, level, Cell, Points);
/* while not off an edge, follow line */
while (!outside) {
hit[current.r][current.c] +=
findcrossing(¤t, level, Cell, Points,
&ncrossing);
newedge(¤t);
outside = getnewcell(¤t, nrow, ncol, z);
}
if ((n_cut <= 0) || ((Points->n_points) > n_cut)) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, n + 1);
Vect_write_line(&Map, GV_LINE, Points, Cats);
}
Vect_reset_line(Points);
} /* if checkedge */
} /* if ! hit */
} /* for rows */
} /* for columns */
/* check each interior Cell */
for (startrow = 1; startrow <= nrow - 3; startrow++) {
for (startcol = 1; startcol <= ncol - 3; startcol++) {
/* look for starting point of new line */
if (!hit[startrow][startcol]) {
current.r = startrow;
current.c = startcol;
current.edge = 0;
outside = getnewcell(¤t, nrow, ncol, z);
if (!outside &&
checkedge(current.z[0], current.z[1], level)) {
getpoint(¤t, level, Cell, Points);
hit[current.r][current.c] +=
findcrossing(¤t, level, Cell, Points,
&ncrossing);
newedge(¤t);
outside = getnewcell(¤t, nrow, ncol, z);
/* while not back to starting point, follow line */
while (!outside &&
((current.edge != 0) ||
((current.r != startrow) ||
(current.c != startcol)))) {
hit[current.r][current.c] +=
findcrossing(¤t, level, Cell, Points,
&ncrossing);
newedge(¤t);
outside = getnewcell(¤t, nrow, ncol, z);
}
if ((n_cut <= 0) || ((Points->n_points) > n_cut)) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, n + 1);
Vect_write_line(&Map, GV_LINE, Points, Cats);
}
Vect_reset_line(Points);
} /* if checkedge */
} /* if ! hit */
} /* for rows */
} /* for columns */
} /* for levels */
if (ncrossing > 0) {
G_warning(_n("%d crossing found",
"%d crossings found",
ncrossing), ncrossing);
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
}
