void StaffTypeTablature::setFretMetrics()
{
if(_fretMetricsValid && _refDPI == MScore::DPI)
return;
QFontMetricsF fm(fretFont());
// compute total height of used characters
QRectF bb(fm.tightBoundingRect(_useNumbers ? g_strNumbers : g_strLetters));
// compute vertical displacement
if(_useNumbers) {
// for numbers: centre on '0': move down by the whole part above (negative)
// the base line ( -bb.y() ) then up by half the whole height ( -bb.height()/2 )
QRectF bx( fm.tightBoundingRect("0") );
_fretYOffset = -(bx.y() + bx.height()/2.0);
// _fretYOffset = -(bb.y() + bb.height()/2.0); // <- using bbox of all chars
}
else {
// for letters: centre on the 'a' ascender, by moving down half of the part above the base line in bx
QRectF bx( fm.tightBoundingRect("a") );
_fretYOffset = -bx.y() / 2.0;
}
// if on string, we are done; if between strings, raise by half line distance
if(!_onLines)
_fretYOffset -= lineDistance().val()*MScore::DPI*SPATIUM20 / 2.0;
// from _fretYOffset, compute _charBoxH and _charBoxY
_fretBoxH = bb.height();
_fretBoxY = bb.y() + _fretYOffset;
// keep track of the conditions under which metrics have been computed
_refDPI = MScore::DPI;
_fretMetricsValid = true;
}
Word ea()
{
modRM = fetchByte();
useMemory = true;
switch (modRM & 7) {
case 0: segment = 3; address = bx() + si(); break;
case 1: segment = 3; address = bx() + di(); break;
case 2: segment = 2; address = bp() + si(); break;
case 3: segment = 2; address = bp() + di(); break;
case 4: segment = 3; address = si(); break;
case 5: segment = 3; address = di(); break;
case 6: segment = 2; address = bp(); break;
case 7: segment = 3; address = bx(); break;
}
switch (modRM & 0xc0) {
case 0x00:
if ((modRM & 0xc7) == 6) {
segment = 3;
address = fetchWord();
}
break;
case 0x40: address += signExtend(fetchByte()); break;
case 0x80: address += fetchWord(); break;
case 0xc0:
useMemory = false;
address = modRM & 7;
}
return address;
}
void RBFVectorFieldGenerator2D::process() {
if (samples_.size() != static_cast<size_t>(seeds_.get())) {
createSamples();
}
Eigen::MatrixXd A(seeds_.get(), seeds_.get());
Eigen::VectorXd bx(seeds_.get()), by(seeds_.get());
Eigen::VectorXd xx(seeds_.get()), xy(seeds_.get());
int row = 0;
for (auto &a : samples_) {
int col = 0;
for (auto &b : samples_) {
auto r = glm::distance(a.first, b.first);
A(row, col++) = shape_.get() + gaussian_.evaluate(r);
}
bx(row) = a.second.x;
by(row++) = a.second.y;
}
auto solverX = A.llt();
auto solverY = A.llt();
xx = solverX.solve(bx);
xy = solverY.solve(by);
auto img = std::make_shared<Image>(size_.get(), DataVec4Float32::get());
vec4 *data =
static_cast<vec4 *>(img->getColorLayer()->getEditableRepresentation<LayerRAM>()->getData());
int i = 0;
for (int y = 0; y < size_.get().y; y++) {
for (int x = 0; x < size_.get().x; x++) {
dvec2 p(x, y);
p /= size_.get();
p *= 2;
p -= 1;
vec3 v(0, 0, 0);
int s = 0;
for (; s < seeds_.get(); s++) {
double r = glm::distance(p, samples_[s].first);
auto w = gaussian_.evaluate(r);
v.x += static_cast<float>(xx(s) * w);
v.y += static_cast<float>(xy(s) * w);
}
data[i++] = vec4(v, 1.0f);
}
}
vectorField_.setData(img);
}
void
edit_graphics_rep::set_graphical_object (tree t) {
go_box= box ();
graphical_object= t;
if (N (graphical_object) == 0) return;
edit_env env= get_typesetter ()->env;
//tree old_fr= env->local_begin (GR_FRAME, (tree) find_frame ());
frame f_env= env->fr;
env->fr= find_frame ();
if (!is_nil (env->fr)) {
int i,n=0;
go_box= typeset_as_concat (env, t, path (0));
for (i=0; i<N(go_box); i++)
if (go_box[i]!="") n++;
if (n) {
array<box> bx(n);
n=0;
for (i=0; i<N(go_box); i++) if (go_box[i]!="") {
array<box> bx2(1);
array<SI> spc2(1);
bx2[0]= go_box[i];
spc2[0]=0;
bx[n]= concat_box (path (0), bx2, spc2);
n++;
}
go_box= composite_box (path (0), bx);
}
}
env->fr= f_env;
//env->local_end (GR_FRAME, old_fr);
}
Box
BoxLib::enclosedCells (const Box& b)
{
Box bx(b);
bx.enclosedCells();
return bx;
}
Box
BoxLib::convert (const Box& b, const IndexType& t)
{
Box bx(b);
bx.convert(t);
return bx;
}
Box
BoxLib::convert (const Box& b, const IntVect& typ)
{
Box bx(b);
bx.convert(typ);
return bx;
}
Box
BoxLib::surroundingNodes (const Box& b)
{
Box bx(b);
bx.surroundingNodes();
return bx;
}
template<typename CellList> void Test_CellDecomposer_consistent()
{
Box<2,float> bx({-1.0/3.0,-1.0/3.0},{1.0/3.0,1.0/3.0});
size_t div[2] = {36,36};
CellDecomposer_sm<2,float,shift<2,float>> cd(bx,div,1);
Box<2,float> bx_sub({-1.0/5.0,-1.0/5.0},{1.0/5.0,1.0/5.0});
size_t bc[2] = {NON_PERIODIC,NON_PERIODIC};
CellList cl(cd,bx_sub);
Box<2,long int> bx_int = cd.convertDomainSpaceIntoGridUnits(bx_sub,bc);
BOOST_REQUIRE_EQUAL(bx_int.getLow(0),8);
BOOST_REQUIRE_EQUAL(bx_int.getLow(1),8);
BOOST_REQUIRE_EQUAL(bx_int.getHigh(0),28);
BOOST_REQUIRE_EQUAL(bx_int.getHigh(1),28);
cd.convertCellUnitsIntoDomainSpace(bx_sub);
BOOST_REQUIRE_EQUAL(bx_sub.getLow(0),-1.0f/5.0f);
BOOST_REQUIRE_EQUAL(bx_sub.getLow(1),-1.0f/5.0f);
BOOST_REQUIRE_EQUAL(bx_sub.getHigh(0),1.0f/5.0f);
BOOST_REQUIRE_EQUAL(bx_sub.getHigh(1),1.0f/5.0f);
}
Box
BoxLib::surroundingNodes (const Box& b,
int dir)
{
Box bx(b);
bx.surroundingNodes(dir);
return bx;
}
Box
BoxLib::enclosedCells (const Box& b,
int dir)
{
Box bx(b);
bx.enclosedCells(dir);
return bx;
}
Vec3q SATSampler::operator()(const Vec2q &uv,const Vec2q &diff) const {
f32x4b fullMask=diff.x>=0.5f||diff.x>= 0.5f;
if(ForAll(fullMask)) return Vec3q(avg.x,avg.y,avg.z);
Vec2q tDiff=diff*floatq(0.5f);
Vec2q a=(uv-tDiff),b=(uv+tDiff);
a*=Vec2q(floatq(w),floatq(h));
b*=Vec2q(floatq(w),floatq(h));
i32x4 ax(a.x),ay(a.y);
i32x4 bx(b.x),by(b.y);
ax&=wMask; ay&=hMask;
bx&=wMask; by&=hMask;
union { __m128 count; float countf[4]; };
TSample sum[4];
i32x4 one(1);
if(ForAll(ax<=bx&&ay<=by)) {
count = (f32x4(by-ay+one)*f32x4(bx-ax+one)).m;
ComputeRect(ax,ay,bx,by,sum);
}
else for(int k=0;k<4;k++) {
if(ax[k]>bx[k]) {
if(ay[k]>by[k]) {
countf[k]=(bx[k]+1)*(by[k]+1)+(w-ax[k])*(h-ay[k]);
sum[k]=ComputeRect(0,0,bx[k],by[k])+ComputeRect(ax[k],ay[k],w-1,h-1);
}
else {
countf[k]=(bx[k]+1+w-ax[k])*(by[k]-ay[k]+1);
sum[k]=ComputeRect(0,ay[k],bx[k],by[k])+ComputeRect(ax[k],ay[k],w-1,by[k]);
}
}
else {
if(ay[k]>by[k]) {
countf[k]=(bx[k]-ax[k]+1)*(by[k]+h+1-ay[k]);
sum[k]=ComputeRect(ax[k],0,bx[k],by[k])+ComputeRect(ax[k],ay[k],bx[k],h-1);
}
else {
countf[k]=(by[k]-ay[k]+1)*(bx[k]-ax[k]+1);
sum[k]=ComputeRect(ax[k],ay[k],bx[k],by[k]);
}
}
}
union {
__m128 out[3];
struct { float ox[4]; float oy[4]; float oz[4]; } o;
};
o.ox[0]=sum[0].R(); o.oy[0]=sum[0].G(); o.oz[0]=sum[0].B();
o.ox[1]=sum[1].R(); o.oy[1]=sum[1].G(); o.oz[1]=sum[1].B();
o.ox[2]=sum[2].R(); o.oy[2]=sum[2].G(); o.oz[2]=sum[2].B();
o.ox[3]=sum[3].R(); o.oy[3]=sum[3].G(); o.oz[3]=sum[3].B();
return Condition(fullMask,Vec3q(avg.x,avg.y,avg.z),
Vec3q(out[0], out[1], out[2]) * Inv(floatq(count) * 255.0f));
}
QGroupBox* GuiPreferences::createUpdateBtnsGrp(void)
{
QGroupBox* bx(new QGroupBox(tr("Update Actions")));
QHBoxLayout* lyt(new QHBoxLayout());
lyt->addWidget(m_applySettingBtn);
lyt->addWidget(m_addAsSourceBtn);
lyt->addWidget(m_deleteSourceBtn);
bx->setLayout(lyt);
return bx;
}
bool KL2Map_Base::_InsertJointToBlock(const _Node_Lite * pNode)
{ PERF_COUNTER(KL2Map_Base__InsertJointToBlock);
ASSERT_RETURN(pNode, false);
int_r bx(-1), by(-1);
GetJointBlockPos(pNode->x, pNode->y, bx, by);
ASSERT_RETURN(bx >= 0, false);
ASSERT_RETURN(by >= 0, false);
return m_L2MapByBlock[bx][by].insert_unique(pNode) > -1;
}
void StaffTypeTablature::setFretMetrics()
{
if(_fretMetricsValid && _refDPI == MScore::DPI)
return;
QFontMetricsF fm(fretFont());
QRectF bb;
// compute vertical displacement
if(_useNumbers) {
// compute total height of used characters
QString txt = QString();
for (int idx = 0; idx < 10; idx++) // use only first 10 digits
txt.append(_fretFonts[_fretFontIdx].displayDigit[idx]);
bb = fm.tightBoundingRect(txt);
// for numbers: centre on '0': move down by the whole part above (negative)
// the base line ( -bb.y() ) then up by half the whole height ( -bb.height()/2 )
QRectF bx( fm.tightBoundingRect(_fretFonts[_fretFontIdx].displayDigit[0]) );
_fretYOffset = -(bx.y() + bx.height()/2.0);
// _fretYOffset = -(bb.y() + bb.height()/2.0); // <- using bbox of all chars
}
else {
// compute total height of used characters
QString txt(_fretFonts[_fretFontIdx].displayLetter, NUM_OF_LETTERFRETS);
bb = fm.tightBoundingRect(txt);
// for letters: centre on the 'a' ascender, by moving down half of the part above the base line in bx
QRectF bx( fm.tightBoundingRect(_fretFonts[_fretFontIdx].displayLetter[0]) );
_fretYOffset = -bx.y() / 2.0;
}
// if on string, we are done; if between strings, raise by half line distance
if(!_onLines)
_fretYOffset -= lineDistance().val()*MScore::DPI*SPATIUM20 / 2.0;
// from _fretYOffset, compute _charBoxH and _charBoxY
_fretBoxH = bb.height();
_fretBoxY = bb.y() + _fretYOffset;
// keep track of the conditions under which metrics have been computed
_refDPI = MScore::DPI;
_fretMetricsValid = true;
}
int main()
{
Delaunay_triangulation T;
Point_value_map value_function;
Point_vector_map gradient_function;
//parameters for spherical function:
Coord_type a(0.25), bx(1.3), by(-0.7), c(0.2);
for (int y=0; y<4; y++) {
for (int x=0; x<4; x++) {
K::Point_2 p(x,y);
T.insert(p);
value_function.insert(std::make_pair(p,a + bx* x+ by*y + c*(x*x+y*y)));
}
}
sibson_gradient_fitting_nn_2(T, std::inserter(gradient_function,
gradient_function.begin()),
CGAL:: Data_access<Point_value_map>(value_function),
Traits());
for(Point_vector_map::iterator it = gradient_function.begin(); it != gradient_function.end(); ++it)
{
std::cout << it->first << " " << it->second << std::endl;
}
// coordinate computation
K::Point_2 p(1.6, 1.4);
std::vector< std::pair< Point, Coord_type > > coords;
Coord_type norm = CGAL::natural_neighbor_coordinates_2(T, p, std::back_inserter(coords)).second;
//Sibson interpolant: version without sqrt:
std::pair<Coord_type, bool> res =
CGAL::sibson_c1_interpolation_square(coords.begin(),
coords.end(), norm, p,
CGAL::Data_access<Point_value_map>(value_function),
CGAL::Data_access<Point_vector_map>(gradient_function),
Traits());
if(res.second)
std::cout << "Tested interpolation on " << p
<< " interpolation: " << res.first << " exact: "
<< a + bx*p.x() + by*p.y() + c*(p.x()*p.x()+p.y()*p.y())
<< std::endl;
else
std::cout << "C^1 Interpolation not successful." << std::endl
<< " not all gradients are provided." << std::endl
<< " You may resort to linear interpolation." << std::endl;
return EXIT_SUCCESS;
}
void show_cb(Fl_Widget *,void *)
{
Fl_Popup_Window pw(10,10,200,200,"Popup Window");
pw.box(FL_BORDER_BOX);
pwp = &pw;
Fl_Box bx(5,5,190,50,"Click on the button \nor outside this window");
bx.align(FL_ALIGN_INSIDE|FL_ALIGN_CENTER);
Fl_Button bt(10,60,180,20,"Click me");
bt.callback(hide_cb);
pw.end();
pw.show_popup();
}
QGroupBox* GuiPreferences::createCommonGrp(void)
{
QHBoxLayout* sourceBtnsLyt(new QHBoxLayout());
sourceBtnsLyt = new QHBoxLayout();
sourceBtnsLyt->setContentsMargins(0,0,0,0);
sourceBtnsLyt->setMargin(0);
for (int i=0; i<MAX_SRCS; ++i)
{
QRadioButton* btn(new QRadioButton(QString::number(i)));
btn->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
m_sourceBtns.push_back(btn);
connect(btn, SIGNAL(clicked()), this, SLOT(handleSourceSelected()));
sourceBtnsLyt->addWidget(btn);
}
int line =0;
QGridLayout* lyt(new QGridLayout());
lyt->addWidget(new QLabel(tr("Sources")), line, 0),
lyt->addLayout(sourceBtnsLyt, line, 1, 1, 1, Qt::AlignLeft);
lyt->addWidget(new QLabel(tr("Monitor Web URL*")), ++line, 0),
lyt->addWidget(m_monitorUrlField, line, 1),
m_monitorTypeField->addItem(tr("Select a monitor type")),
m_monitorTypeField->addItems(ngrt4n::sourceTypes()),
lyt->addWidget(m_monitorTypeField, line, 2);
lyt->addWidget(m_verifySslPeerChkBx, ++line, 0, 1, 3, Qt::AlignCenter);
lyt->addWidget(new QLabel(tr("Auth String")), ++line, 0),
lyt->addWidget(m_serverPassField, line, 1),
lyt->addWidget(m_showAuthInfoChkbx, line, 2);
lyt->addWidget(new QLabel(tr("Update Interval")), ++line, 0),
m_updateIntervalField->setMinimum(5),
m_updateIntervalField->setMaximum(1200),
lyt->addWidget(m_updateIntervalField, line, 1),
lyt->addWidget(new QLabel(tr("seconds")), line, 2);
lyt->addWidget(new QLabel(tr("Language")), ++line, 0),
lyt->addWidget(m_languageBoxField);
lyt->setColumnStretch(0, 0);
lyt->setColumnStretch(1, 1);
QGroupBox* bx(new QGroupBox(tr("Common Settings")));
bx->setFlat(false);
bx->setLayout(lyt);
bx->setAlignment(Qt::AlignLeft);
return bx;
}
int main()
{
box bx(point(2, 0), point(6, 4.5));
polygon poly;
bg::exterior_ring(poly) = boost::assign::list_of<point>
(1, 1)
(5, 5)
(5, 1)
(1, 1)
;
std::vector<polygon> out;
bg::intersection(bx, poly, out);
save_svg("intersection.svg", bx, poly, out);
}
Joint Filter::Filter_LeastSquare(Joint joint)
{
LS_count++;
LS_List.push_back(joint);
while (LS_count > LS_n)
{
LS_count--;
LS_List.erase(LS_List.begin());
}
if (LS_count < LS_n)
{
return joint;
}
//Generate b
Mat bx(LS_m, 1, CV_64FC1);
Mat by(LS_m, 1, CV_64FC1);
for (int i = 0; i < LS_m; i++)
{
bx.at<double>(i, 0) = 0;
by.at<double>(i, 0) = 0;
for (int j = 0; j < LS_n; j++)
{
double t = LS_t0 + j*LS_delta;
double xt = LS_List[j].Position.X * pow(t, i);
bx.at<double>(i, 0) += xt;
double yt = LS_List[j].Position.Y * pow(t, i);
by.at<double>(i, 0) += yt;
}
}
Mat ax = LS_A.inv()*bx;
Mat ay = LS_A.inv()*by;
double x = 0; double y = 0;
double t = LS_t0 + LS_n*LS_delta;
for (int i = 0; i < LS_m; i++)
{
x += ax.at<double>(i, 0)*pow(t, i);
y += ay.at<double>(i, 0)*pow(t, i);
}
Joint result;
result = joint;
result.Position.X = x;
result.Position.Y = y;
return result;
}
Box
MFIter::tilebox () const
{
Box bx(pta->tileArray[currentIndex]);
if (! typ.cellCentered())
{
bx.convert(typ);
const IntVect& Big = validbox().bigEnd();
for (int d=0; d<BL_SPACEDIM; ++d) {
if (typ.nodeCentered(d)) { // validbox should also be nodal in d-direction.
if (bx.bigEnd(d) < Big[d]) {
bx.growHi(d,-1);
}
}
}
}
return bx;
}
QGroupBox* GuiPreferences::createScktGrp(void)
{
QGroupBox* bx(new QGroupBox(tr("Livestatus/Ngrt4nd Endpoint")));
QHBoxLayout* lyt(new QHBoxLayout());
lyt->addWidget(new QLabel(tr("Server Address")));
lyt->addWidget(m_sockAddrField);
lyt->addWidget(new QLabel(tr("Port")), Qt::AlignRight);
lyt->addWidget(m_sockPortField);
lyt->addWidget(m_useNgrt4ndChkbx);
lyt->setStretch(0, 0);
lyt->setStretch(1, 1);
lyt->setStretch(2, 0);
lyt->setStretch(3, 0);
lyt->setStretch(4, 0);
bx->setFlat(false);
lyt->setMargin(0);
bx->setLayout(lyt);
bx->setAlignment(Qt::AlignLeft);
return bx;
}
int main()
{
Delaunay_triangulation T;
std::map<Point, Coord_type, K::Less_xy_2> function_values;
typedef CGAL::Data_access< std::map<Point, Coord_type, K::Less_xy_2 > >
Value_access;
Coord_type a(0.25), bx(1.3), by(-0.7);
for (int y=0 ; y<3 ; y++)
for (int x=0 ; x<3 ; x++){
K::Point_2 p(x,y);
T.insert(p);
function_values.insert(std::make_pair(p,a + bx* x+ by*y));
}
//coordinate computation
K::Point_2 p(1.3,0.34);
std::vector< std::pair< Point, Coord_type > > coords;
Coord_type norm =
CGAL::natural_neighbor_coordinates_2
(T, p,std::back_inserter(coords)).second;
Coord_type res = CGAL::linear_interpolation(coords.begin(), coords.end(),
norm,
Value_access(function_values));
std::cout << " Tested interpolation on " << p << " interpolation: "
<< res << " exact: " << a + bx* p.x()+ by* p.y()<< std::endl;
std::cout << "done" << std::endl;
//////////////////////////////////////////////////////////////////////
// own version
return 0;
}
void setup_coeffs(BoxArray& bs, MultiFab& alpha, MultiFab beta[], const Geometry& geom)
{
BL_PROFILE("setup_coeffs");
Real sigma = 1.0;
Real w = 1.0;
MultiFab cc_coef(bs,Ncomp,1); // cell-centered beta
for ( MFIter mfi(alpha); mfi.isValid(); ++mfi ) {
const Box& bx = mfi.validbox();
const int* alo = alpha[mfi].loVect();
const int* ahi = alpha[mfi].hiVect();
FORT_SET_ALPHA(alpha[mfi].dataPtr(),ARLIM(alo),ARLIM(ahi),
bx.loVect(),bx.hiVect(),dx);
const int* clo = cc_coef[mfi].loVect();
const int* chi = cc_coef[mfi].hiVect();
FORT_SET_CC_COEF(cc_coef[mfi].dataPtr(),ARLIM(clo),ARLIM(chi),
bx.loVect(),bx.hiVect(),dx, sigma, w);
}
// convert cell-centered beta to edges
for ( int n=0; n<BL_SPACEDIM; ++n ) {
for ( MFIter mfi(beta[n]); mfi.isValid(); ++mfi ) {
int i = mfi.index();
Box bx(bs[i]);
const int* clo = cc_coef[mfi].loVect();
const int* chi = cc_coef[mfi].hiVect();
const int* edgelo = beta[n][mfi].loVect();
const int* edgehi = beta[n][mfi].hiVect();
FORT_COEF_TO_EDGES(&n,beta[n][mfi].dataPtr(),ARLIM(edgelo),ARLIM(edgehi),
cc_coef[mfi].dataPtr(),ARLIM(clo),ARLIM(chi),
bx.loVect(),bx.hiVect());
}
}
}
Box
MFIter::nodaltilebox (int dir) const
{
Box bx(pta->tileArray[currentIndex]);
bx.convert(typ);
const IntVect& Big = validbox().bigEnd();
int d0, d1;
if (dir < 0) {
d0 = 0;
d1 = BL_SPACEDIM-1;
} else {
d0 = d1 = dir;
}
for (int d=d0; d<=d1; ++d) {
if (typ.cellCentered(d)) { // validbox should also be cell-centered in d-direction.
bx.surroundingNodes(d);
if (bx.bigEnd(d) <= Big[d]) {
bx.growHi(d,-1);
}
}
}
return bx;
}
int _tmain(int argc, _TCHAR* argv[])
{
if (bxsi(0x1111, 0x2222) != 0x3333)
return 1;
if (bxdi(0x1212, 0x2222) != 0x3434)
return 2;
if (bpsi(0x1234, 0x5678) != 0x68ac)
return 3;
if (bpdi(0xf000, 0x1000) != 0x0000)
return 4;
if (si(0xcafe) != 0xcafe)
return 5;
if (di(0xdead) != 0xdead)
return 5;
if (disp16() != 0xeeee)
return 6;
if (bx(0x1) != 0x1)
return 7;
if (bxsidisp8(0x1111, 0x2222) != 0x3334)
return 8;
if (bxsidisp16(0x1111, 0x2222) != 0x3333)
return 16;
if (reg(0xf0f0) != 0xf0f0)
return 32;
return 0;
}
void initialize_new_objects(parameter_t const& P, directory_structure_t const& ds,
geometric_info_t const& gi, object_info_t& oi,
vector<std::vector<std::string> > const &seq, int tt,
vector<CImg<unsigned char> > const& images,
vector<matrix<float> > const& grd,
vector<matrix<float> >& detected_rects)
{
int Ncam = seq.size();
vector<object_trj_t> & trlet_list=oi.trlet_list;
int nobj = trlet_list.size();
int num_new_obj = detected_rects(0).size1();
int T = seq[0].size();
int np = oi.model.size();
int num_scales = P.scales.size();
for(int oo=0; oo<num_new_obj; ++oo)
{
int nn = oi.curr_num_obj + oo;
trlet_list(nn).startt = tt;
trlet_list(nn).endt = tt;
trlet_list(nn).state = 1;
trlet_list(nn).trj = vector<matrix<float> >(Ncam);
for(int cam=0; cam<Ncam; ++cam)
{
trlet_list(nn).trj(cam) = scalar_matrix<float>(T, 4, 0);
}
trlet_list(nn).trj_3d = scalar_matrix<float>(T, 2, 0);
trlet_list(nn).hist_p = vector<matrix<float> >(Ncam);
trlet_list(nn).hist_q = vector<matrix<float> >(Ncam);
trlet_list(nn).fscores = vector<matrix<float> >(Ncam);
trlet_list(nn).scores = scalar_matrix<float>(Ncam, T, 0);
vector<candidate_array<Float> > cand_array(Ncam);
for(int cam=0; cam<Ncam; ++cam)
{
trlet_list(nn).fscores(cam) = scalar_matrix<float>(np*2, T, 0);
float w = detected_rects(cam)(oo, 2)-detected_rects(cam)(oo, 0);
float h = detected_rects(cam)(oo, 3)-detected_rects(cam)(oo, 1);
row(trlet_list(nn).trj(cam), tt) = row(detected_rects(cam), oo);
matrix<float> rects;
compute_part_rects(detected_rects(cam)(oo, 0), detected_rects(cam)(oo, 1),
w, h, oi.model, rects);
pmodel_t pmodel;
vector<float> br(row(detected_rects(cam), oo));
rects_to_pmodel_geom(br, gi.horiz_mean, pmodel);
oi.pmodel_list(cam, nn) = pmodel;
//collect_sift(grd(cam), );
matrix<float> hist_p, hist_q;
collect_hist(images(cam), rects, hist_p, hist_q);
trlet_list(nn).hist_p(cam) = hist_p;
trlet_list(nn).hist_q(cam) = hist_q;
std::vector<float> sxr, syr;
for(float v=-P.xrange/2; v<=P.xrange/2; v+=P.xstep)
{
sxr.push_back(v);
}
for(float v=-P.yrange/2; v<=P.yrange/2; v+=P.ystep)
{
syr.push_back(v);
}
vector<float> xr(sxr.size()), yr(syr.size());
std::copy(sxr.begin(), sxr.end(), xr.begin());
std::copy(syr.begin(), syr.end(), yr.begin());
float feetx = (trlet_list(nn).trj(cam)(tt, 0)
+trlet_list(nn).trj(cam)(tt, 2))/2;
float feety = trlet_list(nn).trj(cam)(tt, 3);
matrix<Float> cand_rects;
vector<Float> cand_scale;
matrix<int> cand_ijs;
enumerate_rects_inpoly(images(cam), oi.pmodel_list(cam, nn),
feetx, feety,
xr, yr, P.scales, gi.horiz_mean, gi.horiz_sig,
gi.polys_im(cam),
cand_rects, cand_scale,
cand_ijs, cand_array(cam));
vector<Float> cand_hist_score;
matrix<Float> hist_fscores;
real_timer_t timer;
get_cand_hist_score(images(cam), oi.model, P.logp1, P.logp2,
trlet_list(nn).hist_p(cam),
trlet_list(nn).hist_q(cam),
cand_rects,
cand_hist_score, hist_fscores);
vector<Float> cand_score=cand_hist_score;
std::cout<<"\t\t"<<cand_rects.size1()<<" rects, \tget_cand_hist_score time:"
<<timer.elapsed()/1000.0f<<"s."<<std::endl;
int idx_max = std::max_element(cand_score.begin(), cand_score.end())
- cand_score.begin();
column(trlet_list(nn).fscores(cam), tt) = row(hist_fscores, idx_max);
trlet_list(nn).scores(cam, tt) = cand_score(idx_max);
cand_array(cam).fill_score(cand_score, cand_ijs);
}//end for cam
real_timer_t timer;
ground_scoremap_t<Float> grd_scoremap;
combine_ground_score(cand_array, grd_scoremap, gi);
int best_y, best_x, best_s;
grd_scoremap.peak(best_y, best_x, best_s);
for(int cam=0; cam<Ncam; ++cam)
{
vector<double> bx(1), by(1), ix, iy;
bx <<= best_x; by <<= best_y;
apply_homography(gi.grd2img(cam), bx, by, ix, iy);
float hpre = oi.pmodel_list(cam, nn).hpre;
float cur_fy = iy(0);
float cur_fx = ix(0);
float cur_hy = gi.horiz_mean+hpre*(cur_fy-gi.horiz_mean);
float ds = P.scales(best_s)*(cur_fy-cur_hy)/oi.pmodel_list(cam, nn).bh;
float ww = ds*oi.pmodel_list(cam, nn).bw;
float hh = cur_fy - cur_hy;
vector<Float> tmp(4);
tmp <<= (cur_fx-ww/2), cur_hy, (cur_fx+ww/2), cur_fy;
row(trlet_list(nn).trj(cam), tt) = tmp;
//std::cout<<"trlet_list(nn).trj(cam)(tt, :)="
// <<row(trlet_list(nn).trj(cam), tt)<<std::endl;
}//endfor cam
}//endfor oo
oi.curr_num_obj += num_new_obj;
}
void initialize_new_objects(mpi::communicator& world,
parameter_t const& P, directory_structure_t const& ds,
geometric_info_t const& gi, object_info_t& oi,
vector<std::vector<std::string> > const &seq, int tt,
vector<CImg<unsigned char> > const& images,
vector<matrix<float> > const& grd,
vector<matrix<float> >& detected_rects)
{
int Ncam = seq.size();
vector<object_trj_t> & trlet_list=oi.trlet_list;
int nobj = trlet_list.size();
int num_new_obj = detected_rects(0).size1();
int T = seq[0].size();
int np = oi.model.size();
int num_scales = P.scales.size();
//std::cout<<"detected_rects="<<detected_rects<<std::endl;
for(int oo=0; oo<num_new_obj; ++oo)
{
int nn = oi.curr_num_obj + oo;
trlet_list(nn).startt = tt;
trlet_list(nn).endt = tt;
trlet_list(nn).state = 1;
trlet_list(nn).trj = vector<matrix<float> >(Ncam);
for(int cam=0; cam<Ncam; ++cam)
{
trlet_list(nn).trj(cam) = scalar_matrix<float>(T, 4, 0);
}
trlet_list(nn).trj_3d = scalar_matrix<float>(T, 2, 0);
trlet_list(nn).hist_p = vector<matrix<float> >(Ncam);
trlet_list(nn).hist_q = vector<matrix<float> >(Ncam);
trlet_list(nn).fscores = vector<matrix<float> >(Ncam);
trlet_list(nn).scores = scalar_matrix<float>(Ncam, T, 0);
vector<candidate_array<Float> > cand_array(Ncam);
for(int cam=0; cam<Ncam; ++cam)
{
trlet_list(nn).fscores(cam) = scalar_matrix<float>(np*2, T, 0);
float w = detected_rects(cam)(oo, 2)-detected_rects(cam)(oo, 0);
float h = detected_rects(cam)(oo, 3)-detected_rects(cam)(oo, 1);
row(trlet_list(nn).trj(cam), tt) = row(detected_rects(cam), oo);
matrix<float> rects;
compute_part_rects(detected_rects(cam)(oo, 0), detected_rects(cam)(oo, 1),
w, h, oi.model, rects);
pmodel_t pmodel;
vector<float> br(row(detected_rects(cam), oo));
rects_to_pmodel_geom(br, gi.horiz_mean, pmodel);
oi.pmodel_list(cam, nn) = pmodel;
//collect_sift(grd(cam), );
matrix<float> hist_p, hist_q;
collect_hist(images(cam), rects, hist_p, hist_q);
trlet_list(nn).hist_p(cam) = hist_p;
trlet_list(nn).hist_q(cam) = hist_q;
matrix<Float> cand_rects;
vector<Float> cand_scale;
matrix<int> cand_ijs;
if(0==world.rank())
{
std::vector<float> sxr, syr;
for(float v=-P.xrange/2; v<=P.xrange/2; v+=P.xstep)
{
sxr.push_back(v);
}
for(float v=-P.yrange/2; v<=P.yrange/2; v+=P.ystep)
{
syr.push_back(v);
}
vector<float> xr(sxr.size()), yr(syr.size());
std::copy(sxr.begin(), sxr.end(), xr.begin());
std::copy(syr.begin(), syr.end(), yr.begin());
float feetx = (trlet_list(nn).trj(cam)(tt, 0)
+trlet_list(nn).trj(cam)(tt, 2))/2;
float feety = trlet_list(nn).trj(cam)(tt, 3);
enumerate_rects_inpoly(images(cam), oi.pmodel_list(cam, nn),
feetx, feety,
xr, yr, P.scales, gi.horiz_mean, gi.horiz_sig,
gi.polys_im(tt, cam),
cand_rects, cand_scale,
cand_ijs, cand_array(cam));
}
mpi::broadcast(world, cand_rects, 0);
real_timer_t timer;
vector<Float> cand_hist_score(cand_rects.size1());
matrix<Float> hist_fscores;
range rrank(world.rank()*cand_rects.size1()/world.size(),
(world.rank()+1)*cand_rects.size1()/world.size());
matrix<Float> cand_rects_rank(project(cand_rects, rrank, range(0, 4)));
vector<Float> cand_hist_score_rank;
matrix<Float> hist_fscores_rank;
get_cand_hist_score(images(cam), oi.model, P.logp1, P.logp2,
trlet_list(nn).hist_p(cam),
trlet_list(nn).hist_q(cam),
cand_rects_rank,
cand_hist_score_rank, hist_fscores_rank);
if(world.rank()==0)
{
std::vector<vector<Float> > v1;
std::vector<matrix<Float> > v2;
mpi::gather(world, cand_hist_score_rank, v1, 0);
mpi::gather(world, hist_fscores_rank, v2, 0);
hist_fscores = matrix<Float>(cand_rects.size1(),
hist_fscores_rank.size2());
for(int r=0; r<world.size(); ++r)
{
int start = r*cand_rects.size1()/world.size();
for(int vv=0; vv<v1[r].size(); ++vv)
{
cand_hist_score(start+vv) = v1[r](vv);
}
for(int vv=0; vv<v2[r].size1(); ++vv)
{
row(hist_fscores, start+vv) = row(v2[r], vv);
}
}
}
else
{
mpi::gather(world, cand_hist_score_rank, 0);
mpi::gather(world, hist_fscores_rank, 0);
}
mpi::broadcast(world, cand_hist_score, 0);
mpi::broadcast(world, hist_fscores, 0);
vector<Float> cand_score=cand_hist_score;
if(0==world.rank())
std::cout<<"\t\t"<<cand_rects.size1()<<" rects, \tget_cand_hist_score time:"
<<timer.elapsed()/1000.0f<<"s."<<std::endl;
if(0==world.rank())
{
int idx_max = std::max_element(cand_score.begin(), cand_score.end())
- cand_score.begin();
column(trlet_list(nn).fscores(cam), tt) = row(hist_fscores, idx_max);
trlet_list(nn).scores(cam, tt) = cand_score(idx_max);
cand_array(cam).fill_score(cand_score, cand_ijs);
}
mpi::broadcast(world, cand_array(cam), 0);
mpi::broadcast(world, trlet_list(nn).scores(cam, tt), 0);
vector<Float> fscore_col;
if(0==world.rank())
{
fscore_col = column(trlet_list(nn).fscores(cam), tt);
}
mpi::broadcast(world, fscore_col, 0);
if(0!=world.rank())
{
column(trlet_list(nn).fscores(cam), tt) = fscore_col;
}
}//end for cam
int best_y, best_x, best_s;
if(0==world.rank())
{
ground_scoremap_t<Float> grd_scoremap;
combine_ground_score(tt, cand_array, grd_scoremap, gi);
grd_scoremap.peak(best_y, best_x, best_s);
}
mpi::broadcast(world, best_y, 0);
mpi::broadcast(world, best_x, 0);
trlet_list(nn).trj_3d(tt, 0) = best_x;
trlet_list(nn).trj_3d(tt, 1) = best_y;
for(int cam=0; cam<Ncam; ++cam)
{
vector<Float> trj_row(4);
if(0==world.rank())
{
vector<double> bx(1), by(1), ix, iy;
bx <<= best_x; by <<= best_y;
apply_homography(gi.grd2img(tt, cam), bx, by, ix, iy);
float hpre = oi.pmodel_list(cam, nn).hpre;
float cur_fy = iy(0);
float cur_fx = ix(0);
float cur_hy = gi.horiz_mean+hpre*(cur_fy-gi.horiz_mean);
float ds = P.scales(best_s)*(cur_fy-cur_hy)/oi.pmodel_list(cam, nn).bh;
float ww = ds*oi.pmodel_list(cam, nn).bw;
float hh = cur_fy - cur_hy;
trj_row <<= (cur_fx-ww/2), cur_hy, (cur_fx+ww/2), cur_fy;
}
mpi::broadcast(world, trj_row, 0);
row(trlet_list(nn).trj(cam), tt) = trj_row;
}//endfor cam
}//endfor oo
oi.curr_num_obj += num_new_obj;
}
int main(int argc, char* argv[])
{
if (argc < 2) {
printf("Usage: %s <program name>\n", argv[0]);
exit(0);
}
filename = argv[1];
FILE* fp = fopen(filename, "rb");
if (fp == 0)
error("opening");
ram = (Byte*)malloc(0x10000);
memset(ram, 0, 0x10000);
if (ram == 0) {
fprintf(stderr, "Out of memory\n");
exit(1);
}
if (fseek(fp, 0, SEEK_END) != 0)
error("seeking");
length = ftell(fp);
if (length == -1)
error("telling");
if (fseek(fp, 0, SEEK_SET) != 0)
error("seeking");
if (length > 0x10000 - 0x100) {
fprintf(stderr, "%s is too long to be a .com file\n", filename);
exit(1);
}
if (fread(&ram[0x100], length, 1, fp) != 1)
error("reading");
fclose(fp);
Word segment = 0x1000;
setAX(0x0000);
setCX(0x00FF);
setDX(segment);
registers[3] = 0x0000;
setSP(0xFFFE);
registers[5] = 0x091C;
setSI(0x0100);
setDI(0xFFFE);
for (int i = 0; i < 4; ++i)
registers[8 + i] = segment;
Byte* byteData = (Byte*)®isters[0];
int bigEndian = (byteData[2] == 0 ? 1 : 0);
int byteNumbers[8] = {0, 2, 4, 6, 1, 3, 5, 7};
for (int i = 0 ; i < 8; ++i)
byteRegisters[i] = &byteData[byteNumbers[i] ^ bigEndian];
bool prefix = false;
for (int i = 0; i < 1000000000; ++i) {
if (!repeating) {
if (!prefix) {
segmentOverride = -1;
rep = 0;
}
prefix = false;
opcode = fetchByte();
}
wordSize = ((opcode & 1) != 0);
bool sourceIsRM = ((opcode & 2) != 0);
int operation = (opcode >> 3) & 7;
bool jump;
switch (opcode) {
case 0x00: case 0x01: case 0x02: case 0x03:
case 0x08: case 0x09: case 0x0a: case 0x0b:
case 0x10: case 0x11: case 0x12: case 0x13:
case 0x18: case 0x19: case 0x1a: case 0x1b:
case 0x20: case 0x21: case 0x22: case 0x23:
case 0x28: case 0x29: case 0x2a: case 0x2b:
case 0x30: case 0x31: case 0x32: case 0x33:
case 0x38: case 0x39: case 0x3a: case 0x3b: // alu rmv,rmv
data = readEA();
if (!sourceIsRM) {
destination = data;
source = getReg();
}
else {
destination = getReg();
source = data;
}
aluOperation = operation;
doALUOperation();
if (aluOperation != 7) {
if (!sourceIsRM)
finishWriteEA(data);
else
setReg(data);
}
break;
case 0x04: case 0x05: case 0x0c: case 0x0d:
case 0x14: case 0x15: case 0x1c: case 0x1d:
case 0x24: case 0x25: case 0x2c: case 0x2d:
case 0x34: case 0x35: case 0x3c: case 0x3d: // alu accum,i
destination = getAccum();
source = !wordSize ? fetchByte() : fetchWord();
aluOperation = operation;
doALUOperation();
if (aluOperation != 7)
setAccum();
break;
case 0x06: case 0x0e: case 0x16: case 0x1e: // PUSH segreg
push(registers[operation + 8]);
break;
case 0x07: case 0x17: case 0x1f: // POP segreg
registers[operation + 8] = pop();
break;
case 0x26: case 0x2e: case 0x36: case 0x3e: // segment override
segmentOverride = operation;
prefix = true;
break;
case 0x27: case 0x2f: // DA
if (af() || (al() & 0x0f) > 9) {
data = al() + (opcode == 0x27 ? 6 : -6);
setAL(data);
setAF(true);
if ((data & 0x100) != 0)
setCF(true);
}
setCF(cf() || al() > 0x9f);
if (cf())
setAL(al() + (opcode == 0x27 ? 0x60 : -0x60));
wordSize = false;
data = al();
setPZS();
break;
case 0x37: case 0x3f: // AA
if (af() || (al() & 0xf) > 9) {
setAL(al() + (opcode == 0x37 ? 6 : -6));
setAH(ah() + (opcode == 0x37 ? 1 : -1));
setCA();
}
else
clearCA();
setAL(al() & 0x0f);
break;
case 0x40: case 0x41: case 0x42: case 0x43:
case 0x44: case 0x45: case 0x46: case 0x47:
case 0x48: case 0x49: case 0x4a: case 0x4b:
case 0x4c: case 0x4d: case 0x4e: case 0x4f: // incdec rw
destination = rw();
wordSize = true;
setRW(incdec((opcode & 8) != 0));
break;
case 0x50: case 0x51: case 0x52: case 0x53:
case 0x54: case 0x55: case 0x56: case 0x57: // PUSH rw
push(rw());
break;
case 0x58: case 0x59: case 0x5a: case 0x5b:
case 0x5c: case 0x5d: case 0x5e: case 0x5f: // POP rw
setRW(pop());
break;
case 0x60: case 0x61: case 0x62: case 0x63:
case 0x64: case 0x65: case 0x66: case 0x67:
case 0x68: case 0x69: case 0x6a: case 0x6b:
case 0x6c: case 0x6d: case 0x6e: case 0x6f:
case 0xc0: case 0xc1: case 0xc8: case 0xc9: // invalid
case 0xcc: case 0xf0: case 0xf1: case 0xf4: // INT 3, LOCK, HLT
case 0x9b: case 0xce: case 0x0f: // WAIT, INTO, POP CS
case 0xd8: case 0xd9: case 0xda: case 0xdb:
case 0xdc: case 0xdd: case 0xde: case 0xdf: // escape
case 0xe4: case 0xe5: case 0xe6: case 0xe7:
case 0xec: case 0xed: case 0xee: case 0xef: // IN, OUT
fprintf(stderr, "Invalid opcode %02x", opcode);
runtimeError("");
break;
case 0x70: case 0x71: case 0x72: case 0x73:
case 0x74: case 0x75: case 0x76: case 0x77:
case 0x78: case 0x79: case 0x7a: case 0x7b:
case 0x7c: case 0x7d: case 0x7e: case 0x7f: // Jcond cb
switch (opcode & 0x0e) {
case 0x00: jump = of(); break;
case 0x02: jump = cf(); break;
case 0x04: jump = zf(); break;
case 0x06: jump = cf() || zf(); break;
case 0x08: jump = sf(); break;
case 0x0a: jump = pf(); break;
case 0x0c: jump = sf() != of(); break;
default: jump = sf() != of() || zf(); break;
}
jumpShort(fetchByte(), jump == ((opcode & 1) == 0));
break;
case 0x80: case 0x81: case 0x82: case 0x83: // alu rmv,iv
destination = readEA();
data = fetch(opcode == 0x81);
if (opcode != 0x83)
source = data;
else
source = signExtend(data);
aluOperation = modRMReg();
doALUOperation();
if (aluOperation != 7)
finishWriteEA(data);
break;
case 0x84: case 0x85: // TEST rmv,rv
data = readEA();
test(data, getReg());
break;
case 0x86: case 0x87: // XCHG rmv,rv
data = readEA();
finishWriteEA(getReg());
setReg(data);
break;
case 0x88: case 0x89: // MOV rmv,rv
ea();
finishWriteEA(getReg());
break;
case 0x8a: case 0x8b: // MOV rv,rmv
setReg(readEA());
break;
case 0x8c: // MOV rmw,segreg
ea();
wordSize = 1;
finishWriteEA(registers[modRMReg() + 8]);
break;
case 0x8d: // LEA
address = ea();
if (!useMemory)
runtimeError("LEA needs a memory address");
setReg(address);
break;
case 0x8e: // MOV segreg,rmw
wordSize = 1;
data = readEA();
registers[modRMReg() + 8] = data;
break;
case 0x8f: // POP rmw
writeEA(pop());
break;
case 0x90: case 0x91: case 0x92: case 0x93:
case 0x94: case 0x95: case 0x96: case 0x97: // XCHG AX,rw
data = ax();
setAX(rw());
setRW(data);
break;
case 0x98: // CBW
setAX(signExtend(al()));
break;
case 0x99: // CWD
setDX((ax() & 0x8000) == 0 ? 0x0000 : 0xffff);
break;
case 0x9a: // CALL cp
savedIP = fetchWord();
savedCS = fetchWord();
farCall();
break;
case 0x9c: // PUSHF
push((flags & 0x0fd7) | 0xf000);
break;
case 0x9d: // POPF
flags = pop() | 2;
break;
case 0x9e: // SAHF
flags = (flags & 0xff02) | ah();
break;
case 0x9f: // LAHF
setAH(flags & 0xd7);
break;
case 0xa0: case 0xa1: // MOV accum,xv
data = read(fetchWord());
setAccum();
break;
case 0xa2: case 0xa3: // MOV xv,accum
write(getAccum(), fetchWord());
break;
case 0xa4: case 0xa5: // MOVSv
stoS(lodS());
doRep();
break;
case 0xa6: case 0xa7: // CMPSv
lodDIS();
source = data;
sub();
doRep();
break;
case 0xa8: case 0xa9: // TEST accum,iv
data = fetch(wordSize);
test(getAccum(), data);
break;
case 0xaa: case 0xab: // STOSv
stoS(getAccum());
doRep();
break;
case 0xac: case 0xad: // LODSv
data = lodS();
setAccum();
doRep();
break;
case 0xae: case 0xaf: // SCASv
lodDIS();
destination = getAccum();
source = data;
sub();
doRep();
break;
case 0xb0: case 0xb1: case 0xb2: case 0xb3:
case 0xb4: case 0xb5: case 0xb6: case 0xb7:
setRB(fetchByte());
break;
case 0xb8: case 0xb9: case 0xba: case 0xbb:
case 0xbc: case 0xbd: case 0xbe: case 0xbf: // MOV rv,iv
setRW(fetchWord());
break;
case 0xc2: case 0xc3: case 0xca: case 0xcb: // RET
savedIP = pop();
savedCS = (opcode & 8) == 0 ? cs() : pop();
if (!wordSize)
setSP(sp() + fetchWord());
farJump();
break;
case 0xc4: case 0xc5: // LES/LDS
ea();
farLoad();
*modRMRW() = savedIP;
registers[8 + (!wordSize ? 0 : 3)] = savedCS;
break;
case 0xc6: case 0xc7: // MOV rmv,iv
ea();
finishWriteEA(fetch(wordSize));
break;
case 0xcd:
data = fetchByte();
if (data != 0x21) {
fprintf(stderr, "Unknown interrupt 0x%02x", data);
runtimeError("");
}
switch (ah()) {
case 2:
printf("%c", dl());
break;
case 0x4c:
printf("*** Bytes: %i\n", length);
printf("*** Cycles: %i\n", ios);
printf("*** EXIT code %i\n", al());
exit(0);
break;
default:
fprintf(stderr, "Unknown DOS call 0x%02x", data);
runtimeError("");
}
break;
case 0xcf:
ip = pop();
setCS(pop());
flags = pop() | 2;
break;
case 0xd0: case 0xd1: case 0xd2: case 0xd3: // rot rmv,n
data = readEA();
if ((opcode & 2) == 0)
source = 1;
else
source = cl();
while (source != 0) {
destination = data;
switch (modRMReg()) {
case 0: // ROL
data <<= 1;
doCF();
data |= (cf() ? 1 : 0);
setOFRotate();
break;
case 1: // ROR
setCF((data & 1) != 0);
data >>= 1;
if (cf())
data |= (!wordSize ? 0x80 : 0x8000);
setOFRotate();
break;
case 2: // RCL
data = (data << 1) | (cf() ? 1 : 0);
doCF();
setOFRotate();
break;
case 3: // RCR
data >>= 1;
if (cf())
data |= (!wordSize ? 0x80 : 0x8000);
setCF((destination & 1) != 0);
setOFRotate();
break;
case 4: // SHL
case 6:
data <<= 1;
doCF();
setOFRotate();
setPZS();
break;
case 5: // SHR
setCF((data & 1) != 0);
data >>= 1;
setOFRotate();
setAF(true);
setPZS();
break;
case 7: // SAR
setCF((data & 1) != 0);
data >>= 1;
if (!wordSize)
data |= (destination & 0x80);
else
data |= (destination & 0x8000);
setOFRotate();
setAF(true);
setPZS();
break;
}
--source;
}
finishWriteEA(data);
break;
case 0xd4: // AAM
data = fetchByte();
if (data == 0)
divideOverflow();
setAH(al() / data);
setAL(al() % data);
wordSize = true;
setPZS();
break;
case 0xd5: // AAD
data = fetchByte();
setAL(al() + ah()*data);
setAH(0);
setPZS();
break;
case 0xd6: // SALC
setAL(cf() ? 0xff : 0x00);
break;
case 0xd7: // XLATB
setAL(readByte(bx() + al()));
break;
case 0xe0: case 0xe1: case 0xe2: // LOOPc cb
setCX(cx() - 1);
jump = (cx() != 0);
switch (opcode) {
case 0xe0: if (zf()) jump = false; break;
case 0xe1: if (!zf()) jump = false; break;
}
jumpShort(fetchByte(), jump);
break;
case 0xe3: // JCXZ cb
jumpShort(fetchByte(), cx() == 0);
break;
case 0xe8: // CALL cw
call(ip + fetchWord());
break;
case 0xe9: // JMP cw
ip += fetchWord();
break;
case 0xea: // JMP cp
savedIP = fetchWord();
savedCS = fetchWord();
farJump();
break;
case 0xeb: // JMP cb
jumpShort(fetchByte(), true);
break;
case 0xf2: case 0xf3: // REP
rep = opcode == 0xf2 ? 1 : 2;
prefix = true;
break;
case 0xf5: // CMC
flags ^= 1;
break;
case 0xf6: case 0xf7: // math rmv
data = readEA();
switch (modRMReg()) {
case 0: case 1: // TEST rmv,iv
test(data, fetch(wordSize));
break;
case 2: // NOT iv
finishWriteEA(~data);
break;
case 3: // NEG iv
source = data;
destination = 0;
sub();
finishWriteEA(data);
break;
case 4: case 5: // MUL rmv, IMUL rmv
source = data;
destination = getAccum();
data = destination;
setSF();
setPF();
data *= source;
setAX(data);
if (!wordSize) {
if (modRMReg() == 4)
setCF(ah() != 0);
else {
if ((source & 0x80) != 0)
setAH(ah() - destination);
if ((destination & 0x80) != 0)
setAH(ah() - source);
setCF(ah() ==
((al() & 0x80) == 0 ? 0 : 0xff));
}
}
else {
setDX(data >> 16);
if (modRMReg() == 4) {
data |= dx();
setCF(dx() != 0);
}
else {
if ((source & 0x8000) != 0)
setDX(dx() - destination);
if ((destination & 0x8000) != 0)
setDX(dx() - source);
data |= dx();
setCF(dx() ==
((ax() & 0x8000) == 0 ? 0 : 0xffff));
}
}
setZF();
setOF(cf());
break;
case 6: case 7: // DIV rmv, IDIV rmv
source = data;
if (source == 0)
divideOverflow();
if (!wordSize) {
destination = ax();
if (modRMReg() == 6) {
div();
if (data > 0xff)
divideOverflow();
}
else {
destination = ax();
if ((destination & 0x8000) != 0)
destination |= 0xffff0000;
source = signExtend(source);
div();
if (data > 0x7f && data < 0xffffff80)
divideOverflow();
}
setAH(remainder);
setAL(data);
}
else {
destination = (dx() << 16) + ax();
div();
if (modRMReg() == 6) {
if (data > 0xffff)
divideOverflow();
}
else {
if (data > 0x7fff && data < 0xffff8000)
divideOverflow();
}
setDX(remainder);
setAX(data);
}
break;
}
break;
case 0xf8: case 0xf9: // STC/CLC
setCF(wordSize);
break;
case 0xfa: case 0xfb: // STI/CLI
setIF(wordSize);
break;
case 0xfc: case 0xfd: // STD/CLD
setDF(wordSize);
break;
case 0xfe: case 0xff: // misc
ea();
if ((!wordSize && modRMReg() >= 2 && modRMReg() <= 6) ||
modRMReg() == 7) {
fprintf(stderr, "Invalid instruction %02x %02x", opcode,
modRM);
runtimeError("");
}
switch (modRMReg()) {
case 0: case 1: // incdec rmv
destination = readEA2();
finishWriteEA(incdec(modRMReg() != 0));
break;
case 2: // CALL rmv
call(readEA2());
break;
case 3: // CALL mp
farLoad();
farCall();
break;
case 4: // JMP rmw
ip = readEA2();
break;
case 5: // JMP mp
farLoad();
farJump();
break;
case 6: // PUSH rmw
push(readEA2());
break;
}
break;
}
}
runtimeError("Timed out");
}
void DumpModel::dump(Amr* parent, int force_dump)
{
// Exit if it isn't the right time to do the dump
if (force_dump == 0 &&
parent->levelSteps(0) % interval != 0) {
return;
}
// Create flattened list of ordered, disjoint boxes from the grid hierarchy
list<Box> bxlist;
list<int> lnlist;
vector<int> rat(parent->finestLevel(), 1);
for (int ln = 0; ln <= parent->finestLevel(); ln++) {
// rat[lnp] will be ratio between levels lnp and ln
if (ln > 0) {
for (int lnp = 0; lnp < ln; lnp++) {
rat[lnp] *= parent->refRatio(ln - 1)[0];
}
}
// Insert grids of level ln into list, trimming coarser grids as needed
const BoxArray& grids = parent->boxArray(ln);
for (int igr = 0; igr < grids.size(); igr++) {
const Box& reg = grids[igr];
list<Box>::iterator bi = bxlist.begin();
list<int>::iterator li = lnlist.begin();
for ( ; bi != bxlist.end(); ) {
if (*li == ln) {
if (bi->smallEnd(0) > reg.bigEnd(0)) {
// Insert reg before bi and break
bxlist.insert(bi, reg);
lnlist.insert(li, ln);
break;
}
// Increment and continue loop as reg not inserted yet
}
else { // *li < ln
Box bx(BoxLib::refine(*bi,rat[*li]));
if (bx.bigEnd(0) >= reg.smallEnd(0)) {
if (bx.smallEnd(0) < reg.smallEnd(0) &&
bx.bigEnd(0) <= reg.bigEnd(0)) {
// Trim overlap with reg from *bi leaving low end of *bi
bx.setBig(0, reg.smallEnd(0) - 1);
bx.coarsen(rat[*li]);
*bi = bx;
// Increment and continue loop as reg not inserted yet
}
else if (bx.smallEnd(0) >= reg.smallEnd(0) &&
bx.bigEnd(0) <= reg.bigEnd(0)) {
// Remove *bi from list as reg covers it completely
list<Box>::iterator bt = bi;
list<int>::iterator lt = li;
++bi;
++li;
bxlist.erase(bt);
lnlist.erase(lt);
// Continue loop as reg not inserted yet; but bypass
// increment at end of loop since we've done it already.
continue;
}
else {
// To get this far (bx.bigEnd(0) > reg.bigEnd(0)) must be true
if (bx.smallEnd(0) < reg.smallEnd(0)) {
// Trim overlap with reg from middle of *bi, extract low frag
Box bxx(bx);
bxx.setBig(0, reg.smallEnd(0) - 1);
bxx.coarsen(rat[*li]);
// Insert this low fragment of *bi before remainder of *bi
bxlist.insert(bi, bxx);
lnlist.insert(li, *li);
}
if (bx.smallEnd(0) <= reg.bigEnd(0)) {
// Trim overlap with reg leaving end high end of *bi
bx.setSmall(0, reg.bigEnd(0) + 1);
bx.coarsen(rat[*li]);
*bi = bx;
}
// Insert reg before high end of *bi and break
bxlist.insert(bi, reg);
lnlist.insert(li, ln);
break;
}
}
}
// Increment and continue loop as reg not inserted yet
++bi;
++li;
} // end of loop over bi, li
if (bi == bxlist.end()) {
// We made it to the end without finding another place to insert reg
bxlist.push_back(reg);
lnlist.push_back(ln);
}
}
}
// bxlist now contains an ordered list of disjoint boxes representing
// the exposed portions of all levels of the hierarchy. Each box is
// at the resolution of its respective level, and the corresponding
// entry of lnlist contains the level number.
if (ParallelDescriptor::IOProcessor() && verbose >= 2) {
cout << "Printing disjoint box list" << endl;
list<Box>::iterator bi = bxlist.begin();
list<int>::iterator li = lnlist.begin();
for ( ; bi != bxlist.end(); ++bi, ++li) {
cout << "Level " << *li << ", box " << *bi << endl;
}
}
if (ParallelDescriptor::IOProcessor() && verbose >= 1) {
cout << "Creating modelDump" << endl;
}
ofstream dumpfile;
if (ParallelDescriptor::IOProcessor()) {
dumpfile.open("modelDump", std::ios::out);
}
const int bufsiz = 200; // must hold 9 fields of width 16 plus a little more
char buf[bufsiz];
// The following are not parallel loops.
// We are doing the Fab copy portion on all processors because
// all must participate, but the write is done only on IOProcessor.
int k = 1;
list<Box>::iterator bi = bxlist.begin();
list<int>::iterator li = lnlist.begin();
for ( ; bi != bxlist.end(); ++bi, ++li) {
const Box& reg = *bi;
int ln = *li;
Castro *castro = dynamic_cast<Castro*>(&parent->getLevel(ln));
MultiFab& S_new = castro->get_new_data(State_Type);
Fab stmp(reg, S_new.nComp());
S_new.copy(stmp);
if (ParallelDescriptor::IOProcessor()) {
for (int i = reg.smallEnd(0); i <= reg.bigEnd(0); i++) {
IntVect p(i);
// Quantities written as 0.0 are not currently used, so we
// don't bother to derive them.
sprintf(buf,
"%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E %d\n",
parent->Geom(ln).CellCenter(i, 0), // radius
stmp(p, Density), // density
stmp(p, Xmom) / stmp(p, Density), // velocity
0.0, // pressure
stmp(p, Temp), // temperature (MeV ?)
stmp(p, Eint) / stmp(p, Density), // internal energy e
0.0, // entropy
0.0, // cumulative mass
stmp(p, FirstAux / stmp(p, Density), // Ye
k++);
std::string Buf = buf;
dumpfile << Buf;
}
}
}
if (ParallelDescriptor::IOProcessor()) {
dumpfile << Radiation::nGroups << '\n';
}
k = 1;
bi = bxlist.begin();
li = lnlist.begin();
for ( ; bi != bxlist.end(); ++bi, ++li) {
const Box& reg = *bi;
int ln = *li;
Castro *castro = dynamic_cast<Castro*>(&parent->getLevel(ln));
MultiFab& R_new = castro->get_new_data(Rad_Type);
Fab rtmp(reg, R_new.nComp());
R_new.copy(rtmp);
if (ParallelDescriptor::IOProcessor()) {
for (int i = reg.smallEnd(0); i <= reg.bigEnd(0); i++) {
IntVect p(i);
char* bufp = buf;
for (int j = 0; ; j++) {
sprintf(bufp, "%16.8E", rtmp(p, j));
bufp += 16;
if (j + 1 == Radiation::nGroups) {
sprintf(bufp, " %d\n", k++);
std::string Buf = buf;
dumpfile << Buf;
break;
}
else if (j % 4 == 3) {
sprintf(bufp, "\n");
std::string Buf = buf;
dumpfile << Buf;
bufp = buf;
}
}
}
}
}
if (ParallelDescriptor::IOProcessor()) {
dumpfile.close();
}
}
