bool Gobby::FindDialog::find_and_select(const GtkTextIter* from,
SearchDirection direction)
{
SessionView* view = m_folder->get_current_document();
TextSessionView* text_view = dynamic_cast<TextSessionView*>(view);
g_assert(text_view != NULL);
const GtkTextIter* real_begin = from;
GtkTextIter insert_iter;
// Search from cursor position if from is not given
if(from == NULL)
{
GtkTextBuffer* buffer =
GTK_TEXT_BUFFER(text_view->get_text_buffer());
GtkTextMark* mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &insert_iter, mark);
real_begin = &insert_iter;
}
GtkTextIter match_start, match_end;
if(find_wrap(real_begin, direction, &match_start, &match_end))
{
if(direction == SEARCH_FORWARD)
text_view->set_selection(&match_end, &match_start);
else
text_view->set_selection(&match_start, &match_end);
return true;
}
return false;
}
//calculate the reliability of the horizontal edges of the image
//it is calculated by adding the reliability of pixel and the relibility of
//its right-hand neighbour
//edge is calculated between a pixel and its next neighbour
void horizontalEDGEs(PIXELM *pixel, EDGE *edge,
int image_width, int image_height,
params_t *params)
{
int i, j;
EDGE *edge_pointer = edge;
PIXELM *pixel_pointer = pixel;
int no_of_edges = params->no_of_edges;
for (i = 0; i < image_height; i++)
{
for (j = 0; j < image_width - 1; j++)
{
if (pixel_pointer->input_mask == NOMASK && (pixel_pointer + 1)->input_mask == NOMASK)
{
edge_pointer->pointer_1 = pixel_pointer;
edge_pointer->pointer_2 = (pixel_pointer+1);
edge_pointer->reliab = pixel_pointer->reliability + (pixel_pointer + 1)->reliability;
edge_pointer->increment = find_wrap(pixel_pointer->value, (pixel_pointer + 1)->value);
edge_pointer++;
no_of_edges++;
}
pixel_pointer++;
}
pixel_pointer++;
}
//construct edges at the right border of the image
if (params->x_connectivity == 1)
{
pixel_pointer = pixel + image_width - 1;
for (i = 0; i < image_height; i++)
{
if (pixel_pointer->input_mask == NOMASK && (pixel_pointer - image_width + 1)->input_mask == NOMASK)
{
edge_pointer->pointer_1 = pixel_pointer;
edge_pointer->pointer_2 = (pixel_pointer - image_width + 1);
edge_pointer->reliab = pixel_pointer->reliability + (pixel_pointer - image_width + 1)->reliability;
edge_pointer->increment = find_wrap(pixel_pointer->value, (pixel_pointer - image_width + 1)->value);
edge_pointer++;
no_of_edges++;
}
pixel_pointer+=image_width;
}
}
params->no_of_edges = no_of_edges;
}
//calculate the reliability of the vertical edges of the image
//it is calculated by adding the reliability of pixel and the relibility of
//its lower neighbour in the image.
void verticalEDGEs(PIXELM *pixel, EDGE *edge,
int image_width, int image_height,
params_t *params)
{
int i, j;
int no_of_edges = params->no_of_edges;
PIXELM *pixel_pointer = pixel;
EDGE *edge_pointer = edge + no_of_edges;
for (i=0; i < image_height - 1; i++)
{
for (j=0; j < image_width; j++)
{
if (pixel_pointer->input_mask == NOMASK && (pixel_pointer + image_width)->input_mask == NOMASK)
{
edge_pointer->pointer_1 = pixel_pointer;
edge_pointer->pointer_2 = (pixel_pointer + image_width);
edge_pointer->reliab = pixel_pointer->reliability + (pixel_pointer + image_width)->reliability;
edge_pointer->increment = find_wrap(pixel_pointer->value, (pixel_pointer + image_width)->value);
edge_pointer++;
no_of_edges++;
}
pixel_pointer++;
} //j loop
} // i loop
//construct edges that connect at the bottom border of the image
if (params->y_connectivity == 1)
{
pixel_pointer = pixel + image_width *(image_height - 1);
for (i = 0; i < image_width; i++)
{
if (pixel_pointer->input_mask == NOMASK && (pixel_pointer - image_width *(image_height - 1))->input_mask == NOMASK)
{
edge_pointer->pointer_1 = pixel_pointer;
edge_pointer->pointer_2 = (pixel_pointer - image_width *(image_height - 1));
edge_pointer->reliab = pixel_pointer->reliability + (pixel_pointer - image_width *(image_height - 1))->reliability;
edge_pointer->increment = find_wrap(pixel_pointer->value, (pixel_pointer - image_width *(image_height - 1))->value);
edge_pointer++;
no_of_edges++;
}
pixel_pointer++;
}
}
params->no_of_edges = no_of_edges;
}
void
diy::detail::KDTreeSamplingPartition<Block,Point>::
update_links(Block* b, const diy::ReduceProxy& srp, int dim, int round, int rounds, bool wrap, const Bounds& domain) const
{
auto log = get_logger();
int gid = srp.gid();
int lid = srp.master()->lid(gid);
RCLink* link = static_cast<RCLink*>(srp.master()->link(lid));
// (gid, dir) -> i
std::map<std::pair<int,diy::Direction>, int> link_map;
for (int i = 0; i < link->size(); ++i)
link_map[std::make_pair(link->target(i).gid, link->direction(i))] = i;
// NB: srp.enqueue(..., ...) should match the link
std::vector<float> splits(link->size());
for (int i = 0; i < link->size(); ++i)
{
float split; diy::Direction dir;
int in_gid = link->target(i).gid;
while(srp.incoming(in_gid))
{
srp.dequeue(in_gid, split);
srp.dequeue(in_gid, dir);
// reverse dir
for (int j = 0; j < dim_; ++j)
dir[j] = -dir[j];
int k = link_map[std::make_pair(in_gid, dir)];
log->trace("{} {} {} -> {}", in_gid, dir, split, k);
splits[k] = split;
}
}
RCLink new_link(dim_, link->core(), link->core());
bool lower = !(gid & (1 << (rounds - 1 - round)));
// fill out the new link
for (int i = 0; i < link->size(); ++i)
{
diy::Direction dir = link->direction(i);
//diy::Direction wrap_dir = link->wrap(i); // we don't use existing wrap, but restore it from scratch
if (dir[dim] != 0)
{
if ((dir[dim] < 0 && lower) || (dir[dim] > 0 && !lower))
{
int nbr_gid = divide_gid(link->target(i).gid, !lower, round, rounds);
diy::BlockID nbr = { nbr_gid, srp.assigner().rank(nbr_gid) };
new_link.add_neighbor(nbr);
new_link.add_direction(dir);
Bounds bounds = link->bounds(i);
update_neighbor_bounds(bounds, splits[i], dim, !lower);
new_link.add_bounds(bounds);
if (wrap)
new_link.add_wrap(find_wrap(new_link.bounds(), bounds, domain));
else
new_link.add_wrap(diy::Direction());
}
} else // non-aligned side
{
for (int j = 0; j < 2; ++j)
{
int nbr_gid = divide_gid(link->target(i).gid, j == 0, round, rounds);
Bounds bounds = link->bounds(i);
update_neighbor_bounds(bounds, splits[i], dim, j == 0);
if (intersects(bounds, new_link.bounds(), dim, wrap, domain))
{
diy::BlockID nbr = { nbr_gid, srp.assigner().rank(nbr_gid) };
new_link.add_neighbor(nbr);
new_link.add_direction(dir);
new_link.add_bounds(bounds);
if (wrap)
new_link.add_wrap(find_wrap(new_link.bounds(), bounds, domain));
else
new_link.add_wrap(diy::Direction());
}
}
}
}
// add link to the dual block
int dual_gid = divide_gid(gid, !lower, round, rounds);
diy::BlockID dual = { dual_gid, srp.assigner().rank(dual_gid) };
new_link.add_neighbor(dual);
Bounds nbr_bounds = link->bounds(); // old block bounds
update_neighbor_bounds(nbr_bounds, find_split(new_link.bounds(), nbr_bounds), dim, !lower);
new_link.add_bounds(nbr_bounds);
new_link.add_wrap(diy::Direction()); // dual block cannot be wrapped
if (lower)
{
diy::Direction right;
right[dim] = 1;
new_link.add_direction(right);
} else
{
diy::Direction left;
left[dim] = -1;
new_link.add_direction(left);
}
// update the link; notice that this won't conflict with anything since
// reduce is using its own notion of the link constructed through the
// partners
link->swap(new_link);
}
