void
astrometryC(FL_OBJECT *obj, long val)
{
int m;
int x, y, z;
m = fl_get_menu(obj);
switch (m) {
case EDIT_PARAMETERS:
edit_parameters(obj, m);
break;
case DETECT_STARS:
detect_stars(frame, state.control[state.control_num]);
break;
case MATCH_STARS:
match_stars(frame, state.control[state.control_num]);
break;
case SAVE_STAR_LIST:
star_list(frame, state.control[state.control_num]);
break;
case LOAD_STAR_LIST:
load_star_list(frame, state.control[state.control_num]);
break;
case DO_ASTROMETRY:
state.doastr = 1;
fl_get_mouse(&x, &y, &z);
fl_set_mouse(0, 0);
fl_set_mouse(x, y);
break;
case OPTIONS:
edit_options(obj, m);
break;
case CATALOGS:
edit_catalogs(obj, m);
break;
case SAVE_SETTINGS:
show_settings(obj, m);
break;
case SEND_MAIL:
edit_mail(obj, m);
break;
case SHOW_REPORT:
show_report();
break;
}
}
void StarFinder::roughlyFitBrightStars(
const std::vector<PotentialStar*>& obj_list,
Function2D *f,double *out_sigma)
{
// obj_list is already sorted by magnitude
// make a new list with just the 50 brightest objects:
std::vector<PotentialStar*> bright_list(
obj_list.begin(),
obj_list.begin()+int(_nstart1*obj_list.size()));
// now sort this list by size
std::sort(bright_list.begin(),bright_list.end(),
std::mem_fun(&PotentialStar::isSmallerThan));
xdbg<<"brightlist is:\n";
const int twenty = std::min(20,int(bright_list.size()));
for(int i=0; i<twenty; ++i) {
xdbg<<bright_list[i]->getMag()<<" , "<<
bright_list[i]->getSize()<<std::endl;
}
if (bright_list.size() > 20) {
xdbg<<"... (total of "<<bright_list.size()<<" elements)\n";
}
// Of the smallest 20, find the 5 that form the tightest peak
// Originally I hardcoded this number as 5, but now it is calculated
// from _star_frac.
int five = int(0.5*_star_frac*bright_list.size());
xdbg<<"'five' = "<<five<<std::endl;
if (five < 5) {
five = 5;
xdbg<<"'five' => "<<five<<std::endl;
}
if (3*five-1 >= int(bright_list.size())) {
std::ostringstream err;
err<<"Too few objects in bright_list. Increase startn1.";
throw StarFinderException(err.str());
}
int peak_start = 0;
double peakWidth = bright_list[five-1]->getSize()-bright_list[0]->getSize();
for(int k=1;k<=2*five;++k) {
Assert(k+five-1<int(bright_list.size()));
double sizeRange = bright_list[k+five-1]->getSize() -
bright_list[k]->getSize();
if (sizeRange < peakWidth) {
peakWidth = bright_list[k+five-1]->getSize() -
bright_list[k]->getSize();
peak_start = k;
}
}
xdbg<<"found peak starting at "<<peak_start<<
" with width "<<peakWidth<<std::endl;
int k1=peak_start, k2=peak_start+five;
// Now expand list to be 2*bin_size1 wide
while (
k1 > 0 && bright_list[peak_start+2]->getSize() -
bright_list[k1-1]->getSize() < _bin_size1) {
--k1;
}
const int nbright = bright_list.size();
while (
k2 < nbright &&
bright_list[k2]->getSize() - bright_list[k1]->getSize() < 2.*_bin_size1) {
++k2;
}
xdbg<<"expanded to "<<k1<<','<<k2<<std::endl;
// Call these objects in the expanded peak stars
std::vector<PotentialStar*> star_list(
bright_list.begin()+k1, bright_list.begin()+k2);
// Fit f using a linear fit with 2 sigma clipping
fitStellarSizes(f,0,2.,star_list,out_sigma);
// if sigma is too big, drop either the first or last "star" and try again.
while(*out_sigma > _max_rms && star_list.size() > 4) {
double diff1 = star_list.front()->getSize() -
(*f)(star_list.front()->getPos());
double diff2 = star_list.back()->getSize() -
(*f)(star_list.back()->getPos());
if (std::abs(diff1) > std::abs(diff2)) {
star_list.erase(star_list.begin());
xdbg<<"Erased first star. New size = "<<star_list.size()<<std::endl;
} else {
star_list.erase(star_list.end()-1);
xdbg<<"Erased last star. New size = "<<star_list.size()<<std::endl;
}
fitStellarSizes(f,0,2.,star_list,out_sigma);
}
}
