void ConversionStation::build() {
try {
stationType_ = typeString.at(type_());
buildConversions();
} catch (const std::out_of_range& ex) {
logERROR("Station type \"" + type_() + "\" not recognized.");
}
cleanup();
}
multi_geometry_generator_grammar()
: multi_geometry_generator_grammar::base_type(start)
{
boost::spirit::karma::uint_type uint_;
boost::spirit::bool_type bool_;
boost::spirit::karma::_val_type _val;
boost::spirit::karma::_1_type _1;
boost::spirit::karma::lit_type lit;
boost::spirit::karma::_a_type _a;
boost::spirit::karma::eps_type eps;
boost::spirit::karma::string_type kstring;
geometry_types.add
(mapnik::geometry_type::types::Point,"\"Point\"")
(mapnik::geometry_type::types::LineString,"\"LineString\"")
(mapnik::geometry_type::types::Polygon,"\"Polygon\"")
(mapnik::geometry_type::types::Point + 3,"\"MultiPoint\"")
(mapnik::geometry_type::types::LineString + 3,"\"MultiLineString\"")
(mapnik::geometry_type::types::Polygon + 3,"\"MultiPolygon\"")
;
start %= ( eps(phoenix::at_c<1>(_a))[_a = multi_type_(_val)]
<< lit("{\"type\":\"GeometryCollection\",\"geometries\":[")
<< geometry_collection << lit("]}")
|
geometry)
;
geometry_collection = -(geometry2 % lit(','))
;
geometry = ( &bool_(true)[_1 = not_empty_(_val)] << lit("{\"type\":")
<< geometry_types[_1 = phoenix::at_c<0>(_a)][_a = multi_type_(_val)]
<< lit(",\"coordinates\":")
<< kstring[ phoenix::if_ (phoenix::at_c<0>(_a) > 3) [_1 = '['].else_[_1 = ""]]
<< coordinates
<< kstring[ phoenix::if_ (phoenix::at_c<0>(_a) > 3) [_1 = ']'].else_[_1 = ""]]
<< lit('}')) | lit("null")
;
geometry2 = lit("{\"type\":")
<< geometry_types[_1 = _a][_a = type_(_val)]
<< lit(",\"coordinates\":")
<< path
<< lit('}')
;
coordinates %= path % lit(',')
;
}
void MaterialObject::build() {
check();
if (!debugInactivate_()) {
// for (auto& currentSensor : sensorNode_) {
// ReferenceSensor temporarySensor;
// temporarySensor.store(currentSensor.second);
// temporarySensor.check();
// temporarySensor.cleanup();
// std::cout << "[" << currentSensor.first << "]=" << temporarySensor.numChannels() << "; ";
// sensorChannels[currentSensor.first] = temporarySensor.numChannels();
// }
// std::cout << "}" << std::endl;
static std::map<MaterialObjectKey, Materials*> materialsMap_; //for saving memory
for (auto& currentMaterialNode : materialsNode_) {
store(currentMaterialNode.second);
check();
if (type_().compare(getTypeString()) == 0) {
MaterialObjectKey myKey(currentMaterialNode.first, sensorChannels, destination_.state()? destination_() : std::string(""));
if (materialsMap_.count(myKey) == 0) {
Materials * newMaterials = new Materials(materialType_);
newMaterials->store(currentMaterialNode.second);
//pass destination to newMaterials
if(destination_.state()) {
PropertyTree destinationPt;
destinationPt.add(destination_.name(), destination_());
newMaterials->store(destinationPt);
}
newMaterials->build(sensorChannels);
materialsMap_[myKey] = newMaterials;
}
materials_ = materialsMap_[myKey];
break;
}
}
}
cleanup();
}
void Path::generate_subpath()
{
float duration = duration_(rng_);
CurveType type = static_cast<CurveType>(type_(rng_));
if (current_.curve) {
current_.origin += current_.curve->evaluate(current_.end - current_.start);
current_.start = current_.end;
} else {
std::uniform_real_distribution<float> origin(0.0f, 2.0f);
current_.origin = glm::vec3(origin(rng_), origin(rng_), origin(rng_));
current_.start = current_.now;
}
current_.end = current_.start + duration;
Curve *curve;
switch (type) {
case CURVE_RANDOM:
curve = new RandomCurve(rng_());
break;
case CURVE_CIRCLE:
{
std::uniform_real_distribution<float> dir(-1.0f, 1.0f);
glm::vec3 axis(dir(rng_), dir(rng_), dir(rng_));
if (axis.x == 0.0f && axis.y == 0.0f && axis.z == 0.0f)
axis.x = 1.0f;
std::uniform_real_distribution<float> radius_(0.02f, 0.2f);
curve = new CircleCurve(radius_(rng_), axis);
}
break;
default:
assert(!"unreachable");
curve = nullptr;
break;
}
current_.curve.reset(curve);
}
