How to check if more than two coordinates are adjacent - coordinates

I’m developing some code in solidity, I need to write a function to check whether more than two points are adjacent, given an array with the xs and another array with the ys.
I’m currently blocked because I don’t know how to make it.
This is my pseudocode:
function isCoordsAdjacent(
uint256 x1,
uint256 y1,
uint256 x2,
uint256 y2
) public pure returns (bool) {
unchecked {
if (1 == ((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))) {
return true;
} else {
return false;
}
}
}
function testCoords(uint256[] calldata x, uint256[] calldata y) public view returns (bool) {
for (uint256 i = 0; i < coords.length; i++) {
for (uint256 j = 0; j < coords.length; j++) {
if (
isCoordsAdjacent(x, y, x, y - 1)
isCoordsAdjacent(x, y, (x - 1), y) ||
isCoordsAdjacent(x, y, (x - 1), (y + 1)) ||
isCoordsAdjacent(x, y, x, (y - 1)) ||
isCoordsAdjacent(x, y, x, y) ||
isCoordsAdjacent(x, y, x, y + 1) ||
isCoordsAdjacent(x, y, (x + 1), (y - 1)) ||
isCoordsAdjacent(x, y, (x + 1), y) ||
isCoordsAdjacent(x, y, (x + 1), (y + 1))
) {
return true;
}
}
}
return false;
}
Hope you can help me get to the right solution.
Thanks a lot!
UPDATE
I fixed the code in this way, but still it doesn't work:
function testCoords(uint256[] calldata x, uint256[] calldata y)
public
pure
returns (bool result)
{
unchecked {
for (uint256 i = 0; i < x.length; i++) {
for (uint256 j = 0; j < y.length; j++) {
if (i == j) {
continue;
} else if (isCoordsAdjacent(x[i], y[i], x[j], y[j])) {
return true;
} else {
return false;
}
}
}
}
}

There are several errors in your code. From what I understand you want to check each point against each other (hence 2 loops).
Do not check if a point if adjacent to itself. You should add if {i==j} continue; to your code in the inner loop.
You need to check i-th element of x and y arrays not x or y itself. You should do isCoordsAdjacent(x[i], y[i], x[j], y[j])
isCoordsAdjacent is already checking adjacency no need for the chain of ||

Related

New to classes and my class doesn't work. Why doesn't it?

