Line length on circle scaled to ellipse is very wrong

ely862me

Once you get to copy them around you get all kinds of lengths.

pbacot

@baz said:

@pbacot said:

if you split the circles before the length of the two half curves remains the same when scaled regardless of sides...

Sorry, not quite following you there.

But to restate the question: If I draw a line at 100, Entity Info will tell me its 100.
If I draw an arc and explode, I will get an accurate line length.
However, if I scale a circle to make an ellipse, Entity Info gives me nonsense, and not even consistent nonsense. I just went back to my example model as shown at top and all the reported numbers are now different...

It's to do with scaling, I reckon. It confuses SU's little brain.

It doesn't make sense. Really CAD programs should have an ellipse tool.

Screen Shot 2016-02-09 at 8.35.22 AM.png

slbaumgartner

I did some probing via Ruby, and it seems there is a chain of bugs causing this. First, when you scale a circle to make it an ellipse, SketchUp should drop the metadata defining it as a circle and treat it as just a closed loop of segments (a Curve). It does not do so, it continues to carry the center point, radius, and normal vector as if the loop is still a circle, and the edges still say they are part of an ArcCurve. This evidently triggers a second bug in the method that calculates the circumference of the loop. In some cases it still calculates the mathematical 2pir as if the circle hasn't been scaled. In other cases it calculates a strange value that has no evident relationship to anything. In no case does it return the sum of the lengths of the edges!

Wo3Dan

Lengths of (part of) an ellips do not show rigtht. This has been mentioned before.
I hope you can see this thread. See posts around 17/4/2008 and on.
https://groups.google.com/forum/#!searchin/sketchup3d/ellips$2Barea%7Csort:relevance/sketchup3d/z70T5xdUm_I/g-ChcSEcL2YJ

*"Taff, Google SU team,

Very nice approach Taff, almost precise. Here again there is the
lack of a precise ''snap to" with these rotations. But it's the best
you can do!

But I noticed an (important) bug in the "Entity Info" and "Text"
tool output.
The curve length shown is only half of what it should be.

Before you exploded the 1/4 ellipse curve the Entity Info reports
141.371669' as the curve length (also through Text tool)
It should however be: 282.743338'

16 segments out of the exploded curve add up to: 281.923143'
just a bit shorter which is obvious.
The more segments the more precise Taff's approach will be.
Even better when there were a "rotate snap" option to a curve.

Regards,
Wo3Dan "*

baz

Pilou. The actual line length is 2155 +/- 5. measured in the real world.

This thread is starting to make my brain hurt...so, respected elders, is it a Bug or not?

pilou

@unknownuser said:

Using Approximation 2, the perimeter would be 2118.265712279433

A nurbs program 400 * 900 ellipse gives 2118,2799332 length line perimeter

Sketchup gives 2118,276442 with circle 1000 segments

slbaumgartner

I think it is a bug. I looked up the formula for perimeter of an ellipse and compared that with what SketchUp's entity info returns. For a 10x20 ellipse, the result should be 96.88. SketchUp variously returned 62.83 (20*pi), 111.3, and 113.27.

ely862me

There was already a bug submitted for this, yes it is a bug. Also changing lengths when copying an ellipse is a bug. They are in the database and most likely sometime in the near future will be fixed.

mac1

There is no closed form equation for perimeter of ellipse
it is approximated by p=2PIsqrt[[[ a^2+b^2]/2]^1/2]
The correct value p=4aE where E is the elliptic integral where k=1/asqrt[a^2-b^2]

baz

@mac1 said:

There is no closed form equation for perimeter of ellipse
it is approximated by p=2PIsqrt[[[ a^2+b^2]/2]^1/2]
The correct value p=4aE where E is the elliptic integral where k=1/asqrt[a^2-b^2]

Yeah, what Mac said...

slbaumgartner

Mac is right, though there are several other approximate formulas that are better than the one he gave. Also, there are power-series that can be run to enough terms to get arbitrarily close. The point here is that even the sum of the lengths of the edges in the oval comes much closer than the strange values that SketchUp sometimes provides.i

CAUL

The best estimation of the circumference I've found is this:


  def self.circumference(major, minor)
    a = major / 2.0
    b = minor / 2.0 
    d = b / a
    
    x0 = d**0.5
    x1 = d
    x2 = d**1.5
    x3 = d**2
    x4 = d**2.5
    
    s0 = 3929 * x0 + 1639157 * x1 + 19407215 * x2 + 24302653 * x3 + 12892432 * x4
    s1 = 86251 + 1924742 * x0 + 6612384 * x1 + 7291509 * x2 + 6436977 * x3 + 3158719 * x4
    c = 4 * a + b * (s0 / s1)
    return c
  end

