point
edit_graphics_rep::adjust (point p) {
frame f= find_frame ();
grid g= find_grid ();
if (!is_nil (g) && !is_nil (gr0) &&
(g != gr0 || p[0] != p_x || p[1] != p_y)) {
graphical_select (p[0], p[1]);
g= gr0;
p[0]= p_x;
p[1]= p_y;
}
if (is_nil (g)) return p;
point res;
gr_selections sels= copy (gs);
frame f2= find_frame (true);
if (is_nil (f2)) return p;
point fp= f2 (p);
if ((tree) g != "empty_grid") {
point q= g->find_point_around (p, snap_distance, f);
point fq= f2 (q);
if (norm (fq - fp) < snap_distance) {
gr_selection sel;
sel->type= "grid-point";
sel->p = fq;
sel->dist= (SI) norm (fq - fp);
sels << sel;
}
array<grid_curve> gc=
g->get_curves_around (p, snap_distance, f);
for (int i=0; i<N(gc); i++) {
point fc= closest (f2 (gc[i]->c), fp);
if (norm (fc - fp) < snap_distance) {
gr_selection sel;
sel->type= "grid-curve-point";
sel->p = fc;
sel->dist= (SI) norm (fc - fp);
sel->c = f2 (gc[i]->c);
sels << sel;
}
}
}
double eps= get_pixel_size () / 10.0;
gr_selection snap= snap_to_guide (fp, sels, eps);
//cout << "Snap " << fp << " to " << snap << ", " << snap->p << "\n";
point snapped= f2[snap->p];
if (N(snapped) == 2) return snapped;
return p;
// FIXME: why can snapped be an invalid point?
}
tree
edit_graphics_rep::graphical_select (double x, double y) {
frame f= find_frame ();
if (is_nil (f)) return tuple ();
gr_selections sels;
point p0 = point (x, y);
point p = f (p0);
sels= eb->graphical_select ((SI)p[0], (SI)p[1], 10*get_pixel_size ());
gs= sels;
pts= array<point> (0);
ci= array<point> (0);
cgi= array<point> (0);
gr0= empty_grid ();
grid g= find_grid ();
frame f2= find_frame (true);
if (!is_nil (g) && !is_nil (f2)) {
gr0= g;
p = f2 (point (x, y));
int i, j, n= N(sels);
for (i=0; i<n; i++) {
array<point> pts2= sels[i]->pts;
if (N(pts2)>0 && norm (pts2[0] - p) <= 10*get_pixel_size ())
pts= pts << pts2[0];
if (N(pts2)>1 && norm (pts2[1] - p) <= 10*get_pixel_size ())
pts= pts << pts2[1];
}
double eps= get_pixel_size () / 10.0;
for (i=0; i<n; i++) {
for (j=0; j<n; j++)
if (i<j) {
curve c1= sels[i]->c;
curve c2= sels[j]->c;
if (!is_nil (c1) && !is_nil (c2))
ci= ci << intersection (c1, c2, p, eps);
}
}
array<grid_curve> gc= g->get_curves_around (p0, 10*get_pixel_size (), f);
//FIXME: Too slow
for (i=0; i<N(gc); i++) {
curve c= f2 (gc[i]->c);
for (j=0; j<n; j++)
if (!is_nil (sels[j]->c))
cgi= cgi << intersection (c, sels[j]->c, p, eps);
}
}
return as_tree (sels);
}
tree
edit_graphics_rep::graphical_select (double x, double y) {
frame f= find_frame ();
if (is_nil (f)) return tuple ();
gr_selections pre_sels, sels;
point p0 = point (x, y);
point p = f (p0);
pre_sels= eb->graphical_select ((SI)p[0], (SI)p[1], snap_distance);
for (int i=0; i<N(pre_sels); i++)
if (admissible_selection (pre_sels[i]))
sels << pre_sels[i];
//for (int i=0; i<N(sels); i++)
// cout << i << ":\t" << sels[i] << "\n";
gs= sels;
gr0= empty_grid ();
grid g= find_grid ();
frame f2= find_frame (true);
if (!is_nil (g) && !is_nil (f2)) {
gr0= g;
p_x= x;
p_y= y;
}
return as_tree (sels);
}
point
edit_graphics_rep::adjust (point p) {
frame f= find_frame ();
grid g= find_grid ();
if (!is_nil (g) && !is_nil (gr0) && g!=gr0) {
graphical_select (p[0], p[1]);
g= gr0;
}
if (is_nil (g))
return p;
else {
point res;
gr_selections sels= gs;
frame f2= find_frame (true);
if (!is_nil (f2)) {
point fp= f2 (p);
int i;
if ((tree)g == "empty_grid") {
if (N(pts)>0)
res= pts[0];
for (i=0; i<N(pts); i++) {
point sp= pts[i];
if (N(sp)>0 && norm (fp - sp) < 5*get_pixel_size ())
res= pts[i];
}
int n= N(sels);
for (i=0; i<n; i++) {
point sp= sels[i]->p;
if (N(res)==0 || (N(sp)>0 && norm (fp - sp) < 5*get_pixel_size ()
&& norm (fp - sp) < norm (fp - res)))
res= sels[i]->p;
}
}
else
if (!is_nil (f)) {
res= f2 (g->find_point_around (p, 10*get_pixel_size (), f));
for (i=0; i<N(pts); i++) {
point sp= pts[i];
if (N(sp)>0 && norm (fp - sp) < norm (fp - res))
res= pts[i];
}
for (i=0; i<N(ci); i++) {
point sp= ci[i];
if (N(sp)>0 && norm (fp - sp) < norm (fp - res))
res= ci[i];
}
for (i=0; i<N(cgi); i++) {
point sp= cgi[i];
if (N(sp)>0 && norm (fp - sp) < norm (fp - res))
res= cgi[i];
}
//TODO: Adjusting by means on freely moving on surface of closed curves
;
}
if (N(res)>0)
res= f2[res];
else
res= p;
}
return res;
}
}
inline bool pj_apply_gridshift_3(StreamPolicy const& stream_policy,
Range & range,
srs::shared_grids & grids,
std::vector<std::size_t> const& gridindexes)
{
typedef typename boost::range_size<Range>::type size_type;
// If the grids are empty the indexes are as well
if (gridindexes.empty())
{
//pj_ctx_set_errno(ctx, PJD_ERR_FAILED_TO_LOAD_GRID);
//return PJD_ERR_FAILED_TO_LOAD_GRID;
return false;
}
size_type point_count = boost::size(range);
// local storage
pj_gi_load local_gi;
for (size_type i = 0 ; i < point_count ; )
{
bool load_needed = false;
CalcT in_lon = 0;
CalcT in_lat = 0;
{
boost::shared_lock<boost::shared_mutex> lock(grids.mutex);
for ( ; i < point_count ; ++i )
{
typename boost::range_reference<Range>::type
point = range::at(range, i);
in_lon = geometry::get_as_radian<0>(point);
in_lat = geometry::get_as_radian<1>(point);
pj_gi * gip = find_grid(in_lon, in_lat, grids.gridinfo, gridindexes);
if (gip == NULL)
{
// do nothing
}
else if (! gip->ct.cvs.empty())
{
// TODO: use set_invalid_point() or similar mechanism
CalcT out_lon = HUGE_VAL;
CalcT out_lat = HUGE_VAL;
nad_cvt<Inverse>(in_lon, in_lat, out_lon, out_lat, *gip);
// TODO: check differently
if (out_lon != HUGE_VAL)
{
geometry::set_from_radian<0>(point, out_lon);
geometry::set_from_radian<1>(point, out_lat);
}
}
else
{
// loading is needed
local_gi = *gip;
load_needed = true;
break;
}
}
}
if (load_needed)
{
if (load_grid(stream_policy, local_gi))
{
boost::unique_lock<boost::shared_mutex> lock(grids.mutex);
// check again in case other thread already loaded the grid.
pj_gi * gip = find_grid(in_lon, in_lat, grids.gridinfo, gridindexes);
if (gip != NULL && gip->ct.cvs.empty())
{
// swap loaded local storage with empty grid
local_gi.swap(*gip);
}
}
else
{
++i;
}
}
}
return true;
}
