Hybrid parallel

[dexus]

Nice test @PGia, thanks!

For some reason I didnt consider closed polylines in the _checkOffset function, so I added an extra check there.

Should work as expected now:

 

Not sure about the short corner. The lines are so narrow the centerline is pushed back out of the point.

Seems to be logical to me but it does feel intuitive.

 

Narrow indents don't get much love from the centerline. So "inlets" don't have enough influence on the shape of the line.

What would the expected result be? Below makes sense since there is not enough space to go into the indent.

Or are you maybe something like this where the line splits and goes into the hole:

 

Edited December 4 by dexus

[dexus]

I did some more tests today and found that when the end segments were parallel, they didn't get added to the line.

So I added support for that. This one was easy because the _cornerOffset function already checks for parallel segments and I just had to add a flag to inform the offset loop. 

 

 

And I found another example which it has a hard time on with concentric arcs, attached below.

But that will be for another day since I have no more time for that this week.

 

AxisExple3.dxf

Edited December 5 by dexus

[PGia]

I think the real-world situation may be more complex than what we’ve seen here so far.

I took a look at the links that @SLW210 attached and decided to test the Lisp codes proposed up to this point.

I looked through my drawings for something that could serve as an example for this problem, but it was like looking for a needle in a haystack.
So, in the end, I decided to look for something in the real world that clearly corresponds to this issue — something like this:

 

So I drew those margins and tested all the codes that have appeared in this thread so far.
The result was… this!

 

In the drawing, you can see the ones that managed to reach the end.
However, the codes by BIGAL, GP_, GLAVCVS, and MarkoRibar couldn't even do that.

Here’s the drawing

AxisExple4.dwg

 

Edited December 8 by PGia

[dexus]

Hi @PGia, wow, you managed to find another example that fails. Good stress testing!

 

The reason mine fails is because it ignores the offset lines that are split in two or more parts.

But some of the parts are still be usable and should be used.

I looked into fixing this and managed to add those lines, but this resulted in some other problems so I didn't update the code on the earlier post yet.

 

The zigzag problem is coming back on your example. The result below.

I really need to find a solution for that, but it looks like I might have to use a path finding algorithm which would slow down the code a lot. Sorting the points by distance on the offset line is not enough anymore.

[SLW210]

IIRC, those are tough to manage on GIS programs with Add-ons made with Python, .NET, etc.

 

Remember, real rivers/roads/ROWs have curves and organic shapes, not just straight lines.

 

I did see some information on how to tackle those, hopefully it can be worked out, but don't expect perfection.

 

As I mentioned, from what my daughter said and what I've seen in various related forums, the GIS pros are using whatever program and add-ons they can to get the bulk of it and cleaning up and filling in manually.

 

Most that are doing those shapes want the main channel center, if needed I would ignore the very wide sections and side pieces and get those as center lines running back to the main channel separately.

 

As your example shows, it would take separate polylines, so it will need to account for those sections and then ran again on the offshoots.

 

You still haven't answered all of the questions asked.

 

What type of work are you doing? What you have posted looks to be Civil and/or GIS work.

 

I'll try some more on this when I can, I have also looked at some different shortest path codes, the last example is way over my head in LISP, I'll concentrate on the previous examples then try to run just the main channel on the last example .dwg.

 

I have a full slate at work again today, but I'll try to jump back on this when I get some things out of the way.

 

Home time is limited, but I'll try to get back on this with QGIS solution, I may see if my daughter's coworkers want to take a shot at these.

[BIGAL]

I think with those big side offshoots you need to break the river into multiple plines so you would have two or more centrelines lines in that situation. As suggested by @SLW210 The problem will be how to work out the break offset shape..

 

 

Ps image dummied up.

Edited Tuesday at 11:04 PM by BIGAL

[PGia]

On 12/9/2025 at 1:37 PM, SLW210 said:

 

You still haven't answered all of the questions asked.

 

What type of work are you doing? What you have posted looks to be Civil and/or GIS work.

 

 

In general, we work with plans for projects of various kinds: engineering, cadastral mapping, and so on. Sometimes we submit proposals for public tenders, but so far without success.

@dexus, the performance of your code looks different in that last drawing compared to what I’m seeing on my end.

In any case, I think this topic has now entered the realm of a real challenge.
@BIGAL: I agree. I think that’s the correct way to draw the centerline in the inlets.

[GLAVCVS]

Obviously, this has now become something more than just the search for a solution to a single user’s problem.

First of all, I should say that I myself was also reluctant to accept the concept of equidistance advocated by @GP_ and @dexus
For the simple reason that applying this principle forced me to accept that the centerline should be the same in these two drawings.