It's extremely accurate, unfortunately I don't know where I found it so I can't give credits.

pilou

And what is its result in this case ? (Ellipse 400*900)

CAUL

@pilou said:

And what is its result in this case ? (Ellipse 400*900)

2118.2799288074484

The result above is for major = 900, minor = 400, if your input refers to the semi axes multiply the result by 2.

pilou

@ Caul
So my result of Nurbs prog was not so bad!
2118,2799 332 against your theoric 2118.2799 288074484

Sketchup gives 2118,27 6442 with circle 1000 segments!

But what think of this

@unknownuser said:

The actual line length is 2155 +/- 5. measured in the real world.

Measured with ?

or

or...?

mac1

Attched is pic of ellipse drawn by the means of supplemental chords with no scaling. I included different seg counts just to show what can be done. If there is intersest I'll redo with more care.
Su reports length of 48.364" for size shown.
If you can run the polynomial curve fit equation shown I would appreciate. If this approach is useful for you I'll redo and show how to draw. It is a little more complicated than scaling but not much since you can draw 1/4 and then mirrow.
Oops see one dimension got cropped it is 10" conjuate ellipse.jpg

baz

@pilou said:

@ Caul
So my result of Nurbs prog was not so bad!
2118,2799 332 against your theoric 2118.2799 288074484

Sketchup gives 2118,27 6442 with circle 1000 segments!

But what think of this
The actual line length is 2155 +/- 5. measured in the real world.

Measured with ?

A piece of string Pilou, sorry I cant recheck it, the job is done and dusted.

baz

@mac1 said:

Attched is pic of ellipse drawn by the means of supplemental chords with no scaling. I included different seg counts just to show what can be done. If there is interest I'll redo with more care.
Su reports length of 48.364" for size shown. (1228.4456mm)
If you can run the polynomial curve fit equation shown I would appreciate. If this approach is useful for you I'll redo and show how to draw. It is a little more complicated than scaling but not much since you can draw 1/4 and then mirrow.
Oops see one dimension got cropped it is 10"[attachment=0:cf3intzr]conjuate ellipse.jpg[/attachment:cf3intzr]

Curious to see how you do it Mac. (Tho' the curve on the minor axis is a bit pointy n'est pas?)

CAUL

The code below constructs an ellipse in a group centered at origo where all edges have the exact same length. Since the script only computes a quarter ellipse the final full ellipse has an edge count divisible by 4. There's a "user interface" at the end to set major, minor and edge count. The circumference converges to the correct value with increased edgecount.

To run it, just paste the code into the ruby console and press enter.


