Topic: Comparing List of Points

[cmwade77]

Ok, I have a list of points from two different polyline objects. I need to compare to see if the list points are identical, but I need to account for the fact that the order of the points may be different. Any ideas on how to accomplish this?

[Tharwat]

Try this .
lst-1 represents the first list as well the second one .

Code - Auto/Visual Lisp: [Select]

1. (vl-every '(lambda (q p) (equal q p 1e-8)) lst-1 lst-2)
2.  

[cmwade77]

Perhaps I am doing something wrong, here is what I have:

Code: [Select]

(setq PtA (vlax-safearray->list (vlax-variant-value retCoordA))
PtB (vlax-safearray->list (vlax-variant-value retCoordB))
)
(if (vl-every '(lambda (q p) (equal q p 1e-8)) PtA PtB)
     (alert "Objects are the same")
     (alert "Objects are different")
)
Even when the objects are the same, it returns that they are different.

[ribarm]

Code - Auto/Visual Lisp: [Select]

1. (vl-every '(lambda ( x ) (eq x T)) (mapcar '(lambda ( x ) (vl-some '(lambda ( y ) (equal x y 1e-5)) lst-1)) lst-2))
2.  

The same as Tharwat explained lst-1 and lst-2 are point lists...

[Tharwat]

Post the two lists PtA and PtB to have a close look .

[cmwade77]

Ok, here are the list of points:
PtA - (9.34785 4.79562 9.34785 5.55109 10.2356 5.55109 10.2356 4.79562)
PtB - (9.34785 5.55109 9.34785 4.79562 10.2356 5.55109 10.2356 4.79562)

[ribarm]

Code: [Select]

Command: (setq lst-1 '(9.34785 4.79562 9.34785 5.55109 10.2356 5.55109 10.2356
4.79562))
(9.34785 4.79562 9.34785 5.55109 10.2356 5.55109 10.2356 4.79562)

Command: (setq lst-2 '(9.34785 5.55109 9.34785 4.79562 10.2356 5.55109 10.2356
4.79562))
(9.34785 5.55109 9.34785 4.79562 10.2356 5.55109 10.2356 4.79562)

Command: (vl-every '(lambda ( x ) (eq x T)) (mapcar '(lambda ( x ) (vl-some
'(lambda ( y ) (equal x y 1e-5)) lst-1)) lst-2))
T

Command: (vl-every '(lambda (q p) (equal q p 1e-8)) lst-1 lst-2)
nil

My and Tharwat's codes...
HTH

[Lee Mac]

Code - Auto/Visual Lisp: [Select]

1. (vl-every '(lambda ( x ) (eq x T)) (mapcar '(lambda ( x ) (vl-some '(lambda ( y ) (equal x y 1e-5)) lst-1)) lst-2))
2.  

The same as Tharwat explained lst-1 and lst-2 are point lists...

This can be reduced to:

Code - Auto/Visual Lisp: [Select]

1. (vl-every '(lambda ( x ) (vl-some '(lambda ( y ) (equal x y 1e-8)) PtB)) PtA)

[Lee Mac]

Or recursively,

Code - Auto/Visual Lisp: [Select]

1. (defun f ( l1 l2 )
2.     (or (null l1) (and (g (car l1) l2) (f (cdr l1) l2)))
3. )
4. (defun g ( x l )
5.     (and l (or (equal x (car l) 1e-8) (g x (cdr l))))
6. )

Code - Auto/Visual Lisp: [Select]

1. (f PtA PtB)

[roy_043]

... to see if the list points are identical...

Do you want to check if the polylines overlap? If so, the order of the points is still important. Also the OCS and the elevation should be taken into account.

[Patrick_35]

Hi

To compare two list without vl-every

Code: [Select]

(setq lst-1 '(9.34785 4.79562 9.34785 5.55109 10.2356 5.55109 10.2356 4.79562))
(setq lst-2 '(9.34786 4.79563 9.34786 5.55110 10.2357 5.55110 10.2357 4.79563))
(equal lst-1 lst-2 1e-4) --> T
(equal lst-1 lst-2 1e-5) --> nil

@+

[Kerry]

Hi

To compare two list without vl-every

< ... >


(equal lst-1 lst-2 1e-4) --> T
(equal lst-1 lst-2 1e-5) --> nil

[cmwade77]

Hi

To compare two list without vl-every

< ... >


(equal lst-1 lst-2 1e-4) --> T
(equal lst-1 lst-2 1e-5) --> nil

This only seems to work if the order is identical.

[Kerry]

< .. >
This only seems to work if the order is identical.

Yes,
I tried to visualise the use for comparing point lists where the point order does not matter.
.... wasn't successful.
Care to share the purpose of the test ?

[roy_043]

... to see if the list points are identical...

Do you want to check if the polylines overlap? If so, the order of the points is still important. Also the OCS and the elevation should be taken into account.

[Patrick_35]

Hi

To compare two list without vl-every

< ... >


(equal lst-1 lst-2 1e-4) --> T
(equal lst-1 lst-2 1e-5) --> nil

This only seems to work if the order is identical.

Yes, the goal is to see if the two lists are identical
Now, if the order does not matter, we can do

Code: [Select]

(equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
@+

[Lee Mac]

Now, if the order does not matter, we can do

Code: [Select]

(equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
@+

Be careful with vl-sort:

Code: [Select]

_$ (setq lst-1 '(1 2 3 4 4 5) lst-2 '(1 2 2 3 4 5))
(1 2 2 3 4 5)
_$ (equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
T

[ribarm]

Now, if the order does not matter, we can do

Code: [Select]

(equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
@+

Be careful with vl-sort:

Code: [Select]

_$ (setq lst-1 '(1 2 3 4 4 5) lst-2 '(1 2 2 3 4 5))
(1 2 2 3 4 5)
_$ (equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
T

1+

Maybe...

Code: [Select]

(defun f ( lst-1 lst-2 )
  (if (and (listp (car lst-1)) (listp (car lst-2)))
    (equal
      (mapcar 'nth
        (vl-sort-i lst-1 '(lambda ( a b ) (< (distance '(0.0 0.0 0.0) a) (distance '(0.0 0.0 0.0) b))))
        (mapcar '(lambda ( x ) lst-1) lst-1)
      )
      (mapcar 'nth
        (vl-sort-i lst-2 '(lambda ( a b ) (< (distance '(0.0 0.0 0.0) a) (distance '(0.0 0.0 0.0) b))))
        (mapcar '(lambda ( x ) lst-2) lst-2)
      )
      1e-4
    )
    (equal
      (mapcar 'nth
        (vl-sort-i lst-1 '<)
        (mapcar '(lambda ( x ) lst-1) lst-1)
      )
      (mapcar 'nth
        (vl-sort-i lst-2 '<)
        (mapcar '(lambda ( x ) lst-2) lst-2)
      )
      1e-4
    )
  )
)


[roy_043]

I am stating the obvious here: Sorting a flat list of reals representing alternating X and Y coordinates of 2D points makes little sense.

[Lee Mac]

I am stating the obvious here: Sorting a flat list of reals representing alternating X and Y coordinates of 2D points makes little sense.

Agreed, but then neither does comparing arbitrary X & Y values between the two lists - if I've understood what the OP is looking to achieve, I would have expected an ordered comparison up to permutation, e.g. something like:

Code - Auto/Visual Lisp: [Select]

1. (defun compare ( a b )
2.     (defun recurse ( a b c )
3.         (and a (or (equal (append a c) b 1e-8) (recurse (cddr a) b (append c (list (car a) (cadr a))))))
4.     )
5.     (recurse a b nil)
6. )

Code - Auto/Visual Lisp: [Select]

1. _$ (compare '(1 2 3 4 5 6 7 8 9 0) '(5 6 7 8 9 0 1 2 3 4))
2. T

[Patrick_35]

Now, if the order does not matter, we can do

Code: [Select]

(equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
@+

Be careful with vl-sort:

Code: [Select]

_$ (setq lst-1 '(1 2 3 4 4 5) lst-2 '(1 2 2 3 4 5))
(1 2 2 3 4 5)
_$ (equal (vl-sort lst-1 '<) (vl-sort lst-2 '<) 1e-4)
T

Oh yes, you are right, I had not seen that vl-sort truncates the result with integer
(vl-sort '(1 2 3 4 4 5) '<) --> (1 2 3 4 5)
(vl-sort '(1 2 2 3 4 5) '<) --> (1 2 3 4 5)
and (equal '(1 2 3 4 5) '(1 2 3 4 5)) return T

but (equal (vl-sort '(1.0 2.0 3.0 4.0 4.0 5.0) '<) (vl-sort '(1.0 2.0 2.0 3.0 4.0 5.0) '<)) work
and (equal (vl-sort '(1.0 2.0 3.0 4.0 4.0 5.0) '<) (vl-sort '(1.0 2.0 2.0 3.0 4.0 5.0) '<) 1e-4) work too

@+

[Marc'Antonio Alessi]

Oh yes, you are right, I had not seen that vl-sort truncates the result with integer

Only with integers:

Code: [Select]

(vl-sort  '(3 2 1 3 1 2 2 2 1.0 1.0 1.0 1.0) '<)
(1 1.0 1.0 1.0 1.0 2 3)

(vl-sort  '("a" "A" "a") '<)
("A" "a" "a")

(vl-sort  '("a" "A" "a" "A") '<)
("A" "A" "a" "a")

[roy_043]

Iterative approach:

Code - Auto/Visual Lisp: [Select]

1. (defun Roy_Compare (lstA lstB / num revLstB)
2.   (if (= (setq num (length lstA)) (length lstB))
3.     (progn
4.       (while
5.         (and
6.           (> num 0)
7.           (not (equal lstA lstB 1e-8))
8.         )
9.         (setq num (- num 2))
10.         (setq lstA (append (cddr lstA) (list (car lstA) (cadr lstA))))
11.       )
12.       (/= num 0)
13.     )
14.   )
15. )

Code - Auto/Visual Lisp: [Select]

1. (Roy_Compare '(1 2 3 4 5 6 7 8 9 0) '(5 6 7 8 9 0 1 2 3 4))

Of course there is still the issue of polylines that overlap but are reversed.

[cmwade77]

< .. >
This only seems to work if the order is identical.

Yes,
I tried to visualise the use for comparing point lists where the point order does not matter.
.... wasn't successful.
Care to share the purpose of the test ?

Yes, I am using the boundary command to generate plines and as a result there are some instances where a duplicate polyline gets created but with a different order for the points. This causes the overkill command to fail to identify that they are identical and delete the duplicate. Basically, the polylines need to be identical, but the order that the points were drawn in do not need to be identical.