Topic: How to check if coordinates are equal ?

[Coder]

Hello .

I would like to check if a coordinate is a member in a list .

Code: [Select]

  (setq mylist (23.337 6.63198) (22.9351 6.23005) (22.9351 8.02967) (16.5646 12.593) (14.5698 8.22248) (9.64711 7.83685) (6.42968 11.661) (6.42968 5.65161))

this code fail >>>>
(mapcar (function (lambda (coord)
  (if (member '(23.337 6.63198) coord)
    (setq num (1+ num))
    )))
    mylist
  )
and this one also >>>>

(mapcar (function (lambda (coord)
  (if (vl-position '(23.337 6.63198) coord)
    (setq num (1+ num))
    )))
    mylist
  )

Thanks

[dgorsman]

Coordinates may have additional numbers past the displayed precision, so unlike definite information (e.g. "a" always matches "a") its very difficult to get an exact match out of a list with (member...), (vl-position...), etc. which by default do an (= ...) type check which requires an exact match.

Consider rolling your own comparison function using (equal...) so you can specify a fuzz-factor.

[gile]

Hi,

Code: [Select]

(defun gc:memberFuzz (expr lst fuzz)
  (while (and lst (not (equal (car lst) expr fuzz)))
    (setq lst (cdr lst))
  )
  lst
)

[Keith™]

+1 on the roll yer own and "equal"

In your lambda function, try comparing the X and Y coords independently using a fuzz factor

Code: [Select]

(and (equal 23.337 (car coord) 0.0001)(equal 6.63198 (cadr coord) 0.0001))


[Lee Mac]

Code - Auto/Visual Lisp: [Select]

1. (defun MemberWithFuzz ( itm lst fuzz )
2.     (vl-member-if '(lambda ( x ) (equal x itm fuzz)) lst)
3. )

[Coder]

Thank you all guys .

What is the best value for fuzz ?

[MP]

peach

[Coder]

peach

peach has a value ?

[fixo]

0.00001 would be enough for your list

[dgorsman]

I generally aim for one decimal place smaller than the most precise number e.g. coordinates are in millimeters, I would use a fuzz factor of 0.1 (mm).  If coordinates are in meters to three decimal places i.e. m.mmm I would use 0.0001 (m).

[Kerry]

Thank you all guys .

What is the best value for fuzz ?

Bill's beard.



sorry, you probably had to be there

[Coder]

Thank you all guys .

What is the best value for fuzz ?

Bill's beard.

sorry, you probably had to be there

Hi Kerry .

I have no idea about that , can you please be more straight to the point . ? 

Thank you

[Coder]

I am sorry guys , I am still don't know how to chose the correct value for the fuzz and how to filter a list of coordinates to
remove the equal one from the list. 

Thanks

[Stefan]

Remove a point from a list:

Code - Auto/Visual Lisp: [Select]

1. (defun remove_point (point lst)
2.   (if (equal point (car lst) 1e-4)
3.     (cdr lst)
4.     (if lst (cons (car lst) (remove_point point (cdr lst))))
5.     )
6.   )
7.  

Code: [Select]

_$ (setq mylist '((23.337 6.63198) (22.9351 6.23005) (22.9351 8.02967) (16.5646 12.593) (14.5698 8.22248) (9.64711 7.83685) (6.42968 11.661) (6.42968 5.65161)))
_$ (remove_point '(16.5646 12.593) mylist)
((23.337 6.63198) (22.9351 6.23005) (22.9351 8.02967) (14.5698 8.22248) (9.64711 7.83685) (6.42968 11.661) (6.42968 5.65161))A precision of 1e-4 would be enough.

[Stefan]

Previous lisp will remove only first instance of a point from a list of points.
To remove all points, use this

Code - Auto/Visual Lisp: [Select]

1. (defun remove_point (point lst)
2.   (if lst
3.     (if (equal point (car lst) 1e-4)
4.       (remove_point point (cdr lst))
5.       (cons (car lst) (remove_point point (cdr lst)))
6.       )
7.     )
8.   )

[Lee Mac]

Or simply;

Code - Auto/Visual Lisp: [Select]

1. (defun _RemoveWithFuzz ( item lst fuzz )
2.     (vl-remove-if '(lambda ( x ) (equal item x fuzz)) lst)
3. )
4.  

[VovKa]

when dealing with coordinates, i suggest checking distances between them

Code: [Select]

(equal (distance p1 p2) 0 fuzz)i think it's more correct

[Keith™]

that is a good idea

[irneb]

In that same vein, you could then get rid of the equal function itself. All you need to figure is if the distance between the points is smaller than the fuzz:

Code: [Select]

(< (distance p1 p2) fuzz)

[dgorsman]

Depending on the means used to calculate the distance, it could start throwing errors if the coordinates are far enough away from the WCS origin (we get this quite often with models in mm).  For example, if the numbers need to be squared in the distance calculation.  Progressive checking (e.g. first X, then Y, then Z) may be of some benefit, since if the first value is too far off the rest of the values are irrelevant, same with the second.  Changes it from multiple square/root operations to a comparison of reals.

There may also be some other concerns - doesn't (distance...) use some current dimension style variables for precision?

[gile]

Hi,

The minFuzz routine returns the minimum fuzz usable with equal according to the point position within the significant digits of a floating point number.

Code - Lisp: [Select]

1. (defun minFuzz (n)
2.   (if (zerop n)
3.     1e-14
4.     (expt 10. (- (fix (/ (log (abs n)) (log 10))) 14))
5.   )
6. )

(minFuzz 1.234567890123456) returns 1.0e-014
(minFuzz 1234567.890123456) returns 1.0e-008

To compare points whith the greatest minFuzz of the 2 points coordinates:

Code - Lisp: [Select]

1. (defun equalPoints (p1 p2)
2.   (equal p1 p2 (apply 'max (mapcar 'minFuzz (append p1 p2))))
3. )

[irneb]

That's a very good idea. One thing I'd do though: Calculate the minFuzz only on the coordinate vale which has the largest absolute value:

Code - Auto/Visual Lisp: [Select]

1. (defun equalPoints (p1 p2)
2.   (equal p1 p2 (minFuzz (apply 'max (mapcar 'abs (append p1 p2))))))

Don't know if this might be faster, but to me it looks more logical.

[irneb]

There may also be some other concerns - doesn't (distance...) use some current dimension style variables for precision?

It's the first I've heard of that, aren't you thinking of the rtos function? You have a point about the squaring though, I think the distance function uses the Pythagorean theorem. So it squares all values and then square roots them, thus it might produce larger floating point errors than expected.

On the other hand, comparing xyz values creates a fuzz box in a cube form, while comparing distances fuzzes a sphere. So the same fuzz in xyz might make for a larger distance between two points if they fall in opposite corners of the cube.

[irneb]

Hi,

The minFuzz routine returns the minimum fuzz usable with equal according to the point position within the significant digits of a floating point number.

Code - Lisp: [Select]

1. (defun minFuzz (n)
2.   (if (zerop n)
3.     1e-14
4.     (expt 10. (- (fix (/ (log (abs n)) (log 10))) 14))
5.   )
6. )

To get the min Fuzz even smaller, you might want to change the 14 decimal points to 52 binary points. Seeing as the double precision uses 53 bits for the significand, and 11 for the exponent. But that's just splitting hairs ... literally  .