/*
* Propagation proper
*
*/
ExecStatus
Pack::propagate(Space& home, const ModEventDelta& med) {
// Number of items
int n = bs.size();
// Number of bins
int m = l.size();
{
Region region(home);
// Possible sizes for bins
int* s = region.alloc<int>(m);
for (int j=m; j--; )
s[j] = 0;
// Compute sizes for bins
if (OffsetView::me(med) == ME_INT_VAL) {
// Also eliminate assigned items
int k=0;
for (int i=0; i<n; i++)
if (bs[i].assigned()) {
int j = bs[i].bin().val();
l[j].offset(l[j].offset() - bs[i].size());
t -= bs[i].size();
} else {
for (ViewValues<IntView> j(bs[i].bin()); j(); ++j)
s[j.val()] += bs[i].size();
bs[k++] = bs[i];
}
n=k; bs.size(n);
} else {
for (int i=n; i--; ) {
assert(!bs[i].assigned());
for (ViewValues<IntView> j(bs[i].bin()); j(); ++j)
s[j.val()] += bs[i].size();
}
}
// Propagate bin loads and compute lower and upper bound
int min = t, max = t;
for (int j=m; j--; ) {
GECODE_ME_CHECK(l[j].gq(home,0));
GECODE_ME_CHECK(l[j].lq(home,s[j]));
min -= l[j].max(); max -= l[j].min();
}
// Propagate that load must be equal to total size
for (bool mod = true; mod; ) {
mod = false; ModEvent me;
for (int j=m; j--; ) {
int lj_min = l[j].min();
me = l[j].gq(home, min + l[j].max());
if (me_failed(me))
return ES_FAILED;
if (me_modified(me)) {
max += lj_min - l[j].min(); mod = true;
}
int lj_max = l[j].max();
me = l[j].lq(home, max + l[j].min());
if (me_failed(me))
return ES_FAILED;
if (me_modified(me)) {
min += lj_max - l[j].max(); mod = true;
}
}
}
if (n == 0) {
assert(l.assigned());
return home.ES_SUBSUMED(*this);
}
{
TellCache tc(region,m);
int k=0;
for (int i=0; i<n; i++) {
for (ViewValues<IntView> j(bs[i].bin()); j(); ++j) {
if (bs[i].size() > l[j.val()].max())
tc.nq(j.val());
if (s[j.val()] - bs[i].size() < l[j.val()].min())
tc.eq(j.val());
}
GECODE_ES_CHECK(tc.tell(home,bs[i].bin()));
// Eliminate assigned bin
if (bs[i].assigned()) {
int j = bs[i].bin().val();
l[j].offset(l[j].offset() - bs[i].size());
t -= bs[i].size();
} else {
bs[k++] = bs[i];
}
}
n=k; bs.size(n);
//.........这里部分代码省略.........
void PrintLayout::printTable()
{
// create and setup a table
QTableView table;
table.setAttribute(Qt::WA_DontShowOnScreen);
table.setSelectionMode(QAbstractItemView::NoSelection);
table.setFocusPolicy(Qt::NoFocus);
table.horizontalHeader()->setVisible(false);
table.horizontalHeader()->setResizeMode(QHeaderView::Fixed);
table.verticalHeader()->setVisible(false);
table.verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
table.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
table.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
// fit table to one page initially
table.resize(scaledPageW, scaledPageH);
// create and fill a table model
TablePrintModel model;
struct dive *dive;
int i, row = 0;
addTablePrintHeadingRow(&model, row); // add one heading row
row++;
for_each_dive(i, dive) {
if (!dive->selected && printOptions->print_selected)
continue;
addTablePrintDataRow(&model, row, dive);
row++;
}
table.setModel(&model); // set model to table
// resize columns to percentages from page width
for (int i = 0; i < model.columns; i++) {
int pw = qCeil((qreal)(tablePrintColumnWidths.at(i) * table.width()) / 100);
table.horizontalHeader()->resizeSection(i, pw);
}
// reset the model at this point
model.callReset();
// a list of vertical offsets where pages begin and some helpers
QList<unsigned int> pageIndexes;
pageIndexes.append(0);
int tableHeight = 0, rowH = 0, accH = 0;
// process all rows
for (int i = 0; i < model.rows; i++) {
rowH = table.rowHeight(i);
accH += rowH;
if (accH > scaledPageH) { // push a new page index and add a heading
pageIndexes.append(pageIndexes.last() + (accH - rowH));
addTablePrintHeadingRow(&model, i);
accH = 0;
i--;
}
tableHeight += rowH;
}
pageIndexes.append(pageIndexes.last() + accH);
// resize the whole widget so that it can be rendered
table.resize(scaledPageW, tableHeight);
// attach a painter and render pages by using pageIndexes
QPainter painter(printer);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::SmoothPixmapTransform);
painter.scale(scaleX, scaleY);
for (int i = 0; i < pageIndexes.size() - 1; i++) {
if (i > 0)
printer->newPage();
QRegion region(0, pageIndexes.at(i) - 1,
table.width(),
pageIndexes.at(i + 1) - pageIndexes.at(i) + 2);
table.render(&painter, QPoint(0, 0), region);
}
}
// Compute single tracking score
TrackingScore* TrackingEvaluator::computeScore(const TrackedObject& tracked_object, const Mat& frame, int frame_number, TrackingScoreHistory *history)
{
// Create score
TrackingScore* score = new TrackingScore(&nbc);
// Add score to history
history->addScore(score, frame_number);
// Get blob
const cvb::CvBlob& orig_blob = tracked_object.currentRegion();
// Random move blobs - to test certainties
cvb::CvBlob blob;
cvCloneBlob(orig_blob, blob);
// Save shape ratio
score->setShapeRatio(((float)blob.width())/((float)blob.height()));
// Save area
score->setArea(blob.width()*blob.height());
// Compute object's binary mask, for the histogram
Mat mask = drawBlob(blob, true, frame.cols, frame.rows);
// Get grayscale frame
Mat frame_gs;
cvtColor(frame, frame_gs, CV_BGR2GRAY);
// Split the color channels
Mat* channels = new Mat[3];
split(frame, channels);
Mat frame_b = channels[0];
Mat frame_g = channels[1];
Mat frame_r = channels[2];
delete [] channels;
// Compute histograms
Histogram hist_gs(frame_gs, mask);
Histogram hist_r(frame_r, mask);
Histogram hist_g(frame_g, mask);
Histogram hist_b(frame_b, mask);
// Save histogram
score->setHistograms(hist_gs, hist_r, hist_g, hist_b);
// Select part of frame on which to compute the texture features
Mat copy_gs = frame_gs.clone();
// Blacken non-mask pixels
for(unsigned int x=blob.x; x<=blob.maxx; x++)
{
for(unsigned int y=blob.y; y<=blob.maxy; y++)
{
if(mask.at<uchar>(y,x) == 0)
{
copy_gs.at<uchar>(y,x) = 0;
}
}
}
// Crop image
Rect region(blob.x, blob.y, blob.width(), blob.height());
Mat texture_input = copy_gs(region);
// Compute texture features for this object
vector<float> texture_features = GaborFilter::applyFilterSet(texture_input, gabor_scales, parameters.get<int>("num_orientations"), false, 1, 0.5, 101);
// Save texture features
score->setTextureFeatures(texture_features);
// Set temporal score to the number of appearances
score->temporal_score = history->numScores();
// Get the frame number of the previous detection of this object, if available
int prev_frame = -1;
TrackingScore* prev_score = NULL;
cvb::CvBlob prev_blob;
if(history->numScores() > 1)
{
// Read frame number
prev_frame = *(tracked_object.frameList().end() - 2);
// Get previous score
prev_score = (TrackingScore*) history->getScore(prev_frame);
// Get previous blob
prev_blob = *(tracked_object.regionList().end() - 2);
// Compute shape ratio score
score->shape_ratio_score = computeShapeRatioScore(prev_score->getShapeRatio(), score->getShapeRatio());
// Compute area score
score->area_score = computeAreaScore(prev_score->getArea(), score->getArea());
// Compute histogram difference score
score->histogram_diff_score = computeHistogramDiffScore(score, prev_score);
// Compute texture difference score
score->texture_diff_score = computeTextureDiffScore(score->getTextureFeatures(), prev_score->getTextureFeatures());
// Compute velocity for this score
Point2f prev_position((prev_blob.maxx+prev_blob.x)/2, (prev_blob.maxy+prev_blob.y)/2);
Point2f curr_position((blob.maxx+blob.x)/2, (blob.maxy+blob.y)/2);
float velocity = sqrt((prev_position.x-curr_position.x)*(prev_position.x-curr_position.x) + (prev_position.y-curr_position.y)*(prev_position.y-curr_position.y));
score->setVelocity(velocity);
// Add velocity to the accumulated velocity for this object (will be used to compute an average according to the number of detections)
history->accumulateVelocity(velocity);
// Check if the previous score has its velocity set
if(prev_score->getVelocity() > 0)
{
//cout << "computing ms: " << score->getVelocity() << ", " << history->getAverageVelocity() << endl;
// Compute motion smoothness score, based on current velocity and average velocity
score->motion_smoothness = computeMotionSmoothnessScore(score->getVelocity(), history->getAverageVelocity());
}
else
{
// Set score to 0
score->motion_smoothness = 0.0f;
// Mark score as not full
score->full = false;
}
// Compute direction for this score
float direction = fastAtan2(-curr_position.y + prev_position.y, curr_position.x - prev_position.x);
//.........这里部分代码省略.........
请发表评论