Equidistance requires ignoring those areas of the margins that do not geometrically affect the axis.
This, which initially caused me some resistance, I eventually came to accept conceptually when I realized that it could serve as a criterion for defining what is a “recodo/inlet” and what is not.
So I have abandoned my previous approach and adapted it to this new situation.

Having made this clarification, I must say that this concept of equidistance makes the calculation of a centerline more feasible.

 

I’ve been running some tests with Dexus’s latest code, which is the best so far.
However, I’ve discovered some “holes” that I hadn’t noticed before.
I’m attaching a few images showing this.

In my view, these are conceptual errors rather than geometric limitations.
And what can we consider “geometric limitations”?
I believe that, in any case, every vertex of the centerline must be equidistant from both margins.
If this is not the case, the result is not correct.

However, the intermediate regions along each segment may be subject to geometric limitations depending on the desired precision.
Therefore, in bends or turns, the points taken within the adjustment or “problematic” segments may deviate (within a tolerance) from strict equidistance.

The goal, therefore (in my opinion), should be to achieve equidistance at every vertex and to remain within a tolerance in the intermediate zone of each segment.

After everything written here so far, some might wonder: is it really possible to obtain a centerline that meets these requirements?

As far as I’m concerned, I’m running some tests.

 

I’ll post something over the weekend

[GLAVCVS]

Attempt number 2:

This code is intended to always return a centerline whose points are all perfectly equidistant from the margins.
This should happen in all cases where two LWPOLYLINEs are provided, one for each margin.
The case of islands has not been considered yet.

 

The resulting centerline is geometrically dense. This can probably be simplified in a future version.

The approach taken in this code has been to obtain points from the normals and the bisectors of each margin, which are then combined at the end to build a list of points.

Therefore, it is a fragmentary and massive approach. For this reason, the code is not very fast.

However, there is another, more elegant approach, based on dynamically relating the geometry of both margins.
It is more complex, but it would also be faster, and the error margins would be “bridgable”.

If this thread has enough life in it, I may feel sufficiently motivated to finish it.
That’s all for now.
 

 

;|***********************  CENTER-LINE  *************************     
 ************************ G L A V C V S *************************     
 ************************** F E C I T ***************************   |;
