LISP Request - Block Count Inside a Closed Polyline
@Kent1Cooper wrote:
.... for Polylines or Splines with certain kinds of convolutions in their shapes, Offsetting even outward can result in more than one new Polyline. ...
Here's a thought: When that happens, if such a Polyline is Offset outboard, there will be one resulting Polyline that is larger than the selected boundary, even if there may also be some other smaller one(s). So what if, after Offsetting, the routine finds all objects newer than the last one before starting, no matter how many there are [i.e. all results from the Offset], and compares the area of the largest of those to the boundary? If the largest of them is smaller than the boundary, then the Block must be inside the boundary. If that's a sufficient test, it takes a heck of a lot less code than making ray-casting (etc.) routines foolproof:
(defun C:BIB ; = Blocks Inside Boundary
(/ bndry reflen blks n new elast blk)
(setq
bndry (car (entsel "\nBoundary object: "))
reflen (vla-get-area (vlax-ename->vla-object bndry))
blks (ssget "_X" (list '(0 . "INSERT") (cons 410 (getvar 'ctab))))
insiders (ssadd); initially empty
); setq
(repeat (setq n (sslength blks))
(setq new (ssadd) elast (entlast)); reset for each -- initially empty set
(command "_.offset" "_through" bndry
"_none" (cdr (assoc 10 (entget (setq blk (ssname blks (setq n (1- n)))))))
""
); command
(while (setq elast (entnext elast)) (ssadd elast new)); however many result
(if ; are ALL of the objects resulting from Offset smaller than the boundary?
(<
(apply 'max ; compare only the largest resulting object
(mapcar
'(lambda (x) (vla-get-area (vlax-ename->vla-object x)))
(mapcar 'cadr (ssnamex new)); list of result-object entity names
); mapcar
); 'max
reflen
); <
(ssadd blk insiders); then -- put it in selection
); if
(command "_.u"); Undo Offset [however many it made]
); repeat
(prompt (strcat "\n" (itoa (sslength insiders)) " Block(s) found inside & put in 'insiders' selection set."))
(princ)
); defun
HOWEVER, I find that Splines of not-even-all-that-convoluted shapes can sometimes result in an outboard path that isn't one Spline, but is in segments. So the above wouldn't be completely reliable with Spline boundaries. But if you use it only on Polylines [Circles and Ellipses work, too], it may be viable for you.
Again, it only identifies the Blocks with insertion points inside -- process further in ways already offered. And it would still have a problem if a Block was at a central interior point that would not give a result [see Post 31], if that's a possibility, but that one, at least, could perhaps be accounted for with some (vl-catch-all...) code.
[If you use it on an Arc or a partial Ellipse, I believe it will "see" all Blocks whose insertion points would be inside the equivalent closed extension of the boundary -- Circle or full Ellipse -- whether or not they're inside the shape of the boundary if closed across with a straight line.]
Kent Cooper, AIA 
Kent,
To me it seems you want to sacrifice accuracy to save some additional lines of code.
And offsetting will not always work even with polylines. If you have something like a polyline below, offsetting inside or outside will always create an offset to the inside..
@DannyNL wrote:
.... If you have something like a polyline below, offsetting inside or outside will always create an offset to the inside..
I admit I hadn't thought of the possibility of a self-intersecting Polyline. They cause difficulties with a lot of approaches to a lot of things. For instance, in something like a ray-casting approach to this thread's problem, in which the number of intersections of a ray with the boundary object, using (intersectwith) methods, are counted, a Ray [or Line or Xline] that goes through the self-intersection point will give incorrect results -- if it is cast from outside, it will be counted as having only one intersection, even though it crosses two segments, and one that goes through there from inside [i.e. also crossing the left or right end segment in your image] will be counted as having only two, though it crosses three segments.
Kent Cooper, AIA
Accepted solution
Yes, you are right.
But that is the reason why my routine doesn't just use one ray but multiple rays in all directions.
- If only some of the rays have intersections, the point is outside the boundary.
- If all rays have intersections with the boundary but all rays intersect an even times, the point is considered outside the boundary.
- If all rays have intersections with the boundary but some intersect an odd times, the point is inside the boundary.
True, still not foolproof and I guess I could come up with some weird shaped complex polyline that still gives a false positive or negative due to rays intersecting one or more vertices instead of edges. But I hope to believe this is currently a more accurate detection than using boundary or offset 
I've extracted the ray casting routine and modified it, so the rays are not deleted and colored red (no intersection) or green (one or more intersections).
If all rays intersect an even times with the selected boundary, all rays will be colored red. Please try to find some flaws, so it may be further improved.
(defun c:RayCaster (/ PI_Point PI_PolylineObject PI_RayAngles PI_ClosestPoint PI_Distance PI_AngleList PI_RaySelection PI_RefAngle PI_AngleList PI_CheckLine PI_IntersectPoints PI_CheckList)
(setq PI_OnEdgeTrue nil)
(if
(and
(setq PI_Point (getpoint "\nSelect point "))
(not (vl-catch-all-error-p (setq PI_PolylineObject (vl-catch-all-apply 'vlax-ename->vla-object (list (car (entsel "\nSelect boundary: ")))))))
(member (vla-get-ObjectName PI_PolylineObject) '("AcDbPolyline" "AcDb2dPolyline" "AcDbCircle" "AcDbEllipse" "AcDbSpline"))
(vlax-Curve-isClosed PI_PolylineObject)
(vlax-Curve-isPlanar PI_PolylineObject)
)
(progn
(setq PI_ClosestPoint (vlax-curve-GetClosestPointTo PI_PolylineObject PI_Point))
(setq PI_Distance (distance PI_Point PI_ClosestPoint))
(if
(not (equal PI_Distance 0.0))
(progn
(vla-StartUndoMark (vla-get-ActiveDocument (vlax-get-acad-object)))
(setq PI_RayAngles (_AngleList 12))
(setq PI_AngleList (mapcar '(lambda (PI_Factor) (* pi PI_Factor)) PI_RayAngles))
(if
(not (equal (rem (setq PI_RefAngle (angle PI_Point PI_ClosestPoint)) (/ pi 2.0)) 0))
(setq PI_AngleList (append (mapcar '(lambda (PI_Factor) (+ (* pi PI_Factor) PI_RefAngle )) PI_RayAngles) PI_AngleList))
)
(setq PI_RaySelection (ssadd))
(foreach PI_Angle PI_AngleList
(setq PI_CheckLine (entmakex (list '(0 . "RAY") '(100 . "AcDbEntity") '(100 . "AcDbRay") (cons 10 PI_Point) (cons 11 (mapcar '- (polar PI_Point PI_Angle 5.0) PI_Point)))))
(if
(not (vl-catch-all-error-p (setq PI_IntersectPoints (vl-catch-all-apply 'vlax-safearray->list (list (vlax-variant-value (vla-IntersectWith (vlax-ename->vla-object PI_CheckLine) PI_PolylineObject acExtendNone)))))))
(progn
(setq PI_CheckList (cons (length (_GroupByNum PI_IntersectPoints 3)) PI_CheckList))
(vla-put-Color (vlax-ename->vla-object PI_CheckLine) 3)
)
(progn
(setq PI_CheckList (cons nil PI_CheckList))
(vla-put-Color (vlax-ename->vla-object PI_CheckLine) 1)
)
)
(ssadd PI_CheckLine PI_RaySelection)
;(entdel PI_CheckLine)
)
(vla-EndUndoMark (vla-get-ActiveDocument (vlax-get-acad-object)))
)
)
(cond
(
(and
(equal PI_Distance 0.0)
PI_OnEdgeTrue
)
T
)
(
(and
(not (vl-some 'not PI_CheckList))
(vl-some '(lambda (PI_Value) (= (rem PI_Value 2) 1)) PI_CheckList)
)
T
)
(
(and
(not (vl-some 'not PI_CheckList))
(not (vl-some '(lambda (PI_Value) (= (rem PI_Value 2) 1)) PI_CheckList))
)
(foreach PI_Ray (ssnamex PI_RaySelection)
(vla-put-Color (vlax-ename->vla-object (cadr PI_Ray)) 1)
)
(setq PI_RaySelection nil)
)
(
T
nil
)
)
)
)
)
(defun _AngleList (AL_Integer / AL_Step AL_Factor AL_Return)
(setq AL_Step (/ 2.0 AL_Integer))
(setq AL_Factor 0.0)
(repeat AL_Integer
(setq AL_Return (append AL_Return (list (+ 0.0 AL_Factor))))
(setq AL_Factor (+ AL_Factor AL_Step))
)
AL_Return
)
; By Lee Mac
(defun _GroupByNum (l n / r)
(if
l
(cons (reverse (repeat n (setq r (cons (car l) r) l (cdr l)) r)) (_GroupByNum l n))
)
)
In case someone wonder why I cast 12 or 24 rays; if the angle from the (insertion)point to the closest point on the boundary is not 0, 0.5, 1.0, 1.5 pi, 12 additional rays will be cast with the measured angle as reference. This way rays will be cast parallel to the closest edge and may find an opening in the boundary, which in case of only 12 rays would have gone undetected.
