LLCurlRequest::~LLCurlRequest()
{
for_each(mMultiSet.begin(), mMultiSet.end(), DeletePointer());
}
inline DstIterator assign_pixels(SrcIterator src,SrcIterator src_end,DstIterator dst) {
for_each(src,src_end,dst,pixel_assigns_t<typename pixel_proxy<typename std::iterator_traits<SrcIterator>::value_type>::type,
typename pixel_proxy<typename std::iterator_traits<DstIterator>::value_type>::type>());
return dst+(src_end-src);
}
int
main(int argc, const char** argv){
ndb_init();
int help = 0;
const char *cmd=0, *name=0, *group=0, *owner=0;
int list = 0, start = 0, stop = 0, rm = 0;
struct getargs args[] = {
{ "cmd", 'c', arg_string, &cmd, "command", "command to run (default ls)" }
,{ "name", 'n', arg_string, &name,
"apply command for all processes with name" }
,{ "group", 'g', arg_string, &group,
"apply command for all processes in group" }
,{ "owner", 'g', arg_string, &owner,
"apply command for all processes with owner" }
,{ "long", 'l', arg_flag, &g_settings.m_longl, "long", "long listing"}
,{ "usage", '?', arg_flag, &help, "Print help", "" }
,{ "ls", 0, arg_flag, &list, "-c list", "list process(es)" }
,{ "start", 0, arg_flag, &start, "-c start", "start process(es)" }
,{ "stop", 0, arg_flag, &stop, "-c stop", "stop process(es)" }
,{ "rm", 0, arg_flag, &rm, "-c rm", "undefine process(es)" }
};
const int num_args = 10;
int i;
int optind = 0;
char desc[] = "[host:[port]]\n";
if(getarg(args, num_args, argc, argv, &optind) || help) {
arg_printusage(args, num_args, argv[0], desc);
return 1;
}
if(list + start + stop + rm > 1){
ndbout_c("Can only specify one command");
arg_printusage(args, num_args, argv[0], desc);
return 1;
}
if(list) cmd = "list";
if(start) cmd = "start";
if(stop) cmd = "stop";
if(rm) cmd = "rm";
if(!cmd) cmd = "list";
Expression * m_expr = 0;
for(i = optind; i<argc; i++){
add_host(g_hosts, argv[i]);
}
OrExpr * orE = new OrExpr(new Operate(cmd, g_settings), true);
m_expr = orE;
for(i = optind; i<argc; i++){
BaseString tmp(argv[i]);
Vector<BaseString> split;
tmp.split(split, ":");
if(split.size() > 2){
Uint32 id = atoi(split[2].c_str());
orE->push_back(new ProcEQ(g_hosts[i-optind], id));
}
}
if(g_hosts.size() == 0){
char buf[1024];
if(NdbEnv_GetEnv(ENV_HOSTS, buf, sizeof(buf))){
add_hosts(g_hosts, BaseString(buf));
}
}
if(g_hosts.size() == 0){
g_hosts.push_back(new SimpleCpcClient("localhost", g_settings.m_port));
}
if(group != 0){
Expression * tmp = new FieldEQ("group", group);
m_expr = new Match(* tmp, * m_expr);
}
if(name != 0){
Expression * tmp = new FieldEQ("name", name);
m_expr = new Match(* tmp, * m_expr);
}
if(owner != 0){
Expression * tmp = new FieldEQ("owner", owner);
m_expr = new Match(* tmp, * m_expr);
}
connect(g_hosts);
for_each(g_hosts, * m_expr);
return 0;
}
~Settings()
{
for_each(recorders.begin(), recorders.end(),
DeletePointer());
}
void RenderBucket::CollectOverlayHandles(RefPointer<OverlayTree> tree)
{
for_each(m_overlay.begin(), m_overlay.end(), bind(&OverlayTree::Add, tree.GetRaw(),
bind(&MasterPointer<OverlayHandle>::GetRefPointer, _1)));
}
void replace_ver_info(const wstring& pe_path, const SfxVersionInfo& ver_info) {
// numeric version
list<wstring> ver_parts = split(ver_info.version, L'.');
DWORD ver_hi = 0, ver_lo = 0;
list<wstring>::const_iterator ver_part = ver_parts.cbegin();
if (ver_part != ver_parts.end()) {
ver_hi |= (str_to_int(*ver_part) & 0xFFFF) << 16;
ver_part++;
}
if (ver_part != ver_parts.end()) {
ver_hi |= str_to_int(*ver_part) & 0xFFFF;
ver_part++;
}
if (ver_part != ver_parts.end()) {
ver_lo |= (str_to_int(*ver_part) & 0xFFFF) << 16;
ver_part++;
}
if (ver_part != ver_parts.end()) {
ver_lo |= str_to_int(*ver_part) & 0xFFFF;
ver_part++;
}
// existing version info list
list<IdLang> vi_list;
RsrcModule module(pe_path);
list<RsrcId> ids = enum_rsrc_names(module.handle(), RT_VERSION);
for_each(ids.begin(), ids.end(), [&] (const RsrcId& id) {
list<WORD> lang_ids = enum_rsrc_langs(module.handle(), RT_VERSION, id);
for_each(lang_ids.begin(), lang_ids.end(), [&] (WORD lang_id) {
IdLang id_lang;
id_lang.id = id;
id_lang.lang_id = lang_id;
vi_list.push_back(id_lang);
});
});
module.close();
WORD lang_id;
RsrcId ver_id;
if (vi_list.empty()) {
ver_id = MAKEINTRESOURCE(1);
lang_id = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
}
else {
ver_id = vi_list.front().id;
lang_id = vi_list.front().lang_id;
}
// encode version info
VersionEncoder e;
e.reserve(4096);
size_t vs_versioninfo_pos = e.size();
e.encode_WORD(0); // VS_VERSIONINFO
e.encode_WORD(sizeof(VS_FIXEDFILEINFO));
e.encode_WORD(0);
e.encode_string(L"VS_VERSION_INFO");
e.pad();
e.encode_DWORD(0xFEEF04BD); // VS_FIXEDFILEINFO
e.encode_DWORD(0x00010000);
e.encode_DWORD(ver_hi);
e.encode_DWORD(ver_lo);
e.encode_DWORD(ver_hi);
e.encode_DWORD(ver_lo);
e.encode_DWORD(0x3F);
e.encode_DWORD(0);
e.encode_DWORD(VOS_NT_WINDOWS32);
e.encode_DWORD(VFT_APP);
e.encode_DWORD(0);
e.encode_DWORD(0);
e.encode_DWORD(0);
e.pad();
size_t string_file_info_pos = e.size();
e.encode_WORD(0); // StringFileInfo
e.encode_WORD(0);
e.encode_WORD(1);
e.encode_string(L"StringFileInfo");
e.pad();
size_t string_table_pos = e.size();
e.encode_WORD(0); // StringTable
e.encode_WORD(0);
e.encode_WORD(1);
wostringstream st;
st << hex << setw(4) << setfill(L'0') << lang_id << L"04b0";
e.encode_string(st.str());
e.pad();
map<wstring, wstring> strings;
strings[L"Comments"] = ver_info.comments;
strings[L"CompanyName"] = ver_info.company_name;
strings[L"FileDescription"] = ver_info.file_description;
strings[L"FileVersion"] = ver_info.version;
strings[L"LegalCopyright"] = ver_info.legal_copyright;
strings[L"ProductName"] = ver_info.product_name;
strings[L"ProductVersion"] = ver_info.version;
for_each(strings.cbegin(), strings.cend(), [&] (const pair<wstring, wstring>& str) {
size_t string_pos = e.size();
e.encode_WORD(0); // String
e.encode_WORD(str.second.size() + 1);
e.encode_WORD(1);
e.encode_string(str.first);
e.pad();
e.encode_string(str.second);
e.pad();
e.update_length(string_pos);
});
e.update_length(string_table_pos);
e.update_length(string_file_info_pos);
size_t var_file_info_pos = e.size();
e.encode_WORD(0); // VarFileInfo
e.encode_WORD(0);
e.encode_WORD(1);
e.encode_string(L"VarFileInfo");
e.pad();
size_t var_pos = e.size();
e.encode_WORD(0); // Var
e.encode_WORD(4);
e.encode_WORD(0);
e.encode_string(L"Translation");
e.pad();
e.encode_WORD(lang_id);
e.encode_WORD(0x04B0);
e.update_length(var_pos);
e.update_length(var_file_info_pos);
e.update_length(vs_versioninfo_pos);
// wrire resource
ResourceUpdate rupdate(pe_path);
for_each(vi_list.cbegin(), vi_list.cend(), [&] (const IdLang& id_lang) {
rupdate.update(RT_VERSION, id_lang.id, id_lang.lang_id, nullptr, 0);
});
rupdate.update(RT_VERSION, ver_id, lang_id, e.data(), e.size());
rupdate.finalize();
}
void pre(std::ostream& out, Actions& actions)
{
// The quickbook file has been parsed. Now, it's time to
// generate the output. Here's what we'll do *before* anything else.
if (actions.doc_id.empty())
actions.doc_id = detail::make_identifier(
actions.doc_title.begin(),actions.doc_title.end());
if (actions.doc_dirname.empty())
actions.doc_dirname = actions.doc_id;
if (actions.doc_last_revision.empty())
{
// default value for last-revision is now
char strdate[ 30 ];
time_t t = time(0);
strftime(
strdate, sizeof(strdate),
"$" /* prevent CVS substitution */ "Date: %Y/%m/%d %H:%M:%S $",
gmtime(&t)
);
actions.doc_last_revision = strdate;
}
out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
<< "<!DOCTYPE library PUBLIC \"-//Boost//DTD BoostBook XML V1.0//EN\"\n"
<< " \"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd\">\n"
<< '<' << actions.doc_type << "\n"
<< " id=\"" << actions.doc_id << "\"\n"
<< " name=\"" << actions.doc_title << "\"\n"
<< " dirname=\"" << actions.doc_dirname << "\"\n"
<< " last-revision=\"" << actions.doc_last_revision << "\" \n"
<< " xmlns:xi=\"http://www.w3.org/2001/XInclude\">\n"
<< " <" << actions.doc_type << "info>\n";
for_each(
actions.doc_authors.begin()
, actions.doc_authors.end()
, xml_author(out));
if (!actions.doc_copyright_holder.empty())
{
out << "\n" << " <copyright>\n";
for_each(
actions.doc_copyright_years.begin()
, actions.doc_copyright_years.end()
, xml_year(out));
out << " <holder>" << actions.doc_copyright_holder << "</holder>\n"
<< " </copyright>\n"
<< "\n"
;
}
if (!actions.doc_license.empty())
{
out << " <legalnotice>\n"
<< " <para>\n"
<< " " << actions.doc_license << "\n"
<< " </para>\n"
<< " </legalnotice>\n"
<< "\n"
;
}
if (!actions.doc_purpose.empty())
{
out << " <" << actions.doc_type << "purpose>\n"
<< " " << actions.doc_purpose
<< " </" << actions.doc_type << "purpose>\n"
<< "\n"
;
}
if (!actions.doc_purpose.empty())
{
out << " <" << actions.doc_type << "category name=\"category:"
<< actions.doc_category
<< "\"></" << actions.doc_type << "category>\n"
<< "\n"
;
}
out << " </" << actions.doc_type << "info>\n"
<< "\n"
;
if (!actions.doc_title.empty())
{
out << " <title>" << actions.doc_title;
if (!actions.doc_version.empty())
out << ' ' << actions.doc_version;
out << "</title>\n\n\n";
}
}
//-------------------------------------------------------------------------------------------------
RegionManager::~RegionManager()
{
for_each (_regions.begin(), _regions.end(), free_ptr<Delete2ndPairObject<> >());
}
LLDXDevice::~LLDXDevice()
{
for_each(mDriverFiles.begin(), mDriverFiles.end(), DeletePairedPointer());
}
void CFileSet::clear_index()
{
for_each(m_word_index.begin(), m_word_index.end(), std::mem_fun_ref(&WordIndexItem::dec));
m_word_index.clear();
}
void ForEachMapping(TFunctor toDo)
{
for_each(m_mapping.begin(), m_mapping.end(), toDo);
}
~Session_impl()
{
for_each(listeners.begin(), listeners.end(), sendMessage);
}
void Container::Update() {
//Update Components
for_each(components.begin(), components.end(), [](shared_ptr<Component> & c) { c->Update(); });
}
void createCDF ()
{
std::cout << "==> create CDF" << std::endl;
std::vector<std::string> inputNames = {"training"};
for (auto inputName : inputNames)
{
std::stringstream outfilename;
outfilename << inputName << "_cdf__" << inputName << ".root";
std::cout << outfilename.str () << std::endl;
/* return; */
std::stringstream infilename;
infilename << pathToData.Data () << inputName << ".root";
TFile *input(0);
std::cout << "infilename = " << infilename.str ().c_str () << std::endl;
input = TFile::Open (infilename.str ().c_str ());
TTree* tree = (TTree*)input->Get("data");
// variables for prediction
std::cout << "prepare variables" << std::endl;
auto localVariableNames = variableNames+additionalVariableNames;
std::vector<Float_t> variables (localVariableNames.size ());
auto itVar = begin (variables);
for (auto inputName : localVariableNames)
{
Float_t* pVar = &(*itVar);
tree->SetBranchAddress(inputName.c_str(), pVar);
++itVar;
}
Int_t id;
// id field
tree->SetBranchAddress("id", &id);
Long64_t ievtEnd = tree->GetEntries ();
ievtEnd = 100;
std::cout << "process entries #" << ievtEnd << std::endl;
std::vector<double> sumSmaller (ievtEnd, 0.0);
struct Vars
{
typedef std::vector<Float_t>::const_iterator iterator;
Vars (iterator itBegin, iterator itEnd, Float_t _weight, Int_t _id, Long64_t _order)
: variables (itBegin, itEnd)
, weight (_weight)
, id (_id)
, order (_order)
{
}
std::vector<Float_t> variables;
Int_t id;
Float_t weight;
Float_t cdf;
Long64_t order;
bool operator< (const Vars& other) const
{
for (auto itOther = begin (other.variables), it = begin (variables),
itOtherEnd = end (other.variables), itEnd = end (variables);
it != itEnd && itOther != itOtherEnd; ++itOther, ++it)
{
//std::cout << "(" << *it << "," << *itOther << ")" << std::flush;
if (*it >= *itOther)
{
// std::cout << "X" << std::flush;
return false;
}
else
std::cout << "D" << std::flush;
}
std::cout << "U" << std::flush;
return true;
}
};
Float_t weightSum (0.0);
std::vector<Vars> vars;
for (Long64_t ievt=0; ievt < ievtEnd; ievt++)
{
tree->GetEntry (ievt);
std::cout << "." << std::flush;
Float_t weight = 1.0;
vars.emplace_back (begin (variables), end (variables), weight, id, ievt);
weightSum += weight;
}
std::cout << "provide values" << std::endl;
for (auto it = begin (vars), itEnd = end (vars); it != itEnd; ++it)
{
std::cout << "-" << std::flush;
for (auto itCmp = begin (vars), itCmpEnd = end (vars); itCmp != itCmpEnd; ++itCmp)
{
if (*it < *itCmp)
{
std::cout << "!" << std::flush;
break;
}
else
{
std::cout << "+" << std::flush;
(*it).cdf += (*itCmp).weight;
}
}
}
std::cout << "normalize" << std::endl;
for_each (begin (vars), end (vars), [weightSum](Vars& v) {
v.cdf /= weightSum;
});
// sort by order
std::sort (begin (vars), end (vars), [](const Vars& lhs, const Vars& rhs){
return lhs.order < rhs.order;
});
input->Close();
std::cout << "store data" << std::endl;
TFile* outFile = new TFile (outfilename.str ().c_str (), "RECREATE");
TTree* outTree = new TTree("cdf_raw","cdf_raw");
Float_t cdf (0.0);
outTree->Branch ("id", &id, "F");
outTree->Branch ("cdf", &cdf, "F");
for (auto v : vars)
{
id = v.id;
cdf = v.cdf;
outTree->Fill ();
}
outFile->Write ();
outFile->Close ();
}
}
void LLTextureView::draw()
{
if (!mFreezeView)
{
// LLViewerObject *objectp;
// S32 te;
for_each(mTextureBars.begin(), mTextureBars.end(), DeletePointer());
mTextureBars.clear();
delete mGLTexMemBar;
mGLTexMemBar = 0;
typedef std::multiset<decode_pair_t, compare_decode_pair > display_list_t;
display_list_t display_image_list;
if (mPrintList)
{
llinfos << "ID\tMEM\tBOOST\tPRI\tWIDTH\tHEIGHT\tDISCARD" << llendl;
}
for (LLViewerImageList::image_priority_list_t::iterator iter = gImageList.mImageList.begin();
iter != gImageList.mImageList.end(); )
{
LLPointer<LLViewerImage> imagep = *iter++;
S32 cur_discard = imagep->getDiscardLevel();
S32 desired_discard = imagep->mDesiredDiscardLevel;
if (mPrintList)
{
llinfos << imagep->getID()
<< "\t" << imagep->mTextureMemory
<< "\t" << imagep->getBoostLevel()
<< "\t" << imagep->getDecodePriority()
<< "\t" << imagep->getWidth()
<< "\t" << imagep->getHeight()
<< "\t" << cur_discard
<< llendl;
}
#if 0
if (imagep->getDontDiscard())
{
continue;
}
if (imagep->isMissingAsset())
{
continue;
}
#endif
#define HIGH_PRIORITY 100000000.f
F32 pri;
if (mOrderFetch)
{
pri = ((F32)imagep->mFetchPriority)/256.f;
}
else
{
pri = imagep->getDecodePriority();
}
pri = llclamp(pri, 0.0f, HIGH_PRIORITY-1.f);
if (sDebugImages.find(imagep) != sDebugImages.end())
{
pri += 4*HIGH_PRIORITY;
}
if (!mOrderFetch)
{
#if 1
if (pri < HIGH_PRIORITY && LLSelectMgr::getInstance())
{
struct f : public LLSelectedTEFunctor
{
LLViewerImage* mImage;
f(LLViewerImage* image) : mImage(image) {}
virtual bool apply(LLViewerObject* object, S32 te)
{
return (mImage == object->getTEImage(te));
}
} func(imagep);
const bool firstonly = true;
bool match = LLSelectMgr::getInstance()->getSelection()->applyToTEs(&func, firstonly);
if (match)
{
pri += 3*HIGH_PRIORITY;
}
}
#endif
#if 1
if (pri < HIGH_PRIORITY && (cur_discard< 0 || desired_discard < cur_discard))
{
LLViewerObject *objectp = gHoverView->getLastHoverObject();
if (objectp)
{
S32 tex_count = objectp->getNumTEs();
for (S32 i = 0; i < tex_count; i++)
{
if (imagep == objectp->getTEImage(i))
{
pri += 2*HIGH_PRIORITY;
break;
}
}
}
}
#endif
#if 1
if (pri > 0.f && pri < HIGH_PRIORITY)
{
if (imagep->mLastPacketTimer.getElapsedTimeF32() < 1.f ||
imagep->mFetchDeltaTime < 0.25f)
{
pri += 1*HIGH_PRIORITY;
}
}
#endif
}
if (pri > 0.0f)
{
display_image_list.insert(std::make_pair(pri, imagep));
}
}
if (mPrintList)
{
mPrintList = FALSE;
}
static S32 max_count = 50;
S32 count = 0;
for (display_list_t::iterator iter = display_image_list.begin();
iter != display_image_list.end(); iter++)
{
LLViewerImage* imagep = iter->second;
S32 hilite = 0;
F32 pri = iter->first;
if (pri >= 1 * HIGH_PRIORITY)
{
hilite = (S32)((pri+1) / HIGH_PRIORITY) - 1;
}
if ((hilite || count < max_count-10) && (count < max_count))
{
if (addBar(imagep, hilite))
{
count++;
}
}
}
if (mOrderFetch)
sortChildren(LLTextureBar::sort_fetch());
else
sortChildren(LLTextureBar::sort());
mGLTexMemBar = new LLGLTexMemBar("gl texmem bar", this);
addChild(mGLTexMemBar);
reshape(getRect().getWidth(), getRect().getHeight(), TRUE);
/*
count = gImageList.getNumImages();
std::string info_string;
info_string = llformat("Global Info:\nTexture Count: %d", count);
mInfoTextp->setText(info_string);
*/
for (child_list_const_iter_t child_iter = getChildList()->begin();
child_iter != getChildList()->end(); ++child_iter)
{
LLView *viewp = *child_iter;
if (viewp->getRect().mBottom < 0)
{
viewp->setVisible(FALSE);
}
}
}
LLContainerView::draw();
}
WordMultiSet::WordMultiSet( std::istream & an_input_stream )
{
std::istream_iterator<std::string> start(an_input_stream), finish;
*this = for_each(start, finish, *this);
}
void replace_icon(const wstring& pe_path, const wstring& ico_path) {
list<IconRsrc> icons;
RsrcModule module(pe_path);
list<RsrcId> group_ids = enum_rsrc_names(module.handle(), RT_GROUP_ICON);
for_each(group_ids.cbegin(), group_ids.cend(), [&] (const RsrcId& id) {
list<WORD> lang_ids = enum_rsrc_langs(module.handle(), RT_GROUP_ICON, id);
for_each(lang_ids.cbegin(), lang_ids.cend(), [&] (WORD lang_id) {
icons.push_back(load_icon_rsrc(module.handle(), id, lang_id));
});
});
module.close();
ResourceUpdate rupdate(pe_path);
// delete existing icons
for_each(icons.cbegin(), icons.cend(), [&] (const IconRsrc& icon) {
for_each (icon.images.cbegin(), icon.images.cend(), [&] (const IconImageRsrc& image) {
rupdate.update(RT_ICON, MAKEINTRESOURCE(image.id), image.lang_id, nullptr, 0);
});
rupdate.update(RT_GROUP_ICON, icon.id, icon.lang_id, nullptr, 0);
});
WORD lang_id;
if (!icons.empty())
lang_id = icons.front().lang_id;
else
lang_id = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
IconFile icon_file = load_icon_file(ico_path);
IconRsrc icon_rsrc;
icon_rsrc.lang_id = lang_id;
for_each(icon_file.cbegin(), icon_file.cend(), [&] (const IconImage& image) {
IconImageRsrc image_rsrc;
image_rsrc.lang_id = lang_id;
image_rsrc.image = image;
icon_rsrc.images.push_back(image_rsrc);
});
// drop first icon (all languages)
if (!icons.empty()) {
RsrcId id = icons.front().id;
while (!icons.empty() && icons.front().id == id)
icons.pop_front();
}
icons.push_front(icon_rsrc);
// renumber resource ids
WORD icon_id = 1;
WORD image_id = 1;
for_each(icons.begin(), icons.end(), [&] (IconRsrc& icon) {
if (icon.id.is_int()) {
icon.id = MAKEINTRESOURCE(icon_id);
icon_id++;
}
for_each(icon.images.begin(), icon.images.end(), [&] (IconImageRsrc& image) {
image.id = image_id;
image_id++;
});
});
// write new icons
for_each(icons.cbegin(), icons.cend(), [&] (const IconRsrc& icon) {
Buffer<unsigned char> buf(sizeof(IconGroupHeader) + icon.images.size() * sizeof(IconGroupEntry));
IconGroupHeader* header = reinterpret_cast<IconGroupHeader*>(buf.data());
header->reserved = 0;
header->type = 1;
header->count = icon.images.size();
unsigned offset = sizeof(IconGroupHeader);
for_each (icon.images.cbegin(), icon.images.cend(), [&] (const IconImageRsrc& image) {
IconGroupEntry* entry = reinterpret_cast<IconGroupEntry*>(buf.data() + offset);
entry->width = image.image.width;
entry->height = image.image.height;
entry->color_cnt = image.image.color_cnt;
entry->reserved = 0;
entry->plane_cnt = image.image.plane_cnt;
entry->bit_cnt = image.image.bit_cnt;
entry->size = image.image.bitmap.size();
entry->id = image.id;
rupdate.update(RT_ICON, MAKEINTRESOURCE(image.id), image.lang_id, image.image.bitmap.data(), image.image.bitmap.size());
offset += sizeof(IconGroupEntry);
});
rupdate.update(RT_GROUP_ICON, icon.id, icon.lang_id, buf.data(), buf.size());
});
rupdate.finalize();
}
PartialPolicyExecutor::~PartialPolicyExecutor() {
delete active;
for_each(actionMap.begin(),actionMap.end(),ActionMapDelete());
delete policy;
}
void LLTextureView::draw()
{
if (!mFreezeView)
{
// LLViewerObject *objectp;
// S32 te;
for_each(mTextureBars.begin(), mTextureBars.end(), KillView());
mTextureBars.clear();
if (mGLTexMemBar)
{
removeChild(mGLTexMemBar);
mGLTexMemBar->die();
mGLTexMemBar = 0;
}
if (mAvatarTexBar)
{
removeChild(mAvatarTexBar);
mAvatarTexBar->die();
mAvatarTexBar = 0;
}
typedef std::multiset<decode_pair_t, compare_decode_pair > display_list_t;
display_list_t display_image_list;
if (mPrintList)
{
llinfos << "ID\tMEM\tBOOST\tPRI\tWIDTH\tHEIGHT\tDISCARD" << llendl;
}
for (LLViewerTextureList::image_priority_list_t::iterator iter = gTextureList.mImageList.begin();
iter != gTextureList.mImageList.end(); )
{
LLPointer<LLViewerFetchedTexture> imagep = *iter++;
if(!imagep->hasFetcher())
{
continue ;
}
S32 cur_discard = imagep->getDiscardLevel();
S32 desired_discard = imagep->mDesiredDiscardLevel;
if (mPrintList)
{
S32 tex_mem = imagep->hasGLTexture() ? imagep->getTextureMemory() : 0 ;
llinfos << imagep->getID()
<< "\t" << tex_mem
<< "\t" << imagep->getBoostLevel()
<< "\t" << imagep->getDecodePriority()
<< "\t" << imagep->getWidth()
<< "\t" << imagep->getHeight()
<< "\t" << cur_discard
<< llendl;
}
if (imagep->getID() == LLAppViewer::getTextureFetch()->mDebugID)
{
static S32 debug_count = 0;
++debug_count; // for breakpoints
}
F32 pri;
if (mOrderFetch)
{
pri = ((F32)imagep->mFetchPriority)/256.f;
}
else
{
pri = imagep->getDecodePriority();
}
pri = llclamp(pri, 0.0f, HIGH_PRIORITY-1.f);
if (sDebugImages.find(imagep) != sDebugImages.end())
{
pri += 4*HIGH_PRIORITY;
}
if (!mOrderFetch)
{
if (pri < HIGH_PRIORITY && LLSelectMgr::getInstance())
{
struct f : public LLSelectedTEFunctor
{
LLViewerFetchedTexture* mImage;
f(LLViewerFetchedTexture* image) : mImage(image) {}
virtual bool apply(LLViewerObject* object, S32 te)
{
return (mImage == object->getTEImage(te));
}
} func(imagep);
const bool firstonly = true;
bool match = LLSelectMgr::getInstance()->getSelection()->applyToTEs(&func, firstonly);
if (match)
{
pri += 3*HIGH_PRIORITY;
}
}
if (pri < HIGH_PRIORITY && (cur_discard< 0 || desired_discard < cur_discard))
{
LLSelectNode* hover_node = LLSelectMgr::instance().getHoverNode();
if (hover_node)
{
LLViewerObject *objectp = hover_node->getObject();
if (objectp)
{
S32 tex_count = objectp->getNumTEs();
for (S32 i = 0; i < tex_count; i++)
{
if (imagep == objectp->getTEImage(i))
{
pri += 2*HIGH_PRIORITY;
break;
}
}
}
}
}
if (pri > 0.f && pri < HIGH_PRIORITY)
{
if (imagep->mLastPacketTimer.getElapsedTimeF32() < 1.f ||
imagep->mFetchDeltaTime < 0.25f)
{
pri += 1*HIGH_PRIORITY;
}
}
}
if (pri > 0.0f)
{
display_image_list.insert(std::make_pair(pri, imagep));
}
}
if (mPrintList)
{
mPrintList = FALSE;
}
static S32 max_count = 50;
S32 count = 0;
mNumTextureBars = 0 ;
for (display_list_t::iterator iter = display_image_list.begin();
iter != display_image_list.end(); iter++)
{
LLViewerFetchedTexture* imagep = iter->second;
S32 hilite = 0;
F32 pri = iter->first;
if (pri >= 1 * HIGH_PRIORITY)
{
hilite = (S32)((pri+1) / HIGH_PRIORITY) - 1;
}
if ((hilite || count < max_count-10) && (count < max_count))
{
if (addBar(imagep, hilite))
{
count++;
}
}
}
if (mOrderFetch)
sortChildren(LLTextureBar::sort_fetch());
else
sortChildren(LLTextureBar::sort());
LLGLTexMemBar::Params tmbp;
LLRect tmbr;
tmbp.name("gl texmem bar");
tmbp.rect(tmbr);
tmbp.follows.flags = FOLLOWS_LEFT|FOLLOWS_TOP;
tmbp.texture_view(this);
mGLTexMemBar = LLUICtrlFactory::create<LLGLTexMemBar>(tmbp);
addChild(mGLTexMemBar);
sendChildToFront(mGLTexMemBar);
LLAvatarTexBar::Params atbp;
LLRect atbr;
atbp.name("gl avatartex bar");
atbp.texture_view(this);
atbp.rect(atbr);
mAvatarTexBar = LLUICtrlFactory::create<LLAvatarTexBar>(atbp);
addChild(mAvatarTexBar);
sendChildToFront(mAvatarTexBar);
reshape(getRect().getWidth(), getRect().getHeight(), TRUE);
LLUI::popMatrix();
LLUI::pushMatrix();
LLUI::translate((F32)getRect().mLeft, (F32)getRect().mBottom);
for (child_list_const_iter_t child_iter = getChildList()->begin();
child_iter != getChildList()->end(); ++child_iter)
{
LLView *viewp = *child_iter;
if (viewp->getRect().mBottom < 0)
{
viewp->setVisible(FALSE);
}
}
}
LLContainerView::draw();
}
map<set<ushort>, map<Event, string>> loadKeybindings(string strFile) {
jxx::Array arr;
map<set<ushort>, map<Event, string>> mapKeybindings;
stringstream ssContent;
ifstream is(strFile);
bool bValidJson;
ssContent << is.rdbuf();
bValidJson = arr.parse(ssContent.str());
fatal_error(!bValidJson, "invalid json");
for(int i = 0, nLen = arr.size();
i < nLen;
i++) {
if(arr.has<jxx::Object>(i)) {
map<string, jxx::Value*> mapKV = arr.get<jxx::Object>(i).kv_map();
set<ushort> setKeys;
map<Event, string> mapEvents;
if(mapKV.find(JXX_KEY_KEYS) == mapKV.end()
|| !mapKV[JXX_KEY_KEYS]->is<jxx::Array>()) {
// always required
cout << "Error["<<i<<":depth 2]: keys missing / wrong type"<<endl;
}
else {
jxx::Array arrKeys = mapKV[JXX_KEY_KEYS]->get<jxx::Array>();
for(int j = 0, nLen2 = arrKeys.size();
j < nLen2;
j++) {
if(arrKeys.has<jxx::Number>(j)) {
setKeys.insert(static_cast<ushort>(arrKeys.get<jxx::Number>(j)));
}
else if(arrKeys.has<string>(j)) {
string strKey = arrKeys.get<string>(j);
KeyCode kc = getKeyCode(strKey);
if(kc == KEY_UNKNOWN) {
cout<< "Error["<<i<<":depth 3]: keys item unknown key "<<strKey<<endl;
}
else {
setKeys.insert(kc);
}
}
else {
cout << "Error["<<i<<":depth 3]: keys item wrong type"<<endl;
}
}
}
for_each(mapKV.begin(), mapKV.end(), [&i, &mapEvents](pair<string, jxx::Value*> pair) {
string strKey = pair.first;
jxx::Value* value = pair.second;
Event event = getEvent(strKey);
if(strKey != JXX_KEY_KEYS) {
if(strKey == JXX_KEY_REPEAT) {
// repeat on long pressing
if(!value->is<bool>()) {
cout << "Error["<<i<<":depth 2]: invalid value "<<strKey<<endl;
}
else if(value->get<bool>()) {
// value doesn't matter
mapEvents[EVENT_PRESS_LONG_REPEAT] = "true";
}
}
else if(event == EVENT_UNKNOWN) {
// spelling mistake?
cout << "Error["<<i<<":depth 2]: unknown event "<<strKey<<endl;
}
else if(contains(mapEvents, event)) {
// duplicated key - event already added
cout << "Error["<<i<<":depth 2]: duplicated event "<<strKey<<endl;
}
else {
if(!value->is<string>()) {
// value != type string -> we expected a command
cout << "Error["<<i<<":depth 2]: invalid value event "<<strKey<<endl;
}
else {
mapEvents[event] = value->get<string>();
}
}
}
});
if(contains(mapEvents, EVENT_PRESS_LONG_REPEAT)
&& !contains(mapEvents, EVENT_PRESS_LONG)
&& contains(mapEvents, EVENT_PRESS)) {
// repeat enabled - no long press command
// -> use press command
mapEvents[EVENT_PRESS_LONG] = mapEvents[EVENT_PRESS];
}
if(!setKeys.empty() && !mapEvents.empty()) {
mapKeybindings[setKeys] = mapEvents;
}
}
else {
cout << "Error[depth 1]: object expected" << endl;
}
}
return mapKeybindings;
}
//解析插件配置文件，下载并装载
BOOL CPluginManager::Update(const string &strPluginDownLoadFile)
{
LOG((LEVEL_FUNC_IN_OUT,"CPluginManager::ProcessConfig\n"));
int ret;
// 创建下载目录
CreateDirectory(m_szPluginDownLoadPath.c_str(),NULL);
m_recycle.Push(m_szPluginDownLoadPath,CTspRecycle::FLAG_DIR);
// 组装插件配置文件文件名
std::string strPluginConfigFile(m_szPluginConfigPath);
strPluginConfigFile += TSP_PLUGIN_S_CONFIG_NAME;
std::string strPluginDownLoadTmpFile;
// 锁住这个链表，由于网络IO是异步，这个操作需要同步
nm_ddc::CLockGuard<nm_ddc::CThreadMutex> guard(&m_lock);
// 读取配置信息到临时链表中
std::list<CPluginInfo> l;
if( !ReadPluginIniFile<CPluginInfo>(l,strPluginDownLoadFile,true) )
{
LOG((LEVEL_WARNNING,"解析插件配置文件失败.%s\n",strPluginDownLoadFile.c_str()));
return FALSE;
}
// 去除不属于此功能管理的插件
ExceptPluginFile(l);
// 新旧链表的迭代器声明
std::list<CPluginInfo>::iterator iterNew=l.begin();
std::list<CPluginInfo>::iterator iterOld;
char md5[33] = {0};
BOOL bRet = FALSE;
// 比较新老列表，确定要下载的项
for(;iterNew!=l.end();++iterNew)
{
// 在老列表中查找
iterOld = find(m_PluginList.begin(),m_PluginList.end(),iterNew->m_strName);
if( iterOld != m_PluginList.end() )
{
// 找到先做一次自我检测，防止配置文件和实体文件不一致导致不更新
bRet = MD5_Caculate_File ( iterOld->m_strFullName.c_str(),md5);
// 比较md5值
if( bRet && strncmp(iterNew->m_md5,iterOld->m_md5,32) == 0 )
{
// 还要看strFullName，如果一样，说明没变化，仅仅复制个标志位，后面交换到老列表中
if( iterOld->m_strFullName == iterNew->m_strFullName &&
iterOld->m_pid == iterNew->m_pid )
{
*iterNew = *iterOld;
LOG((LEVEL_INFO,"(the same dll,don't update) %s : %d\n",iterOld->m_strFullName.c_str(),iterOld->m_status));
// 用初始状态替代运行状态，防止析构时被卸载
if( iterOld->m_status == CPluginInfo::STATUS_RUNNING )
iterOld->m_status = CPluginInfo::STATUS_INIT;
else
{
// 其他状态就卸载再加载吧
LOG((LEVEL_INFO,"插件未变化，但升级中将被卸载:%s,状态:%d.\n",iterOld->m_strFullName.c_str(),iterOld->m_status));
iterOld->RemovePlug();
}
}
else
{
// 直接拷贝到新路径
ret = ComfirmCopyFile(iterOld->m_strFullName.c_str(),iterNew->m_strFullName.c_str());
if( ret != 0 )
{
LOG((LEVEL_ERROR,"拷贝文件出错:(%s==>%s),Lasterror=%d\n",iterOld->m_strFullName.c_str(),iterNew->m_strFullName.c_str(),GetLastError()));
}
iterNew->m_status = CPluginInfo::STATUS_UNLOAD;
// 拷贝过去的插件肯定能启动成功（最少和老插件一样的状态），所以这里把老插件信息完全删除
iterOld->RemovePlug();
}
// 新纪录中已经有了，老记录中删除
m_PluginList.erase(iterOld);
}
else
// 准备下载
iterNew->m_status = CPluginInfo::STATUS_WAITDOWNLOAD;
}
else
// 准备下载
iterNew->m_status = CPluginInfo::STATUS_WAITDOWNLOAD;
}
// 下载
for_each( l.begin(),l.end(),bind2nd(mem_fun_ref(&CPluginInfo::DownloadPlug),m_szPluginDownLoadPath) );
// 根据下载情况，改记录
for( iterNew=l.begin();iterNew!=l.end();++iterNew )
{
// 在老配置中找
iterOld = find(m_PluginList.begin(),m_PluginList.end(),iterNew->m_strName.c_str() );
if( iterNew->m_status == CPluginInfo::STATUS_DOWNLOAD )
{
// 组装下载文件名
strPluginDownLoadTmpFile.assign(m_szPluginDownLoadPath);
strPluginDownLoadTmpFile += iterNew->m_strName;
//先加入回收站
m_recycle.Push(strPluginDownLoadTmpFile);
// 如果找到，停用，删除
if( iterOld != m_PluginList.end() )
{
ret = iterOld->RemovePlug();
if( ret != 0 )
{
LOG((LEVEL_WARNNING,"卸载插件 %s 出错:%d(%x)\n",iterNew->m_strName.c_str()));
}
}
//将插件文件拷贝到目的地
ret = ComfirmCopyFile(strPluginDownLoadTmpFile.c_str(),iterNew->m_strFullName.c_str());
if( ret != 0 )
{
LOG((LEVEL_ERROR,"拷贝文件出错:(%s==>%s),Lasterror=%d\n",strPluginDownLoadTmpFile.c_str(),iterNew->m_strFullName.c_str(),GetLastError()));
}
// 改状态为准备启用
iterNew->m_status = CPluginInfo::STATUS_UNLOAD;
}
else if( iterNew->m_status == CPluginInfo::STATUS_ERROR )
{
// 可能下载失败，也可能以前就失败，不管怎样，都把信息复制过去
if( iterOld != m_PluginList.end() )
*iterNew = *iterOld;
}
//把url删掉，为了不在后面写入配置文件中；写配置文件是个通用的程序
iterNew->m_strURL = "";
}
// 遍历老插件配置文件，如果新配置中没有,删除
for( iterOld=m_PluginList.begin();iterOld!=m_PluginList.end();++iterOld )
{
// 在新配置中找
iterNew = find(l.begin(),l.end(),iterOld->m_strName.c_str() );
// 如果没找到,卸载
if( iterNew == l.end() )
iterOld->RemovePlug();
// l.push_back(*iterOld); //插入
}
// 根据新配置写加密ini文件
if( !WritePluginIniFile(l,strPluginConfigFile,true) )
{
LOG((LEVEL_ERROR,"写配置文件错:%s",strPluginConfigFile.c_str()));
}
// 清理现场
m_recycle.PopAll();
// 清空老列表，为了避免析构时自动卸载插件，这里强制将状态设为删除
for_each( m_PluginList.begin(),m_PluginList.end(),bind2nd(mem_fun_ref(&CPluginInfo::Status),CPluginInfo::STATUS_DELETE) );
m_PluginList.clear();
// 交换新老插件列表
m_PluginList.swap(l);
//把INIT状态的改为RUNNING
LOG((LEVEL_INFO,"m_PluginList.size()=%d.\n",m_PluginList.size()));
for( iterOld=m_PluginList.begin();iterOld!=m_PluginList.end();++iterOld )
{
LOG((LEVEL_INFO,"%s : %d\n",iterOld->m_strFullName.c_str(),iterOld->m_status));
if( iterOld->m_status == CPluginInfo::STATUS_INIT )
iterOld->m_status = CPluginInfo::STATUS_RUNNING;
}
// 启用
StatusAll(CPluginInfo::STATUS_RUNNING);
return TRUE;
}
Visitor::Result AnimateVisitor::processNodeTopDown(simulation::Node* node)
{
//cerr<<"AnimateVisitor::process Node "<<node->getName()<<endl;
if (!node->isActive()) return Visitor::RESULT_PRUNE;
#ifdef SOFA_HAVE_EIGEN2
if (!firstNodeVisited)
{
firstNodeVisited=true;
// core::behavior::BaseAnimationLoop* presenceAnimationManager;
// node->get(presenceAnimationManager, core::objectmodel::BaseContext::SearchDown);
// if (!presenceAnimationManager)
// {
// std::cerr << "AnimateVisitor::processNodeTopDown, ERROR: no BaseAnimationLoop found while searching down from node: " << node->getName() << std::endl;
// }
sofa::core::MechanicalParams mparams(*this->params);
mparams.setDt(dt);
MechanicalResetConstraintVisitor resetConstraint(&mparams);
node->execute(&resetConstraint);
}
#endif
if (dt == 0) setDt(node->getDt());
else node->setDt(dt);
if (node->collisionPipeline != NULL)
{
//ctime_t t0 = begin(node, node->collisionPipeline);
#ifndef SOFA_SMP
{
CollisionBeginEvent evBegin;
PropagateEventVisitor eventPropagation(this->params /* PARAMS FIRST */, &evBegin);
eventPropagation.execute(node);
}
processCollisionPipeline(node, node->collisionPipeline);
{
CollisionEndEvent evEnd;
PropagateEventVisitor eventPropagation(this->params /* PARAMS FIRST */, &evEnd);
eventPropagation.execute(node);
}
#endif
//end(node, node->collisionPipeline, t0);
}
/* if (node->solver != NULL)
{
ctime_t t0 = begin(node, node->solver);
processOdeSolver(node, node->solver);
end(node, node->solver, t0);
return RESULT_PRUNE;
}*/
if (!node->solver.empty() )
{
sofa::helper::AdvancedTimer::StepVar timer("Mechanical",node);
double nextTime = node->getTime() + dt;
{
IntegrateBeginEvent evBegin;
PropagateEventVisitor eventPropagation( this->params /* PARAMS FIRST */, &evBegin);
eventPropagation.execute(node);
}
MechanicalBeginIntegrationVisitor beginVisitor(this->params /* PARAMS FIRST */, dt);
node->execute(&beginVisitor);
sofa::core::MechanicalParams m_mparams(*this->params);
m_mparams.setDt(dt);
#ifdef SOFA_HAVE_EIGEN2
{
unsigned int constraintId=0;
core::ConstraintParams cparams;
//MechanicalAccumulateConstraint(&m_mparams /* PARAMS FIRST */, constraintId, VecCoordId::position()).execute(node);
simulation::MechanicalAccumulateConstraint(&cparams /* PARAMS FIRST */, core::MatrixDerivId::holonomicC(),constraintId).execute(node);
}
#endif
for( unsigned i=0; i<node->solver.size(); i++ )
{
ctime_t t0 = begin(node, node->solver[i]);
//cerr<<"AnimateVisitor::processNodeTpDown solver "<<node->solver[i]->getName()<<endl;
node->solver[i]->solve(params /* PARAMS FIRST */, getDt());
end(node, node->solver[i], t0);
}
MechanicalPropagatePositionAndVelocityVisitor(&m_mparams /* PARAMS FIRST */, nextTime,VecCoordId::position(),VecDerivId::velocity(),
#ifdef SOFA_SUPPORT_MAPPED_MASS
VecDerivId::dx(),
#endif
true).execute( node );
MechanicalEndIntegrationVisitor endVisitor(this->params /* PARAMS FIRST */, dt);
node->execute(&endVisitor);
{
IntegrateEndEvent evBegin;
PropagateEventVisitor eventPropagation(this->params /* PARAMS FIRST */, &evBegin);
eventPropagation.execute(node);
}
return RESULT_PRUNE;
}
/*
if (node->mechanicalModel != NULL)
{
std::cerr << "Graph Error: MechanicalState without solver." << std::endl;
return RESULT_PRUNE;
}
*/
{
// process InteractionForceFields
for_each(this, node, node->interactionForceField, &AnimateVisitor::fwdInteractionForceField);
return RESULT_CONTINUE;
}
}
void RenderBucket::Update(ScreenBase const & modelView)
{
for_each(m_overlay.begin(), m_overlay.end(), bind(&OverlayHandle::Update,
bind(&dp::NonConstGetter<OverlayHandle>, _1),
modelView));
}
ArcAPI::~ArcAPI() {
for_each(arc_libs.begin(), arc_libs.end(), [&] (const ArcLib& arc_lib) {
if (arc_lib.h_module)
FreeLibrary(arc_lib.h_module);
});
}
Cluster::~Cluster()
{
for_each(clusters.begin(), clusters.end(), delete_object());
clusters.clear();
}
void Archive::make_index() {
num_indices = 0;
CHECK_COM(in_arc->GetNumberOfItems(&num_indices));
file_list.clear();
file_list.reserve(num_indices);
struct DirInfo {
UInt32 index;
UInt32 parent;
wstring name;
bool operator<(const DirInfo& dir_info) const {
if (parent == dir_info.parent)
return lstrcmpiW(name.c_str(), dir_info.name.c_str()) < 0;
else
return parent < dir_info.parent;
}
};
typedef set<DirInfo> DirList;
map<UInt32, unsigned> dir_index_map;
DirList dir_list;
DirInfo dir_info;
UInt32 dir_index = 0;
ArcFileInfo file_info;
wstring path;
PropVariant prop;
for (UInt32 i = 0; i < num_indices; i++) {
// is directory?
file_info.is_dir = in_arc->GetProperty(i, kpidIsDir, prop.ref()) == S_OK && prop.is_bool() && prop.get_bool();
// file name
if (in_arc->GetProperty(i, kpidPath, prop.ref()) == S_OK && prop.is_str())
path.assign(prop.get_str());
else
path.assign(get_default_name());
size_t name_end_pos = path.size();
while (name_end_pos && is_slash(path[name_end_pos - 1])) name_end_pos--;
size_t name_pos = name_end_pos;
while (name_pos && !is_slash(path[name_pos - 1])) name_pos--;
file_info.name.assign(path.data() + name_pos, name_end_pos - name_pos);
// split path into individual directories and put them into DirList
dir_info.parent = c_root_index;
size_t begin_pos = 0;
while (begin_pos < name_pos) {
dir_info.index = dir_index;
size_t end_pos = begin_pos;
while (end_pos < name_pos && !is_slash(path[end_pos])) end_pos++;
if (end_pos != begin_pos) {
dir_info.name.assign(path.data() + begin_pos, end_pos - begin_pos);
pair<DirList::iterator, bool> ins_pos = dir_list.insert(dir_info);
if (ins_pos.second)
dir_index++;
dir_info.parent = ins_pos.first->index;
}
begin_pos = end_pos + 1;
}
file_info.parent = dir_info.parent;
if (file_info.is_dir) {
dir_info.index = dir_index;
dir_info.parent = file_info.parent;
dir_info.name = file_info.name;
pair<DirList::iterator, bool> ins_pos = dir_list.insert(dir_info);
if (ins_pos.second) {
dir_index++;
dir_index_map[dir_info.index] = i;
}
else {
if (dir_index_map.count(ins_pos.first->index))
file_info.parent = c_dup_index;
else
dir_index_map[ins_pos.first->index] = i;
}
}
file_list.push_back(file_info);
}
// add directories that not present in archive index
file_list.reserve(file_list.size() + dir_list.size() - dir_index_map.size());
dir_index = num_indices;
for_each(dir_list.begin(), dir_list.end(), [&] (const DirInfo& dir_info) {
if (dir_index_map.count(dir_info.index) == 0) {
dir_index_map[dir_info.index] = dir_index;
file_info.parent = dir_info.parent;
file_info.name = dir_info.name;
file_info.is_dir = true;
dir_index++;
file_list.push_back(file_info);
}
});
// fix parent references
for_each(file_list.begin(), file_list.end(), [&] (ArcFileInfo& file_info) {
if (file_info.parent != c_root_index)
file_info.parent = dir_index_map[file_info.parent];
});
// create search index
file_list_index.clear();
file_list_index.reserve(file_list.size());
for (UInt32 i = 0; i < file_list.size(); i++) {
file_list_index.push_back(i);
}
sort(file_list_index.begin(), file_list_index.end(), [&] (UInt32 left, UInt32 right) -> bool {
return file_list[left] < file_list[right];
});
load_arc_attr();
}
CameraModel::~CameraModel()
{
for_each(cameras.begin(), cameras.end(), Delete());
}
const matrix<std::complex<T>, N> polar( const T nn, const matrix<T,N,A>& mm )
{
matrix<std::complex<T>,N> m( mm.row(), mm.col() );
for_each( mm.begin(), mm.end(), m.begin(), [nn]( const T _mm, std::complex<T>& m ) { m = std::polar(nn, _mm); } );
return m;
}
void MyLib::InitLrcLib()
{
dataPaths.clear();
for_each(lrcDirs.begin(),lrcDirs.end(),&MyLib::ImportLycByPath);
}
// [[Rcpp::export]]
XPtrImage magick_image_edge( XPtrImage input, size_t radius){
XPtrImage output = copy(input);
for_each ( output->begin(), output->end(), Magick::edgeImage(radius));
return output;
}
