PathList Path::children() const
{
PathList children;
#if WENDY_SYSTEM_WIN32
WIN32_FIND_DATA data;
HANDLE search;
search = FindFirstFile(m_string.c_str(), &data);
if (search == INVALID_HANDLE_VALUE)
return PathList();
do
{
children.push_back(operator + (data.cFileName));
}
while (FindNextFile(search, &data));
FindClose(search);
#else
DIR* stream;
dirent* entry;
stream = opendir(m_string.c_str());
if (!stream)
return PathList();
while ((entry = readdir(stream)))
children.push_back(operator + (entry->d_name));
closedir(stream);
#endif
return children;
}
bool Path::getChildren(PathList& children) const
{
#if WENDY_SYSTEM_WIN32
WIN32_FIND_DATA data;
HANDLE search;
search = FindFirstFile(path.c_str(), &data);
if (search == INVALID_HANDLE_VALUE)
return false;
do
{
children.push_back(operator + (data.cFileName));
}
while (FindNextFile(search, &data));
FindClose(search);
#else
DIR* stream;
dirent* entry;
stream = opendir(path.c_str());
if (!stream)
return false;
while ((entry = readdir(stream)))
children.push_back(operator + (entry->d_name));
closedir(stream);
#endif
return true;
}
/* public */
void
SharedPathsOp::getSharedPaths(PathList& forwDir, PathList& backDir)
{
PathList paths;
findLinearIntersections(paths);
for (size_t i=0, n=paths.size(); i<n; ++i)
{
LineString* path = paths[i];
if ( isSameDirection(*path) ) forwDir.push_back(path);
else backDir.push_back(path);
}
}
/* private */
void
SharedPathsOp::findLinearIntersections(PathList& to)
{
using geos::operation::overlay::OverlayOp;
// TODO: optionally use the tolerance,
// snapping _g2 over _g1 ?
std::auto_ptr<Geometry> full ( OverlayOp::overlayOp(
&_g1, &_g2, OverlayOp::opINTERSECTION) );
// NOTE: intersection of equal lines yelds splitted lines,
// should we sew them back ?
for (size_t i=0, n=full->getNumGeometries(); i<n; ++i)
{
const Geometry* sub = full->getGeometryN(i);
const LineString* path = dynamic_cast<const LineString*>(sub);
if ( path ) {
// NOTE: we're making a copy here, wouldn't be needed
// for a simple predicate
to.push_back(_gf.createLineString(*path).release());
}
}
}
void GapFiller::BFS(const CondensedDeBruijnGraph& graph, const size_t from, const size_t to, int gap, size_t max_depth, size_t max_queue, PathList& pathlist) {
size_t step = 0;
Path path = boost::assign::list_of(from);
typedef std::pair< Path, int > Choice;
std::deque< Choice > Q = boost::assign::list_of(std::make_pair(
path, 0 - (_K - 1)
));
while (!Q.empty()) {
++step;
if (step > max_depth) {
LOG4CXX_DEBUG(logger, boost::format("BFS step is bigger than %d...") % max_depth);
break;
}
if (Q.size() > max_queue) {
LOG4CXX_DEBUG(logger, boost::format("BFS Q size=%d is greater than %d...") % Q.size() % max_queue);
break;
}
std::deque< Choice > nextQ;
while (!Q.empty()) {
Choice choice = Q.front();
Q.pop_front();
size_t node = choice.first.back();
if (node == to) {
pathlist.push_back(choice.first);
}
if (choice.second > gap - (_K - 1)) {
continue;
}
const CondensedDeBruijnGraph::CondensedEdge& edge = graph._indexer[node];
std::string suffix = edge.seq.substr(edge.seq.length() - (_K - 1), _K - 1);
CondensedDeBruijnGraph::NodeList::const_iterator i = graph._parents.find(suffix);
if (i != graph._parents.end()) {
for (CondensedDeBruijnGraph::EdgeList::const_iterator j = i->second.begin(); j != i->second.end(); ++j) {
//size_t length = graph._indexer[j->second].seq.length();
size_t length = graph._indexer[j->second].seq.length() - (_K - 1);
Choice new_choice(choice);
new_choice.first.push_back(j->second);
new_choice.second += length;
nextQ.push_back(new_choice);
}
}
}
Q = nextQ;
}
}
// helps fill in the path matrix (see below)
void add_to_vector (PathList& previous_vector, wstring* to_add) {
wstring string_rep = represent_path (to_add, 2);
if (previous_vector.size() == 0) {
previous_vector.push_back (string_rep);
}
else {
PathList::iterator it;
// if there is more than one possible path, add to all of them
for (it=previous_vector.begin(); it != previous_vector.end(); it++) {
it->append (string_rep);
}
}
}
void init()
{
char* paths = getenv("INCLUDE");
if(paths && *paths != 0)
{
char* part = strtok(paths, ":");
while(part)
{
string s = part;
if(*(s.end()-1) != '/') s.push_back('/');
includePaths.push_back(s);
part = strtok(0, ":");
}
}
}
void
BuildingGrowth::Init()
{
if (_tess) {
return;
}
const Plane* ground = _sketch->GroundPlane();
glm::vec2 offset(0, 0);
const float width = 8;
const float depth = 4;
CoplanarPath* rect =
_sketch->AddRectangle(width, depth, ground->Eqn, offset);
float height = 4;
PathList walls;
_sketch->PushPath(rect, height, &walls);
_sketch->PushPath(rect, -1, &walls);
CoplanarPath* roof = rect;
CoplanarPath* wall;
wall = dynamic_cast<CoplanarPath*>(walls[1]);
rect = _sketch->AddInscribedRectangle(1, 1.5, wall, vec2(0, 0));
_sketch->PushPath(rect, -0.5);
wall = dynamic_cast<CoplanarPath*>(walls[2]);
sketch::PathList cylinders;
for (float y = -3.25; y < 3.26; y += 1.0) {
CoplanarPath* circle = _sketch->AddInscribedPolygon(0.3, wall, vec2(0, y), 48);
cylinders.push_back(circle);
}
_sketch->PushPaths(cylinders, 3);
PathList inners;
FOR_EACH(circle, cylinders) {
CoplanarPath* outer = dynamic_cast<CoplanarPath*>(*circle);
CoplanarPath* inner = _sketch->AddInscribedPolygon(0.15, outer, vec2(0, 0), 8);
inners.push_back(inner);
}
PathList PathName::SearchDirectory(void) const {
PathList opl;
if (!this->IsDirectory())
return opl;
#if defined(WIN32)
#error This needs to be implemented
#else
DIR *dir;
struct dirent *dirp;
if ((dir = opendir(this->GetNativePathName().c_str())) != NULL) {
while ((dirp = readdir(dir)) != NULL) {
opl.push_back(PathName(dirp->d_name));
}
closedir(dir);
}
#endif
return opl;
}
void EnumCallback(void* pUser, const char* path)
{
PathList* pList = (PathList*)pUser;
pList->push_back(path);
}
// calculates the edit distance between two words and tracks the differences
int edit_distance (Word first, Word second, PathList& paths) {
int first_length = first.size() + 1;
int second_length = second.size() + 1;
Word::iterator it1 = first.begin();
Word::iterator it2 = second.begin();
int distance_matrix [first_length][second_length];
PathList path_matrix [first_length][second_length];
wstring charstring[2];
bool match;
distance_matrix[0][0] = 0;
PathList newvector;
newvector.push_back(L"");
path_matrix[0][0] = newvector;
// fill in the top and left edges of the matrix (i.e. one string is empty)
for (int i=1; i != first_length; i++) {
path_matrix[i][0] = path_matrix[i-1][0];
distance_matrix[i][0] = i;
charstring[0] = *(it1++);
charstring[1] = NULL_CHAR;
add_to_vector (path_matrix[i][0], charstring);
}
for (int j=1; j != second_length; j++) {
path_matrix[0][j] = path_matrix[0][j-1];
distance_matrix[0][j] = j;
charstring[0] = NULL_CHAR;
charstring[1] = *(it2++);
add_to_vector (path_matrix[0][j], charstring);
}
it1 = first.begin();
for (int i=1; i != first_length; i++) {
it2 = second.begin();
for (int j=1; j != second_length; j++) {
int deletion = distance_matrix[i-1][j] + 1;
int insertion = distance_matrix[i][j-1] + 1;
int substitution = distance_matrix[i-1][j-1];
match = true;
if (*it1 != *it2) {
substitution++;
match = false;
}
int minimum_distance = min(deletion, min(insertion, substitution));
distance_matrix[i][j] = minimum_distance;
PathList* currcell = &path_matrix[i][j];
PathList::iterator it;
// add the changes to the current cell of the path matrix here
if (minimum_distance == deletion) {
PathList delcell = path_matrix[i-1][j];
charstring[0] = *it1;
charstring[1] = NULL_CHAR;
add_to_vector (delcell, charstring);
for (it=delcell.begin(); it != delcell.end(); it++)
currcell->push_back (*it);
}
if (minimum_distance == insertion) {
PathList inscell = path_matrix[i][j-1];
charstring[0] = NULL_CHAR;
charstring[1] = *it2;
add_to_vector (inscell, charstring);
for (it=inscell.begin(); it != inscell.end(); it++)
currcell->push_back (*it);
}
if (minimum_distance == substitution) {
PathList subcell = path_matrix[i-1][j-1];
// if the letters are identical, no need to track that
if (!match) {
charstring[0] = *it1;
charstring[1] = *it2;
add_to_vector (subcell, charstring);
}
for (it=subcell.begin(); it != subcell.end(); it++)
currcell->push_back (*it);
}
it2++;
}
it1++;
}
paths = path_matrix[first_length-1][second_length-1];
return distance_matrix[first_length-1][second_length-1];
}
