int climb(int n) {
if (n >= N) return 1;
int k;
if (a[n] == 0) {
k = climb(n+1) + climb(n+2);
a[n] = k;
}
else
k = a[n];
return k;
}
// static
void LLLocalInventory::climb(LLInventoryCategory* cat,
LLInventoryModel::cat_array_t& cats,
LLInventoryModel::item_array_t& items)
{
LLInventoryModel* model = &gInventory;
// Add this category
cats.push_back(LLPointer<LLViewerInventoryCategory>((LLViewerInventoryCategory*)cat));
LLInventoryModel::cat_array_t *direct_cats;
LLInventoryModel::item_array_t *direct_items;
model->getDirectDescendentsOf(cat->getUUID(), direct_cats, direct_items);
// Add items
LLInventoryModel::item_array_t::iterator item_iter = direct_items->begin();
LLInventoryModel::item_array_t::iterator item_end = direct_items->end();
for( ; item_iter != item_end; ++item_iter)
{
items.push_back(*item_iter);
}
// Do subcategories
LLInventoryModel::cat_array_t::iterator cat_iter = direct_cats->begin();
LLInventoryModel::cat_array_t::iterator cat_end = direct_cats->end();
for( ; cat_iter != cat_end; ++cat_iter)
{
climb(*cat_iter, cats, items);
}
}
int climbStairs(int n) {
if (n <= 0) return 0;
vector<int> dp(n+1, 0);
dp[1] = 1;
dp[2] = 2;
climb(n, dp);
return dp[n];
}
int main(void) {
printf("%d\n", climb(0));
int i;
for ( i = 0;i < N; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}
//static
void LLLocalInventory::saveInvCache(std::string filename, LLFolderView* folder)
{
LLInventoryModel* model = &gInventory;
std::set<LLUUID> selected_items;
folder->getSelectionList(selected_items);
if(selected_items.size() < 1)
{
// No items selected? Wtfboom
return;
}
LLInventoryModel::cat_array_t cats;
LLInventoryModel::item_array_t items;
// Make complete lists of child categories and items
std::set<LLUUID>::iterator sel_iter = selected_items.begin();
std::set<LLUUID>::iterator sel_end = selected_items.end();
for( ; sel_iter != sel_end; ++sel_iter)
{
LLInventoryCategory* cat = model->getCategory(*sel_iter);
if(cat)
{
climb(cat, cats, items);
}
}
// And what about items inside a folder that wasn't selected?
// I guess I will just add selected items, so long as they aren't already added
for(sel_iter = selected_items.begin(); sel_iter != sel_end; ++sel_iter)
{
LLInventoryItem* item = model->getItem(*sel_iter);
if(item)
{
if(std::find(items.begin(), items.end(), item) == items.end())
{
items.push_back(LLPointer<LLViewerInventoryItem>((LLViewerInventoryItem*)item));
LLInventoryCategory* parent = model->getCategory(item->getParentUUID());
if(std::find(cats.begin(), cats.end(), parent) == cats.end())
{
cats.push_back(LLPointer<LLViewerInventoryCategory>((LLViewerInventoryCategory*)parent));
}
}
}
}
LLInventoryModel::saveToFile(filename, cats, items);
}
/** -------------------------------------------------------------------
** @brief Process image
**
** The functions calculates the Maximally Stable Extremal Regions
** (MSERs) of image @a im using the MSER filter @a f.
**
** The filter @a f must have been initialized to be compatible with
** the dimensions of @a im.
**
** @param f MSER filter.
** @param im image data.
**/
VL_EXPORT
void
vl_mser_process (VlMserFilt* f, vl_mser_pix const* im)
{
/* shortcuts */
vl_uint nel = f-> nel ;
vl_uint *perm = f-> perm ;
vl_uint *joins = f-> joins ;
int ndims = f-> ndims ;
int *dims = f-> dims ;
int *subs = f-> subs ;
int *dsubs = f-> dsubs ;
int *strides = f-> strides ;
VlMserReg *r = f-> r ;
VlMserExtrReg *er = f-> er ;
vl_uint *mer = f-> mer ;
int delta = f-> delta ;
int njoins = 0 ;
int ner = 0 ;
int nmer = 0 ;
int nbig = 0 ;
int nsmall = 0 ;
int nbad = 0 ;
int ndup = 0 ;
int i, j, k ;
/* delete any previosuly computed ellipsoid */
f-> nell = 0 ;
/* -----------------------------------------------------------------
* Sort pixels by intensity
* -------------------------------------------------------------- */
{
vl_uint buckets [ VL_MSER_PIX_MAXVAL ] ;
/* clear buckets */
memset (buckets, 0, sizeof(vl_uint) * VL_MSER_PIX_MAXVAL ) ;
/* compute bucket size (how many pixels for each intensity
value) */
for(i = 0 ; i < (int) nel ; ++i) {
vl_mser_pix v = im [i] ;
++ buckets [v] ;
}
/* cumulatively add bucket sizes */
for(i = 1 ; i < VL_MSER_PIX_MAXVAL ; ++i) {
buckets [i] += buckets [i-1] ;
}
/* empty buckets computing pixel ordering */
for(i = nel ; i >= 1 ; ) {
vl_mser_pix v = im [ --i ] ;
vl_uint j = -- buckets [v] ;
perm [j] = i ;
}
}
/* initialize the forest with all void nodes */
for(i = 0 ; i < (int) nel ; ++i) {
r [i] .parent = VL_MSER_VOID_NODE ;
}
/* -----------------------------------------------------------------
* Compute regions and count extremal regions
* -------------------------------------------------------------- */
/*
In the following:
idx : index of the current pixel
val : intensity of the current pixel
r_idx : index of the root of the current pixel
n_idx : index of the neighbors of the current pixel
nr_idx : index of the root of the neighbor of the current pixel
*/
/* process each pixel by increasing intensity */
for(i = 0 ; i < (int) nel ; ++i) {
/* pop next node xi */
vl_uint idx = perm [i] ;
vl_mser_pix val = im [idx] ;
vl_uint r_idx ;
/* add the pixel to the forest as a root for now */
r [idx] .parent = idx ;
r [idx] .shortcut = idx ;
r [idx] .area = 1 ;
r [idx] .height = 1 ;
r_idx = idx ;
/* convert the index IDX into the subscript SUBS; also initialize
DSUBS to (-1,-1,...,-1) */
{
vl_uint temp = idx ;
for(k = ndims - 1 ; k >= 0 ; --k) {
dsubs [k] = -1 ;
subs [k] = temp / strides [k] ;
temp = temp % strides [k] ;
}
}
/* examine the neighbors of the current pixel */
while (1) {
vl_uint n_idx = 0 ;
vl_bool good = 1 ;
/*
Compute the neighbor subscript as NSUBS+SUB, the
corresponding neighbor index NINDEX and check that the
neighbor is within the image domain.
*/
for(k = 0 ; k < ndims && good ; ++k) {
int temp = dsubs [k] + subs [k] ;
good &= (0 <= temp) && (temp < dims [k]) ;
n_idx += temp * strides [k] ;
}
/*
The neighbor should be processed if the following conditions
are met:
1. The neighbor is within image boundaries.
2. The neighbor is indeed different from the current node
(the opposite happens when DSUB=(0,0,...,0)).
3. The neighbor is already in the forest, meaning that it has
already been processed.
*/
if (good &&
n_idx != idx &&
r [n_idx] .parent != VL_MSER_VOID_NODE ) {
vl_mser_pix nr_val = 0 ;
vl_uint nr_idx = 0 ;
/*
Now we join the two subtrees rooted at
R_IDX = ROOT( IDX)
NR_IDX = ROOT(N_IDX).
Note that R_IDX = ROOT(IDX) might change as we process more
neighbors, so we need keep updating it.
*/
r_idx = climb(r, idx) ;
nr_idx = climb(r, n_idx) ;
int hgt = r [ r_idx] .height ;
int n_hgt = r [nr_idx] .height ;
/*
At this point we have three possibilities:
(A) ROOT(IDX) == ROOT(NR_IDX). In this case the two trees
have already been joined and we do not do anything.
(B) I(ROOT(IDX)) == I(ROOT(NR_IDX)). In this case the pixel
IDX is extending an extremal region with the same
intensity value. Since ROOT(NR_IDX) will NOT be an
extremal region of the full image, ROOT(IDX) can be
safely added as children of ROOT(NR_IDX) if this
reduces the height according to the union rank
heuristic.
(C) I(ROOT(IDX)) > I(ROOT(NR_IDX)). In this case the pixel
IDX is starting a new extremal region. Thus ROOT(NR_IDX)
WILL be an extremal region of the final image and the
only possibility is to add ROOT(NR_IDX) as children of
ROOT(IDX), which becomes parent.
*/
if( r_idx != nr_idx ) { /* skip if (A) */
nr_val = im [nr_idx] ;
if( nr_val == val && hgt < n_hgt ) {
/* ROOT(IDX) becomes the child */
r [r_idx] .parent = nr_idx ;
r [r_idx] .shortcut = nr_idx ;
r [nr_idx] .area += r [r_idx] .area ;
r [nr_idx] .height = VL_MAX(n_hgt, hgt+1) ;
joins [njoins++] = r_idx ;
} else {
/* cases ROOT(IDX) becomes the parent */
r [nr_idx] .parent = r_idx ;
r [nr_idx] .shortcut = r_idx ;
r [r_idx] .area += r [nr_idx] .area ;
r [r_idx] .height = VL_MAX(hgt, n_hgt + 1) ;
joins [njoins++] = nr_idx ;
/* count if extremal */
if (nr_val != val) ++ ner ;
} /* check b vs c */
} /* check a vs b or c */
} /* neighbor done */
/* move to next neighbor */
k = 0 ;
while(++ dsubs [k] > 1) {
dsubs [k++] = -1 ;
if(k == ndims) goto done_all_neighbors ;
}
} /* next neighbor */
done_all_neighbors : ;
} /* next pixel */
/* the last root is extremal too */
++ ner ;
/* save back */
f-> njoins = njoins ;
f-> stats. num_extremal = ner ;
/* -----------------------------------------------------------------
* Extract extremal regions
* -------------------------------------------------------------- */
/*
Extremal regions are extracted and stored into the array ER. The
structure R is also updated so that .SHORTCUT indexes the
corresponding extremal region if any (otherwise it is set to
VOID).
*/
/* make room */
if (f-> rer < ner) {
if (er) vl_free (er) ;
f->er = er = vl_malloc (sizeof(VlMserExtrReg) * ner) ;
f->rer = ner ;
} ;
/* save back */
f-> nmer = ner ;
/* count again */
ner = 0 ;
/* scan all regions Xi */
for(i = 0 ; i < (int) nel ; ++i) {
/* pop next node xi */
vl_uint idx = perm [i] ;
vl_mser_pix val = im [idx] ;
vl_uint p_idx = r [idx] .parent ;
vl_mser_pix p_val = im [p_idx] ;
/* is extremal ? */
vl_bool is_extr = (p_val > val) || idx == p_idx ;
if( is_extr ) {
/* if so, add it */
er [ner] .index = idx ;
er [ner] .parent = ner ;
er [ner] .value = im [idx] ;
er [ner] .area = r [idx] .area ;
/* link this region to this extremal region */
r [idx] .shortcut = ner ;
/* increase count */
++ ner ;
} else {
/* link this region to void */
r [idx] .shortcut = VL_MSER_VOID_NODE ;
}
}
/* -----------------------------------------------------------------
* Link extremal regions in a tree
* -------------------------------------------------------------- */
for(i = 0 ; i < ner ; ++i) {
vl_uint idx = er [i] .index ;
do {
idx = r[idx] .parent ;
} while (r[idx] .shortcut == VL_MSER_VOID_NODE) ;
er[i] .parent = r[idx] .shortcut ;
er[i] .shortcut = i ;
}
/* -----------------------------------------------------------------
* Compute variability of +DELTA branches
* -------------------------------------------------------------- */
/* For each extremal region Xi of value VAL we look for the biggest
* parent that has value not greater than VAL+DELTA. This is dubbed
* `top parent'. */
for(i = 0 ; i < ner ; ++i) {
/* Xj is the current region the region and Xj are the parents */
int top_val = er [i] .value + delta ;
int top = er [i] .shortcut ;
/* examine all parents */
while (1) {
int next = er [top] .parent ;
int next_val = er [next] .value ;
/* Break if:
* - there is no node above the top or
* - the next node is above the top value.
*/
if (next == top || next_val > top_val) break ;
/* so next could be the top */
top = next ;
}
/* calculate branch variation */
{
int area = er [i ] .area ;
int area_top = er [top] .area ;
er [i] .variation = (float) (area_top - area) / area ;
er [i] .max_stable = 1 ;
}
/* Optimization: since extremal regions are processed by
* increasing intensity, all next extremal regions being processed
* have value at least equal to the one of Xi. If any of them has
* parent the parent of Xi (this comprises the parent itself), we
* can safely skip most intermediate node along the branch and
* skip directly to the top to start our search. */
{
int parent = er [i] .parent ;
int curr = er [parent] .shortcut ;
er [parent] .shortcut = VL_MAX (top, curr) ;
}
}
/* -----------------------------------------------------------------
* Select maximally stable branches
* -------------------------------------------------------------- */
nmer = ner ;
for(i = 0 ; i < ner ; ++i) {
vl_uint parent = er [i ] .parent ;
vl_mser_pix val = er [i ] .value ;
float var = er [i ] .variation ;
vl_mser_pix p_val = er [parent] .value ;
float p_var = er [parent] .variation ;
vl_uint loser ;
/*
Notice that R_parent = R_{l+1} only if p_val = val + 1. If not,
this and the parent region coincide and there is nothing to do.
*/
if(p_val > val + 1) continue ;
/* decide which one to keep and put that in loser */
if(var < p_var) loser = parent ; else loser = i ;
/* make loser NON maximally stable */
if(er [loser] .max_stable) {
-- nmer ;
er [loser] .max_stable = 0 ;
}
}
f-> stats. num_unstable = ner - nmer ;
/* -----------------------------------------------------------------
* Further filtering
* -------------------------------------------------------------- */
/* It is critical for correct duplicate detection to remove regions
* from the bottom (smallest one first). */
{
float max_area = (float) f-> max_area * nel ;
float min_area = (float) f-> min_area * nel ;
float max_var = (float) f-> max_variation ;
float min_div = (float) f-> min_diversity ;
/* scan all extremal regions (intensity value order) */
for(i = ner-1 ; i >= 0L ; --i) {
/* process only maximally stable extremal regions */
if (! er [i] .max_stable) continue ;
if (er [i] .variation >= max_var ) { ++ nbad ; goto remove ; }
if (er [i] .area > max_area) { ++ nbig ; goto remove ; }
if (er [i] .area < min_area) { ++ nsmall ; goto remove ; }
/*
* Remove duplicates
*/
if (min_div < 1.0) {
vl_uint parent = er [i] .parent ;
int area, p_area ;
float div ;
/* check all but the root mser */
if((int) parent != i) {
/* search for the maximally stable parent region */
while(! er [parent] .max_stable) {
vl_uint next = er [parent] .parent ;
if(next == parent) break ;
parent = next ;
}
/* Compare with the parent region; if the current and parent
* regions are too similar, keep only the parent. */
area = er [i] .area ;
p_area = er [parent] .area ;
div = (float) (p_area - area) / (float) p_area ;
if (div < min_div) { ++ ndup ; goto remove ; }
} /* remove dups end */
}
continue ;
remove :
er [i] .max_stable = 0 ;
-- nmer ;
} /* check next region */
f-> stats .num_abs_unstable = nbad ;
f-> stats .num_too_big = nbig ;
f-> stats .num_too_small = nsmall ;
f-> stats .num_duplicates = ndup ;
}
/* -----------------------------------------------------------------
* Save the result
* -------------------------------------------------------------- */
/* make room */
if (f-> rmer < nmer) {
if (mer) vl_free (mer) ;
f->mer = mer = vl_malloc( sizeof(vl_uint) * nmer) ;
f->rmer = nmer ;
}
/* save back */
f-> nmer = nmer ;
j = 0 ;
for (i = 0 ; i < ner ; ++i) {
if (er [i] .max_stable) mer [j++] = er [i] .index ;
}
}
int main(void)
{
DDRC |= (1<<PORTC6) | (1<<PORTC7); //init LEDs
//servoTx;
SERVO_init(); //Init servos
USART_init();
init_counters();
set_counter_1(10000);
initvar();
sei();
SERVO_update_EEPROM(BROADCASTING_ID);
//move_to_std();
// ------ TESTCODE FOR READING SERVO -------
//servoGoto(1, 3.14/3, 0x200);
SERVO_update_EEPROM(BROADCASTING_ID); // NOTE: needs to run once for SERVO_get position to work
//----------------------------
_delay_ms(3000);
reset_counter_1();
set_counter_1(3000);
while(1)
{
/*
uint8_t r = USART_getRotation();
uint8_t s = USART_getSpeed();
uint8_t d = USART_getDirection();
if(s != 0 || r != 50)
{
std_pos_flag = 0;
reset_counter_1();
}
move_robot(d, r, s);
if(r == 50 && s == 0 && d == 0)
{
_delay_ms(50);
//PORTD ^= (1<<PORTD5);
cli();
USART_send_ready();
sei();
}
*/
/*change_z(-130);
move_to_std();
for(int i = 0; i < 5; ++i)
{
move_robot(0,50,100);
//_delay_ms(2000);
}
_delay_ms(1000);
move_to_std();
_delay_ms(1000);
*/
climb();
//climb_all_one_leg();
//SERVO_update_data(12);
//USART_SendValue(SERVO_get_load());
USART_DecodeRxFIFO();
_delay_ms(200);
}
}
int main(void)
{
LED_INIT;
//servoTx;
sei();
USART_init();
MPU_init();
SERVO_init();
init_counters();
initvar();
SERVO_update_EEPROM(BROADCASTING_ID);
wait(10);
move_to_std();
wait_until_gyro_stable();
LED0_ON;
USART_send_message("Gyro Stable");
// ------ TESTCODE FOR READING SERVO -------
//servoGoto(1, 3.14/3, 0x200);
SERVO_update_EEPROM(BROADCASTING_ID); // NOTE: needs to run once for SERVO_get position to work
//----------------------------
reset_counter_1();
set_counter_1(3000);
uint8_t readyCounter = 0;
while(1)
{
MPU_update();
if(USART_get_turn_flag())
{
turn_degrees(USART_get_turn_angle(), USART_get_turn_dir());
}
if(USART_get_climb_flag())
{
climb();
}
uint8_t r = USART_getRotation();
uint8_t s = USART_getSpeed();
uint8_t d = USART_getDirection();
if(s != 0 || r != 50)
{
std_pos_flag = 0;
reset_counter_1();
readyCounter = 3;
}
move_robot(d, r, s);
if(r == 50 && s == 0 && d == 0 && readyCounter)
{
cli();
USART_send_ready();
sei();
readyCounter--;
}
if(move_to_std_flag == 1)
{
move_to_std_flag = 0;
move_to_std();
}
/*climb();
for(int i = 0; i < 10; ++i)
{
move_robot(0,50,100);
//wait(2000);
}
*/
/*
change_z(-120);
move_to_std();
turn_degrees(180,1);
// Takes a predecided number of steps forward
// This is good when testing different things.
wait(100);
for(int i = 0; i < 10; ++i)
{
move_robot(0,50,100);
//wait(2000);
}
*/
USART_decode_rx_fifo();
}
}
int climb(int n, vector<int>& dp) {
if (dp[n]) return dp[n];
dp[n] = climb(n-1, dp) + climb(n-2, dp);
return dp[n];
}
