// inserts element with key x into list void skip_list::insert(int x) { vector<element*> update(max_height+1); element* p = &head; for (int i = height; i>=0; --i) { while (p->next[i]->key < x) { p = p->next[i]; } update[i] = p; } p = p->next[0]; if (p->key == x) return; // key x exists already in list int new_height = random_height(); if (new_height > height) { // link new element to head, adjust list height for (int i = height+1; i<=new_height; ++i) { update[i] = &head; } height = new_height; } // create new element with height new_height and key x p = new element(x,new_height); // insert p into level i lists immediately after element update[i] for (int i = 0; i<=new_height; ++i) { p->next[i] = update[i]->next[i]; update[i]->next[i] = p; } }
// Internal method of rope_insert. // This function creates a new node in the rope at the specified position and fills it with the // passed string. static void insert_at(rope *r, rope_iter *iter, const uint8_t *str, size_t num_bytes, size_t num_chars) { #if ROPE_WCHAR size_t num_wchars = count_wchars_in_utf8(str, num_chars); #endif // This describes how many levels of the iter are filled in. uint8_t max_height = r->head.height; uint8_t new_height = random_height(); rope_node *new_node = alloc_node(r, new_height); new_node->num_bytes = num_bytes; memcpy(new_node->str, str, num_bytes); assert(new_height < ROPE_MAX_HEIGHT); // Max height (the rope's head's height) must be 1+ the height of the largest node. while (max_height <= new_height) { r->head.height++; r->head.nexts[max_height] = r->head.nexts[max_height - 1]; // This is the position (offset from the start) of the rope. iter->s[max_height] = iter->s[max_height - 1]; max_height++; } // Fill in the new node's nexts array. int i; for (i = 0; i < new_height; i++) { rope_skip_node *prev_skip = &iter->s[i].node->nexts[i]; new_node->nexts[i].node = prev_skip->node; new_node->nexts[i].skip_size = num_chars + prev_skip->skip_size - iter->s[i].skip_size; prev_skip->node = new_node; prev_skip->skip_size = iter->s[i].skip_size; // & move the iterator to the end of the newly inserted node. iter->s[i].node = new_node; iter->s[i].skip_size = num_chars; #if ROPE_WCHAR new_node->nexts[i].wchar_size = num_wchars + prev_skip->wchar_size - iter->s[i].wchar_size; prev_skip->wchar_size = iter->s[i].wchar_size; iter->s[i].wchar_size = num_wchars; #endif } for (; i < max_height; i++) { iter->s[i].node->nexts[i].skip_size += num_chars; iter->s[i].skip_size += num_chars; #if ROPE_WCHAR iter->s[i].node->nexts[i].wchar_size += num_wchars; iter->s[i].wchar_size += num_wchars; #endif } r->num_chars += num_chars; r->num_bytes += num_bytes; }
// Internal method of rope_insert. static void insert_at(rope *r, size_t pos, const uint8_t *str, size_t num_bytes, size_t num_chars, rope_node *nodes[], size_t tree_offsets[]) { // This describes how many of the nodes[] and tree_offsets[] arrays are filled in. uint8_t max_height = r->height; uint8_t new_height = random_height(); rope_node *new_node = alloc_node(r, new_height); new_node->num_bytes = num_bytes; memcpy(new_node->str, str, num_bytes); // Ensure the rope has enough capacity to store the next pointers to the new object. if (new_height > max_height) { r->height = new_height; if (r->height > r->height_capacity) { do { r->height_capacity *= 2; } while (r->height_capacity < r->height); r->heads = (rope_next_node *)r->realloc(r->heads, sizeof(rope_next_node) * r->height_capacity); } } // Fill in the new node's nexts array. int i; for (i = 0; i < new_height; i++) { if (i < max_height) { rope_next_node *prev_node = (nodes[i] ? &nodes[i]->nexts[i] : &r->heads[i]); new_node->nexts[i].node = prev_node->node; new_node->nexts[i].skip_size = num_chars + prev_node->skip_size - tree_offsets[i]; prev_node->node = new_node; prev_node->skip_size = tree_offsets[i]; } else { // Edit the head node instead of editing the parent listed in nodes. new_node->nexts[i].node = NULL; new_node->nexts[i].skip_size = r->num_chars - pos + num_chars; r->heads[i].node = new_node; r->heads[i].skip_size = pos; } nodes[i] = new_node; tree_offsets[i] = num_chars; } for (; i < max_height; i++) { if (nodes[i]) { nodes[i]->nexts[i].skip_size += num_chars; } else { r->heads[i].skip_size += num_chars; } tree_offsets[i] += num_chars; } r->num_chars += num_chars; r->num_bytes += num_bytes; }
void PixelFeatureLayer<Dtype>::Forward_cpu( const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) { const PixelFeatureParameter& parameter = this->layer_param_.pixel_feature_param(); Dtype* top_data = top[0]->mutable_cpu_data(); switch (this->layer_param_.pixel_feature_param().type()) { case PixelFeatureParameter_Feature_POSITION: { if (!ran_once) { const Dtype scale = parameter.pos_scale(); const Dtype offset_h = parameter.offset_h(); const Dtype offset_w = parameter.offset_w(); for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { Dtype y_offset = scale * y + offset_h; for (unsigned int x = 0; x < width_; ++x) { top_data[top[0]->offset(n, 0, y, x)] = y_offset; top_data[top[0]->offset(n, 1, y, x)] = scale * x + offset_w; } } } } break; } case PixelFeatureParameter_Feature_POSITION_AND_RGB: { const Dtype scale = parameter.pos_scale(); const Dtype color_scale = parameter.color_scale(); const Dtype offset_h = parameter.offset_h(); const Dtype offset_w = parameter.offset_w(); for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { Dtype y_offset = scale * y + offset_h; for (unsigned int x = 0; x < width_; ++x) { top_data[top[0]->offset(n, 0, y, x)] = y_offset; top_data[top[0]->offset(n, 1, y, x)] = scale * x + offset_w; for (unsigned int c = 0; c < bottom[0]->channels(); ++c) { top_data[top[0]->offset(n, c+2, y, x)] = color_scale * bottom[0]->data_at(n, c, y, x); } } } } break; } case PixelFeatureParameter_Feature_RGB_AND_POSITION: { const Dtype scale = parameter.pos_scale(); const Dtype color_scale = parameter.color_scale(); const Dtype offset_h = parameter.offset_h(); const Dtype offset_w = parameter.offset_w(); for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { Dtype y_offset = scale * y + offset_h; for (unsigned int x = 0; x < width_; ++x) { for (unsigned int c = 0; c < bottom[0]->channels(); ++c) { top_data[top[0]->offset(n, c, y, x)] = color_scale * bottom[0]->data_at(n, c, y, x); } top_data[top[0]->offset(n, bottom[0]->channels(), y, x)] = y_offset; top_data[top[0]->offset(n, bottom[0]->channels() + 1, y, x)] = scale * x + offset_w; } } } break; } case PixelFeatureParameter_Feature_RGB: { const Dtype color_scale = parameter.color_scale(); for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { for (unsigned int x = 0; x < width_; ++x) { for (unsigned int c = 0; c < bottom[0]->channels(); ++c) { top_data[top[0]->offset(n, c, y, x)] = color_scale * bottom[0]->data_at(n, c, y, x); } } } } break; } case PixelFeatureParameter_Feature_RANDOM_POSITION: case PixelFeatureParameter_Feature_NUM_RANDOM_POSITION: { if (!ran_once) { const int input_height = bottom[0]->height(); const int input_width = bottom[0]->width(); const Dtype scale = parameter.pos_scale(); boost::uniform_real<Dtype> random_height(0, input_height); boost::variate_generator<caffe::rng_t*, boost::uniform_real<Dtype> > variate_height(caffe_rng(), random_height); boost::uniform_real<Dtype> random_width(0, input_width); boost::variate_generator<caffe::rng_t*, boost::uniform_real<Dtype> > variate_width(caffe_rng(), random_width); for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { for (unsigned int x = 0; x < width_; ++x) { top_data[top[0]->offset(n, 0, y, x)] = scale * variate_height(); top_data[top[0]->offset(n, 1, y, x)] = scale * variate_width(); } } } } break; } case PixelFeatureParameter_Feature_WARPED_POSITION: { if (!ran_once) { const Dtype angle = -parameter.rotation_angle() / 180.0 * M_PI; const Dtype scale = parameter.pos_scale(); const Dtype angle_sigma = parameter.rotation_sigma(); const Dtype cosAngle = std::cos(angle); const Dtype sinAngle = std::sin(angle); const Dtype mid_y = height_ / 2; const Dtype mid_x = width_ / 2; Dtype scaled_y, scaled_x; for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { scaled_y = y * scale - mid_y; for (unsigned int x = 0; x < width_; ++x) { scaled_x = x * scale - mid_x; top_data[top[0]->offset(n, 0, y, x)] = sinAngle * scaled_x + cosAngle * scaled_y + mid_y; top_data[top[0]->offset(n, 1, y, x)] = cosAngle * scaled_x - sinAngle * scaled_y + mid_x; top_data[top[0]->offset(n, 2, y, x)] = angle / angle_sigma; } } } } break; } case PixelFeatureParameter_Feature_RANDOM_ROTATE: { if (!ran_once) { boost::uniform_real<Dtype> random_angle(-10, 10); boost::variate_generator<caffe::rng_t*, boost::uniform_real<Dtype> > variate_angle(caffe_rng(), random_angle); const Dtype angle = variate_angle() / 180.0 * M_PI; const Dtype scale = 1; const Dtype cosAngle = std::cos(angle); const Dtype sinAngle = std::sin(angle); const Dtype mid_y = height_ / 2; const Dtype mid_x = width_ / 2; Dtype scaled_y, scaled_x; for (unsigned int n = 0; n < num_; ++n) { for (unsigned int y = 0; y < height_; ++y) { scaled_y = y * scale - mid_y; for (unsigned int x = 0; x < width_; ++x) { scaled_x = x * scale - mid_x; top_data[top[0]->offset(n, 0, y, x)] = sinAngle * scaled_x + cosAngle * (scaled_y - mid_y) + mid_y; top_data[top[0]->offset(n, 1, y, x)] = cosAngle * scaled_x - sinAngle * scaled_y + mid_x; } } } } break; } default: LOG(FATAL) << "Undefined feature type of pixel feature layer"; } ran_once = true; }