/** Are we in Preview mode?
*
* Preview means that we are visualizing the workspace directly, i.e.,
* while dragging the line around; Therefore there is no "original" workspace
* to change coordinates to.
*
* If NOT in preview mode, then we get a reference to the original workspace,
* which we use to display the right X axis coordinate.
*
* @param preview :: true for Preview mode.
*/
void MantidQwtIMDWorkspaceData::setPreviewMode(bool preview)
{
m_preview = preview;
// If the workspace has no original, then we MUST be in preview mode.
const size_t nOriginalWorkspaces = m_workspace->numOriginalWorkspaces();
if (preview || (nOriginalWorkspaces == 0))
{
// Preview mode. No transformation.
m_originalWorkspace = m_workspace;
}
else
{
// Refer to the last workspace = the intermediate in the case of MDHisto binning
const size_t indexOfWS = nOriginalWorkspaces-1; // Get the last workspace
m_originalWorkspace = boost::dynamic_pointer_cast<IMDWorkspace>(m_workspace->getOriginalWorkspace(indexOfWS));
}
const size_t nTransformsToOriginal = m_workspace->getNumberTransformsToOriginal();
if (preview || (nTransformsToOriginal == 0))
{
m_transform = new NullCoordTransform(m_workspace->getNumDims());
}
else
{
const size_t indexOfTransform = nTransformsToOriginal-1; // Get the last transform
CoordTransform * temp = m_workspace->getTransformToOriginal(indexOfTransform);
if (temp)
m_transform = temp->clone();
}
this->choosePlotAxis();
}
void transform_at(unsigned pos,const CoordTransform& t)
{
if (pos >= pos_) return;
unsigned block = pos >> block_shift;
value_type* vertex = vertexs_[block] + (( pos & block_mask) << 1);
t.forward_x(vertex);
++vertex;
t.forward_y(vertex);
}
void image_symbolizer::render(Feature const& feat,CoordTransform const& t,Image32& image) const
{
geometry_ptr const& geom=feat.get_geometry();
if (geom)
{
double x;
double y;
geom->label_position(&x,&y);
t.forward_x(&x);
t.forward_y(&y);
int w=symbol_.width();
int h=symbol_.height();
int px=int(ceil(x - 0.5 * w));
int py=int(ceil(y - 0.5 * h));
image.set_rectangle_alpha(px,py,symbol_);
}
}
featureset_ptr Map::query_map_point(unsigned index, double x, double y) const
{
if ( index< layers_.size())
{
mapnik::layer const& layer = layers_[index];
CoordTransform tr = view_transform();
tr.backward(&x,&y);
try
{
mapnik::projection dest(srs_);
mapnik::projection source(layer.srs());
proj_transform prj_trans(source,dest);
double z = 0;
prj_trans.backward(x,y,z);
double minx = current_extent_.minx();
double miny = current_extent_.miny();
double maxx = current_extent_.maxx();
double maxy = current_extent_.maxy();
prj_trans.backward(minx,miny,z);
prj_trans.backward(maxx,maxy,z);
double tol = (maxx - minx) / width_ * 3;
mapnik::datasource_ptr ds = layer.datasource();
if (ds)
{
#ifdef MAPNIK_DEBUG
std::clog << " query at point tol = " << tol << " (" << x << "," << y << ")\n";
#endif
featureset_ptr fs = ds->features_at_point(mapnik::coord2d(x,y));
if (fs)
return boost::make_shared<filter_featureset<hit_test_filter> >(fs,
hit_test_filter(x,y,tol));
}
}
catch (...)
{
#ifdef MAPNIK_DEBUG
std::clog << "exception caught in \"query_map_point\"\n";
#endif
}
}
return featureset_ptr();
}
inline void write_point(CoordTransform const& t, double x, double y, bool last = false)
{
double z = 0.0;
t.backward(&x, &y);
trans_->forward(x, y, z);
*f_ << "["<<x<<","<<y<<"]";
if (!last) {
*f_ << ",";
}
}
void Renderer<Image>::renderLayer(const Layer& l,const CoordTransform& t,
const Envelope<double>& bbox,Image& image)
{
const datasource_p& ds=l.datasource();
if (!ds) return;
//volatile named_style_cache* styles=named_style_cache::instance();
//get copy
std::vector<std::string> const& namedStyles=l.styles();
std::vector<std::string>::const_iterator stylesIter=namedStyles.begin();
while (stylesIter!=namedStyles.end())
{
feature_type_style style=named_style_cache::instance()->find(*stylesIter++);
std::set<std::string> names;
attribute_collector<Feature> collector(names);
property_index<Feature> indexer(names);
query q(bbox);
double scale = 1.0/t.scale();
std::vector<rule_type*> if_rules;
std::vector<rule_type*> else_rules;
bool active_rules=false;
const std::vector<rule_type>& rules=style.rules();
std::vector<rule_type>::const_iterator ruleIter=rules.begin();
while (ruleIter!=rules.end())
{
if (ruleIter->active(scale))
{
active_rules=true;
filter_ptr& filter=const_cast<filter_ptr&>(ruleIter->get_filter());
filter->accept(collector);
filter->accept(indexer);
if (ruleIter->has_else_filter())
{
else_rules.push_back(const_cast<rule_type*>(&(*ruleIter)));
}
else
{
if_rules.push_back(const_cast<rule_type*>(&(*ruleIter)));
}
}
++ruleIter;
}
std::set<std::string>::const_iterator namesIter=names.begin();
// push all property names
while (namesIter!=names.end())
{
q.add_property_name(*namesIter);
++namesIter;
}
//only query datasource if there are active rules
if (active_rules)
{
featureset_ptr fs=ds->features(q);
if (fs)
{
Feature* feature=0;
while ((feature = fs->next()))
{
bool do_else=true;
geometry_ptr& geom=feature->get_geometry();
if (geom)
{
geom->transform(t);//todo: transform once
std::vector<rule_type*>::const_iterator itr=if_rules.begin();
while (itr!=if_rules.end())
{
const filter_ptr& filter=(*itr)->get_filter();
if (filter->pass(*feature))
{
do_else=false;
const symbolizers& symbols = (*itr)->get_symbolizers();
symbolizers::const_iterator symIter=symbols.begin();
while (symIter!=symbols.end())
{
(*symIter)->render(*geom,image);
++symIter;
}
break;// not sure !!
}
++itr;
}
if (do_else)
{
//else filter
std::vector<rule_type*>::const_iterator itr=else_rules.begin();
while (itr != else_rules.end())
{
const symbolizers& symbols = (*itr)->get_symbolizers();
symbolizers::const_iterator symIter=symbols.begin();
while (symIter!=symbols.end())
{
(*symIter)->render(*geom,image);
++symIter;
}
++itr;
}
}
}
delete feature;
}
}
if (l.isSelectable() && l.selection().size()) //TODO !!!
{
//volatile style_cache* styles=style_cache::instance();
const Style& style=style_cache::instance()->find(l.selection_style());
std::vector<ref_ptr<Feature> >& selection=l.selection();
Style::Iterator pos = style.begin();
if (pos!=style.end()) {
std::vector<ref_ptr<Feature> >::iterator itr=selection.begin();
while (itr!=selection.end())
{
geometry_ptr& geom=(*itr)->get_geometry();
geom->transform(t);
(*pos)->render(*geom,image);
++itr;
}
}
l.clear_selection();
}
}
}
}
featureset_ptr Map::query_map_point(unsigned index, double x, double y) const
{
CoordTransform tr = view_transform();
tr.backward(&x,&y);
return query_point(index,x,y);
}
static boost::python::tuple
getinitargs(const CoordTransform& c)
{
using namespace boost::python;
return boost::python::make_tuple(c.width(),c.height(),c.extent());
}
