lines to arcs

Hi Guys,

 

means i want place an inside arc everywhere with a fixed radius

i have a route with vertices...in microstation there is a function which is called Circular fillet....means where two lines come together in an anglepoint both lines where curved by a certain radius...

 

Also complicate explanation or?

You want to create continous radius fillets (a piece of a circle..) and be in control of the radius.

 

 

There are a number of ways of doing that.

 

 

Make a network of lines to acquire id and relationships between lines (wich lines do touch/intersect at an angle) . (or use spatialrelator to do that)

 

 

With 2 lines you can create the centerline (line with equal distance to both). On this the circle must reside.

 

This is basic math, so relatively easy to accomplish. These parametric values  u can enter in a 2dArcCreator with radius as  a manual inputparameter.

 

 

Or you can just go and set up the calculation for equal distance to both the lines, after you have extracted their parametric descirption. And create the fillet circle and cut it with the lines.

 

 

 

 

 

Hi Franco,

 

 

IHi Franco,

 

 

It's possible to calculate parameter values for the 2DArcReplacer, but it would be a little bit complex. I think it's easier to create an arc from 3 points using a script.

 

I wrote a script example. Assuming that the input feature has attributes storing:

 

- the radius of required arc: "_radius"

 

- the coordinates of 3 vertices of the bended line. start: (_x0, _y0), middle: (_x1, _y1), end: (_x2, _y2).

 

-----

 

# Script Example for PythonCaller

 

import fme, fmeobjects, math

 

 

class ArcReplacer(object):

 

    def __init__(self):

 

        self.logger = fmeobjects.FMELogFile()

 

        

 

    def input(self,feature):

 

        radius = float(feature.getAttribute('_radius'))

 

        x0, y0 = float(feature.getAttribute('_x0')), float(feature.getAttribute('_y0'))

 

        x1, y1 = float(feature.getAttribute('_x1')), float(feature.getAttribute('_y1'))

 

        x2, y2 = float(feature.getAttribute('_x2')), float(feature.getAttribute('_y2'))

 

        

 

        # Calculate vectors of the 2 line segments (start node -> end node).

 

        ax, ay = x1 - x0, y1 - y0

 

        bx, by = x2 - x1, y2 - y1

 

        len0, len1 = math.hypot(ax, ay), math.hypot(bx, by) # lengths of them

 

        

 

        # If a length is nearly equal to zero, arc cannot be created.

 

        if len0 < 1.0e-8 or len1 < 1.0e-8:

 

            self.logger.logMessageString('Warning: Arc cannot be created', fmeobjects.FME_WARN)

 

            return

 

        

 

        # Convert the vectors to unit vectors and calculate cross product of them.

 

        ax, ay = ax / len0, ay / len0

 

        bx, by = bx / len1, by / len1

 

        cross = ax * by - ay * bx # cross product

 

        

 

        # If the two lines on the same straight line, arc cannot be created.

 

        if abs(cross) < 1.0e-8:

 

           self.logger.logMessageString('Warning: Arc cannot be created', fmeobjects.FME_WARN)

 

           return

 

        

 

        # Calculate distance between the middle vertex and start/end point of the arc.

 

        angle = math.radians(180) - abs(math.asin(cross))

 

        d = radius / math.tan(angle * 0.5)

 

        

 

        # Create FMEPoint objects for start and end points of the arc.

 

        xs, ys = x1 - ax * d, y1 - ay * d

 

        xe, ye = x1 + bx * d, y1 + by * d

 

        start = fmeobjects.FMEPoint(xs, ys)

 

        end = fmeobjects.FMEPoint(xe, ye)

 

        

 

        # Create FMEPoint object for middle point on the arc.

 

        nx, ny = (-ay, ax) if 0 < cross else (ay, -ax) # normal vector: start -> center of the arc

 

        xc, yc = xs + nx * radius, ys + ny * radius # center of the arc

 

        distance = math.hypot(x1 - xc, y1 - yc) # distance between center and middle vertex

 

        ux, uy = (x1 - xc) / distance, (y1 - yc) / distance # unit vector: center -> middle vertex

 

        middle = fmeobjects.FMEPoint(xc + ux * radius, yc + uy * radius)

 

        

 

        # Create FMEArc object from the 3 points, set the arc to the feature and output it.

 

        arc = fmeobjects.FMEArc((start, middle, end))

 

        feature.setGeometry(arc)

 

        self.pyoutput(feature)

 

-----

 

 

Result

 

 

 

Takashi

Hi Takashi,

yeah it looks very complex....i will try it but befor ethat one question....from which line the attributes should be stored in an attribute? from the lines between the vertices? e.g. i have a route with 125 segments.....the script need coordinates (start, middle, end) from each segment?

Thx

Franco

oops, forgot. Add another attribute storing the radius.

Specify the class name ("AreaReplacer") to the "Class or Function to Process Features" parameter of the PythonCaller...

No. "ArcReplacer" is the class name that I defined in the script.

 

---

 

# Script Example for PythonCaller ver.2

 

import fme, fmeobjects, math

 

 

class ArcReplacer(object):  <== This is it!

Check if all the attribute names (_radius, _x0, _y0, _x1, _y1, _x2, _y2) are correct.

Hi Takashi,

 

 

Even I was also trying for fillet.

 

Is it possible to provide the workbench in lower version? else please provide the screenshot of the workbech.

 

 

Thank you

 

 

 

Hi Pratap,

 

 

This is FME 2013 SP4+ version. (https://drive.google.com/file/d/0B0ufVP2t0eApQ3JEQlhGUHJNTzA/view?usp=sharing)

 

The script creates arcs based on a given radius and a polyline, like this image.

 

 

 

Takashi

I'm not sure what the "fillet" function is. If the function means inserting an arc between the two adjoining line segments to smooth the bending point, I think that the script which performs that can be developed by improving my script.