(defun c:CLG (/ PI/2 lst e1 e2 l1 l2 lp lp1 lp2 p0 p> p< r1? x m a tol autoInt? ordenaPts interCpta ptEqd)
  (defun autoInt? (l lp / p0 p1 p2);autointersecci贸n?
    (if l
      (setq p1 (polar (car l) (setq a (angle (car l) (cadr l))) 0.001) p2 (polar (cadr l) (+ a PI) 0.001)
	    x (if (not (vl-some '(lambda (p) (if p0 (inters p0 (setq p0 p) p1 p2) (not (setq p0 p)))) lp)) l)
      )
    )
  )
  (defun ordenaPts (lst / pIni dm d ps? ps lr); puntos en orden
    (setq pIni (mapcar '(lambda (a b) (/ (+ a b) 2.0)) (car lp1) (car lp2)))
    (while lst
      (foreach p lst
        (if (and dm (/= (min (setq d (distance (if ps ps pIni) p)) dm) dm))
          (setq dm d ps? p)
          (if (not dm) (setq dm (distance (if ps ps pIni) p) ps? p))
        )
      )
      (setq ps ps? ps? nil dm nil lst (vl-remove ps lst) lr (cons (cadr ps) (cons (car ps) lr)))
    )
    lr
  )
  (defun interCpta (pM p1 p2 lp / i? i1 i2 d a b); captura de los m谩rgenes
    (defun i? (pA pB lp / p0 i dm is a)
      (foreach p lp
	(if p0
	  (if (setq i (inters p0 (setq p0 p) pA pB))
	    (if (and dm (/= (min (setq d (distance pM i)) dm) dm))
	      (setq dm d is i)
	      (if (not dm) (setq dm (distance pm i) is i))
	    )
	  )
        )
        (setq p0 p)
      )
      (if is (list (car is) (cadr is) 0.0))
    )
    (if (and (setq a (i? p1 p2 lp1)) (setq b (i? p1 p2 lp2)))
      (list a b)
    )
  )
  (defun ptEqd (A B e1 e2 / eqDist-f t0 t1 f0 f1 tm fm n i v+- v*); captura punto equidistante
    (defun v+- (o a b) (mapcar o a b))
    (defun v* (p s) (mapcar '(lambda (x) (* x s)) p))
    (defun eqDist-f (ds A B e1 e2 / pt d1 d2)
      (setq pt (v+- '+ A (v* (v+- '- B A) ds)); Punto sobre AB: P(ds) = A + ds (B - A)
            d1 (distance pt (vlax-curve-getClosestPointTo e1 pt))
            d2 (distance pt (vlax-curve-getClosestPointTo e2 pt))
      )
      (- d1 d2)
    )
    (setq t0 0.0 t1 1.0)
    (while (and (< (setq n (if n (1+ n) 0)) 100) (> (- t1 t0) 1e-6));m茅todo de bisecci贸n
      (setq tm (/ (+ t0 t1) 2.0)
	    fm (eqDist-f tm A B e1 e2)
      )
      (if (< (abs fm) 1e-9)
	(setq n 100 t1 tm t0 tm)
        (if (< (* (if f0 f0 (eqDist-f t0 A B e1 e2)) fm) 0.0)
          (setq t1 tm f1 fm)
          (setq t0 tm f0 fm)
	)
      )
    )
    (if (< t1 1.0) ; par谩metro final y punto equidistante 
      (v+- '+ A (v* (v+- '- B A) (/ (+ t0 t1) 2.0)))
    )
  )
  
  (if (and (setq e1 (car (entsel "\nSelect FIRST LWPolyline..."))) (= (cdr (assoc 0 (setq l1 (entget e1)))) "LWPOLYLINE") )
    (if (and (setq e2 (car (entsel "\nSelect SECOND LWPolyline..."))) (= (cdr (assoc 0 (setq l2 (entget e2)))) "LWPOLYLINE") )
      (progn
	(foreach l l1 (if (= (car l) 10) (setq lp1 (cons (cdr l) lp1))))
	(foreach l l2 (if (= (car l) 10) (setq lp2 (cons (cdr l) lp2))))
	(setq r1? (> (distance (car lp1) (car lp2)) (distance (car lp1) (last lp2))))
	(setq tol 0.01 PI/2 (/ PI 2.) lp1 (if r1? (reverse lp1) lp1))
	(foreach e (list e1 e2)
	  (setq p0 nil m nil r? (if (equal e e1) r1?) lp (if (equal e e1) lp2 lp1))
	  (while (setq p (vlax-curve-getPointAtParam e (setq m (if m ((if r? 1- 1+) m) (if r? (vlax-curve-getEndParam e) 0)))))
	    (if p0
	      (progn
		(setq lAB  (autoInt? (interCpta p (polar p (setq a (+ (angle p0 p) PI/2)) 10000) (polar p (+ a PI) 10000) lp) (if (equal e e1) lp1 lp2));NORMAL AL COMIENZO DEL SEGMENTO
		      lst (if lAB (cons (ptEqd (car lAB) (cadr lAB) e1 e2) lst) lst)
	        )
	        (if (setq p> (vlax-curve-getPointAtParam e ((if r? 1- 1+) m)))
	          (setq lAB  (autoInt? (interCpta p (polar p (setq a (/ (+ (angle p p0) (angle p p>)) 2.)) 10000) (polar p (+ a PI) 10000) lp) (if (equal e e1) lp1 lp2)) ; Bisectriz
			lst (if lAB (cons (ptEqd (car lAB) (cadr lAB) e1 e2) lst) lst)
			lAB  (autoInt? (interCpta p (polar p (setq a (+ (angle p p>) PI/2)) 10000) (polar p (+ a PI) 10000) lp) (if (equal e e1) lp1 lp2));NORMAL AL FINAL DEL SEGMENTO
		        lst (if lAB (cons (ptEqd (car lAB) (cadr lAB) e1 e2) lst) lst)
	          )
		)
		(setq p< p0 p0 p)
	      )
	      (if (setq p> (vlax-curve-getPointAtParam e ((if r? 1- 1+) m)))
	        (setq lAB  (autoInt? (interCpta p (polar (setq p0 p) (setq a (+ (angle p0 p>) PI/2)) 10000) (polar p0 (+ a PI) 10000) lp) (if (equal e e1) lp1 lp2))
		      lst (if lAB (cons (ptEqd (car lAB) (cadr lAB) e1 e2) lst) lst)
		)
	      )
	    )
	  )
	)
	(vla-AddLightWeightPolyline
	  (vla-get-modelspace (vla-get-activedocument (vlax-get-acad-object)))
	  (vlax-Make-Variant (vlax-SafeArray-Fill (vlax-Make-SafeArray 5 (cons 0 (- (length (setq lst (reverse (ordenaPts lst)))) 1))) lst))
	)
      )
    )
  )
  (princ)
)