module CAUL_RegularEllipse
  
  #hack found on the internets. Very accurate...
  def self.circumference(major, minor)
    a = major / 2.0
    b = minor / 2.0 
    d = b / a
    
    x0 = d**0.5
    x1 = d
    x2 = d**1.5
    x3 = d**2
    x4 = d**2.5
    
    s0 = 3929 * x0 + 1639157 * x1 + 19407215 * x2 + 24302653 * x3 + 12892432 * x4
    s1 = 86251 + 1924742 * x0 + 6612384 * x1 + 7291509 * x2 + 6436977 * x3 + 3158719 * x4
    c = 4 * a + b * (s0 / s1)
    return c
  end
  
  #find the intersection between a positive half ellipse at (0, 0) and a 
  #positive half circle at (h, k) with radius r in the first quadrant.
  def self.circle_ellipse_intersect(a, b, h, k, r, c)
    #start point must be chosen with care so we don't end up outside the domain
    x = h - c * r
    epsilon = 0.000000000000001
    f_e = f_c = 0
    (0..15).each { |i|
      f_e_sqr = 4 * (a*a * b*b) * (a*a - x*x)
      f_c_sqr = 2 * h * x + r*r - x*x - h*h
      df_e_sqr = a*a * b*b * (a*a - x*x)
      df_c_sqr = r*r + 2 * h * x - x*x - h*h
      
      return nil if f_e_sqr < 0 || f_c_sqr < 0 || df_e_sqr < 0 || df_c_sqr < 0
        
      f_e  = Math;;sqrt(f_e_sqr) / (2 * a*a)      
      f_c =  Math;;sqrt(f_c_sqr) + k
      df_e = -(b*b * x) / Math;;sqrt(df_e_sqr)
      df_c = (h - x) / Math;;sqrt(df_c_sqr)
      break if (f_e - f_c).abs <= epsilon
      x = x - (f_e - f_c) / (df_e - df_c)
    }
    return [x, f_e]  
  end
  
  #given a positive x-value, return the point on the ellipse in the first qudrant
  def self.get_ellipse_point(major, minor, x)
    a = major / 2.0
    b = minor / 2.0
    f_e_sqr = 4 * (a*a * b*b) * (a*a - x*x)
    f_e  = Math;;sqrt(f_e_sqr) / (2 * a*a)
    return Geom;;Point3d.new(x, f_e, 0)
  end
  
  #return how close the ellipse gets to the endpoint at ex with #bits segments
  #of length len.
  def self.test_ellipse(len, q_bits, major, minor, ex)
    a = major / 2.0;
    b = minor / 2.0;
    d = count = 0
    coff = [0.99999999, 0.00000001, 0.5]
    p0 = Geom;;Point3d.new(a, 0, 0)
    pe = get_ellipse_point(major, minor, ex)
    
    (0..q_bits - 2).each { |i|
      arr = nil
      coff.each { |c|
        arr = circle_ellipse_intersect(a, b, p0.x, p0.y, len, c)
        break if arr != nil
      }
      return nil, nil if arr == nil
 
      p0.x = arr[0]
      p0.y = arr[1]
      d = pe.distance(p0)
      count += 1
      break if d < len
    }
    return d, count
  end
  
  #given an ellipse and the number of segments (q_bits) covering a quarter of the ellipse,
  #compute the length of a segment.
  def self.get_segment_length(major, minor, q_bits, ex)
    
    c = circumference(major, minor)
    #len is guaranteed to be a close over estimation
    len = (c / 4.0) / q_bits
    #regress towards the root by adjusting len downwards. Very rapid convergence..
    (0..10).each { |i|
      d, count =  test_ellipse(len, q_bits, major, minor, ex)
      over = (len - d) + (q_bits - 1 - count) * d
      len -= over / q_bits  
    }
    return len
  end
  
  def self.get_quarter_ellipse(major, minor, q_bits, len)
    a = major / 2.0;
    b = minor / 2.0;
    d = count = 0
    coff = [0.99999999, 0.00000001, 0.5]
    p0 = Geom;;Point3d.new(a, 0, 0)
    ps = [p0]
    pe = Geom;;Point3d.new(0, b, 0)
    
    (0..q_bits - 2).each { |i|
      arr = nil
      coff.each { |c|
        arr = circle_ellipse_intersect(a, b, p0.x, p0.y, len, c)
        break if arr != nil
      }
      return nil, nil if arr == nil
      
      p1 = Geom;;Point3d.new(arr[0], arr[1], 0)
      ps << p1
      p0 = p1
    }
    ps << pe
    return ps
  end
  
  def self.get_ellipse(major, minor, q_bits, len)
    ps = get_quarter_ellipse(major, minor, q_bits, len)
    ##add the other three quadrants
    len = ps.length
    (0..len - 2).each { |i| ps << Geom;;Point3d.new(-ps[len - 2 - i].x, ps[len - 2 - i].y, 0) }
    len = ps.length
    (0..len - 2).each { |i| ps << Geom;;Point3d.new(ps[len - 2 - i].x, -ps[len - 2 - i].y, 0) }
    ps.delete_at(ps.length - 1)
    return ps
  end
  
  ########################
  ######### MAIN #########
  ########################
  
  def self.main
    mod = Sketchup.active_model
    ent = mod.entities
    sel = mod.selection
    
    ###### USER INTERFACE ####
    major = 900.mm
    minor = 400.mm
    q_bits = 100 #number of segments in a quarter ellipse (-> full ellipse has q_bits * 4 segments)
    #################
    
    len = get_segment_length(major, minor, q_bits, 0)
    ps = get_ellipse(major, minor, q_bits, len)
    
    ### ADD THE ELLIPSE ##
    ng = ent.add_group
    (0..ps.length - 1).each { |i| ng.entities.add_line ps[i], ps[(i+1) % ps.length] }
    puts 'done'
  end
  
  main
end

baz

A L. Great, that will be very useful in the future. Thanks.
Ps: 2118mm again, How long was my piece of string?