void SplayTree::insert(node* n)
{
if (unlikely(header.parent == NULL)) // First element.
{
header.parent = header.child[LEFT] = header.child[RIGHT] = n;
n->parent = n->child[LEFT] = n->child[RIGHT] = NULL;
}
else // Not first element.
{
// Find place to insert node and insert it.
node* insert_location = header.parent;
__find(insert_location, n);
__insert(insert_location, n);
// Fix up header nodes.
header.child[LEFT] = leftmost(header.child[LEFT]);
header.child[RIGHT] = rightmost(header.child[RIGHT]);
// Splay new node.
splay(n);
}
// Increment size count.
(header_n()->data)++;
}
/**
* Debug function for Lowest common ancestor
*/
void SSTree::CheckLCA(ulong v)
{
ulong len = br->rank(rightmost(v));
v++;ulong w, temp, v1;
for (w = 1; w < len - 1; w++)
{
temp = br->select(w);
v1 = br->select(w+1);
while(v1 < len)
{
if (lca(temp, v1) != lcaParen(temp, v1))
{
printf("conflict at (%lu, %lu)::lcaParen() = %lu and lca() = %lu\n", temp, v1, lcaParen(temp, v1), lca(temp, v1));
exit(0);
}
v1 = br->select(br->rank(v1)+1);
}
// Check for the value v1 == len
if (lca(temp, v1) != lcaParen(temp, v1))
{
printf("conflict at (%lu, %lu)::lcaParen() = %lu and lca() = %lu\n", temp, v1, lcaParen(temp, v1), lca(temp, v1));
exit(0);
}
}
}
int transpose_onerank(Agraph_t* g, int r, boolean reverse)
{
int i,c0,c1,rv;
node_t *v,*w;
rv = 0;
GD_rank(g)[r].candidate = FALSE;
for (i = leftmost(g,r); i < rightmost(g,r); i++) {
v = GD_rank(g)[r].v[i];
w = GD_rank(g)[r].v[i+1];
assert (ND_order(v) < ND_order(w));
if (left2right(g,v,w)) continue;
c0 = c1 = 0;
if (r > GD_minrank(g)) {
c0 += in_cross(v,w);
c1 += in_cross(w,v);
}
if (r < GD_maxrank(g)) {
c0 += out_cross(v,w);
c1 += out_cross(w,v);
}
if ((c1 < c0) || ((c0 > 0) && reverse && (c1 == c0))) {
exchange(g,v,w);
rv += (c0 - c1);
}
}
return rv;
}
/*
* defines ND_sortweight of each node in r0 w.r.t. r1
* returns...
*/
static boolean medians(Agraph_t *g, int r0, int r1)
{
static int *list;
static int list_extent;
int i,j,lm,rm,lspan,rspan;
node_t *n,**v;
edge_t *e;
boolean hasfixed = FALSE;
if (list_extent < GD_maxinoutdeg(g->root)) {
list_extent = GD_maxinoutdeg(g->root);
if (!list) list = realloc(list,sizeof(list[0])*list_extent);
else list = realloc(list,sizeof(list[0])*list_extent);
}
v = GD_rank(g)[r0].v;
for (i = leftmost(g,r0); i <= rightmost(g,r0); i++) {
n = v[i]; j = 0;
if (r1 > r0) for (e = agfstout(g,n); e; e = agnxtout(g,e))
{if (ED_xpenalty(e) > 0) list[j++] = VAL(e->head,ED_headport(e));}
else for (e = agfstin(g,n); e; e = agnxtin(g,e))
{if (ED_xpenalty(e) > 0) list[j++] = VAL(e->tail,ED_tailport(e));}
switch(j) {
case 0:
ND_sortweight(n) = -1; /* no neighbor - median undefined */
break;
case 1:
ND_sortweight(n) = list[0];
break;
case 2:
ND_sortweight(n) = (list[0] + list[1])/2;
break;
default:
qsort(list,j,sizeof(int),int_cmpf);
if (j % 2) ND_sortweight(n) = list[j/2];
else {
/* weighted median */
rm = j/2;
lm = rm - 1;
rspan = list[j-1] - list[rm];
lspan = list[lm] - list[0];
if (lspan == rspan)
ND_sortweight(n) = (list[lm] + list[rm])/2;
else {
int w = list[lm]*rspan + list[rm]*lspan;
ND_sortweight(n) = w / (lspan + rspan);
}
}
}
}
#ifdef NOTDEF
/* this code was in the old mincross */
for (i = 0; i < GD_rank(g)[r0].n; i++) {
n = v[i];
if ((ND_out(n).size == 0) && (ND_in(n).size == 0))
hasfixed |= flat_sortweight(n);
}
#endif
return hasfixed;
}
/* Returns the previous node of N. NULL iff n is the minimum. */
static Node *prev_node(Node *n)
{
if (n->left) return rightmost(n->left);
while (n->parent) {
if (RIGHTP(n)) return n->parent;
n = n->parent;
}
return NULL;
}
static void
screen_next_col(Screen *s)
{
s->x_pos = 0;
s->x_col++;
if (s->x_col >= numfields(s)) {
s->x_col = rightmost(s);
}
}
static void reorder(graph_t *g, int r, boolean reverse, boolean hasfixed)
{
boolean changed, muststay;
node_t **vlist, **lp, **rp, **ep;
int i;
changed = FALSE;
vlist = GD_rank(g)[r].v;
ep = &vlist[rightmost(g,r)];
for (i = leftmost(g,r); i <= rightmost(g,r); i++) {
lp = &vlist[leftmost(g,r)];
/* find leftmost node that can be compared */
while ((lp < ep) && (ND_sortweight(*lp) < 0)) lp++;
if (lp >= ep) break;
/* find the node that can be compared */
muststay = FALSE;
for (rp = lp + 1; rp < ep; rp++) {
if (left2right(g,*lp,*rp)) { muststay = TRUE; break; }
if (ND_sortweight(*rp) >= 0) break; /* weight defined; it's comparable */
}
if (rp >= ep) break;
if (muststay == FALSE) {
register int p1 = ND_sortweight(*lp);
register int p2 = ND_sortweight(*rp);
if ((p1 > p2) || ((p1 == p2) && (reverse))) {
exchange(g,*lp,*rp);
changed = TRUE;
}
}
lp = rp;
if ((hasfixed == FALSE) && (reverse == FALSE)) ep--;
}
if (changed) {
GD_rank(g)[r].changed = TRUE;
GD_rank(g)[r].crossing_cache.valid = FALSE;
if (r > 0) GD_rank(g)[r-1].crossing_cache.valid = FALSE;
if (r + 1 > GD_rank(g)[r+1].n) GD_rank(g)[r-1].crossing_cache.valid = FALSE;
}
}
static void presort(Agraph_t *ug)
{
int r;
int i;
Agraph_t *mg;
if (ug == ug->root) return;
mg = GD_model(ug);
for (r = GD_minrank(mg); r <= GD_maxrank(mg); r++) {
qsort(GD_rank(mg)[r].v,GD_rank(mg)[r].n,sizeof(Agnode_t*),presort_cmpf);
for (i = leftmost(mg,r); i < rightmost(mg,r); i++)
ND_order(GD_rank(mg)[r].v[i]) = i;
}
}
static Node *core_bound(ScmTreeCore *tc, ScmTreeCoreBoundOp op, int pop)
{
Node *root = ROOT(tc);
if (root) {
Node *n = (op == SCM_TREE_CORE_MIN)? leftmost(root) : rightmost(root);
if (pop) {
n = delete_node(tc, n);
tc->num_entries--;
}
return n;
} else {
return NULL;
}
}
const RbTreeNode *RbTreeUtil::previous(const RbTreeNode *node)
{
BSLS_ASSERT(node);
if (node->leftChild()) {
return rightmost(node->leftChild()); // RETURN
}
const RbTreeNode *parent = node->parent();
while (node == parent->leftChild()) {
node = parent;
parent = node->parent();
}
return parent;
}
void flatten(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(!root)
return;
flatten(root->left);
flatten(root->right);
if(!root->left)
return;
TreeNode* r = root->right;
TreeNode* rm = rightmost(root->left);
root->right = root->left;
root->left = NULL;
rm->right = r;
}
static void
screen_scroll_right(Screen *s)
{
s->x_pos++;
if (s->x_pos > maxlen(s,s->x_col)) {
s->x_pos = 0;
s->x_col++;
if (s->x_col >= numfields(s)) {
s->x_col = rightmost(s);
s->x_pos = maxlen(s,s->x_col);
}
}
}
const SplayTree::node* SplayTree::predecessor(const node* n) const
{
// If left child, predecessor is just the largest of the left
// subtree.
if (likely(NULL != n->child[LEFT]))
{
return rightmost(n->child[LEFT]);
}
// Else, need to work up the tree to find predecessor.
const node* y = n->parent;
while ((NULL != y) && (n == y->child[LEFT]))
{
n = y;
y = y->parent;
}
return y;
}
MapvNodeBase * MapvBase::unbalancing_removal( MapvNodeBase ** n )
{
MapvNodeBase * t = *n ;
while ( t != header() && t->parent ) {
if ( t->left ) { t = t->left ; }
else if ( t->right ) { t = t->right ; }
else { // Move to parent and remove this leaf
*n = t->parent ; t->parent = 0 ;
if ( (*n)->left == t ) (*n)->left = 0 ;
else (*n)->right = 0 ;
}
}
if ( t == header() ) {
header()->parent = 0 ;
header()->left = 0 ;
header()->right = 0 ;
header()->color = red ; /* Color the header node red */
Count = 0 ;
left_end.parent = 0 ;
left_end.left = 0 ;
left_end.right = 0 ;
left_end.color = black ;
right_end.parent = 0 ;
right_end.left = 0 ;
right_end.right = 0 ;
right_end.color = black ;
leftmost( header()->left = nREnd() ); // left end of the tree
rightmost( header()->right = nEnd() ); // right end of the tree
t = 0 ;
}
return t ;
}
void preorder(struct node *x){
struct node *temp = NULL;
while(x != NULL){
if(x->left == NULL){
printf("%c",x->data);
x = x->right;
}
else{
temp = rightmost(x->left, x);
if(temp->right == x){
temp->right = NULL;
x = x->right;
}
else{
printf("%c",x->data);
temp->right = x;
x = x->left;
}
}
}
}
static void
screen_end(Screen *s)
{
s->x_col = rightmost(s);
s->x_pos = 0;
}
void MapvBase::insert( MapvNodeBase * y , MapvNodeBase * z , bool z_lt_y )
{
z->remove_from_container();
if ( y == nEnd() ) { // First node inserted
root(z);
leftmost(z);
rightmost(z);
z->parent = header() ; // header is 'super-root'
}
else {
if ( z_lt_y ) {
y->left = z ;
// maintain leftmost() pointing to minimum node
if ( y == leftmost() ) leftmost(z);
}
else {
y->right = z;
// maintain rightmost() pointing to maximum node
if ( y == rightmost() ) rightmost(z);
}
z->parent = y ;
}
z->left = 0 ;
z->right = 0 ;
z->color = red ;
++Count ;
// -------------------------------------------------------------------
// Rebalance, 'y' and 'z' are reused as a local variable
while ( z != nRoot() && z->parent->color == red ) {
if ( z->parent == z->parent->parent->left ) {
y = z->parent->parent->right ;
if ( y && y->color == red ) {
z->parent->color = black;
y->color = black;
z->parent->parent->color = red;
z = z->parent->parent ;
}
else {
if ( z == z->parent->right ) {
z = z->parent ;
rotate_left(z);
}
z->parent->color = black;
z->parent->parent->color = red;
rotate_right( z->parent->parent );
}
}
else {
y = z->parent->parent->left ;
if ( y && y->color == red ) {
z->parent->color = black;
y->color = black;
z->parent->parent->color = red;
z = z->parent->parent ;
}
else {
if ( z == z->parent->left ) {
z = z->parent ;
rotate_right(z);
}
z->parent->color = black;
z->parent->parent->color = red;
rotate_left(z->parent->parent);
}
}
}
nRoot()->color = black;
}
void VideoCorrect::correctImage(Mat& inputFrame, Mat& outputFrame, bool developerMode){
resize(inputFrame, inputFrame, CAMERA_RESOLUTION);
inputFrame.copyTo(img);
//Convert to YCbCr color space
cvtColor(img, ycbcr, CV_BGR2YCrCb);
//Skin color thresholding
inRange(ycbcr, Scalar(0, 150 - Cr, 100 - Cb), Scalar(255, 150 + Cr, 100 + Cb), bw);
if(IS_INITIAL_FRAME){
face = detectFaces(img);
if(face.x != 0){
lastFace = face;
}
else{
outputFrame = img;
return;
}
prevSize = Size(face.width/2, face.height/2);
head = Mat::zeros(bw.rows, bw.cols, bw.type());
ellipse(head, Point(face.x + face.width/2, face.y + face.height/2), prevSize, 0, 0, 360, Scalar(255,255,255,0), -1, 8, 0);
if(face.x > 0 && face.y > 0 && face.width > 0 && face.height > 0
&& (face.x + face.width) < img.cols && (face.y + face.height) < img.rows){
img(face).copyTo(bestImg);
}
putText(img, "Give your best pose!", Point(face.x, face.y), CV_FONT_HERSHEY_SIMPLEX, 0.4, Scalar(255,255,255,0), 1, CV_AA);
}
firstFrameCounter--;
if(face.x == 0) //missing face prevention
face = lastFace;
//Mask the background out
bw &= head;
//Compute more accurate image moments after background removal
m = moments(bw, true);
angle = (atan((2*m.nu11)/(m.nu20-m.nu02))/2)*180/PI;
center = Point(m.m10/m.m00,m.m01/m.m00);
//Smooth rotation (running average)
bufferCounter++;
rotationBuffer[ bufferCounter % SMOOTHER_SIZE ] = angle;
smoothAngle += (angle - rotationBuffer[(bufferCounter + 1) % SMOOTHER_SIZE]) / SMOOTHER_SIZE;
//Expand borders
copyMakeBorder( img, img, BORDER_EXPAND, BORDER_EXPAND, BORDER_EXPAND, BORDER_EXPAND,
BORDER_REPLICATE, Scalar(255,255,255,0));
if(!IS_INITIAL_FRAME){
//Rotate the image to correct the leaning angle
rotateImage(img, smoothAngle);
//After rotation detect faces
face = detectFaces(img);
if(face.x != 0)
lastFace = face;
//Create background mask around the face
head = Mat::zeros(bw.rows, bw.cols, bw.type());
ellipse(head, Point(face.x - BORDER_EXPAND + face.width/2, face.y -BORDER_EXPAND + face.height/2),
prevSize, 0, 0, 360, Scalar(255,255,255,0), -1, 8, 0);
//Draw a rectangle around the face
//rectangle(img, face, Scalar(255,255,255,0), 1, 8, 0);
//Overlay the ideal pose
if(replaceFace && center.x > 0 && center.y > 0){
center = Point(face.x + face.width/2, face.y + face.width/2);
overlayImage(img, bestImg, center, smoothSize);
}
} else{
face.x += BORDER_EXPAND; //position alignment after border expansion (not necessary if we detect the face after expansion)
face.y += BORDER_EXPAND;
}
//Smooth ideal image size (running average)
sizeBuffer[ bufferCounter % SMOOTHER_SIZE ] = face.width;
smoothSize += (face.width - sizeBuffer[(bufferCounter + 1) % SMOOTHER_SIZE]) / SMOOTHER_SIZE;
//Get ROI
center = Point(face.x + face.width/2, face.y + face.width/2);
roi = getROI(img, center);
if(roi.x > 0 && roi.y > 0 && roi.width > 0 && roi.height > 0
&& (roi.x + roi.width) < img.cols && (roi.y + roi.height) < img.rows){
img = img(roi);
}
//Resize the final image
resize(img, img, CAMERA_RESOLUTION);
if(developerMode){
Mat developerScreen(img.rows,
img.cols +
inputFrame.cols +
bw.cols, CV_8UC3);
Mat left(developerScreen, Rect(0, 0, img.size().width, img.size().height));
img.copyTo(left);
Mat center(developerScreen, Rect(img.cols, 0, inputFrame.cols, inputFrame.rows));
inputFrame.copyTo(center);
cvtColor(bw, bw, CV_GRAY2BGR);
Mat right(developerScreen, Rect(img.size().width + inputFrame.size().width, 0, bw.size().width, bw.size().height));
bw.copyTo(right);
Mat rightmost(developerScreen, Rect(img.size().width + inputFrame.size().width + bw.size().width - bestImg.size().width, 0,
bestImg.size().width, bestImg.size().height));
bestImg.copyTo(rightmost);
outputFrame = developerScreen;
}
else{
outputFrame = img;
}
}
void MapvBase::remove( MapvNodeBase * node )
{
static const char method_name[] = "MapvBase::remove" ;
if ( container(node) != this ) {
std::string msg(method_name);
msg.append(" given object not in this container");
throw std::invalid_argument( msg );
}
if ( 1 == Count ) { // The last node ?
if ( node != leftmost() || node != rightmost() || node != nRoot() ) {
std::string msg(method_name);
msg.append(" internal data structure corrupted" );
throw std::runtime_error( msg );
}
leftmost( nREnd() );
rightmost( nEnd() );
root(0);
Count = 0 ;
header()->color = red ;
node->left = node->right = node->parent = 0 ; node->color = 0 ;
return ;
}
MapvNodeBase * z = node ;
MapvNodeBase * y = node ;
MapvNodeBase * x = 0 ;
MapvNodeBase * x_parent = 0 ;
// Ready to remove
if ( y->left == 0 ) { // z has at most one non-null child. y == z
x = y->right ; // x might be null
}
else if ( y->right == 0 ) { // z has exactly one non-null child. y == z
x = y->left ; // z is not null
}
else { // z has two non-null children.
y = y->right ; // Set y to z's successor.
while ( y->left ) y = y->left ;
x = y->right ; // x might be null
}
if ( y != z ) { // relink y in place of z. y is z's successor
z->left->parent = y ;
y->left = z->left ;
if ( y != z->right ) {
x_parent = y->parent ;
if ( x ) x->parent = x_parent ;
y->parent->left = x; // y must be a left child
y->right = z->right;
z->right->parent = y;
} else {
x_parent = y; // needed in case x == 0
}
if ( nRoot() == z) {
root(y);
}
else if ( z->parent->left == z) {
z->parent->left = y;
}
else {
z->parent->right = y;
}
y->parent = z->parent;
{ int c = y->color; y->color = z->color; z->color = c ; }
y = z;
// y points to node to be actually deleted
}
else { // y == z
x_parent = y->parent ;
if ( x ) x->parent = x_parent ; // possibly x == 0
if ( nRoot() == z) {
root(x);
}
else if ( z->parent->left == z ) {
z->parent->left = x;
}
else {
z->parent->right = x;
}
if ( leftmost() == z ) {
if ( z->right == 0 ) { // z->left must be null also
// makes leftmost() == nEnd() if z == nRoot()
leftmost( z->parent );
}
else {
leftmost( minimum(x) );
}
}
if ( rightmost() == z ) {
if ( z->left == 0 ) { // z->right must be null also
// makes rightmost() == nEnd() if z == nRoot()
rightmost( z->parent );
}
else { // x == z->left
rightmost( maximum(x) );
}
}
}
if ( y->color != red ) {
while ( x != nRoot() && ( x == 0 || x->color == black ) ) {
if ( x == x_parent->left ) {
MapvNodeBase * w = x_parent->right ;
if ( w->color == red ) {
w->color = black;
x_parent->color = red;
rotate_left(x_parent);
w = x_parent->right ;
}
if ((w->left == 0 || w->left->color == black) &&
(w->right == 0 || w->right->color == black)) {
w->color = red ;
x = x_parent ;
x_parent = x_parent->parent ;
}
else {
if (w->right == 0 || w->right->color == black) {
if ( w->left ) w->left->color = black;
w->color = red;
rotate_right(w);
w = x_parent->right ;
}
w->color = x_parent->color ;
x_parent->color = black;
if ( w->right ) w->right->color = black;
rotate_left(x_parent);
break;
}
}
else { // same as then clause with "right" and "left" exchanged
MapvNodeBase * w = x_parent->left ;
if ( w->color == red ) {
w->color = black;
x_parent->color = red;
rotate_right(x_parent);
w = x_parent->left ;
}
if ((w->right == 0 || w->right->color == black) &&
(w->left == 0 || w->left->color == black)) {
w->color = red;
x = x_parent ;
x_parent = x_parent->parent ;
}
else {
if ( w->left == 0 || w->left->color == black ) {
if ( w->right ) w->right->color = black;
w->color = red;
rotate_left(w);
w = x_parent->left ;
}
w->color = x_parent->color ;
x_parent->color = black;
if ( w->left ) w->left->color = black;
rotate_right(x_parent);
break;
}
}
}
if ( x ) x->color = black;
}
y->left = y->right = y->parent = 0 ; y->color = 0 ;
--Count ; // Decrement the tree's count
}
