int dwarf_entry_breakpoints (Dwarf_Die *die, Dwarf_Addr **bkpts) { int nbkpts = 0; *bkpts = NULL; /* Fetch the CU's line records to look for this DIE's addresses. */ Dwarf_Die cudie = CUDIE (die->cu); Dwarf_Lines *lines; size_t nlines; if (INTUSE(dwarf_getsrclines) (&cudie, &lines, &nlines) < 0) { int error = INTUSE (dwarf_errno) (); if (error == 0) /* CU has no DW_AT_stmt_list. */ return entrypc_bkpt (die, bkpts, &nbkpts); __libdw_seterrno (error); return -1; } /* Search each contiguous address range for DWARF prologue_end markers. */ Dwarf_Addr base; Dwarf_Addr begin; Dwarf_Addr end; ptrdiff_t offset = INTUSE(dwarf_ranges) (die, 0, &base, &begin, &end); if (offset < 0) return -1; /* Most often there is a single contiguous PC range for the DIE. */ if (offset == 1) return search_range (begin, end, true, true, lines, nlines, bkpts, &nbkpts) ?: entrypc_bkpt (die, bkpts, &nbkpts); Dwarf_Addr lowpc = (Dwarf_Addr) -1l; Dwarf_Addr highpc = (Dwarf_Addr) -1l; while (offset > 0) { /* We have an address range entry. */ if (search_range (begin, end, true, false, lines, nlines, bkpts, &nbkpts) < 0) return -1; if (begin < lowpc) { lowpc = begin; highpc = end; } offset = INTUSE(dwarf_ranges) (die, offset, &base, &begin, &end); } /* If we didn't find any proper DWARF markers, then look in the lowest-addressed range for an ad hoc marker. Failing that, fall back to just using the entrypc value. */ return (nbkpts ?: (lowpc == (Dwarf_Addr) -1l ? 0 : search_range (lowpc, highpc, false, true, lines, nlines, bkpts, &nbkpts)) ?: entrypc_bkpt (die, bkpts, &nbkpts)); }
int main() { p_srand(0); static int32_t x[MAXN], y[MAXN], w[MAXN]; int N = 1000, M = 10000, R = 100; init(N, R, x, y, w); int32_t hash = 0; for (int it = 0; it < M; it++) { Rect rect = rand_rect(R); int32_t ret = search_range(rect, x, y, w, N); hash ^= ret; tick(N, R, x, y, w); } printf("%" PRIi32 "\n", hash); return 0; }
void test() { int data[5] = {0, 1, 2, 3, 4}; int search_array[2] = {0, 4}; const int const_search_array[2] = {0, 4}; range<int> data_range(data, 5); range<const int> const_data_range= data_range; range<int> search_range(data, 2); range<const int> const_search_range(data, 2); find_first_of(data_range, 2); find_first_of(data_range, search_range); find_first_of(data_range, const_search_range); find_first_of(data_range, search_array); find_first_of(data_range, const_search_array); find_first_of(const_data_range, 2); find_first_of(const_data_range, search_range); find_first_of(const_data_range, const_search_range); find_first_of(const_data_range, search_array); find_first_of(const_data_range, const_search_array); find_last_of(data_range, 2); find_last_of(data_range, search_range); find_last_of(data_range, const_search_range); find_last_of(data_range, search_array); find_last_of(data_range, const_search_array); find_last_of(const_data_range, 2); find_last_of(const_data_range, search_range); find_last_of(const_data_range, const_search_range); find_last_of(const_data_range, search_array); find_last_of(const_data_range, const_search_array); // range algorithms }
bool KeypointMatcher::matchPatch(const cv::Mat& patch, const cv::Mat& target, cv::Point2d& target_pt) const { const int rx = irange(static_cast<int>(target_pt.x)-ncc_range,0,target.cols), ry = irange(static_cast<int>(target_pt.y)-ncc_range,0,target.rows), rw = rx+ncc_range_dbl>target.cols? target.cols-rx:ncc_range_dbl, rh = ry+ncc_range_dbl>target.rows? target.rows-ry:ncc_range_dbl; cv::Mat search_range(target, cv::Rect(rx,ry,rw,rh)); if (rw < patch.cols || rh < patch.rows) return false; double peak; cv::Mat result; cv::Point peak_pt; /* */ cv::matchTemplate(search_range, patch, result, CV_TM_CCORR_NORMED); cv::minMaxLoc(result, NULL, &peak, NULL, &peak_pt); if (peak < threshold) { return false; } /* * cv::matchTemplate(search_range, patch, result, CV_TM_SQDIFF_NORMED); cv::minMaxLoc(result, &peak, NULL, &peak_pt, NULL); /* */ double peak_x = static_cast<double>(peak_pt.x); double peak_y = static_cast<double>(peak_pt.y); if (refine_subpx) { //Quadratic Interpolation const double z_00 = static_cast<double>( result.at<float>(peak_y,peak_x) ); const double z_p10 = static_cast<double>( result.at<float>(peak_y,peak_x+1) ); const double z_m10 = static_cast<double>( result.at<float>(peak_y,peak_x-1) ); const double z_0m1 = static_cast<double>( result.at<float>(peak_y-1,peak_x) ); //const double z_p1m1 = static_cast<double>( result.at<float>(peak_y-1,peak_x+1) ); //const double z_m1m1 = static_cast<double>( result.at<float>(peak_y-1,peak_x-1) ); const double z_0p1 = static_cast<double>( result.at<float>(peak_y+1,peak_x) ); //const double z_p1p1 = static_cast<double>( result.at<float>(peak_y+1,peak_x+1) ); //const double z_m1p1 = static_cast<double>( result.at<float>(peak_y+1,peak_x-1) ); //const double a = z_00; const double b = (z_p10 - z_m10) / 2; const double c = (z_0p1 - z_0m1) / 2; const double d = -z_00 + (z_p10 + z_m10) / 2; const double e = -z_00 + (z_0p1 + z_0m1) / 2; target_pt.x = rx + peak_x + b/(2*d); target_pt.y = ry + peak_y + c/(2*e); //std::cout << "===" << std::endl; //std::cout << target_pt.x << std::endl; //std::cout << rx+peak_x << std::endl; } else { target_pt.x = rx + peak_x; target_pt.y = ry + peak_y; } return true; }
PointedThing ClientEnvironment::getPointedThing( core::line3d<f32> shootline, bool liquids_pointable, bool look_for_object) { PointedThing result; INodeDefManager *nodedef = m_map->getNodeDefManager(); core::aabbox3d<s16> maximal_exceed = nodedef->getSelectionBoxIntUnion(); // The code needs to search these nodes core::aabbox3d<s16> search_range(-maximal_exceed.MaxEdge, -maximal_exceed.MinEdge); // If a node is found, there might be a larger node behind. // To find it, we have to go further. s16 maximal_overcheck = std::max(abs(search_range.MinEdge.X), abs(search_range.MaxEdge.X)) + std::max(abs(search_range.MinEdge.Y), abs(search_range.MaxEdge.Y)) + std::max(abs(search_range.MinEdge.Z), abs(search_range.MaxEdge.Z)); const v3f original_vector = shootline.getVector(); const f32 original_length = original_vector.getLength(); f32 min_distance = original_length; // First try to find an active object if (look_for_object) { ClientActiveObject *selected_object = getSelectedActiveObject( shootline, &result.intersection_point, &result.intersection_normal); if (selected_object != NULL) { min_distance = (result.intersection_point - shootline.start).getLength(); result.type = POINTEDTHING_OBJECT; result.object_id = selected_object->getId(); } } // Reduce shootline if (original_length > 0) { shootline.end = shootline.start + shootline.getVector() / original_length * min_distance; } // Try to find a node that is closer than the selected active // object (if it exists). voxalgo::VoxelLineIterator iterator(shootline.start / BS, shootline.getVector() / BS); v3s16 oldnode = iterator.m_current_node_pos; // Indicates that a node was found. bool is_node_found = false; // If a node is found, it is possible that there's a node // behind it with a large nodebox, so continue the search. u16 node_foundcounter = 0; // If a node is found, this is the center of the // first nodebox the shootline meets. v3f found_boxcenter(0, 0, 0); // The untested nodes are in this range. core::aabbox3d<s16> new_nodes; while (true) { // Test the nodes around the current node in search_range. new_nodes = search_range; new_nodes.MinEdge += iterator.m_current_node_pos; new_nodes.MaxEdge += iterator.m_current_node_pos; // Only check new nodes v3s16 delta = iterator.m_current_node_pos - oldnode; if (delta.X > 0) new_nodes.MinEdge.X = new_nodes.MaxEdge.X; else if (delta.X < 0) new_nodes.MaxEdge.X = new_nodes.MinEdge.X; else if (delta.Y > 0) new_nodes.MinEdge.Y = new_nodes.MaxEdge.Y; else if (delta.Y < 0) new_nodes.MaxEdge.Y = new_nodes.MinEdge.Y; else if (delta.Z > 0) new_nodes.MinEdge.Z = new_nodes.MaxEdge.Z; else if (delta.Z < 0) new_nodes.MaxEdge.Z = new_nodes.MinEdge.Z; // For each untested node for (s16 x = new_nodes.MinEdge.X; x <= new_nodes.MaxEdge.X; x++) { for (s16 y = new_nodes.MinEdge.Y; y <= new_nodes.MaxEdge.Y; y++) { for (s16 z = new_nodes.MinEdge.Z; z <= new_nodes.MaxEdge.Z; z++) { MapNode n; v3s16 np(x, y, z); bool is_valid_position; n = m_map->getNodeNoEx(np, &is_valid_position); if (!(is_valid_position && isPointableNode(n, nodedef, liquids_pointable))) { continue; } std::vector<aabb3f> boxes; n.getSelectionBoxes(nodedef, &boxes, n.getNeighbors(np, m_map)); v3f npf = intToFloat(np, BS); for (std::vector<aabb3f>::const_iterator i = boxes.begin(); i != boxes.end(); ++i) { aabb3f box = *i; box.MinEdge += npf; box.MaxEdge += npf; v3f intersection_point; v3s16 intersection_normal; if (!boxLineCollision(box, shootline.start, shootline.getVector(), &intersection_point, &intersection_normal)) { continue; } f32 distance = (intersection_point - shootline.start).getLength(); if (distance >= min_distance) { continue; } result.type = POINTEDTHING_NODE; result.node_undersurface = np; result.intersection_point = intersection_point; result.intersection_normal = intersection_normal; found_boxcenter = box.getCenter(); min_distance = distance; is_node_found = true; } } } } if (is_node_found) { node_foundcounter++; if (node_foundcounter > maximal_overcheck) { break; } } // Next node if (iterator.hasNext()) { oldnode = iterator.m_current_node_pos; iterator.next(); } else { break; } } if (is_node_found) { // Set undersurface and abovesurface nodes f32 d = 0.002 * BS; v3f fake_intersection = result.intersection_point; // Move intersection towards its source block. if (fake_intersection.X < found_boxcenter.X) fake_intersection.X += d; else fake_intersection.X -= d; if (fake_intersection.Y < found_boxcenter.Y) fake_intersection.Y += d; else fake_intersection.Y -= d; if (fake_intersection.Z < found_boxcenter.Z) fake_intersection.Z += d; else fake_intersection.Z -= d; result.node_real_undersurface = floatToInt(fake_intersection, BS); result.node_abovesurface = result.node_real_undersurface + result.intersection_normal; } return result; }