[Closed] How to find if the object is cylinder?

Thank you to all. All methods works fine and I use all of them.

Aandres, your first method finds 62 cylinders(300 ms).
The Polytools method finds 59 cylinders(900 ms).
Aandres+Polytoos method finds: 58 cylinders(670 ms).

When I combine methods the found cylinders are 75.

If you lower the threshold1 and threshold2, possibly you’ll find all of them with the last method. My first method is not secure (it doesn’t work with truncated cones for example).

P.S.: do you have problems with batteries at home?

As you can see, I did not include any time measurement in the code, which means it is not meant to be measured, it is just a generic idea. And certainly I can’t warrantee it will work perfectly, moreover when the details of the problem are not very clear to me.

The first step would be to make sure the algorithm works, just then it can be optimized.

But before you can design an algorithm you need to have a detailed description of the problem, otherwise it would fall in the “generic” category, which often is a lot harder than a “specific” algorithm, and many times it is not even possible to develop.

Could you please give us a detailed description of the cylinders in question? Something like:

• They will be always default primitives converted to mesh, or not
• They will always have 2 caps, or 1 or none
• The caps will have no segments, or they will have N amount of segments
• The sides will have no segments, or they will have N amount segments
• They can be rotated in any angle, or they always have a fixed rotation
• They can have any size or they will have a size in range X

Any other detail that you know about the cylinders is very important.

Is there any way we can reproduce the failing objects?

The time measurement is not so important. Aandres included it in the last code he posted, so I have decide to share the results. My own
code takes 2 sec to find cylinders and it detects 92 objects as
cylinders, but it is not perfect and your codes finds 55 more cylinders that mine can’t. The most important for me are the ideas you have shared here.

In my first post you can find a link to download max scene with two cylinders. But in the scene there are cylinders that looks different than those two. What I need was an idea/advice how to find which object is a cylinder.
In this image you can see how other “cylinders” looks, but they have to be detected as cylinders:

The object on the left is one single mesh object(one cap is missing, tha half of the side faces are missing). On the right there are bunch of objects, each one of them are single mesh object(one triangle face), but they(all of them) also have to be detected as a cylinder(I find them using the intersects function).
Your methods of finding a cylinder can’t detect the object on the left as a cylinder, but it is not a “proper” cylinder and your codes are not optimized to search for such an object.

But, as I said the most important for me is your ideas of how to solve the problem and I am grateful for the help all of you gave me.

Could you please give us a detailed description of the cylinders in question? Something like:

• They will be always default primitives converted to mesh, or not – Not
• They will always have 2 caps, or 1 or none – all situations are possible
• The caps will have no segments, or they will have N amount of segments – all situations are possible
• The sides will have no segments, or they will have N amount segments – all situations are possible
• They can be rotated in any angle, or they always have a fixed rotation – they can be rotated in any angle
• They can have any size or they will have a size in range X – they can have any size

Let’s change the rules, and make the task more interesting

Let’s rotate and move baseobject and reset xform!

Jorge tests work seems like the same, but all others fail because of object transform

I use the scene with 3629 objects. more than 3000 ot them are single mesh objects that have only one triangle face. The results I have posted are using this scene. I use all the codes posted here one by one.

Ok, that makes things a lot more complex. For geometries like the one in the image you can’t use any of the solutions we’ve proposed here as using Smoothing Groups (or meshop.explodefaces()) won’t work with them.

Run the previous code on the geometries, if it fails run the following one. It return 1 if the object is a cylinder, otherwise it returns negative values.

NOTE: Absolutely unoptimized and only tested with the geometry you provided. If you have an object that fails please upload it.