In my program, I want to have triangles that spin and follow your mouse position. I had it working but it was ugly because I didn't use any classes (I'm new) and just pasted the triangle over and changed the variables. This is the class I came up with.
class Enemy {
float x = random(-width, 0);
float y = random(0, height);
float x1;
float x2 = -20;
float x3 = 20;
float y1 = (+(sqrt(3)/3)*40);
float y2 = (-(sqrt(3)/3)*40);
float y3 = (-(sqrt(3)/3)*40);
float speed;
float slope;
float atanSlope;
Enemy(float tempSpeed) {
speed = tempSpeed;
}
void rotateEnemy() {
float x1Rotated = rotateX(x1, y1, theta2, 0);
y1 = rotateY(x1, y1, theta2, 0);
x1 = x1Rotated;
float x2Rotated = rotateX(x2, x2, theta2, 0);
x2 = rotateY(x2, x2, theta2, 0);
x2 = x2Rotated;
float x3Rotated = rotateX(x3, x3, theta2, 0);
x3 = rotateY(x3, x3, theta2, 0);
x3 = x3Rotated;
}
void move() {
slope = (y - mouseY)/(x-mouseX);
atanSlope = atan(slope);
if (slope < 0 && mouseY < y ) {
x += cos(atanSlope)*(speed + speedChange);
y += sin(atanSlope)*(speed + speedChange);
} else if (slope >= 0 && mouseY < y) {
x -= cos(atanSlope)*(speed + speedChange);
y -= sin(atanSlope)*(speed + speedChange);
} else if (slope > 0) {
x += cos(atanSlope)*(speed + speedChange);
y += sin(atanSlope)*(speed + speedChange);
} else {
x -= cos(atanSlope)*(speed + speedChange);
y -= sin(atanSlope)*(speed + speedChange);
}
}
void drawEnemy() {
translate(x, y);
triangle(x1, y1, x2, x2, x3, x3);
translate(-x, -y);
}
void collisionDetect() {
if (abs(mouseX-x) + abs(mouseY-y) < 80)
if (isDeadly) {
respawn();
energy -= height/16;
points += 500;
} else
energy = 0;
}
void respawn() {
int ranQuadrant1 = (int)random(0, 2);
int ranSide1 = (int)random(0, 2);
if (ranQuadrant1 == 0)
if (ranSide1 == 0)
x = random(0, -width/2);
else {
x = random(width, 3*width/2);
y = random(-height/2, 3*height/2);
} else
if (ranSide1 == 0)
y = random(0, -height/2);
else {
y = random(height, 3*height/2);
x = random(-width/2, 3*width/2);
}
}
}
And I use it like this
ArrayList<Enemy> enemies = new ArrayList<Enemy>();
void setup() {
for (i = 0; i<difficulty; i++);
enemies.add(new Enemy(i*5));
for (i = 0; i<enemies.size()-1; i++)
enemies.get(i).respawn();
}
void draw() {
for(i = enemies.size()-1; i>=0; i--) {
enemies.get(i).rotateEnemy();
enemies.get(i).move();
enemies.get(i).drawEnemy();
enemies.get(i).collisionDetect();
}
When I run it, the triangles don't draw. Not only that, some ellipses I wrote that come right after trying to draw the triangles don't draw either. The square that follows your mouse along with a timer and other things DO draw though. Please help. Thank you!
Now, this isn't the whole program. I'm making a game for a project and these triangles are the enemies.
If you want to see the whole program for context/if I didn't put enough, I put it in a pastebin: https://pastebin.com/Bfd4Fk6t
Okay I figured it out, turns out I'm a dummy.
Look at the rotateEnemy function for the 2nd and 3rd points. There are no y's only x's. I was using a lot of find and replace when copying it over so I must have gotten rid of the y's and replaced them with x's. Another error is in drawEnemy, I draw the triangle with parameters (x1,y1,x2,x2,x3,x3). No y's again. Geez I'm a smart guy lol.

How to change direction of X Value?

I'm using Eclipse IDE, and I am trying to change the direction of an X axis.
So I use(simplified) :
int x = 50;
while (true){
synchronized(c){
c.clear();
X = X+5;
}
if (X == 500 ){
X = X-5;
}
It will go to 500, then to 495 then keep going to 500 like a bump. I want it to change the direction to X-5;? How can I do that?
So you need to use (simplified)
int x = 50;
int inc = 5;
while (true) {
synchronized (c) {
c.clear();
x = x + inc;
}
if (x >= 500) {
inc = -5;
}
if (x <= 0) {
inc = 5;
}
}

Best Way to Add 3 Numbers (or 4, or N) in Java - Kahan Sums?

I found a completely different answer to this question, the whole original question makes no sense anymore. However, the answer way be useful, so I modify it a bit...
I want to sum up three double numbers, say a, b, and c, in the most numerically stable way possible.
I think using a Kahan Sum would be the way to go.
However, a strange thought occured to me: Would it make sense to:
First sum up a, b, and c and remember the (absolute value of the) compensation.
Then sum up a, c, b
If the (absolute value of the) compensation of the second sum is smaller, use this sum instead.
Proceed similar with b, a, c and other permutations of the numbers.
Return the sum with the smallest associated absolute compensation.
Would I get a more "stable" Addition of three numbers this way? Or does the order of numbers in the sum have no (use-able) impact on the compensation left at the end of the Summation? With (use-able) I mean to ask whether the compensation value itself is stable enough to contain Information that I can use?
(I am using the Java programming language, although I think this does not matter here.)
Many thanks,
Thomas.
I think I found a much more reliable way to solve the "Add 3" (or "Add 4" or "Add N" numbers problem.
First of all, I implemented my idea from the original post. It resulted into quite some big code which seemed, initially, to work. However, it failed in the following case: add Double.MAX_VALUE, 1, and -Double.MAX_VALUE. The result was 0.
#njuffa's comments inspired me dig somewhat deeper and at http://code.activestate.com/recipes/393090-binary-floating-point-summation-accurate-to-full-p/, I found that in Python, this problem has been solved quite nicely. To see the full code, I downloaded the Python source (Python 3.5.1rc1 - 2015-11-23) from https://www.python.org/getit/source/, where we can find the following method (under PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2):
static PyObject*
math_fsum(PyObject *self, PyObject *seq)
{
PyObject *item, *iter, *sum = NULL;
Py_ssize_t i, j, n = 0, m = NUM_PARTIALS;
double x, y, t, ps[NUM_PARTIALS], *p = ps;
double xsave, special_sum = 0.0, inf_sum = 0.0;
volatile double hi, yr, lo;
iter = PyObject_GetIter(seq);
if (iter == NULL)
return NULL;
PyFPE_START_PROTECT("fsum", Py_DECREF(iter); return NULL)
for(;;) { /* for x in iterable */
assert(0 <= n && n <= m);
assert((m == NUM_PARTIALS && p == ps) ||
(m > NUM_PARTIALS && p != NULL));
item = PyIter_Next(iter);
if (item == NULL) {
if (PyErr_Occurred())
goto _fsum_error;
break;
}
x = PyFloat_AsDouble(item);
Py_DECREF(item);
if (PyErr_Occurred())
goto _fsum_error;
xsave = x;
for (i = j = 0; j < n; j++) { /* for y in partials */
y = p[j];
if (fabs(x) < fabs(y)) {
t = x; x = y; y = t;
}
hi = x + y;
yr = hi - x;
lo = y - yr;
if (lo != 0.0)
p[i++] = lo;
x = hi;
}
n = i; /* ps[i:] = [x] */
if (x != 0.0) {
if (! Py_IS_FINITE(x)) {
/* a nonfinite x could arise either as
a result of intermediate overflow, or
as a result of a nan or inf in the
summands */
if (Py_IS_FINITE(xsave)) {
PyErr_SetString(PyExc_OverflowError,
"intermediate overflow in fsum");
goto _fsum_error;
}
if (Py_IS_INFINITY(xsave))
inf_sum += xsave;
special_sum += xsave;
/* reset partials */
n = 0;
}
else if (n >= m && _fsum_realloc(&p, n, ps, &m))
goto _fsum_error;
else
p[n++] = x;
}
}
if (special_sum != 0.0) {
if (Py_IS_NAN(inf_sum))
PyErr_SetString(PyExc_ValueError,
"-inf + inf in fsum");
else
sum = PyFloat_FromDouble(special_sum);
goto _fsum_error;
}
hi = 0.0;
if (n > 0) {
hi = p[--n];
/* sum_exact(ps, hi) from the top, stop when the sum becomes
inexact. */
while (n > 0) {
x = hi;
y = p[--n];
assert(fabs(y) < fabs(x));
hi = x + y;
yr = hi - x;
lo = y - yr;
if (lo != 0.0)
break;
}
/* Make half-even rounding work across multiple partials.
Needed so that sum([1e-16, 1, 1e16]) will round-up the last
digit to two instead of down to zero (the 1e-16 makes the 1
slightly closer to two). With a potential 1 ULP rounding
error fixed-up, math.fsum() can guarantee commutativity. */
if (n > 0 && ((lo < 0.0 && p[n-1] < 0.0) ||
(lo > 0.0 && p[n-1] > 0.0))) {
y = lo * 2.0;
x = hi + y;
yr = x - hi;
if (y == yr)
hi = x;
}
}
sum = PyFloat_FromDouble(hi);
_fsum_error:
PyFPE_END_PROTECT(hi)
Py_DECREF(iter);
if (p != ps)
PyMem_Free(p);
return sum;
}
This summation method is different from Kahan's method, it uses a variable number of compensation variables. When adding the ith number, at most i additional compensation variables (stored in the array p) get used. This means if I want to add 3 numbers, I may need 3 additional variables. For 4 numbers, I may need 4 additional variables. Since the number of used variables may increase from n to n+1 only after the nth summand is loaded, I can translate the above code to Java as follows:
/**
* Compute the exact sum of the values in the given array
* {#code summands} while destroying the contents of said array.
*
* #param summands
* the summand array – will be summed up and destroyed
* #return the accurate sum of the elements of {#code summands}
*/
private static final double __destructiveSum(final double[] summands) {
int i, j, n;
double x, y, t, xsave, hi, yr, lo;
boolean ninf, pinf;
n = 0;
lo = 0d;
ninf = pinf = false;
for (double summand : summands) {
xsave = summand;
for (i = j = 0; j < n; j++) {
y = summands[j];
if (Math.abs(summand) < Math.abs(y)) {
t = summand;
summand = y;
y = t;
}
hi = summand + y;
yr = hi - summand;
lo = y - yr;
if (lo != 0.0) {
summands[i++] = lo;
}
summand = hi;
}
n = i; /* ps[i:] = [summand] */
if (summand != 0d) {
if ((summand > Double.NEGATIVE_INFINITY)
&& (summand < Double.POSITIVE_INFINITY)) {
summands[n++] = summand;// all finite, good, continue
} else {
if (xsave <= Double.NEGATIVE_INFINITY) {
if (pinf) {
return Double.NaN;
}
ninf = true;
} else {
if (xsave >= Double.POSITIVE_INFINITY) {
if (ninf) {
return Double.NaN;
}
pinf = true;
} else {
return Double.NaN;
}
}
n = 0;
}
}
}
if (pinf) {
return Double.POSITIVE_INFINITY;
}
if (ninf) {
return Double.NEGATIVE_INFINITY;
}
hi = 0d;
if (n > 0) {
hi = summands[--n];
/*
* sum_exact(ps, hi) from the top, stop when the sum becomes inexact.
*/
while (n > 0) {
x = hi;
y = summands[--n];
hi = x + y;
yr = hi - x;
lo = y - yr;
if (lo != 0d) {
break;
}
}
/*
* Make half-even rounding work across multiple partials. Needed so
* that sum([1e-16, 1, 1e16]) will round-up the last digit to two
* instead of down to zero (the 1e-16 makes the 1 slightly closer to
* two). With a potential 1 ULP rounding error fixed-up, math.fsum()
* can guarantee commutativity.
*/
if ((n > 0) && (((lo < 0d) && (summands[n - 1] < 0d)) || //
((lo > 0d) && (summands[n - 1] > 0d)))) {
y = lo * 2d;
x = hi + y;
yr = x - hi;
if (y == yr) {
hi = x;
}
}
}
return hi;
}
This function will take the array summands and add up the elements while simultaneously using it to store the compensation variables. Since we load the summand at index i before the array element at said index may become used for compensation, this will work.
Since the array will be small if the number of variables to add is small and won't escape the scope of our method, I think there is a decent chance that it will be allocated directly on the stack by the JIT, which may make the code quite fast.
I admit that I did not fully understand why the authors of the original code handled infinities, overflows, and NaNs the way they did. Here my code deviates from the original. (I hope I did not mess it up.)
Either way, I can now sum up 3, 4, or n double numbers by doing:
public static final double add3(final double x0, final double x1,
final double x2) {
return __destructiveSum(new double[] { x0, x1, x2 });
}
public static final double add4(final double x0, final double x1,
final double x2, final double x3) {
return __destructiveSum(new double[] { x0, x1, x2, x3 });
}
If I want to sum up 3 or 4 long numbers and obtain the precise result as double, I will have to deal with the fact that doubles can only represent longs in -9007199254740992..9007199254740992L. But this can easily be done by splitting each long into two parts:
public static final long add3(final long x0, final long x1,
final long x2) {
double lx;
return __destructiveSum(new long[] {new double[] { //
lx = x0, //
(x0 - ((long) lx)), //
lx = x1, //
(x1 - ((long) lx)), //
lx = x2, //
(x2 - ((long) lx)), //
});
}
public static final long add4(final long x0, final long x1,
final long x2, final long x3) {
double lx;
return __destructiveSum(new long[] {new double[] { //
lx = x0, //
(x0 - ((long) lx)), //
lx = x1, //
(x1 - ((long) lx)), //
lx = x2, //
(x2 - ((long) lx)), //
lx = x3, //
(x3 - ((long) lx)), //
});
}
I think this should be about right. At least I can now add Double.MAX_VALUE, 1, and -Double.MAX_VALUE and get 1 as result.

SPOJ - #26 BSHEEP - Build the Fence

#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-9
typedef double coord_t;
typedef double coord2_t;
struct point {
double x, y;
point(double _x, double _y)
{
x = _x, y = _y;
}
bool operator < (point p) const{
if(fabs(x - p.x) > EPS)
return x < p.x;
return y < p.x;
}
bool operator == (point p) const{
return fabs(x - p.x) < EPS && fabs (x - p.y) < EPS;
}
};
coord2_t cross(const point &O, const point &A, const point &B)
{
return (long)(A.x - O.x) * (B.y - O.y) - (long)(A.y - O.y) * (B.x - O.x);
}
bool cmp(point a, point b)
{
if(fabs(a.y - b.y) > EPS)
return a.y < b.y;
return a.x < b.x;
}
vector<point> convex_hull(vector<point> P)
{
int n = P.size();
vector<point> H;
sort(P.begin(), P.end(), cmp);
for (int i = 0; i < n; ++i)
{
while(H.size() >= 2 && cross(H[H.size() - 2], H[H.size() - 1], P[i]) <= 0)
H.pop_back();
H.push_back(P[i]);
}
int l = H.size() + 1;
for (int i = n - 1; i >= 0; i--)
{
while(H.size() >= l && cross(H[H.size() - 2], H[H.size() - 1], P[i]) <= 0)
H.pop_back();
H.push_back(P[i]);
}
return H;
}
int main()
{
int tc, n, x, y;
double length;
vector<point> P;
scanf("%d", &tc);
while(tc--)
{
length = 0;
P.clear();
scanf("%d", &n);
for(int i = 0; i < n; i++)
{
scanf("%d %d", &x, &y);
P.push_back(point(x, y));
}
P = convex_hull(P);
for (int i = 0; i < (int) P.size() - 1; i++) {
length += sqrt(pow((P[i].x - P[i+1].x),2) + pow((P[i].y - P[i+1].y),2));
}
printf("%.2lf\n", length);
for (int i = 1; i < (int) P.size(); i++) {
printf("%lf ", P[i]); // Problem in this line , can't print the required output
}
printf("\n");
}
return 0;
}
It's a convex hull problem and I think I have done everything alright, but can't output p1 p2 .... pk of the problem. The problem is here:
At the beginning of spring all the sheep move to the higher pastures in the mountains. If there are thousands of them, it is well worthwhile gathering them together in one place. But sheep don't like to leave their grass-lands. Help the shepherd and build him a fence which would surround all the sheep. The fence should have the smallest possible length! Assume that sheep are negligibly small and that they are not moving. Sometimes a few sheep are standing in the same place. If there is only one sheep, it is probably dying, so no fence is needed at all...
Input
t [the number of tests <= 100]
[empty line]
n [the number of sheep <= 100000]
x1 y1 [coordinates of the first sheep]
...
xn yn
[integer coordinates from -10000 to 10000]
[empty line]
[other lists of sheep]
Text grouped in [ ] does not appear in the input file. Assume that sheep are numbered in the input order.
Output
o [length of circumference, 2 digits precision]
p1 p2 ... pk
[the sheep that are standing in the corners of the fence; the first one should be positioned bottommost and as far to the left as possible, the others ought to be written in anticlockwise order; ignore all sheep standing in the same place but the first to appear in the input file; the number of sheep should be the smallest possible]
[empty line]
[next solutions]
In your struct, add one more variable while will hold the position of the point.
struct point {
double x, y, c;
point(double _x, double _y, double _c)
{
x = _x, y = _y,c = _c;
}
bool operator < (point p) const{
if(fabs(x - p.x) > EPS)
return x < p.x;
return y < p.x;
}
bool operator == (point p) const{
return fabs(x - p.x) < EPS && fabs (x - p.y) < EPS;
}
};
When you take input, pushback all three of them:
for(int i = 0; i < n; i++)
{
scanf("%d %d", &x, &y);
P.push_back(point(x, y,i+1));
}

imregionalmax matlab function's equivalent in opencv

I have an image of connected components(circles filled).If i want to segment them i can use watershed algorithm.I prefer writing my own function for watershed instead of using the inbuilt function in OPENCV.I have successfu How do i find the regionalmax of objects using opencv?
I wrote a function myself. My results were quite similar to MATLAB, although not exact. This function is implemented for CV_32F but it can easily be modified for other types.
I mark all the points that are not part of a minimum region by checking all the neighbors. The remaining regions are either minima, maxima or areas of inflection.
I use connected components to label each region.
I check each region for any point belonging to a maxima, if yes then I push that label into a vector.
Finally I sort the bad labels, erase all duplicates and then mark all the points in the output as not minima.
All that remains are the regions of minima.
Here is the code:
// output is a binary image
// 1: not a min region
// 0: part of a min region
// 2: not sure if min or not
// 3: uninitialized
void imregionalmin(cv::Mat& img, cv::Mat& out_img)
{
// pad the border of img with 1 and copy to img_pad
cv::Mat img_pad;
cv::copyMakeBorder(img, img_pad, 1, 1, 1, 1, IPL_BORDER_CONSTANT, 1);
// initialize binary output to 2, unknown if min
out_img = cv::Mat::ones(img.rows, img.cols, CV_8U)+2;
// initialize pointers to matrices
float* in = (float *)(img_pad.data);
uchar* out = (uchar *)(out_img.data);
// size of matrix
int in_size = img_pad.cols*img_pad.rows;
int out_size = img.cols*img.rows;
int x, y;
for (int i = 0; i < out_size; i++) {
// find x, y indexes
y = i % img.cols;
x = i / img.cols;
neighborCheck(in, out, i, x, y, img_pad.cols); // all regions are either min or max
}
cv::Mat label;
cv::connectedComponents(out_img, label);
int* lab = (int *)(label.data);
in = (float *)(img.data);
in_size = img.cols*img.rows;
std::vector<int> bad_labels;
for (int i = 0; i < out_size; i++) {
// find x, y indexes
y = i % img.cols;
x = i / img.cols;
if (lab[i] != 0) {
if (neighborCleanup(in, out, i, x, y, img.rows, img.cols) == 1) {
bad_labels.push_back(lab[i]);
}
}
}
std::sort(bad_labels.begin(), bad_labels.end());
bad_labels.erase(std::unique(bad_labels.begin(), bad_labels.end()), bad_labels.end());
for (int i = 0; i < out_size; ++i) {
if (lab[i] != 0) {
if (std::find(bad_labels.begin(), bad_labels.end(), lab[i]) != bad_labels.end()) {
out[i] = 0;
}
}
}
}
int inline neighborCleanup(float* in, uchar* out, int i, int x, int y, int x_lim, int y_lim)
{
int index;
for (int xx = x - 1; xx < x + 2; ++xx) {
for (int yy = y - 1; yy < y + 2; ++yy) {
if (((xx == x) && (yy==y)) || xx < 0 || yy < 0 || xx >= x_lim || yy >= y_lim)
continue;
index = xx*y_lim + yy;
if ((in[i] == in[index]) && (out[index] == 0))
return 1;
}
}
return 0;
}
void inline neighborCheck(float* in, uchar* out, int i, int x, int y, int x_lim)
{
int indexes[8], cur_index;
indexes[0] = x*x_lim + y;
indexes[1] = x*x_lim + y+1;
indexes[2] = x*x_lim + y+2;
indexes[3] = (x+1)*x_lim + y+2;
indexes[4] = (x + 2)*x_lim + y+2;
indexes[5] = (x + 2)*x_lim + y + 1;
indexes[6] = (x + 2)*x_lim + y;
indexes[7] = (x + 1)*x_lim + y;
cur_index = (x + 1)*x_lim + y+1;
for (int t = 0; t < 8; t++) {
if (in[indexes[t]] < in[cur_index]) {
out[i] = 0;
break;
}
}
if (out[i] == 3)
out[i] = 1;
}
The following listing is a function similar to Matlab's "imregionalmax". It looks for at most nLocMax local maxima above threshold, where the found local maxima are at least minDistBtwLocMax pixels apart. It returns the actual number of local maxima found. Notice that it uses OpenCV's minMaxLoc to find global maxima. It is "opencv-self-contained" except for the (easy to implement) function vdist, which computes the (euclidian) distance between points (r,c) and (row,col).
input is one-channel CV_32F matrix, and locations is nLocMax (rows) by 2 (columns) CV_32S matrix.
int imregionalmax(Mat input, int nLocMax, float threshold, float minDistBtwLocMax, Mat locations)
{
Mat scratch = input.clone();
int nFoundLocMax = 0;
for (int i = 0; i < nLocMax; i++) {
Point location;
double maxVal;
minMaxLoc(scratch, NULL, &maxVal, NULL, &location);
if (maxVal > threshold) {
nFoundLocMax += 1;
int row = location.y;
int col = location.x;
locations.at<int>(i,0) = row;
locations.at<int>(i,1) = col;
int r0 = (row-minDistBtwLocMax > -1 ? row-minDistBtwLocMax : 0);
int r1 = (row+minDistBtwLocMax < scratch.rows ? row+minDistBtwLocMax : scratch.rows-1);
int c0 = (col-minDistBtwLocMax > -1 ? col-minDistBtwLocMax : 0);
int c1 = (col+minDistBtwLocMax < scratch.cols ? col+minDistBtwLocMax : scratch.cols-1);
for (int r = r0; r <= r1; r++) {
for (int c = c0; c <= c1; c++) {
if (vdist(Point2DMake(r, c),Point2DMake(row, col)) <= minDistBtwLocMax) {
scratch.at<float>(r,c) = 0.0;
}
}
}
} else {
break;
}
}
return nFoundLocMax;
}
I do not know if it is what you want, but in my answer to this post, I gave some code to find local maxima (peaks) in a grayscale image (resulting from distance transform).
The approach relies on subtracting the original image from the dilated image and finding the zero pixels).
I hope it helps,
Good luck
I had the same problem some time ago, and the solution was to reimplement the imregionalmax algorithm in OpenCV/Cpp. It is not that complicated, because you can find the C++ source code of the function in the Matlab distribution. (somewhere in toolbox). All you have to do is to read carefully and understand the algorithm described there. Then rewrite it or remove the matlab-specific checks and you'll have it.