static double math_model_Pcw(double variable, Container<double> in_list) {
double result=variable;
result = (((*(in_list.getNextItem()))*sin(((6.283185307179586*(*(in_list.getNextItem())))*((*(in_list.getNextItem()))-(*(in_list.getNextItem()))))*0.016666666666666666))-(*(in_list.getNextItem())))*1.3565;
return result;
};
ContainerIterator Container::end() const
{
Container* evil = const_cast<Container*>(this);
return evil->end();
}
Object* Analitza::removeDependencies(Object * o) const
{
Q_ASSERT(o);
if(o->type()==Object::variable) {
Ci* var=(Ci*) o;
qDebug() << "Wanna remove" << var->name() << m_vars->value(var->name());
if(m_vars->contains(var->name()) && m_vars->value(var->name())) {
Object *value=Expression::objectCopy(m_vars->value(var->name()));
Object *no = removeDependencies(value);
delete o;
return no;
}
} else if(o->type()==Object::container) {
Container *c = (Container*) o;
Operator op(c->firstOperator());
if(c->containerType()==Object::apply && op.isBounded()) { //it is a function
Container *cbody = c;
QStringList bvars;
if(op.operatorType()==Object::function) {
Ci *func= (Ci*) c->m_params[0];
Object* body= (Object*) m_vars->value(func->name());
if(body->type()!=Object::container)
return body;
cbody = (Container*) body;
}
bvars = cbody->bvarList();
qDebug() << bvars;
if(op.operatorType()==Object::function) {
QStringList::const_iterator iBvars(bvars.constBegin());
int i=0;
for(; iBvars!=bvars.constEnd(); ++iBvars)
m_vars->stack(*iBvars, c->m_params[++i]);
delete c;
}
QList<Object*>::iterator fval(cbody->firstValue());
qDebug() << "removing: " << (*fval)->toString();
Object *ret= removeDependencies(Expression::objectCopy(*fval));
QStringList::const_iterator iBvars(bvars.constBegin());
for(; iBvars!=bvars.constEnd(); ++iBvars)
m_vars->destroy(*iBvars);
if(op.operatorType()==Object::function)
return ret;
else {
delete *fval;
*fval=ret;
return c;
}
} else {
QList<Object*>::iterator it(c->m_params.begin());
for(; it!=c->m_params.end(); ++it)
*it = removeDependencies(*it);
}
}
return o;
}
static double math_model_h_conc(double variable,Container<double> in_list){
double result = variable;
result = ((*(in_list.getNextItem()))*((*(in_list.getNextItem()))-(*(in_list.getNextItem())))-(*(in_list.getNextItem()))*(*(in_list.getNextItem())))/(*(in_list.getNextItem()));
return result;
};
ContainerRangeReverse(Container &c) : IteratorRange<typename ContainerProperties<Container>::RBeginType>(c.rbegin(),
c.rend()) {}
static bool eval(const Container& container, const typename Container::key_type& value)
{
return container.find(value) != container.end();
}
bool empty() const
{
return container_.empty();
}
void adjacent_for_each(Container & c, BinaryFunction func)
{
adjacent_for_each(c.begin(), c.end(), func);
}
bool IOLoginData::loadPlayer(Player* player, DBResult_ptr result)
{
if (!result) {
return false;
}
Database* db = Database::getInstance();
uint32_t accno = result->getNumber<uint32_t>("account_id");
Account acc = loadAccount(accno);
player->setGUID(result->getNumber<uint32_t>("id"));
player->name = result->getString("name");
player->accountNumber = accno;
player->accountType = acc.accountType;
player->coinBalance = acc.coinBalance;
if (g_config.getBoolean(ConfigManager::FREE_PREMIUM)) {
player->premiumDays = std::numeric_limits<uint16_t>::max();
} else {
player->premiumDays = acc.premiumDays;
}
Group* group = g_game.groups.getGroup(result->getNumber<uint16_t>("group_id"));
if (!group) {
std::cout << "[Error - IOLoginData::loadPlayer] " << player->name << " has Group ID " << result->getNumber<uint16_t>("group_id") << " which doesn't exist" << std::endl;
return false;
}
player->setGroup(group);
player->bankBalance = result->getNumber<uint64_t>("balance");
player->setSex(static_cast<PlayerSex_t>(result->getNumber<uint16_t>("sex")));
player->level = std::max<uint32_t>(1, result->getNumber<uint32_t>("level"));
uint64_t experience = result->getNumber<uint64_t>("experience");
uint64_t currExpCount = Player::getExpForLevel(player->level);
uint64_t nextExpCount = Player::getExpForLevel(player->level + 1);
if (experience < currExpCount || experience > nextExpCount) {
experience = currExpCount;
}
player->experience = experience;
if (currExpCount < nextExpCount) {
player->levelPercent = Player::getPercentLevel(player->experience - currExpCount, nextExpCount - currExpCount);
} else {
player->levelPercent = 0;
}
player->soul = result->getNumber<uint16_t>("soul");
player->capacity = result->getNumber<uint32_t>("cap") * 100;
player->blessings = result->getNumber<uint16_t>("blessings");
unsigned long conditionsSize;
const char* conditions = result->getStream("conditions", conditionsSize);
PropStream propStream;
propStream.init(conditions, conditionsSize);
Condition* condition = Condition::createCondition(propStream);
while (condition) {
if (condition->unserialize(propStream)) {
player->storedConditionList.push_front(condition);
} else {
delete condition;
}
condition = Condition::createCondition(propStream);
}
if (!player->setVocation(result->getNumber<uint16_t>("vocation"))) {
std::cout << "[Error - IOLoginData::loadPlayer] " << player->name << " has Vocation ID " << result->getNumber<uint16_t>("vocation") << " which doesn't exist" << std::endl;
return false;
}
player->mana = result->getNumber<uint32_t>("mana");
player->manaMax = result->getNumber<uint32_t>("manamax");
player->magLevel = result->getNumber<uint32_t>("maglevel");
uint64_t nextManaCount = player->vocation->getReqMana(player->magLevel + 1);
uint64_t manaSpent = result->getNumber<uint64_t>("manaspent");
if (manaSpent > nextManaCount) {
manaSpent = 0;
}
player->manaSpent = manaSpent;
player->magLevelPercent = Player::getPercentLevel(player->manaSpent, nextManaCount);
player->health = result->getNumber<int32_t>("health");
player->healthMax = result->getNumber<int32_t>("healthmax");
player->defaultOutfit.lookType = result->getNumber<uint16_t>("looktype");
player->defaultOutfit.lookHead = result->getNumber<uint16_t>("lookhead");
player->defaultOutfit.lookBody = result->getNumber<uint16_t>("lookbody");
player->defaultOutfit.lookLegs = result->getNumber<uint16_t>("looklegs");
player->defaultOutfit.lookFeet = result->getNumber<uint16_t>("lookfeet");
player->defaultOutfit.lookAddons = result->getNumber<uint16_t>("lookaddons");
player->currentOutfit = player->defaultOutfit;
if (g_game.getWorldType() != WORLD_TYPE_PVP_ENFORCED) {
const time_t skullSeconds = result->getNumber<time_t>("skulltime") - time(nullptr);
if (skullSeconds > 0) {
//ensure that we round up the number of ticks
player->skullTicks = (skullSeconds + 2) * 1000;
uint16_t skull = result->getNumber<uint16_t>("skull");
if (skull == SKULL_RED) {
player->skull = SKULL_RED;
} else if (skull == SKULL_BLACK) {
player->skull = SKULL_BLACK;
}
}
}
player->loginPosition.x = result->getNumber<uint16_t>("posx");
player->loginPosition.y = result->getNumber<uint16_t>("posy");
player->loginPosition.z = result->getNumber<uint16_t>("posz");
player->lastLoginSaved = result->getNumber<time_t>("lastlogin");
player->lastLogout = result->getNumber<time_t>("lastlogout");
player->offlineTrainingTime = result->getNumber<int32_t>("offlinetraining_time") * 1000;
player->offlineTrainingSkill = result->getNumber<int32_t>("offlinetraining_skill");
Town* town = g_game.map.towns.getTown(result->getNumber<uint32_t>("town_id"));
if (!town) {
std::cout << "[Error - IOLoginData::loadPlayer] " << player->name << " has Town ID " << result->getNumber<uint32_t>("town_id") << " which doesn't exist" << std::endl;
return false;
}
player->town = town;
const Position& loginPos = player->loginPosition;
if (loginPos.x == 0 && loginPos.y == 0 && loginPos.z == 0) {
player->loginPosition = player->getTemplePosition();
}
player->staminaMinutes = result->getNumber<uint16_t>("stamina");
static const std::string skillNames[] = {"skill_fist", "skill_club", "skill_sword", "skill_axe", "skill_dist", "skill_shielding", "skill_fishing"};
static const std::string skillNameTries[] = {"skill_fist_tries", "skill_club_tries", "skill_sword_tries", "skill_axe_tries", "skill_dist_tries", "skill_shielding_tries", "skill_fishing_tries"};
static const size_t size = sizeof(skillNames) / sizeof(std::string);
for (uint8_t i = 0; i < size; ++i) {
uint16_t skillLevel = result->getNumber<uint16_t>(skillNames[i]);
uint64_t skillTries = result->getNumber<uint64_t>(skillNameTries[i]);
uint64_t nextSkillTries = player->vocation->getReqSkillTries(i, skillLevel + 1);
if (skillTries > nextSkillTries) {
skillTries = 0;
}
player->skills[i].level = skillLevel;
player->skills[i].tries = skillTries;
player->skills[i].percent = Player::getPercentLevel(skillTries, nextSkillTries);
}
std::ostringstream query;
query << "SELECT `guild_id`, `rank_id`, `nick` FROM `guild_membership` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
uint32_t guildId = result->getNumber<uint32_t>("guild_id");
uint32_t playerRankId = result->getNumber<uint32_t>("rank_id");
player->guildNick = result->getString("nick");
Guild* guild = g_game.getGuild(guildId);
if (!guild) {
query.str(std::string());
query << "SELECT `name` FROM `guilds` WHERE `id` = " << guildId;
if ((result = db->storeQuery(query.str()))) {
guild = new Guild(guildId, result->getString("name"));
g_game.addGuild(guild);
query.str(std::string());
query << "SELECT `id`, `name`, `level` FROM `guild_ranks` WHERE `guild_id` = " << guildId << " LIMIT 3";
if ((result = db->storeQuery(query.str()))) {
do {
guild->addRank(result->getNumber<uint32_t>("id"), result->getString("name"), result->getNumber<uint16_t>("level"));
} while (result->next());
}
}
}
if (guild) {
player->guild = guild;
GuildRank* rank = guild->getRankById(playerRankId);
if (rank) {
player->guildLevel = rank->level;
} else {
player->guildLevel = 1;
}
IOGuild::getWarList(guildId, player->guildWarList);
query.str(std::string());
query << "SELECT COUNT(*) AS `members` FROM `guild_membership` WHERE `guild_id` = " << guildId;
if ((result = db->storeQuery(query.str()))) {
guild->setMemberCount(result->getNumber<uint32_t>("members"));
}
}
}
query.str(std::string());
query << "SELECT `player_id`, `name` FROM `player_spells` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
do {
player->learnedInstantSpellList.emplace_front(result->getString("name"));
} while (result->next());
}
//load inventory items
ItemMap itemMap;
query.str(std::string());
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_items` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if ((result = db->storeQuery(query.str()))) {
loadItems(itemMap, result);
for (ItemMap::const_reverse_iterator it = itemMap.rbegin(), end = itemMap.rend(); it != end; ++it) {
const std::pair<Item*, int32_t>& pair = it->second;
Item* item = pair.first;
int32_t pid = pair.second;
if (pid >= 1 && pid <= 10) {
player->internalAddThing(pid, item);
} else {
ItemMap::const_iterator it2 = itemMap.find(pid);
if (it2 == itemMap.end()) {
continue;
}
Container* container = it2->second.first->getContainer();
if (container) {
container->internalAddThing(item);
}
}
}
}
//load depot items
itemMap.clear();
query.str(std::string());
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_depotitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if ((result = db->storeQuery(query.str()))) {
loadItems(itemMap, result);
for (ItemMap::const_reverse_iterator it = itemMap.rbegin(), end = itemMap.rend(); it != end; ++it) {
const std::pair<Item*, int32_t>& pair = it->second;
Item* item = pair.first;
int32_t pid = pair.second;
if (pid >= 0 && pid < 100) {
DepotChest* depotChest = player->getDepotChest(pid, true);
if (depotChest) {
depotChest->internalAddThing(item);
}
} else {
ItemMap::const_iterator it2 = itemMap.find(pid);
if (it2 == itemMap.end()) {
continue;
}
Container* container = it2->second.first->getContainer();
if (container) {
container->internalAddThing(item);
}
}
}
}
//load inbox items
itemMap.clear();
query.str(std::string());
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_inboxitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if ((result = db->storeQuery(query.str()))) {
loadItems(itemMap, result);
for (ItemMap::const_reverse_iterator it = itemMap.rbegin(), end = itemMap.rend(); it != end; ++it) {
const std::pair<Item*, int32_t>& pair = it->second;
Item* item = pair.first;
int32_t pid = pair.second;
if (pid >= 0 && pid < 100) {
player->getInbox()->internalAddThing(item);
} else {
ItemMap::const_iterator it2 = itemMap.find(pid);
if (it2 == itemMap.end()) {
continue;
}
Container* container = it2->second.first->getContainer();
if (container) {
container->internalAddThing(item);
}
}
}
}
//load storage map
query.str(std::string());
query << "SELECT `key`, `value` FROM `player_storage` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
do {
player->addStorageValue(result->getNumber<uint32_t>("key"), result->getNumber<int32_t>("value"), true);
} while (result->next());
}
//load vip
query.str(std::string());
query << "SELECT `player_id` FROM `account_viplist` WHERE `account_id` = " << player->getAccount();
if ((result = db->storeQuery(query.str()))) {
do {
player->addVIPInternal(result->getNumber<uint32_t>("player_id"));
} while (result->next());
}
player->updateBaseSpeed();
player->updateInventoryWeight();
player->updateItemsLight(true);
return true;
}
static double math_model_Pcc(double variable, Container<double> in_list) {
double result=variable;
result = (*(in_list.getNextItem()))+(*(in_list.getNextItem()));
return result;
};
iterator insert(Container &container)
{
return __insert(container.begin(), container.end());
}
static double math_model_PplcFOL(double variable,Container<double> in_list) {
double result = variable;
result = ((*(in_list.getNextItem()))-(*(in_list.getNextItem())))/(0.001);
return result;
};
static double math_model_Pmouth(double variable, Container<double> in_list) {
double result=variable;
result = (*(in_list.getNextItem()))*1.3565;
return result;
};
static double math_model_PplmmHg(double variable, Container<double> in_list) {
double result=variable;
result = (*(in_list.getNextItem()))*.7371913011426465;
return result;
};
std::size_t RangeHash(Container c, std::size_t total_hash = 0)
{
return RangeHash(c.begin(), c.end(), total_hash);
}
Range ( Container const& cont )
: begin_( cont.begin() )
, end_( cont.end() )
{}
static bool eval(const Container& container, const Value& value)
{
typename Container::const_iterator end = container.end();
return std::find(container.begin(), end, value) != end;
}
template <class Container, class Function> Function for_each(Container &container, Function fn) {
return for_each(container.begin(), container.end(), fn);
}
void emplace( Args&&... args ) {
container_.emplace_back( std::forward<Args>( args )... );
}
void MapTest::template_methods()
{
#if defined (STLPORT) && defined (_STLP_USE_CONTAINERS_EXTENSION)
{
typedef map<Key, int, KeyCmp> Container;
typedef Container::value_type value;
Container cont;
cont.insert(value(Key(1), 1));
cont.insert(value(Key(2), 2));
cont.insert(value(Key(3), 3));
cont.insert(value(Key(4), 4));
CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
CPPUNIT_ASSERT( cont.count(1) == 1 );
CPPUNIT_ASSERT( cont.count(5) == 0 );
CPPUNIT_ASSERT( cont.find(2) != cont.end() );
CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
Container const& ccont = cont;
CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
}
{
typedef map<Key*, int, KeyCmpPtr> Container;
typedef Container::value_type value;
Container cont;
Key key1(1), key2(2), key3(3), key4(4);
cont.insert(value(&key1, 1));
cont.insert(value(&key2, 2));
cont.insert(value(&key3, 3));
cont.insert(value(&key4, 4));
CPPUNIT_ASSERT( cont.count(1) == 1 );
CPPUNIT_ASSERT( cont.count(5) == 0 );
CPPUNIT_ASSERT( cont.find(2) != cont.end() );
CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
Container const& ccont = cont;
CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
}
{
typedef multimap<Key, int, KeyCmp> Container;
typedef Container::value_type value;
Container cont;
cont.insert(value(Key(1), 1));
cont.insert(value(Key(2), 2));
cont.insert(value(Key(3), 3));
cont.insert(value(Key(4), 4));
CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
CPPUNIT_ASSERT( cont.count(1) == 1 );
CPPUNIT_ASSERT( cont.count(5) == 0 );
CPPUNIT_ASSERT( cont.find(2) != cont.end() );
CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
Container const& ccont = cont;
CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
}
{
typedef multimap<Key const volatile*, int, KeyCmpPtr> Container;
typedef Container::value_type value;
Container cont;
Key key1(1), key2(2), key3(3), key4(4);
cont.insert(value(&key1, 1));
cont.insert(value(&key2, 2));
cont.insert(value(&key3, 3));
cont.insert(value(&key4, 4));
CPPUNIT_ASSERT( cont.count(1) == 1 );
CPPUNIT_ASSERT( cont.count(5) == 0 );
CPPUNIT_ASSERT( cont.find(2) != cont.end() );
CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
Container const& ccont = cont;
CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
}
#endif
}
size_type size() const
{
return container_.size();
}
void TestContainer(const std::string& name)
{
typedef ContainerType Container;
// test empty container
Container cont;
if( cont.begin() != cont.end() )
{
V3D_UNITTEST_ERROR_STATIC(
(name + " Empty Container " "'s begin and end "
" iterators did not match").c_str()
);
}
// add value to container
int val = 3;
cont.push_back(val);
// test whether it was correctly added
if( *cont.begin() != val )
{
V3D_UNITTEST_ERROR_STATIC(
(name +
" Container::push_back did not insert element"
).c_str()
);
}
// empty container
cont.clear();
if( cont.begin() != cont.end() )
{
V3D_UNITTEST_ERROR_STATIC(
(name +
" Container::clear did not clear container: "
" begin() and end() mismatch"
).c_str()
);
}
if( cont.size() != 0 )
{
V3D_UNITTEST_ERROR_STATIC(
(name +
" Container::size() != 0 after clear()"
).c_str()
);
}
if( ! cont.empty() )
{
V3D_UNITTEST_ERROR_STATIC(
(name + "::empty() does not return true after clearing the "
"container.").c_str()
);
}
// "complex" test:
const int cnTestDataCount = 10;
int naTestData[cnTestDataCount];
for(int i = 0; i < cnTestDataCount; ++i)
{
naTestData[i] = i;
cont.push_back(i);
}
// test data
if( ! std::equal(cont.begin(), cont.end(), naTestData) )
{
V3D_UNITTEST_ERROR_STATIC(
(name +
" Filling with values and reading them back failed"
).c_str()
);
}
// test erasing: delete 3rd element
typename Container::iterator it(cont.begin());
advance(it, 2);
it = cont.erase(it);
if( *it != 3 )
{
V3D_UNITTEST_ERROR_STATIC(
(name +
"::erase did not return the correct iterator"
).c_str()
);
}
//cout << cont.size() << ": ";
//for( Container::iterator iter = cont.begin(); iter != cont.end(); ++ iter)
// cout << *iter << ",";
//cout << endl;
// test insert
it = cont.begin();
advance(it, 2);
it = cont.insert(it, 2);
int t = *it;
if( *it != 2 )
{
V3D_UNITTEST_ERROR_STATIC(
(name+
"::insert returned an invalid iterator"
).c_str()
);
}
//cout << cont.size() << ": ";
//for( Container::iterator iter = cont.begin(); iter != cont.end(); ++ iter)
// cout << *iter << ",";
//cout << endl;
if( ! std::equal(cont.begin(), cont.end(), naTestData) )
{
V3D_UNITTEST_ERROR_STATIC(
(name+ "::insert did not insert correctly").c_str()
);
}
}
ContainerRange(Container &c) : IteratorRange<typename ContainerProperties<Container>::BeginType>(c.begin(),
c.end()) {}
void
MapNodeHelper::parse(MapNode* mapNode,
osg::ArgumentParser& args,
osgViewer::View* view,
osg::Group* root,
Container* userContainer ) const
{
if ( !root )
root = mapNode;
// options to use for the load
osg::ref_ptr<osgDB::Options> dbOptions = Registry::instance()->cloneOrCreateOptions();
// parse out custom example arguments first:
bool useSky = args.read("--sky");
bool useOcean = args.read("--ocean");
bool useMGRS = args.read("--mgrs");
bool useDMS = args.read("--dms");
bool useDD = args.read("--dd");
bool useCoords = args.read("--coords") || useMGRS || useDMS || useDD;
bool useOrtho = args.read("--ortho");
bool useAutoClip = args.read("--autoclip");
bool useShadows = args.read("--shadows");
bool animateSky = args.read("--animate-sky");
bool showActivity = args.read("--activity");
bool useLogDepth = args.read("--logdepth");
bool useLogDepth2 = args.read("--logdepth2");
bool kmlUI = args.read("--kmlui");
bool inspect = args.read("--inspect");
if (args.read("--verbose"))
osgEarth::setNotifyLevel(osg::INFO);
if (args.read("--quiet"))
osgEarth::setNotifyLevel(osg::FATAL);
float ambientBrightness = 0.2f;
args.read("--ambientBrightness", ambientBrightness);
std::string kmlFile;
args.read( "--kml", kmlFile );
std::string imageFolder;
args.read( "--images", imageFolder );
std::string imageExtensions;
args.read("--image-extensions", imageExtensions);
// animation path:
std::string animpath;
if ( args.read("--path", animpath) )
{
view->setCameraManipulator( new osgGA::AnimationPathManipulator(animpath) );
}
// Install a new Canvas for our UI controls, or use one that already exists.
ControlCanvas* canvas = ControlCanvas::getOrCreate( view );
Container* mainContainer;
if ( userContainer )
{
mainContainer = userContainer;
}
else
{
mainContainer = new VBox();
mainContainer->setAbsorbEvents( true );
mainContainer->setBackColor( Color(Color::Black, 0.8) );
mainContainer->setHorizAlign( Control::ALIGN_LEFT );
mainContainer->setVertAlign( Control::ALIGN_BOTTOM );
}
canvas->addControl( mainContainer );
// look for external data in the map node:
const Config& externals = mapNode->externalConfig();
const Config& skyConf = externals.child("sky");
const Config& oceanConf = externals.child("ocean");
const Config& annoConf = externals.child("annotations");
const Config& declutterConf = externals.child("decluttering");
// some terrain effects.
// TODO: Most of these are likely to move into extensions.
const Config& lodBlendingConf = externals.child("lod_blending");
const Config& vertScaleConf = externals.child("vertical_scale");
const Config& contourMapConf = externals.child("contour_map");
// Adding a sky model:
if ( useSky || !skyConf.empty() )
{
SkyOptions options(skyConf);
if ( options.getDriver().empty() )
{
if ( mapNode->getMapSRS()->isGeographic() )
options.setDriver("simple");
else
options.setDriver("gl");
}
SkyNode* sky = SkyNode::create(options, mapNode);
if ( sky )
{
sky->attach( view, 0 );
if ( mapNode->getNumParents() > 0 )
{
osgEarth::insertGroup(sky, mapNode->getParent(0));
}
else
{
sky->addChild( mapNode );
root = sky;
}
Control* c = SkyControlFactory().create(sky, view);
if ( c )
mainContainer->addControl( c );
if (animateSky)
{
sky->setUpdateCallback( new AnimateSkyUpdateCallback() );
}
}
}
// Adding an ocean model:
if ( useOcean || !oceanConf.empty() )
{
OceanNode* ocean = OceanNode::create(OceanOptions(oceanConf), mapNode);
if ( ocean )
{
// if there's a sky, we want to ocean under it
osg::Group* parent = osgEarth::findTopMostNodeOfType<SkyNode>(root);
if ( !parent ) parent = root;
parent->addChild( ocean );
Control* c = OceanControlFactory().create(ocean);
if ( c )
mainContainer->addControl(c);
}
}
// Shadowing.
if ( useShadows )
{
ShadowCaster* caster = new ShadowCaster();
caster->setLight( view->getLight() );
caster->getShadowCastingGroup()->addChild( mapNode->getModelLayerGroup() );
if ( mapNode->getNumParents() > 0 )
{
insertGroup(caster, mapNode->getParent(0));
}
else
{
caster->addChild(mapNode);
root = caster;
}
}
// Loading KML from the command line:
if ( !kmlFile.empty() )
{
KMLOptions kml_options;
kml_options.declutter() = true;
// set up a default icon for point placemarks:
IconSymbol* defaultIcon = new IconSymbol();
defaultIcon->url()->setLiteral(KML_PUSHPIN_URL);
kml_options.defaultIconSymbol() = defaultIcon;
osg::Node* kml = KML::load( URI(kmlFile), mapNode, kml_options );
if ( kml )
{
if (kmlUI)
{
Control* c = AnnotationGraphControlFactory().create(kml, view);
if ( c )
{
c->setVertAlign( Control::ALIGN_TOP );
canvas->addControl( c );
}
}
root->addChild( kml );
}
else
{
OE_NOTICE << "Failed to load " << kmlFile << std::endl;
}
}
// Annotations in the map node externals:
if ( !annoConf.empty() )
{
osg::Group* annotations = 0L;
AnnotationRegistry::instance()->create( mapNode, annoConf, dbOptions.get(), annotations );
if ( annotations )
{
mapNode->addChild( annotations );
//root->addChild( annotations );
}
}
// Configure the de-cluttering engine for labels and annotations:
if ( !declutterConf.empty() )
{
Decluttering::setOptions( DeclutteringOptions(declutterConf) );
}
// Configure the mouse coordinate readout:
if ( useCoords )
{
LabelControl* readout = new LabelControl();
readout->setBackColor( Color(Color::Black, 0.8) );
readout->setHorizAlign( Control::ALIGN_RIGHT );
readout->setVertAlign( Control::ALIGN_BOTTOM );
Formatter* formatter =
useMGRS ? (Formatter*)new MGRSFormatter(MGRSFormatter::PRECISION_1M, 0L, MGRSFormatter::USE_SPACES) :
useDMS ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DEGREES_MINUTES_SECONDS) :
useDD ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DECIMAL_DEGREES) :
0L;
MouseCoordsTool* mcTool = new MouseCoordsTool( mapNode );
mcTool->addCallback( new MouseCoordsLabelCallback(readout, formatter) );
view->addEventHandler( mcTool );
canvas->addControl( readout );
}
// Configure for an ortho camera:
if ( useOrtho )
{
view->getCamera()->setProjectionMatrixAsOrtho(-1, 1, -1, 1, 0, 1);
//EarthManipulator* manip = dynamic_cast<EarthManipulator*>(view->getCameraManipulator());
//if ( manip )
//{
// manip->getSettings()->setCameraProjection( EarthManipulator::PROJ_ORTHOGRAPHIC );
//}
}
// activity monitor (debugging)
if ( showActivity )
{
VBox* vbox = new VBox();
vbox->setBackColor( Color(Color::Black, 0.8) );
vbox->setHorizAlign( Control::ALIGN_RIGHT );
vbox->setVertAlign( Control::ALIGN_BOTTOM );
view->addEventHandler( new ActivityMonitorTool(vbox) );
canvas->addControl( vbox );
}
// Install an auto clip plane clamper
if ( useAutoClip )
{
mapNode->addCullCallback( new AutoClipPlaneCullCallback(mapNode) );
}
// Install logarithmic depth buffer on main camera
if ( useLogDepth )
{
OE_INFO << LC << "Activating logarithmic depth buffer (vertex-only) on main camera" << std::endl;
osgEarth::Util::LogarithmicDepthBuffer logDepth;
logDepth.setUseFragDepth( false );
logDepth.install( view->getCamera() );
}
else if ( useLogDepth2 )
{
OE_INFO << LC << "Activating logarithmic depth buffer (precise) on main camera" << std::endl;
osgEarth::Util::LogarithmicDepthBuffer logDepth;
logDepth.setUseFragDepth( true );
logDepth.install( view->getCamera() );
}
// Scan for images if necessary.
if ( !imageFolder.empty() )
{
std::vector<std::string> extensions;
if ( !imageExtensions.empty() )
StringTokenizer( imageExtensions, extensions, ",;", "", false, true );
if ( extensions.empty() )
extensions.push_back( "tif" );
OE_INFO << LC << "Loading images from " << imageFolder << "..." << std::endl;
ImageLayerVector imageLayers;
DataScanner scanner;
scanner.findImageLayers( imageFolder, extensions, imageLayers );
if ( imageLayers.size() > 0 )
{
mapNode->getMap()->beginUpdate();
for( ImageLayerVector::iterator i = imageLayers.begin(); i != imageLayers.end(); ++i )
{
mapNode->getMap()->addImageLayer( i->get() );
}
mapNode->getMap()->endUpdate();
}
OE_INFO << LC << "...found " << imageLayers.size() << " image layers." << std::endl;
}
// Install elevation morphing
if ( !lodBlendingConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new LODBlending(lodBlendingConf) );
}
// Install vertical scaler
if ( !vertScaleConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new VerticalScale(vertScaleConf) );
}
// Install a contour map effect.
if ( !contourMapConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new ContourMap(contourMapConf) );
}
// Generic named value uniform with min/max.
VBox* uniformBox = 0L;
while( args.find( "--uniform" ) >= 0 )
{
std::string name;
float minval, maxval;
if ( args.read( "--uniform", name, minval, maxval ) )
{
if ( uniformBox == 0L )
{
uniformBox = new VBox();
uniformBox->setBackColor(0,0,0,0.5);
uniformBox->setAbsorbEvents( true );
canvas->addControl( uniformBox );
}
osg::Uniform* uniform = new osg::Uniform(osg::Uniform::FLOAT, name);
uniform->set( minval );
root->getOrCreateStateSet()->addUniform( uniform, osg::StateAttribute::OVERRIDE );
HBox* box = new HBox();
box->addControl( new LabelControl(name) );
HSliderControl* hs = box->addControl( new HSliderControl(minval, maxval, minval, new ApplyValueUniform(uniform)));
hs->setHorizFill(true, 200);
box->addControl( new LabelControl(hs) );
uniformBox->addControl( box );
OE_INFO << LC << "Installed uniform controller for " << name << std::endl;
}
}
if ( inspect )
{
mapNode->addExtension( Extension::create("mapinspector", ConfigOptions()) );
}
// Process extensions.
for(std::vector<osg::ref_ptr<Extension> >::const_iterator eiter = mapNode->getExtensions().begin();
eiter != mapNode->getExtensions().end();
++eiter)
{
Extension* e = eiter->get();
// Check for a View interface:
ExtensionInterface<osg::View>* viewIF = ExtensionInterface<osg::View>::get( e );
if ( viewIF )
viewIF->connect( view );
// Check for a Control interface:
ExtensionInterface<Control>* controlIF = ExtensionInterface<Control>::get( e );
if ( controlIF )
controlIF->connect( mainContainer );
}
root->addChild( canvas );
}
ContainerIterator Container::begin() const
{
Container* evil = const_cast<Container*>(this);
return evil->begin();
}
void print(Container& c) {
typename Container::iterator it;
for(it = c.begin(); it != c.end(); it++)
cout << *it << " ";
cout << endl;
}
void Analitza::simpPolynomials(Container* c)
{
Q_ASSERT(c!=0 && c->type()==Object::container);
QList<QPair<double, Object*> > monos;
QList<Object*>::iterator it = c->m_params.begin();
Operator o(c->firstOperator());
for(; it!=c->m_params.end(); ++it) {
Object *o2=*it;
QPair<double, Object*> imono;
bool ismono=false;
if(o2->type() == Object::container) {
Container *cx = (Container*) o2;
if(cx->firstOperator()==Operator::multiplicityOperator(o.operatorType()) && cx->m_params.count()==3) {
bool valid=false;
int scalar=-1, var=-1;
if(cx->m_params[1]->type()==Object::value) {
scalar=1;
var=2;
valid=true;
} else if(cx->m_params[2]->type()==Object::value) {
scalar=2;
var=1;
valid=true;
}
if(valid) {
Cn* sc= (Cn*) cx->m_params[scalar];
imono.first = sc->value();
imono.second = cx->m_params[var];
ismono = true;
}
}
}
if(!ismono) {
imono.first = 1;
imono.second = Expression::objectCopy(o2);
}
bool found = false;
QList<QPair<double, Object*> >::iterator it1 = monos.begin();
for(; it1!=monos.end(); ++it1) {
Object *o1=it1->second, *o2=imono.second;
if(o2->type()!=Object::oper && Container::equalTree(o1, o2)) {
found = true;
break;
}
}
if(found)
it1->first += imono.first;
else {
imono.second = Expression::objectCopy(imono.second);
monos.append(imono);
}
}
qDeleteAll(c->m_params);
c->m_params.clear();
if(o.operatorType()==Operator::plus) {
QList<QPair<double, Object*> >::iterator it = monos.begin();
for(;it!=monos.end();++it) {
if(it->first==1) {
c->m_params.append(it->second);
} else {
Container *cint = new Container(Container::apply);
cint->m_params.append(new Operator(Operator::times));
cint->m_params.append(new Cn(it->first));
cint->m_params.append(it->second);
c->m_params.append(cint);
}
}
} else if(o.operatorType()==Operator::times) {
QList<QPair<double, Object*> >::iterator it = monos.begin();
for(;it!=monos.end();++it) {
if(it->first==1) {
c->m_params.append(it->second);
} else {
Container *cint = new Container(Container::apply);
cint->m_params.append(new Operator(Operator::power));
cint->m_params.append(it->second);
cint->m_params.append(new Cn(it->first));
c->m_params.append(cint);
}
}
} else
qDebug() << "wooooo, not implemented";
}
void test_sequence ( Container const &c ) {
typedef typename Container::value_type value_type;
std::vector<value_type> v;
// Copy zero elements
v.clear ();
ba::copy_n ( c.begin (), 0, back_inserter ( v ));
BOOST_CHECK ( v.size () == 0 );
ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
BOOST_CHECK ( v.size () == 0 );
if ( c.size () > 0 ) {
// Just one element
v.clear ();
ba::copy_n ( c.begin (), 1, back_inserter ( v ));
BOOST_CHECK ( v.size () == 1 );
BOOST_CHECK ( v[0] == *c.begin ());
v.clear ();
ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
BOOST_CHECK ( v.size () == 1 );
BOOST_CHECK ( v[0] == *c.begin ());
// Half the elements
v.clear ();
ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size () / 2);
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
// Half the elements + 1
v.clear ();
ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
// All the elements
v.clear ();
ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size ());
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
}
}
void *MsgEdit::processEvent(Event *e)
{
if (e->type() == EventMessageReceived){
Message *msg = (Message*)(e->param());
if ((msg->contact() == m_userWnd->id()) && (msg->type() != MessageStatus)){
if (CorePlugin::m_plugin->getContainerMode()){
bool bSetFocus = false;
if (topLevelWidget() && topLevelWidget()->inherits("Container")){
Container *container = static_cast<Container*>(topLevelWidget());
if (container->wnd() == m_userWnd)
bSetFocus = true;
}
setMessage(msg, bSetFocus);
}else{
if (m_edit->isReadOnly())
QTimer::singleShot(0, this, SLOT(setupNext()));
}
}
}
if (e->type() == EventRealSendMessage){
MsgSend *s = (MsgSend*)(e->param());
if (s->edit == this){
sendMessage(s->msg);
return e->param();
}
}
if (e->type() == EventCheckState){
CommandDef *cmd = (CommandDef*)(e->param());
if ((cmd->menu_id != MenuTextEdit) || (cmd->param != this))
return NULL;
cmd->flags &= ~(COMMAND_CHECKED | COMMAND_DISABLED);
switch (cmd->id){
case CmdUndo:
if (m_edit->isReadOnly())
return NULL;
if (!m_edit->isUndoAvailable())
cmd->flags |= COMMAND_DISABLED;
return e->param();
case CmdRedo:
if (m_edit->isReadOnly())
return NULL;
if (!m_edit->isRedoAvailable())
cmd->flags |= COMMAND_DISABLED;
return e->param();
case CmdCut:
if (m_edit->isReadOnly())
return NULL;
case CmdCopy:
if (!m_edit->hasSelectedText())
cmd->flags |= COMMAND_DISABLED;
return e->param();
case CmdPaste:
if (m_edit->isReadOnly())
return NULL;
if (QApplication::clipboard()->text().isEmpty())
cmd->flags |= COMMAND_DISABLED;
return e->param();
case CmdClear:
if (m_edit->isReadOnly())
return NULL;
case CmdSelectAll:
if (m_edit->text().isEmpty())
cmd->flags |= COMMAND_DISABLED;
return e->param();
}
return NULL;
}
if (e->type() == EventCommandExec){
CommandDef *cmd = (CommandDef*)(e->param());
if ((cmd->id == CmdSmile) && (cmd->param == this)){
Event eBtn(EventCommandWidget, cmd);
QToolButton *btnSmile = (QToolButton*)(eBtn.process());
if (btnSmile){
SmilePopup *popup = new SmilePopup(this);
connect(popup, SIGNAL(insert(int)), this, SLOT(insertSmile(int)));
QPoint p = CToolButton::popupPos(btnSmile, popup);
popup->move(p);
popup->show();
}
return e->param();
}
static double math_model_Pup(double variable, Container<double> in_list) {
double result=variable;
result = ((*(in_list.getNextItem()))*((*(in_list.getNextItem()))+(*(in_list.getNextItem()))))*9.999999999999998E-4;
return result;
};