(
(
    /* denisT ---------------------------------------- */
    fn GetFirstBit bits =
    (
        local b
        for n in bits while not (b = n; bits[n]) do ()
        b
    )
    /* ----------------------------------------------- */

    fn GetVerticesCenter mesh verts =
    (
        cx = cy = cz = 0.0d0

        for j in verts do
        (
            vert = getvert mesh j
            cx += vert.x
            cy += vert.y
            cz += vert.z
        )

        cx /= verts.numberset
        cy /= verts.numberset
        cz /= verts.numberset

        return [cx, cy, cz]
    )

    fn IsObjectCylinder node threshold:0.02 =
    (
        tmesh = snapshotasmesh node
        faces = tmesh.faces as bitarray
        verts = tmesh.verts as bitarray

        maxDistance = 0.0d0

        for j in verts do
        (
            v1 = getvert tmesh j
            for k in verts do
            (
                v2 = getvert tmesh k
                maxDistance = amax maxDistance (distance v1 v2)
            )
        )

        dmin = maxDistance - threshold
        dmax = maxDistance + threshold
        capVerts = #{}

        for j in verts do
        (
            v1 = getvert tmesh j
            for k in verts do
            (
                v2 = getvert tmesh k
                d = distance v1 v2
                if d < dmax and d > dmin do capVerts[j] = capVerts[k] = true
            )
        )

        minDistance = 1E9
        for j in capVerts do
        (
            v1 = getvert tmesh j
            for k in capVerts where k != j do
            (
                v2 = getvert tmesh k
                minDistance = amin minDistance (distance v1 v2)
            )
        )
        
        if capVerts.numberset < 10 do return -1
        
        dmin = minDistance - threshold
        dmax = minDistance + threshold
        
        cap1 = #(GetFirstBit capVerts)
        cap2 = #{}
        done = #{}

        for j in cap1 do
        (
            v1 = getvert tmesh j
            for k in capVerts where not done[k] do
            (
                v2 = getvert tmesh k
                d = distance v1 v2
                if d < dmax and d > dmin do
                (
                    append cap1 k
                    done[k] = true
                )
            )
        )
        
        /* Test Cap 1 */
        cap1    = cap1 as bitarray
        center  = GetVerticesCenter tmesh cap1
        minDist =  1e9
        maxDist = -1e9

        for j in cap1 do
        (
            d = distance center (getvert tmesh j)
            minDist = amin minDist d
            maxDist = amax maxDist d
        )

        if (maxDist-minDist > threshold) do return -2

        /* Test Cap 2 */
        cap2    = capVerts - cap1
        center  = GetVerticesCenter tmesh cap2
        minDist =  1e9
        maxDist = -1e9
        
        for j in cap2 do
        (
            d = distance center (getvert tmesh j)
            minDist = amin minDist d
            maxDist = amax maxDist d
        )

        if (maxDist-minDist > threshold) do return -3

        caps    = cap1 + cap2
        center  = GetVerticesCenter tmesh caps
        minDist =  1e9
        maxDist = -1e9

        for j in caps do
        (
            d = distance center (getvert tmesh j)
            minDist = amin minDist d
            maxDist = amax maxDist d
        )

        if (maxDist-minDist > threshold) do return -4

        return 1

    )

    IsObjectCylinder $ threshold:0.02

)

$Solid_003 is not a cylinder from my point of view. At the caps it has edges with very different lengths. For example edges 286 277 are much shorter than the average.

I made a small update that shoulddetect $Solid_001 and $Solid_002 as not cylinders.

Anyway, it is a very rudimentaryapproach and it will fail in many cases. It needs to be improved. Perhaps from all the code posted here you can build a better solution. If i can think on something else, I will post it.

here is my attempt… there are several cases where it fails on right cylinders, but the approach is different than others and might be interesting:

fn firstbit arr = 
(
   local b
   for n in arr while (b = n; off) do ()
   b
)
fn pointRayDist r p = 
(
   length (cross r.dir (p - r.pos))
)
fn round1 d tolerance:0.001 =
(
   d = (d as float)/tolerance
   v = if (d - (v1 = floor d)) > ((v2 = ceil d) - d) then v2 else v1 
   v*tolerance
)
fn round3 p tolerance:0.001 = [round1 p.x tolerance:tolerance, round1 p.y tolerance:tolerance, round1 p.z tolerance:tolerance]
fn sameBitArrays b1 b2 = (b1.numberset == b2.numberset) and ((b1*b2).numberset == b1.numberset)
fn sortByNumberSet v1 v2 = v2.numberset - v1.numberset
fn getEdgeVerts node edge =
(
   face = (edge - 1)/3 + 1
   vv = getFace node face
   index = mod (edge - 1) 3 
   case index of
   (
      0: point2 vv.x vv.y
      1: point2 vv.y vv.z
      2: point2 vv.z vv.x
   )
)
fn getEdgeVector node edge = 
(
   vv = getEdgeVerts node edge
   p0 = getvert node vv[1]
   p1 = getvert node vv[2]
   ray p0 (normalize (p1 - p0))
)

for obj in objects where iskindof obj Editable_Mesh do undo off
(
   keys = #()
   vals = #()
   --obj = $
   for i=1 to obj.numfaces*3 do 
   (
      v = getedgevector obj i
      d = round3 v.dir tolerance:0.01
      if (k = finditem keys d) == 0 then 
      (
         append keys d
         append vals #{i}
         k = keys.count
      )
      else
      (
         append vals[k] i
      )
   )
   qsort vals sortByNumberSet 
   obj.selectededges = hedges = vals[1]
   faces = meshop.getpolysusingedge obj hedges   
   verts = meshop.getvertsusingedge obj hedges   
   obj.selectedfaces = faces
   obj.selectedverts = verts
   center_test = (vals[1].numberset == vals[2].numberset and vals[1].numberset > vals[3].numberset)
   --format "CENTER ** %
" center_test
   c_axis = ray obj.center (getedgevector obj (firstbit vals[1])).dir
   -- point pos:c_axis.pos dir:c_axis.dir 
   -- pointraydistance c_axis (getvert obj (firstbit (obj.selectedverts as bitarray)))
   vkeys = #()
   vvals = #()
   --obj = $
   for i=1 to obj.numverts do 
   (
      p = getvert obj i
      d = pointraydist c_axis p
      v = round1 d tolerance:0.01
      if (k = finditem vkeys v) == 0 then 
      (
         append vkeys v
         append vvals #{i}
         k = vkeys.count
      )
      else
      (
         append vvals[k] i
      )
   )
   qsort vvals sortByNumberSet
   rverts = vvals[1]
   obj.selectedverts = rverts
   --format "RADIUS *:%
" vkeys
   radius_test = (sameBitArrays verts rverts)
   --format "RADIUS ** %
" radius_test
   bad_faces = #{}
   for i=1 to obj.numfaces do 
   (
      n = getfacenormal obj i
      d = abs (dot c_axis.dir n)
      v = round1 d tolerance:0.001
      if (v != 0 and v != 1) do append bad_faces i
   )
   
   normal_test = (bad_faces.isempty)
   --format "NORMAL ** %
" normal_test
   
   format "% >>>>> PASS ** %
" obj.name (center_test and radius_test and normal_test)   
)

Thank you, Denis. The firstBit function is missing from the code. I assume that this is the GetFirstBit function from the Polytoos code?

Edit: With the GetFirstBit function the code works. It finds 43 cylinders and two objects with this shape [

I will continuw tomorrow after work.