void ProgEvaluateClass::run()
{
MetaData MD((String)"classes@"+fnClass), MDclass;
ClassEvaluation eval;
if (verbose>0)
init_progress_bar(MD.size());
int idx=0;
FOR_ALL_OBJECTS_IN_METADATA(MD)
{
int classNo;
MD.getValue(MDL_REF,classNo,__iter.objId);
MDclass.read(formatString("class%06d_images@%s",classNo,fnClass.c_str()));
evaluateClass(MDclass,eval);
MD.setValue(MDL_CLASSIFICATION_FRC_05,eval.FRC_05,__iter.objId);
MD.setValue(MDL_CLASSIFICATION_DPR_05,eval.DPR_05,__iter.objId);
idx++;
if (verbose>0)
progress_bar(idx);
}
if (verbose>0)
progress_bar(MD.size());
if (fnOut=="")
fnOut=fnClass;
MD.write((String)"classes@"+fnOut,MD_APPEND);
}
void do_loading(void)
{
do_wait("\nInitialising pipelines", 1);
printf("%ssuccessful%s\n", COLOUR_GREEN, COLOUR_RESET);
do_wait("Verifying target network", 3);
printf("%ssuccessful%s\n", COLOUR_GREEN, COLOUR_RESET);
do_wait("Discovering hardware cryptography acceleration", 3);
printf("%ssuccessful%s\n", COLOUR_GREEN, COLOUR_RESET);
do_wait("Probing target network", 2);
printf("%ssuccessful%s\n", COLOUR_GREEN, COLOUR_RESET);
do_wait("Initialising target network lockdown", 1);
printf("%ssuccessful%s\n\n", COLOUR_GREEN, COLOUR_RESET);
printf("%sObtaining internal authentication key...%s\n", COLOUR_YELLOW, COLOUR_RESET);
charset = malloc(16);
int i;
for (i = 0; i < 10; i++) charset[i] = (i + 48);
for (i = 10; i < 16; i++) charset[i] = (i + 55);
do_password();
free(charset);
printf("%sLoading security grid access protocol...%s\n", COLOUR_YELLOW, COLOUR_RESET);
progress_bar(5000, 10000);
printf("%sLoading security grid access database...%s\n", COLOUR_YELLOW, COLOUR_RESET);
progress_bar(1000, 7000);
printf("%sPreparing core security framework...%s\n", COLOUR_YELLOW, COLOUR_RESET);
progress_bar(5000, 25000);
printf("%sInitialising core security framework...%s\n", COLOUR_YELLOW, COLOUR_RESET);
progress_bar(2000, 50000);
printf("%sInfiltrating target network...%s\n", COLOUR_YELLOW, COLOUR_RESET);
progress_bar(100000, 300000);
}
void ParticleSorterMpi::run()
{
int total_nr_images = MDin.numberOfObjects();
features.resize(total_nr_images, NR_FEATURES);
// Each node does part of the work
long int my_first_image, my_last_image, my_nr_images;
divide_equally(total_nr_images, node->size, node->rank, my_first_image, my_last_image);
my_nr_images = my_last_image - my_first_image + 1;
int barstep;
if (verb > 0)
{
std::cout << "Calculating sorting features for all input particles..." << std::endl;
init_progress_bar(my_nr_images);
barstep = XMIPP_MAX(1, my_nr_images/ 60);
}
long int ipart = 0;
FOR_ALL_OBJECTS_IN_METADATA_TABLE(MDin)
{
if (ipart >= my_first_image && ipart <= my_last_image)
{
if (verb > 0 && ipart % barstep == 0)
progress_bar(ipart);
calculateFeaturesOneParticle(ipart);
}
ipart++;
}
if (verb > 0)
progress_bar(my_nr_images);
// Combine results from all nodes
MultidimArray<double> allnodes_features;
allnodes_features.resize(features);
MPI_Allreduce(MULTIDIM_ARRAY(features), MULTIDIM_ARRAY(allnodes_features), MULTIDIM_SIZE(features), MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
features = allnodes_features;
// Only the master writes out files
if (verb > 0)
{
normaliseFeatures();
writeFeatures();
}
}
MateAppProgressKey
mate_app_progress_manual (MateApp * app,
const gchar * description,
MateAppProgressCancelFunc cancel_cb,
gpointer data)
{
ProgressKeyReal * key;
g_return_val_if_fail (app != NULL, NULL);
g_return_val_if_fail (MATE_IS_APP(app), NULL);
g_return_val_if_fail (description != NULL, NULL);
key = g_new (ProgressKeyReal, 1);
key->app = app;
key->cancel_cb = cancel_cb;
key->data = data;
key->timeout_tag = INVALID_TIMEOUT;
if ( mate_app_has_appbar_progress(app) &&
/* FIXME !!! */
0 /*mate_preferences_get_statusbar_dialog() */) {
progress_bar (description, key);
}
else {
progress_dialog (description, key);
}
/* Make sure progress stops if the app is destroyed. */
key->handler_id = g_signal_connect(app, "destroy",
G_CALLBACK(stop_progress_cb),
key);
return key;
}
int sha1_update_done_cb(void *p) {
val++;
UNUSED(p);
progress_bar();
return 0;
}
void TestBarCleansFilesUpAfterException()
{
double smidge = 1e-8;
{
ProgressReporter progress_bar("ProgressReporterException", 1.0, 10.0);
try
{
progress_bar.PrintInitialising();
for (unsigned i=0; i<=900; i++)
{
double t = 1.0 + ((i+0.0)/1000)*9.0 - smidge;
progress_bar.Update(t);
}
EXCEPTION("Throw");
}
catch(Exception&)
{
}
}
// File should now be closed since progress_bar is out of scope
std::string results_dir = OutputFileHandler::GetChasteTestOutputDirectory() + "ProgressReporterException/";
FileComparison(results_dir + "progress_status.txt", "global/test/data/bad_progress_status.txt").CompareFiles();
}
void torrent_view::print_torrent(lt::torrent_status const& s, bool selected)
{
int pos = 0;
char str[512];
// the active torrent is highligted in the list
// this inverses the forground and background colors
char const* selection = "";
if (selected)
selection = "\x1b[1m\x1b[44m";
char queue_pos[16] = {0};
if (s.queue_position == -1)
snprintf(queue_pos, sizeof(queue_pos), "-");
else
snprintf(queue_pos, sizeof(queue_pos), "%d", s.queue_position);
std::string name = s.name;
if (name.size() > 50) name.resize(50);
color_code progress_bar_color = col_yellow;
if (!s.error.empty()) progress_bar_color = col_red;
else if (s.paused) progress_bar_color = col_blue;
else if (s.state == lt::torrent_status::downloading_metadata)
progress_bar_color = col_magenta;
else if (s.current_tracker.empty())
progress_bar_color = col_green;
pos += snprintf(str + pos, sizeof(str) - pos, "%s%c%-3s %-50s %s%s %s (%s) "
"%s (%s) %5d:%-5d %s %s %c%s"
, selection
, s.is_loaded ? 'L' : ' '
, queue_pos
, name.c_str()
, progress_bar(s.progress_ppm / 1000, 35, progress_bar_color, '-', '#', torrent_state(s)).c_str()
, selection
, color(add_suffix(s.download_rate, "/s"), col_green).c_str()
, color(add_suffix(s.total_download), col_green).c_str()
, color(add_suffix(s.upload_rate, "/s"), col_red).c_str()
, color(add_suffix(s.total_upload), col_red).c_str()
, s.num_peers - s.num_seeds, s.num_seeds
, color(add_suffix(s.all_time_download), col_green).c_str()
, color(add_suffix(s.all_time_upload), col_red).c_str()
, s.need_save_resume?'S':' ', esc("0"));
// if this is the selected torrent, restore the background color
if (selected)
pos += snprintf(str + pos, sizeof(str) - pos, "%s", esc("0"));
pos += snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
if (m_width + 1 < sizeof(str))
str[m_width + 1] = '\0';
print(str);
}
void disable_progress_bar()
{
pthread_mutex_lock(&progress_mutex);
if(progress_enabled) {
progress_bar(cur_uncompressed, estimated_uncompressed, columns);
printf("\n");
}
progress_enabled = 0;
pthread_mutex_unlock(&progress_mutex);
}
void ParticlePolisherMpi::polishParticlesAllMicrographs()
{
if (!do_start_all_over && exists(fn_out + ".star"))
{
if (verb > 0)
std::cout << std::endl << " + " << fn_out << ".star already exists: skipping polishing of the particles." << std::endl;
return;
}
int total_nr_micrographs = exp_model.average_micrographs.size();
// Each node does part of the work
long int my_first_micrograph, my_last_micrograph, my_nr_micrographs;
divide_equally(total_nr_micrographs, node->size, node->rank, my_first_micrograph, my_last_micrograph);
my_nr_micrographs = my_last_micrograph - my_first_micrograph + 1;
// Loop over all average micrographs
int barstep;
if (verb > 0)
{
std::cout << " + Write out polished particles for all micrographs ... " << std::endl;
init_progress_bar(my_nr_micrographs);
barstep = XMIPP_MAX(1, my_nr_micrographs/ 60);
}
for (long int i = my_first_micrograph; i <= my_last_micrograph; i++)
{
if (verb > 0 && i % barstep == 0)
progress_bar(i);
polishParticlesOneMicrograph(i);
}
if (verb > 0)
progress_bar(my_nr_micrographs);
if (node->isMaster())
writeStarFilePolishedParticles();
MPI_Barrier(MPI_COMM_WORLD);
}
// Outliers ===============================================================
void ProgClassifyCL2DCore::computeCores()
{
if (verbose && node->rank==0)
std::cerr << "Computing cores ...\n";
ProgAnalyzeCluster analyzeCluster;
analyzeCluster.verbose=0;
analyzeCluster.NPCA=NPCA;
analyzeCluster.Niter=10;
analyzeCluster.distThreshold=thPCAZscore;
analyzeCluster.dontMask=false;
MetaData MD;
size_t first, last;
size_t Nblocks=blocks.size();
if (verbose && node->rank==0)
init_progress_bar(Nblocks);
while (taskDistributor->getTasks(first, last))
for (size_t idx=first; idx<=last; ++idx)
{
// Remove outliers in the PCA projection
analyzeCluster.SFin.clear();
analyzeCluster.fnSel=blocks[idx].block+"@"+blocks[idx].fnLevel;
analyzeCluster.fnOut=blocks[idx].fnLevel.insertBeforeExtension((String)"_core_"+blocks[idx].block);
analyzeCluster.run();
// Remove outliers from file
MD.read(analyzeCluster.fnOut);
MD.removeDisabled();
MD.write(analyzeCluster.fnOut,MD_APPEND);
if (verbose && node->rank==0)
progress_bar(idx);
}
taskDistributor->wait();
if (verbose && node->rank==0)
progress_bar(Nblocks);
// Gather all results
gatherResults(0,"core");
}
void LLWidgetReg::initClass(bool register_widgets)
{
// Only need to register if the Windows linker has optimized away the
// references to the object files.
if (register_widgets)
{
LLDefaultChildRegistry::Register<LLButton> button("button");
LLDefaultChildRegistry::Register<LLMenuButton> menu_button("menu_button");
LLDefaultChildRegistry::Register<LLCheckBoxCtrl> check_box("check_box");
LLDefaultChildRegistry::Register<LLComboBox> combo_box("combo_box");
LLDefaultChildRegistry::Register<LLFilterEditor> filter_editor("filter_editor");
LLDefaultChildRegistry::Register<LLFlyoutButton> flyout_button("flyout_button");
LLDefaultChildRegistry::Register<LLContainerView> container_view("container_view");
LLDefaultChildRegistry::Register<LLIconCtrl> icon("icon");
LLDefaultChildRegistry::Register<LLLoadingIndicator> loading_indicator("loading_indicator");
LLDefaultChildRegistry::Register<LLLineEditor> line_editor("line_editor");
LLDefaultChildRegistry::Register<LLMenuItemSeparatorGL> menu_item_separator("menu_item_separator");
LLDefaultChildRegistry::Register<LLMenuItemCallGL> menu_item_call_gl("menu_item_call");
LLDefaultChildRegistry::Register<LLMenuItemCheckGL> menu_item_check_gl("menu_item_check");
LLDefaultChildRegistry::Register<LLMenuGL> menu("menu");
LLDefaultChildRegistry::Register<LLMenuBarGL> menu_bar("menu_bar");
LLDefaultChildRegistry::Register<LLContextMenu> context_menu("context_menu");
LLDefaultChildRegistry::Register<LLMultiSlider> multi_slider_bar("multi_slider_bar");
LLDefaultChildRegistry::Register<LLMultiSliderCtrl> multi_slider("multi_slider");
LLDefaultChildRegistry::Register<LLPanel> panel("panel", &LLPanel::fromXML);
LLDefaultChildRegistry::Register<LLLayoutStack> layout_stack("layout_stack");
LLDefaultChildRegistry::Register<LLProgressBar> progress_bar("progress_bar");
LLDefaultChildRegistry::Register<LLRadioGroup> radio_group("radio_group");
LLDefaultChildRegistry::Register<LLSearchEditor> search_editor("search_editor");
LLDefaultChildRegistry::Register<LLScrollContainer> scroll_container("scroll_container");
LLDefaultChildRegistry::Register<LLScrollingPanelList> scrolling_panel_list("scrolling_panel_list");
LLDefaultChildRegistry::Register<LLScrollListCtrl> scroll_list("scroll_list");
LLDefaultChildRegistry::Register<LLSlider> slider_bar("slider_bar");
LLDefaultChildRegistry::Register<LLSliderCtrl> slider("slider");
LLDefaultChildRegistry::Register<LLSpinCtrl> spinner("spinner");
LLDefaultChildRegistry::Register<LLStatBar> stat_bar("stat_bar");
//LLDefaultChildRegistry::Register<LLPlaceHolderPanel> placeholder("placeholder");
LLDefaultChildRegistry::Register<LLTabContainer> tab_container("tab_container");
LLDefaultChildRegistry::Register<LLTextBox> text("text");
LLDefaultChildRegistry::Register<LLTimeCtrl> time("time");
LLDefaultChildRegistry::Register<LLTextEditor> simple_text_editor("simple_text_editor");
LLDefaultChildRegistry::Register<LLUICtrl> ui_ctrl("ui_ctrl");
LLDefaultChildRegistry::Register<LLStatView> stat_view("stat_view");
//LLDefaultChildRegistry::Register<LLUICtrlLocate> locate("locate");
//LLDefaultChildRegistry::Register<LLUICtrlLocate> pad("pad");
LLDefaultChildRegistry::Register<LLViewBorder> view_border("view_border");
}
// *HACK: Usually this is registered as a viewer text editor
LLDefaultChildRegistry::Register<LLTextEditor> text_editor("text_editor");
}
int main(int argc,char *argv[])
{
Fl_Socket socket;
sock = &socket;
Fl_Window main_window(600,400,"Socket test");
Fl_Group top_group(0,0,200,25);
top_group.layout_align(FL_ALIGN_TOP);
Fl_Box progress_text(0,0,150,25);
p_text = &progress_text;
Fl_ProgressBar progress_bar(150,0,50,25);
p_bar = &progress_bar;
top_group.resizable(p_bar);
top_group.store_sizes();
top_group.end();
Fl_Text_Buffer buf;
Fl_Text_Editor editor(10,10,200,100);
editor.layout_align(FL_ALIGN_CLIENT);
editor.buffer(buf);
textbuf = &buf;
textdisp = &editor;
Fl_Group status_line(0,0,200,25);
status_line.layout_align(FL_ALIGN_BOTTOM);
Fl_Input url_input(50, 0, 100, 25, "http://");
url_input.value("www.fltk.org/index.php");
Fl_Button go_button(150, 0, 50, 25, "Go!");
go_button.callback(go_callback);
status_line.resizable(url_input);
status_line.store_sizes();
status_line.end();
input = &url_input;
main_window.end();
main_window.resizable(main_window);
main_window.show(argc,argv);
return Fl::run();
}
int sendfile(int sockfd,int fd)
{
char buf[LEN];
int nread,count=0;
int size=file_size_fd(fd);
while((nread=Read(fd,buf,sizeof(buf)))>0)
{
Writen(sockfd,buf,nread);
count+=nread;
progress_bar((count/size)*100);
}
return 0;
}
void Sudoku::process(std::istream& input, std::ostream& output) {
std::vector<std::string> lines;
std::copy(std::istream_iterator<std::string>(input),
std::istream_iterator<std::string>(),
std::back_inserter(lines));
int count = 0;
int total = lines.size();
for (auto& line: lines) {
Sudoku sudoku(line);
sudoku.solve();
output << sudoku;
count++;
progress_bar(count, total);
}
std::cout << std::endl;
}
/* start progress bar animation if choice 1
or start throwing stick animation if choice 2 */
static void animate(const int type, const int len)
{
if (type == 1) {
progress_bar(len);
} else if (type == 2) {
/* loop to run throwing stick animation forwards and backwards */
int i=0;
for (;;) {
throwing_stick(len, (i % 2) ? 'b' : 'f', 1);
i = (i+1) % 2;
}
} else {
fprintf(stderr, "choice must be 1 (progress bar) or 2 (throwing stick)\n");
exit(EXIT_FAILURE);
}
}
void run()
{
long t, export=1;
FILE *f_hi, *f_st;
f_hi = fopen("hi.dat","w");
for (t=0; t<num_of_iteration; t++){
export_conf(t,export);
write_hi(f_hi,t);
progress_bar(t);
//printf("prova_run\n");
one_step();
}
fclose(f_hi);
}
static bool genmatrix(const char *filename,
const ContextID &cid,
DecoderFeatureIndex *fi,
int factor,
int default_cost) {
std::ofstream ofs(filename);
CHECK_DIE(ofs) << "permission denied: " << filename;
LearnerPath path;
LearnerNode rnode;
LearnerNode lnode;
rnode.stat = lnode.stat = MECAB_NOR_NODE;
rnode.rpath = &path;
lnode.lpath = &path;
path.lnode = &lnode;
path.rnode = &rnode;
const std::map<std::string, int> &left = cid.left_ids();
const std::map<std::string, int> &right = cid.right_ids();
CHECK_DIE(left.size()) << "left id size is empty";
CHECK_DIE(right.size()) << "right id size is empty";
ofs << right.size() << ' ' << left.size() << std::endl;
size_t l = 0;
for (std::map<std::string, int>::const_iterator rit = right.begin();
rit != right.end();
++rit) {
++l;
progress_bar("emitting matrix ", l+1, right.size());
for (std::map<std::string, int>::const_iterator lit = left.begin();
lit != left.end();
++lit) {
path.rnode->wcost = 0;
fi->buildBigramFeature(&path, rit->first.c_str(), lit->first.c_str());
fi->calcCost(&path);
ofs << rit->second << ' ' << lit->second << ' '
<< tocost(path.cost, factor, default_cost) << std::endl;
}
}
return true;
}
void TestBar()
{
// This is in a block to make sure the file gets closed (i.e. destructor called)
{
ProgressReporter progress_bar("ProgressReporter", 1.0, 10.0);
progress_bar.PrintInitialising();
for (unsigned i=0; i<=1000; i++)
{
double t = 1.0 + ((i+0.0)/1000)*9.0;
progress_bar.Update(t);
}
progress_bar.PrintFinalising();
}
std::string results_dir = OutputFileHandler::GetChasteTestOutputDirectory() + "ProgressReporter/";
FileComparison(results_dir + "progress_status.txt", "global/test/data/good_progress_status.txt").CompareFiles();
}
void
pass1b(void)
{
int c, i;
union dinode *dp;
struct inodesc idesc;
ino_t inumber;
memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1bcheck;
duphead = duplist;
inumber = 0;
for (c = 0; c < sblock->fs_ncg; c++) {
if (got_siginfo) {
fprintf(stderr,
"%s: phase 1b: cyl group %d of %d (%d%%)\n",
cdevname(), c, sblock->fs_ncg,
c * 100 / sblock->fs_ncg);
got_siginfo = 0;
}
#ifdef PROGRESS
progress_bar(cdevname(), "phase 1b", c, sblock->fs_ncg);
#endif /* PROGRESS */
for (i = 0; i < sblock->fs_ipg; i++, inumber++) {
if (inumber < ROOTINO)
continue;
dp = ginode(inumber);
if (dp == NULL)
continue;
idesc.id_number = inumber;
if (inoinfo(inumber)->ino_state != USTATE &&
(ckinode(dp, &idesc) & STOP))
return;
}
}
#ifdef PROGRESS
progress_done();
#endif /* PROGRESS */
}
void *progress_thrd(void *arg)
{
struct timespec requested_time, remaining;
struct itimerval itimerval;
struct winsize winsize;
if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
if(isatty(STDOUT_FILENO))
printf("TIOCGWINSZ ioctl failed, defaulting to 80 "
"columns\n");
columns = 80;
} else
columns = winsize.ws_col;
signal(SIGWINCH, sigwinch_handler);
signal(SIGALRM, sigalrm_handler);
itimerval.it_value.tv_sec = 0;
itimerval.it_value.tv_usec = 250000;
itimerval.it_interval.tv_sec = 0;
itimerval.it_interval.tv_usec = 250000;
setitimer(ITIMER_REAL, &itimerval, NULL);
requested_time.tv_sec = 0;
requested_time.tv_nsec = 250000000;
while(1) {
int res = nanosleep(&requested_time, &remaining);
if(res == -1 && errno != EINTR)
BAD_ERROR("nanosleep failed in progress thread\n");
if(progress_enabled) {
pthread_mutex_lock(&progress_mutex);
progress_bar(cur_uncompressed, estimated_uncompressed,
columns);
pthread_mutex_unlock(&progress_mutex);
}
}
}
int create_cache_db_impl()
{
// Adding 0% mark at the very beginning of the program
KApp::CProgressBar progress_bar(1);
progress_bar.Process ( 0, true );
VDBObjects::CVDBManager mgr;
mgr.Make();
VDBObjects::CVDatabase vdb = mgr.OpenDB (g_Params.dbPathSrc);
// Scan SEQUENCE table to find mate_alignment_ids that have to be cached
KLib::CKVector vect;
size_t count = FillKVectorWithAlignIDs ( vdb, g_Params.cursor_cache_size, vect );
if ( count*2 >= g_Params.min_cache_count )
{
// For each id in vect cache the PRIMARY_ALIGNMENT record
CachePrimaryAlignment ( mgr, vdb, g_Params.cursor_cache_size, vect, count*2, progress_bar );
}
else
{
if ( ::Quitting() == 0 )
{
PLOGMSG ( klogWarn,
( klogWarn,
"The cache db will not be created because there is not "
"enough records to cache: $(COUNT) is found and minimum $(MIN_COUNT) is required. "
"The minimum required number can be changed via $(OPTION_MIN_CACHE_COUNT) parameter.",
"COUNT=%zu,MIN_COUNT=%zu,OPTION_MIN_CACHE_COUNT=%s",
count*2, g_Params.min_cache_count, OPTION_MIN_CACHE_COUNT
));
}
}
mgr.Release (); // should not be necessary - destructor should do job
return 0;
}
void ProgXrayImport::run()
{
// Delete output stack if it exists
fnOut = fnRoot + ".mrc";
fnOut.deleteFile();
/* Turn off error handling */
H5Eset_auto(H5E_DEFAULT, NULL, NULL);
if (dSource == MISTRAL)
H5File.openFile(fnInput, H5F_ACC_RDONLY);
// Reading bad pixels mask
if ( !fnBPMask.empty() )
{
std::cerr << "Reading bad pixels mask from "+fnBPMask << "." << std::endl;
bpMask.read(fnBPMask);
if ( (cropSizeX + cropSizeY ) > 0 )
bpMask().selfWindow(cropSizeY,cropSizeX,
(int)(YSIZE(bpMask())-cropSizeY-1),(int)(XSIZE(bpMask())-cropSizeX-1));
STARTINGX(bpMask()) = STARTINGY(bpMask()) = 0;
}
// Setting the image projections list
switch (dSource)
{
case MISTRAL:
{
inMD.read(fnInput);
H5File.getDataset("NXtomo/data/rotation_angle", anglesArray, false);
H5File.getDataset("NXtomo/instrument/sample/ExpTimes", expTimeArray, false);
H5File.getDataset("NXtomo/instrument/sample/current", cBeamArray);
/* In case there is no angles information we set them to to an increasing sequence
* just to be able to continue importing data */
if ( anglesArray.size() != inMD.size() )
{
reportWarning("Input file does not contains angle information. Default sequence used.");
anglesArray.resizeNoCopy(inMD.size());
anglesArray.enumerate();
}
// If expTime is empty or only one single value in nexus file then we fill with 1
if (expTimeArray.size() < 2)
{
reportWarning("Input file does not contains tomogram exposition time information.");
expTimeArray.initConstant(anglesArray.size(), 1.);
}
// If current is empty or only one single value in nexus file then we fill with 1
if (cBeamArray.size() < 2)
{
reportWarning("Input file does not contains tomogram current beam information.");
cBeamArray.initConstant(anglesArray.size(), 1.);
}
// Since Alba does not provide slit width, we set to ones
slitWidthArray.initConstant(anglesArray.size(), 1.);
}
break;
case BESSY:
{
size_t objId;
for (size_t i = tIni; i <= tEnd; ++i)
{
objId = inMD.addObject();
inMD.setValue(MDL_IMAGE, fnInput + formatString("/img%d.spe", i), objId);
}
break;
}
case GENERIC:
{
// Get Darkfield
std::cerr << "Getting darkfield from "+fnInput << " ..." << std::endl;
getDarkfield(fnInput, IavgDark);
if (XSIZE(IavgDark())!=0)
IavgDark.write(fnRoot+"_darkfield.xmp");
std::vector<FileName> listDir;
fnInput.getFiles(listDir);
size_t objId;
for (size_t i = 0; i < listDir.size(); ++i)
{
if (!listDir[i].hasImageExtension())
continue;
objId = inMD.addObject();
inMD.setValue(MDL_IMAGE, fnInput+"/"+listDir[i], objId);
}
}
break;
}
inMD.findObjects(objIds);
size_t nIm = inMD.size();
// Create empty output stack file
getImageInfo(inMD, imgInfo);
/* Get the flatfield:: We get the FF after the image list because we need the image size to adapt the FF
* in case they were already cropped.
*/
if (!fnFlat.empty())
{
std::cout << "Getting flatfield from "+fnFlat << " ..." << std::endl;
getFlatfield(fnFlat,IavgFlat);
if ( XSIZE(IavgFlat()) != 0 )
{
FileName ffName = fnRoot+"_flatfield_avg.xmp";
IavgFlat.write(ffName);
fMD.setValue(MDL_IMAGE, ffName, fMD.addObject());
}
}
createEmptyFile(fnOut, imgInfo.adim.xdim-cropSizeXi-cropSizeXe, imgInfo.adim.ydim-cropSizeYi-cropSizeYe, 1, nIm);
// Process images
td = new ThreadTaskDistributor(nIm, XMIPP_MAX(1, nIm/30));
tm = new ThreadManager(thrNum, this);
std::cerr << "Getting data from " << fnInput << " ...\n";
init_progress_bar(nIm);
tm->run(runThread);
progress_bar(nIm);
// Write Metadata and angles
MetaData MDSorted;
MDSorted.sort(outMD,MDL_ANGLE_TILT);
MDSorted.write("tomo@"+fnRoot + ".xmd");
if ( fMD.size() > 0 )
fMD.write("flatfield@"+fnRoot + ".xmd", MD_APPEND);
// We also reference initial and final images at 0 degrees for Mistral tomograms
if ( dSource == MISTRAL )
{
fMD.clear();
FileName degree0Fn = "NXtomo/instrument/sample/0_degrees_initial_image";
if ( H5File.checkDataset(degree0Fn.c_str()))
fMD.setValue(MDL_IMAGE, degree0Fn + "@" + fnInput, fMD.addObject());
degree0Fn = "NXtomo/instrument/sample/0_degrees_final_image";
if ( H5File.checkDataset(degree0Fn.c_str()))
fMD.setValue(MDL_IMAGE, degree0Fn + "@" + fnInput, fMD.addObject());
if ( fMD.size() > 0 )
fMD.write("degree0@"+fnRoot + ".xmd", MD_APPEND);
}
// Write tlt file for IMOD
std::ofstream fhTlt;
fhTlt.open((fnRoot+".tlt").c_str());
if (!fhTlt)
REPORT_ERROR(ERR_IO_NOWRITE,fnRoot+".tlt");
FOR_ALL_OBJECTS_IN_METADATA(MDSorted)
{
double tilt;
MDSorted.getValue(MDL_ANGLE_TILT,tilt,__iter.objId);
fhTlt << tilt << std::endl;
}
fhTlt.close();
delete td;
delete tm;
}
void ProgAngularProjectLibrary::project_angle_vector (int my_init, int my_end, bool verbose)
{
Projection P;
FileName fn_proj;
double rot,tilt,psi;
int mySize;
int numberStepsPsi = 1;
mySize=my_end-my_init+1;
if (psi_sampling < 360)
{
numberStepsPsi = (int) (359.99999/psi_sampling);
mySize *= numberStepsPsi;
}
if (verbose)
init_progress_bar(mySize);
int myCounter=0;
for (double mypsi=0;mypsi<360;mypsi += psi_sampling)
for (int i=0;i<my_init;i++)
myCounter++;
// if (shears && XSIZE(inputVol())!=0 && VShears==NULL)
// VShears=new RealShearsInfo(inputVol());
if (projType == SHEARS && XSIZE(inputVol())!=0 && Vshears==NULL)
Vshears=new RealShearsInfo(inputVol());
if (projType == FOURIER && XSIZE(inputVol())!=0 && Vfourier==NULL)
Vfourier=new FourierProjector(inputVol(),
paddFactor,
maxFrequency,
BSplineDeg);
for (double mypsi=0;mypsi<360;mypsi += psi_sampling)
{
for (int i=my_init;i<=my_end;i++)
{
if (verbose)
progress_bar(i-my_init);
psi= mypsi+ZZ(mysampling.no_redundant_sampling_points_angles[i]);
tilt= YY(mysampling.no_redundant_sampling_points_angles[i]);
rot= XX(mysampling.no_redundant_sampling_points_angles[i]);
// if (shears)
// projectVolume(*VShears, P, Ydim, Xdim, rot,tilt,psi);
// else
// projectVolume(inputVol(), P, Ydim, Xdim, rot,tilt,psi);
if (projType == SHEARS)
projectVolume(*Vshears, P, Ydim, Xdim, rot, tilt, psi);
else if (projType == FOURIER)
projectVolume(*Vfourier, P, Ydim, Xdim, rot, tilt, psi);
else if (projType == REALSPACE)
projectVolume(inputVol(), P, Ydim, Xdim, rot, tilt, psi);
P.setEulerAngles(rot,tilt,psi);
P.setDataMode(_DATA_ALL);
P.write(output_file,(size_t) (numberStepsPsi * i + mypsi +1),true,WRITE_REPLACE);
}
}
if (verbose)
progress_bar(mySize);
}
static void harmonic_coordinates_bind(Scene *UNUSED(scene), MeshDeformModifierData *mmd, MeshDeformBind *mdb)
{
MDefBindInfluence *inf;
MDefInfluence *mdinf;
MDefCell *cell;
float center[3], vec[3], maxwidth, totweight;
int a, b, x, y, z, totinside, offset;
/* compute bounding box of the cage mesh */
INIT_MINMAX(mdb->min, mdb->max);
for (a = 0; a < mdb->totcagevert; a++)
minmax_v3v3_v3(mdb->min, mdb->max, mdb->cagecos[a]);
/* allocate memory */
mdb->size = (2 << (mmd->gridsize - 1)) + 2;
mdb->size3 = mdb->size * mdb->size * mdb->size;
mdb->tag = MEM_callocN(sizeof(int) * mdb->size3, "MeshDeformBindTag");
mdb->phi = MEM_callocN(sizeof(float) * mdb->size3, "MeshDeformBindPhi");
mdb->totalphi = MEM_callocN(sizeof(float) * mdb->size3, "MeshDeformBindTotalPhi");
mdb->boundisect = MEM_callocN(sizeof(*mdb->boundisect) * mdb->size3, "MDefBoundIsect");
mdb->semibound = MEM_callocN(sizeof(int) * mdb->size3, "MDefSemiBound");
mdb->bvhtree = bvhtree_from_mesh_looptri(&mdb->bvhdata, mdb->cagedm, FLT_EPSILON * 100, 4, 6);
mdb->inside = MEM_callocN(sizeof(int) * mdb->totvert, "MDefInside");
if (mmd->flag & MOD_MDEF_DYNAMIC_BIND)
mdb->dyngrid = MEM_callocN(sizeof(MDefBindInfluence *) * mdb->size3, "MDefDynGrid");
else
mdb->weights = MEM_callocN(sizeof(float) * mdb->totvert * mdb->totcagevert, "MDefWeights");
mdb->memarena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "harmonic coords arena");
BLI_memarena_use_calloc(mdb->memarena);
/* initialize data from 'cagedm' for reuse */
{
DerivedMesh *dm = mdb->cagedm;
mdb->cagedm_cache.mpoly = dm->getPolyArray(dm);
mdb->cagedm_cache.mloop = dm->getLoopArray(dm);
mdb->cagedm_cache.looptri = dm->getLoopTriArray(dm);
mdb->cagedm_cache.poly_nors = dm->getPolyDataArray(dm, CD_NORMAL); /* can be NULL */
}
/* make bounding box equal size in all directions, add padding, and compute
* width of the cells */
maxwidth = -1.0f;
for (a = 0; a < 3; a++)
if (mdb->max[a] - mdb->min[a] > maxwidth)
maxwidth = mdb->max[a] - mdb->min[a];
for (a = 0; a < 3; a++) {
center[a] = (mdb->min[a] + mdb->max[a]) * 0.5f;
mdb->min[a] = center[a] - maxwidth * 0.5f;
mdb->max[a] = center[a] + maxwidth * 0.5f;
mdb->width[a] = (mdb->max[a] - mdb->min[a]) / (mdb->size - 4);
mdb->min[a] -= 2.1f * mdb->width[a];
mdb->max[a] += 2.1f * mdb->width[a];
mdb->width[a] = (mdb->max[a] - mdb->min[a]) / mdb->size;
mdb->halfwidth[a] = mdb->width[a] * 0.5f;
}
progress_bar(0, "Setting up mesh deform system");
totinside = 0;
for (a = 0; a < mdb->totvert; a++) {
copy_v3_v3(vec, mdb->vertexcos[a]);
mdb->inside[a] = meshdeform_inside_cage(mdb, vec);
if (mdb->inside[a])
totinside++;
}
/* free temporary MDefBoundIsects */
BLI_memarena_free(mdb->memarena);
mdb->memarena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "harmonic coords arena");
/* start with all cells untyped */
for (a = 0; a < mdb->size3; a++)
mdb->tag[a] = MESHDEFORM_TAG_UNTYPED;
/* detect intersections and tag boundary cells */
for (z = 0; z < mdb->size; z++)
for (y = 0; y < mdb->size; y++)
for (x = 0; x < mdb->size; x++)
meshdeform_add_intersections(mdb, x, y, z);
/* compute exterior and interior tags */
meshdeform_bind_floodfill(mdb);
for (z = 0; z < mdb->size; z++)
for (y = 0; y < mdb->size; y++)
for (x = 0; x < mdb->size; x++)
meshdeform_check_semibound(mdb, x, y, z);
/* solve */
meshdeform_matrix_solve(mmd, mdb);
/* assign results */
if (mmd->flag & MOD_MDEF_DYNAMIC_BIND) {
mmd->totinfluence = 0;
for (a = 0; a < mdb->size3; a++)
for (inf = mdb->dyngrid[a]; inf; inf = inf->next)
mmd->totinfluence++;
/* convert MDefBindInfluences to smaller MDefInfluences */
mmd->dyngrid = MEM_callocN(sizeof(MDefCell) * mdb->size3, "MDefDynGrid");
mmd->dyninfluences = MEM_callocN(sizeof(MDefInfluence) * mmd->totinfluence, "MDefInfluence");
offset = 0;
for (a = 0; a < mdb->size3; a++) {
cell = &mmd->dyngrid[a];
cell->offset = offset;
totweight = 0.0f;
mdinf = mmd->dyninfluences + cell->offset;
for (inf = mdb->dyngrid[a]; inf; inf = inf->next, mdinf++) {
mdinf->weight = inf->weight;
mdinf->vertex = inf->vertex;
totweight += mdinf->weight;
cell->totinfluence++;
}
if (totweight > 0.0f) {
mdinf = mmd->dyninfluences + cell->offset;
for (b = 0; b < cell->totinfluence; b++, mdinf++)
mdinf->weight /= totweight;
}
offset += cell->totinfluence;
}
mmd->dynverts = mdb->inside;
mmd->dyngridsize = mdb->size;
copy_v3_v3(mmd->dyncellmin, mdb->min);
mmd->dyncellwidth = mdb->width[0];
MEM_freeN(mdb->dyngrid);
}
else {
mmd->bindweights = mdb->weights;
MEM_freeN(mdb->inside);
}
MEM_freeN(mdb->tag);
MEM_freeN(mdb->phi);
MEM_freeN(mdb->totalphi);
MEM_freeN(mdb->boundisect);
MEM_freeN(mdb->semibound);
BLI_memarena_free(mdb->memarena);
free_bvhtree_from_mesh(&mdb->bvhdata);
}
static void meshdeform_matrix_solve(MeshDeformModifierData *mmd, MeshDeformBind *mdb)
{
LinearSolver *context;
float vec[3], gridvec[3];
int a, b, x, y, z, totvar;
char message[256];
/* setup variable indices */
mdb->varidx = MEM_callocN(sizeof(int) * mdb->size3, "MeshDeformDSvaridx");
for (a = 0, totvar = 0; a < mdb->size3; a++)
mdb->varidx[a] = (mdb->tag[a] == MESHDEFORM_TAG_EXTERIOR) ? -1 : totvar++;
if (totvar == 0) {
MEM_freeN(mdb->varidx);
return;
}
progress_bar(0, "Starting mesh deform solve");
/* setup linear solver */
context = EIG_linear_solver_new(totvar, totvar, 1);
/* build matrix */
for (z = 0; z < mdb->size; z++)
for (y = 0; y < mdb->size; y++)
for (x = 0; x < mdb->size; x++)
meshdeform_matrix_add_cell(mdb, context, x, y, z);
/* solve for each cage vert */
for (a = 0; a < mdb->totcagevert; a++) {
/* fill in right hand side and solve */
for (z = 0; z < mdb->size; z++)
for (y = 0; y < mdb->size; y++)
for (x = 0; x < mdb->size; x++)
meshdeform_matrix_add_rhs(mdb, context, x, y, z, a);
if (EIG_linear_solver_solve(context)) {
for (z = 0; z < mdb->size; z++)
for (y = 0; y < mdb->size; y++)
for (x = 0; x < mdb->size; x++)
meshdeform_matrix_add_semibound_phi(mdb, x, y, z, a);
for (z = 0; z < mdb->size; z++)
for (y = 0; y < mdb->size; y++)
for (x = 0; x < mdb->size; x++)
meshdeform_matrix_add_exterior_phi(mdb, x, y, z, a);
for (b = 0; b < mdb->size3; b++) {
if (mdb->tag[b] != MESHDEFORM_TAG_EXTERIOR)
mdb->phi[b] = EIG_linear_solver_variable_get(context, 0, mdb->varidx[b]);
mdb->totalphi[b] += mdb->phi[b];
}
if (mdb->weights) {
/* static bind : compute weights for each vertex */
for (b = 0; b < mdb->totvert; b++) {
if (mdb->inside[b]) {
copy_v3_v3(vec, mdb->vertexcos[b]);
gridvec[0] = (vec[0] - mdb->min[0] - mdb->halfwidth[0]) / mdb->width[0];
gridvec[1] = (vec[1] - mdb->min[1] - mdb->halfwidth[1]) / mdb->width[1];
gridvec[2] = (vec[2] - mdb->min[2] - mdb->halfwidth[2]) / mdb->width[2];
mdb->weights[b * mdb->totcagevert + a] = meshdeform_interp_w(mdb, gridvec, vec, a);
}
}
}
else {
MDefBindInfluence *inf;
/* dynamic bind */
for (b = 0; b < mdb->size3; b++) {
if (mdb->phi[b] >= MESHDEFORM_MIN_INFLUENCE) {
inf = BLI_memarena_alloc(mdb->memarena, sizeof(*inf));
inf->vertex = a;
inf->weight = mdb->phi[b];
inf->next = mdb->dyngrid[b];
mdb->dyngrid[b] = inf;
}
}
}
}
else {
modifier_setError(&mmd->modifier, "Failed to find bind solution (increase precision?)");
error("Mesh Deform: failed to find bind solution.");
break;
}
BLI_snprintf(message, sizeof(message), "Mesh deform solve %d / %d |||", a + 1, mdb->totcagevert);
progress_bar((float)(a + 1) / (float)(mdb->totcagevert), message);
}
#if 0
/* sanity check */
for (b = 0; b < mdb->size3; b++)
if (mdb->tag[b] != MESHDEFORM_TAG_EXTERIOR)
if (fabsf(mdb->totalphi[b] - 1.0f) > 1e-4f)
printf("totalphi deficiency [%s|%d] %d: %.10f\n",
(mdb->tag[b] == MESHDEFORM_TAG_INTERIOR) ? "interior" : "boundary", mdb->semibound[b], mdb->varidx[b], mdb->totalphi[b]);
#endif
/* free */
MEM_freeN(mdb->varidx);
EIG_linear_solver_delete(context);
}
bool Ghostscript::Install(HWND hwnd,MSGFUNC &msgfunc){
m_installresult = false;
if(!m_doinst)return true;
if(!m_downloadresult)return false;
ablib::string file = g_Setting.GetDownloadDir() + m_file.file;
boost::filesystem::path path(file);
CProgressBarCtrl progress_bar(::GetDlgItem(hwnd,IDC_PROGRESS));
static const int PROGRESSBAR_MAX = 32768;
if(file.length() < 4 || file.substr(file.length() - 4) != _T(".exe")){
::MessageBox(hwnd,_TR("古い Ghostscript を発見しました．このバージョンには対応していません．"),_T("abtlinst"),0);
return false;
}
ablib::system::Process process;
ablib::system::Process::ProcessStartInfo s;
ablib::string gsdir;
gsdir = g_Setting.GetInstallDir() + _T("gs");
if(m_version != 0){
ablib::string ver = boost::lexical_cast<ablib::string>(m_version);
// 後ろから二つおきにピリオドを挿入
ablib::string::size_type start = (ver.length() % 2);
int len = ver.length();
for(ablib::string::size_type i = 0 ; i < len/2 ; ++i){
ver.insert(start + 3*i,_T("."));
}
gsdir += _T("\\gs") + ver;
}
s.Arguments = _T("\"") + file + _T("\" /S /D=") + gsdir;
// s.Arguments = _T("\"") + file + _T("\" /D=") + g_Setting.GetInstallDir() + _T("gs");
// s.Arg = _T("\"") + file + _T("\"");
s.FileName = _T("");
s.WorkingDirectory = path.parent_path().wstring();
s.RedirectStandardError = false;
s.RedirectStandardOutput = false;
s.RedirectStandardInput = false;
s.ShowState = ablib::system::Process::ProcessStartInfo::show;
s.CreateNoWindow = false;
process.StartInfo(s);
CheckandSetTmp(g_Setting.GetTmpDir().c_str());
msgfunc.msg(_T("Ghostscript のインストール\n"));
msgfunc.detail(_T("Ghostscript をインストール中\n"));
if(!process.Start()){
g_Setting.Log(file + _T(" の起動に失敗"));
return false;
}else{
process.WaitForExit();
}
progress_bar.SetPos(PROGRESSBAR_MAX/2);
gsdir += _T("\\");
// ablib::string gsdir = GetGSDir();
if(g_Setting.SetPath()){
if(gsdir != _T("")){
g_Path.AddPath(gsdir + _T("bin"));
g_Path.AddPath(gsdir + _T("lib"));
}else g_Setting.Log(_TR("Ghostscript のインストールパス取得に失敗したので，PATH の設定を行いません"));
}
msgfunc.detail(_T("cidfmap の生成\n"));
LPITEMIDLIST id;
LPMALLOC mal;
TCHAR fontdir[4096];
if(
FAILED(::SHGetMalloc(&mal)) ||
FAILED(::SHGetSpecialFolderLocation(NULL,CSIDL_FONTS,&id)) ||
!::SHGetPathFromIDList(id,fontdir)
){
g_Setting.Log(_T("cidfmap の生成に失敗（フォントフォルダの取得に失敗）．"));
return false;
}
mal->Free(id);
if(fontdir[::lstrlen(fontdir) - 1] != '\\')::lstrcat(fontdir,_T("\\"));
ablib::string arg = ablib::string(_T("-q -dBATCH -sFONTDIR=")) + fontdir + _T(" -sCIDFMAP=") + gsdir + _T("lib\\cidfmap") + _T(" ") + gsdir + _T("lib\\mkcidfm.ps");
arg.replace(_T("\\"),_T("/"));
s.Arguments = _T("\"") + gsdir + _T("\\bin\\gswin32c.exe\" ") + arg;
s.WorkingDirectory = gsdir + _T("\\bin");
process.StartInfo(s);
if(!process.Start()){
g_Setting.Log(s.Arguments + _T(" の実行に失敗"));
return false;
}else{
process.WaitForExit();
}
progress_bar.SetPos(PROGRESSBAR_MAX);
m_installresult = true;
return true;
}
void ProgValidationNonTilt::run()
{
//Clustering Tendency and Cluster Validity Stephen D. Scott
randomize_random_generator();
MetaData md,mdGallery,mdOut,mdOut2,mdSort;
MDRow row;
FileName fnOut,fnOut2, fnGallery;
fnOut = fnDir+"/clusteringTendency.xmd";
fnGallery = fnDir+"/gallery.doc";
fnOut2 = fnDir+"/validation.xmd";
size_t nSamplesRandom = 500;
md.read(fnParticles);
mdGallery.read(fnGallery);
mdSort.sort(md,MDL_IMAGE_IDX,true,-1,0);
size_t maxNImg;
size_t sz = md.size();
if (useSignificant)
mdSort.getValue(MDL_IMAGE_IDX,maxNImg,sz);
else
{
mdSort.getValue(MDL_ITEM_ID,maxNImg,sz);
}
String expression;
MDRow rowP,row2;
SymList SL;
int symmetry, sym_order;
SL.readSymmetryFile(fnSym.c_str());
SL.isSymmetryGroup(fnSym.c_str(), symmetry, sym_order);
/*
double non_reduntant_area_of_sphere = SL.nonRedundantProjectionSphere(symmetry,sym_order);
double area_of_sphere_no_symmetry = 4.*PI;
double correction = std::sqrt(non_reduntant_area_of_sphere/area_of_sphere_no_symmetry);
*/
double correction = 1;
double validation = 0;
double num_images = 0;
MetaData tempMd;
std::vector<double> sum_u(nSamplesRandom);
double sum_w=0;
std::vector<double> H0(nSamplesRandom);
std::vector<double> H(nSamplesRandom);
std::vector<double> p(nSamplesRandom);
if (rank==0)
init_progress_bar(maxNImg);
for (size_t idx=0; idx<=maxNImg;idx++)
{
if ((idx)%Nprocessors==rank)
{
if (useSignificant)
expression = formatString("imageIndex == %lu",idx);
else
expression = formatString("itemId == %lu",idx);
tempMd.importObjects(md, MDExpression(expression));
if (tempMd.size()==0)
continue;
//compute H_0 from noise
obtainSumU_2(mdGallery, tempMd,sum_u,H0);
//compute H from experimental
obtainSumW(tempMd,sum_w,sum_u,H,correction);
std::sort(H0.begin(),H0.end());
std::sort(H.begin(),H.end());
double P = 0;
for(size_t j=0; j<sum_u.size();j++)
{
//P += H0.at(j)/H.at(j);
P += H0.at(size_t((1-significance_noise)*nSamplesRandom))/H.at(j);
p.at(j) = H0.at(j)/H.at(j);
}
P /= (nSamplesRandom);
if (useSignificant)
rowP.setValue(MDL_IMAGE_IDX,idx);
else
rowP.setValue(MDL_ITEM_ID,idx);
rowP.setValue(MDL_WEIGHT,P);
mdPartial.addRow(rowP);
tempMd.clear();
if (rank==0)
progress_bar(idx+1);
}
}
if (rank==0)
progress_bar(maxNImg);
synchronize();
gatherClusterability();
if (rank == 0)
{
mdPartial.write(fnOut);
std::vector<double> P;
mdPartial.getColumnValues(MDL_WEIGHT,P);
for (size_t idx=0; idx< P.size();idx++)
{
if (P[idx] > 1)
validation += 1.;
num_images += 1.;
}
validation /= (num_images);
row2.setValue(MDL_IMAGE,fnInit);
row2.setValue(MDL_WEIGHT,validation);
mdOut2.addRow(row2);
mdOut2.write(fnOut2);
}
}
static void meshdeform_matrix_solve(MeshDeformBind *mdb)
{
NLContext *context;
float vec[3], gridvec[3];
int a, b, x, y, z, totvar;
char message[1024];
/* setup variable indices */
mdb->varidx= MEM_callocN(sizeof(int)*mdb->size3, "MeshDeformDSvaridx");
for(a=0, totvar=0; a<mdb->size3; a++)
mdb->varidx[a]= (mdb->tag[a] == MESHDEFORM_TAG_EXTERIOR)? -1: totvar++;
if(totvar == 0) {
MEM_freeN(mdb->varidx);
return;
}
progress_bar(0, "Starting mesh deform solve");
/* setup opennl solver */
nlNewContext();
context= nlGetCurrent();
nlSolverParameteri(NL_NB_VARIABLES, totvar);
nlSolverParameteri(NL_NB_ROWS, totvar);
nlSolverParameteri(NL_NB_RIGHT_HAND_SIDES, 1);
nlBegin(NL_SYSTEM);
nlBegin(NL_MATRIX);
/* build matrix */
for(z=0; z<mdb->size; z++)
for(y=0; y<mdb->size; y++)
for(x=0; x<mdb->size; x++)
meshdeform_matrix_add_cell(mdb, x, y, z);
/* solve for each cage vert */
for(a=0; a<mdb->totcagevert; a++) {
if(a != 0) {
nlBegin(NL_SYSTEM);
nlBegin(NL_MATRIX);
}
/* fill in right hand side and solve */
for(z=0; z<mdb->size; z++)
for(y=0; y<mdb->size; y++)
for(x=0; x<mdb->size; x++)
meshdeform_matrix_add_rhs(mdb, x, y, z, a);
nlEnd(NL_MATRIX);
nlEnd(NL_SYSTEM);
#if 0
nlPrintMatrix();
#endif
if(nlSolveAdvanced(NULL, NL_TRUE)) {
for(z=0; z<mdb->size; z++)
for(y=0; y<mdb->size; y++)
for(x=0; x<mdb->size; x++)
meshdeform_matrix_add_semibound_phi(mdb, x, y, z, a);
for(z=0; z<mdb->size; z++)
for(y=0; y<mdb->size; y++)
for(x=0; x<mdb->size; x++)
meshdeform_matrix_add_exterior_phi(mdb, x, y, z, a);
for(b=0; b<mdb->size3; b++) {
if(mdb->tag[b] != MESHDEFORM_TAG_EXTERIOR)
mdb->phi[b]= nlGetVariable(0, mdb->varidx[b]);
mdb->totalphi[b] += mdb->phi[b];
}
if(mdb->weights) {
/* static bind : compute weights for each vertex */
for(b=0; b<mdb->totvert; b++) {
if(mdb->inside[b]) {
copy_v3_v3(vec, mdb->vertexcos[b]);
gridvec[0]= (vec[0] - mdb->min[0] - mdb->halfwidth[0])/mdb->width[0];
gridvec[1]= (vec[1] - mdb->min[1] - mdb->halfwidth[1])/mdb->width[1];
gridvec[2]= (vec[2] - mdb->min[2] - mdb->halfwidth[2])/mdb->width[2];
mdb->weights[b*mdb->totcagevert + a]= meshdeform_interp_w(mdb, gridvec, vec, a);
}
}
}
else {
MDefBindInfluence *inf;
/* dynamic bind */
for(b=0; b<mdb->size3; b++) {
if(mdb->phi[b] >= MESHDEFORM_MIN_INFLUENCE) {
inf= BLI_memarena_alloc(mdb->memarena, sizeof(*inf));
inf->vertex= a;
inf->weight= mdb->phi[b];
inf->next= mdb->dyngrid[b];
mdb->dyngrid[b]= inf;
}
}
}
}
else {
error("Mesh Deform: failed to find solution.");
break;
}
sprintf(message, "Mesh deform solve %d / %d |||", a+1, mdb->totcagevert);
progress_bar((float)(a+1)/(float)(mdb->totcagevert), message);
}
#if 0
/* sanity check */
for(b=0; b<mdb->size3; b++)
if(mdb->tag[b] != MESHDEFORM_TAG_EXTERIOR)
if(fabs(mdb->totalphi[b] - 1.0f) > 1e-4)
printf("totalphi deficiency [%s|%d] %d: %.10f\n",
(mdb->tag[b] == MESHDEFORM_TAG_INTERIOR)? "interior": "boundary", mdb->semibound[b], mdb->varidx[b], mdb->totalphi[b]);
#endif
/* free */
MEM_freeN(mdb->varidx);
nlDeleteContext(context);
}
double optimiseTransformationMatrix(bool do_optimise_nr_pairs)
{
std::vector<int> best_pairs_t2u, best_map;
double score, best_score, best_dist=9999.;
if (do_optimise_nr_pairs)
best_score = 0.;
else
best_score = -999999.;
int nn = XMIPP_MAX(1., (rotF-rot0)/rotStep);
nn *= XMIPP_MAX(1., (tiltF-tilt0)/tiltStep);
nn *= XMIPP_MAX(1., (xF-x0)/xStep);
nn *= XMIPP_MAX(1., (yF-y0)/yStep);
int n = 0;
init_progress_bar(nn);
for (double rot = rot0; rot <= rotF; rot+= rotStep)
{
for (double tilt = tilt0; tilt <= tiltF; tilt+= tiltStep)
{
// Assume tilt-axis lies in-plane...
double psi = -rot;
// Rotate all points correspondingly
Euler_angles2matrix(rot, tilt, psi, Pass);
//std::cerr << " Pass= " << Pass << std::endl;
// Zero-translations for now (these are added in the x-y loops below)
MAT_ELEM(Pass, 0, 2) = MAT_ELEM(Pass, 1, 2) = 0.;
mapOntoTilt();
for (int x = x0; x <= xF; x += xStep)
{
for (int y = y0; y <= yF; y += yStep, n++)
{
if (do_optimise_nr_pairs)
score = getNumberOfPairs(x, y);
else
score = -getAverageDistance(x, y); // negative because smaller distance is better!
bool is_best = false;
if (do_optimise_nr_pairs && score==best_score)
{
double dist = getAverageDistance(x, y);
if (dist < best_dist)
{
best_dist = dist;
is_best = true;
}
}
if (score > best_score || is_best)
{
best_score = score;
best_pairs_t2u = pairs_t2u;
best_rot = rot;
best_tilt = tilt;
best_x = x;
best_y = y;
}
if (n%1000==0) progress_bar(n);
}
}
}
}
progress_bar(nn);
// Update pairs with the best_pairs
if (do_optimise_nr_pairs)
pairs_t2u = best_pairs_t2u;
// Update the Passing matrix and the mapping
Euler_angles2matrix(best_rot, best_tilt, -best_rot, Pass);
// Zero-translations for now (these are added in the x-y loops below)
MAT_ELEM(Pass, 0, 2) = MAT_ELEM(Pass, 1, 2) = 0.;
mapOntoTilt();
return best_score;
}
void runThread(ThreadArgument &thArg)
{
int thread_id = thArg.thread_id;
ProgXrayImport * ptrProg= (ProgXrayImport *)thArg.workClass;
MetaData localMD;
Image<double> Iaux;
FileName fnImgIn, fnImgOut;
size_t first = 0, last = 0;
MultidimArray<char> mask;
while (ptrProg->td->getTasks(first, last))
{
for (size_t i=first; i<=last; i++)
{
ptrProg->inMD.getValue(MDL_IMAGE, fnImgIn, ptrProg->objIds[i]);
MDRow rowGeo;
ptrProg->readGeoInfo(fnImgIn, rowGeo);
// ptrProg->readAndCrop(fnImgIn, Iaux, ptrProg->cropSizeX, ptrProg->cropSizeY);
Iaux.read(fnImgIn);
Iaux().selfWindow(ptrProg->cropSizeYi,ptrProg->cropSizeXi,
(int)(YSIZE(Iaux())-ptrProg->cropSizeYe-1),(int)(XSIZE(Iaux())-ptrProg->cropSizeXe-1));
Iaux().resetOrigin();
if (XSIZE(ptrProg->IavgDark())!=0)
{
Iaux()-=ptrProg->IavgDark();
forcePositive(Iaux());
}
double currentBeam = 1;
double expTime = 1;
double slitWidth = 1;
if ( ptrProg->dSource == ptrProg->MISTRAL )
{
size_t idx = fnImgIn.getPrefixNumber();
currentBeam = dMi(ptrProg->cBeamArray, idx-1);
expTime = dMi(ptrProg->expTimeArray, idx-1);
slitWidth = dMi(ptrProg->slitWidthArray, idx-1);
}
else
ptrProg->readCorrectionInfo(fnImgIn, currentBeam, expTime, slitWidth);
Iaux() *= 1.0/(currentBeam*expTime*slitWidth);
if (XSIZE(ptrProg->IavgFlat())!=0)
Iaux()/=ptrProg->IavgFlat();
// Assign median filter to zero valued pixels to avoid -inf when applying log10
Iaux().equal(0,mask);
mask.resizeNoCopy(Iaux());
if (XSIZE(ptrProg->bpMask()) != 0)
mask += ptrProg->bpMask();
boundMedianFilter(Iaux(), mask);
if (ptrProg->logFix)
{
Iaux().selfLog();
if (ptrProg->selfAttFix)
Iaux() *= -1.;
}
fnImgOut.compose(i+1, ptrProg->fnOut);
size_t objId = localMD.addObject();
localMD.setValue(MDL_IMAGE,fnImgOut,objId);
localMD.setRow(rowGeo, objId); //
// localMD.setValue(MDL_ANGLE_TILT,Iaux.tilt(),objId);
Iaux.write(fnImgOut);
if (thread_id==0)
progress_bar(i);
}
}
//Lock for update the total counter
ptrProg->mutex.lock();
ptrProg->outMD.unionAll(localMD);
ptrProg->mutex.unlock();
}
