Geometry Path Strings

The GoJS Geometry class controls the "shape" of a Shape, whereas the Shape.fill and Shape.stroke and other shape properties control the colors and appearance of the shape. For common shape figures, there are predefined geometries that can be used by setting Shape.figure. However one can also define custom geometries.

One can construct any Geometry by allocating and initializing a Geometry of at least one PathFigure holding some PathSegments. But you may find that using the string representation of a Geometry is easier to write and save in a database. Use the static method Geometry.parse or the Shape.geometryString property to transform a geometry path string into a Geometry object.

See samples that make use of Geometries in the samples index.

Geometry Path String Syntax

The syntax for a geometry path string is an extension of the SVG path string syntax. The string consists of a number of commands, each a single letter followed by some command-specific numeric parameters.

Below are the possible commands along with the parameters they take. The parameter notation (x y)+ means that the command requires exactly two parameters, but there can be 1 or more sets of parameters for each command. For instance, the L (x y)+ command can be written as L 10 10 20 20 to denote two straight line segments.

Commands written with an uppercase letter indicate absolute coordinates; lowercase commands specify coordinates relative to the last command. Some commands do not care about case because they do not take coordinates as arguments.


For detailed information on the SVG path strings, see the W3C's page on SVG Paths.


Additionally there are some tokens specific to GoJS:

Geometry Path String Examples

Here is a simple usage of a geometry path string when initializing a Shape without setting Shape.figure:


diagram.add(
  new go.Node()
    .add(
      new go.Shape({
          geometryString: "F M120 0 L80 80 0 50z",
          fill: "lightgreen"
        })
    ));

Here is a geometry path string that uses quadratic Bezier curves:


diagram.add(
  new go.Node()
    .add(
      new go.Shape({
          geometryString: "F M0 0 L100 0 Q150 50 100 100 L0 100 Q50 50 0 0z",
          fill: "lightgreen"
        })
    ));

This geometry uses GoJS arcs:


diagram.add(
  new go.Node("Spot")
    .add(
      new go.Shape({
          geometryString: "F M0 0 L80 0 B-90 90 80 20 20 20 L100 100 20 100 B90 90 20 80 20 20z",
          fill: "lightgreen"
        }),
      new go.TextBlock("custom shape")
    ));

The following geometry uses GoJS arcs. Because the Shape is stretched to fit around the TextBlock, and because the default value of Shape.geometryStretch causes the Geometry to be stretched too, the custom geometry is also stretched to fit around the text.


diagram.add(
  new go.Node("Auto")
    .add(
      new go.Shape({
          geometryString: "F M0 0 L.8 0 B-90 90 .8 .2 .2 .2 L1 1 .2 1 B90 90 .2 .8 .2 .2z",
          fill: "lightgreen"
        }),
      new go.TextBlock("custom shape", { margin: 4 })
    ));

In the following Diagram we use a path string that contains three PathFigures. Note the X commands separating the figures and the F commands denoting fill.


diagram.add(
  new go.Part()
    .add(
      new go.Shape({
          geometryString:
            "F M 0 0 l 30,30 10,10 35,0 0,-35 x m 50 0 l 0,-50 10,0 35,35 x" +
            "f m 50 0 l 0,-50 10,0 35,35z",
          strokeWidth: 10, stroke: "lightblue",
          fill: "gray"
        })
    ));
The first two PathFigures are open; the first and third figures are filled. The Z command only closes the PathFigure that it ends.

In the following Diagram we use a path string that contains four PathFigures, two of which have a shadow. Note that figures are shadowed by default if the containing Part has Part.isShadowed set to true. To un-shadow specific path figures we use the U command.


diagram.add(
  new go.Part({ isShadowed: true, shadowOffset: new go.Point(10, 10) })
    .add(
      new go.Shape({
          geometryString:
            "F M 0 0 l 30,30 10,10 35,0 0,-35 x u m 50 0 l 0,-50 10,0 35,35 x" +
            "u f m 50 0 l 0,-50 10,0 35,35z x m 70 0 l 0,30 30,0 5,-35z",
          strokeWidth: 8, stroke: "lightblue",
          fill: "lightcoral"
        })
    ));
The first and last PathFigures are shadowed; the second and third are unshadowed.

Even Odd


  diagram.add(
    new go.Part()
      .add(
        new go.Shape({
            geometryString:
              "F M 0 100 L 100 100 100 30 20 30 20 50 70 50 70 80 40 80 40 0 0 0z",
            strokeWidth: 2, stroke: "black",
            fill: "lightcoral"
          })
      ));

  diagram.add(
    new go.Part()
      .add(
        new go.Shape({
            geometryString:
              "F0 M 0 100 L 100 100 100 30 20 30 20 50 70 50 70 80 40 80 40 0 0 0z",
            strokeWidth: 2, stroke: "black",
            fill: "lightcoral"
          })
      ));
  

Use F to fill with the (default) non-zero winding number rule, or F0 to fill with the even-odd fill rule.

Geometry.parse

Use the static function Geometry.parse to convert a GoJS syntax path string into a Geometry.


diagram.add(
  new go.Node("Horizontal")
    .add(
      new go.TextBlock("Custom Triangle:"),
      new go.Shape({
          geometry: go.Geometry.parse("M120 0 L80 80 0 50z"), // Geometry is not filled
          fill: "green", background: "whitesmoke",
          stroke: "orange", strokeWidth: 2
        })
    ));

Note that even though a Shape.fill is specified, the shape does not appear filled. This is because the geometry's one PathFigure is not declared to be filled -- there is no F command. Importing SVG path strings that are filled also requires declaring that the geometry is filled. There are several ways to do that:

Here is the same example, but using a filled geometry path string.


diagram.add(
  new go.Node("Horizontal")
    .add(
      new go.TextBlock("Custom Triangle:"),
      new go.Shape({
          geometry: go.Geometry.parse("F M120 0 L80 80 0 50z"), // Geometry is filled
          fill: "green", background: "whitesmoke",
          stroke: "orange", strokeWidth: 2
        })
    ));

All Geometry objects have bounds that contain the origin, so a geometry created with no points at x==0 or y==0 will have extra space to the left of it or above it. Note how there is extra space in the following node, causing the shape to appear farther away from the text and shifted down:


diagram.add(
  new go.Node("Horizontal")
    .add(
      new go.TextBlock("Custom Triangle:"),
      new go.Shape({
          geometry: go.Geometry.parse("M120 50 L80 80 50 50z", true), // Geometry is filled
          fill: "green", background: "whitesmoke",
          stroke: "orange", strokeWidth: 2
        })
    ));

Often when importing SVG shapes created by drawing applications into GoJS we do not want any extra space above or to the left, so we need to normalize the geometry. There is a function for this, Geometry.normalize, which modifies the Geometry's points in-place and returns a Point describing the amount they were offset.


const geo = go.Geometry.parse("M120 50 L80 80 50 50z", true);
geo.normalize();

diagram.add(
  new go.Node("Horizontal")
    .add(
      new go.TextBlock("Custom Triangle:"),
      new go.Shape({
          geometry: geo,  // normalized above
          fill: "green", background: "whitesmoke",
          stroke: "orange", strokeWidth: 2
        })
    ));

Shape.geometryString

The Shape.geometryString property setter parses a given GoJS path string as a Geometry, normalizes it, sets the Shape.geometry to this new Geometry, and offsets the Shape's position by the amount it was shifted in normalization. The positioning is useful when the shape is inside a Panel.Position panel. But when the shape is used in any other kind of panel (thus ignoring the GraphObject.position), it is still useful to remove the extra space so that the shape fits in well with the other objects in the panel.

The example below adds three Parts with Shapes to the diagram. The first shape uses Geometry.parse to set the Shape's Geometry, the second one uses Geometry.parse and Geometry.normalize. The third uses Shape.geometryString. Note the difference in size between the first Part and the other two.


const pathstring = "M30 100 C 50 50, 70 20, 100 100, 110, 130, 45, 150, 65, 100";

// Just parsing the geometry
diagram.add(
  new go.Part("Vertical")
    .add(
      new go.Shape({
          geometry: go.Geometry.parse(pathstring),
          strokeWidth: 10, stroke: "lightcoral",
          background: "whitesmoke"
        }),
      new go.TextBlock("parse")
    ));

// Parsing the geometry and normalizing it
const geo = go.Geometry.parse(pathstring);
geo.normalize();
diagram.add(
  new go.Part("Vertical")
    .add(
      new go.Shape({
          geometry: geo,
          strokeWidth: 10, stroke: "lightgreen",
          background: "whitesmoke"
        }),
      new go.TextBlock("parse/normalize")
    ));

// Using geometryString to parse and normalize the geometry
diagram.add(
  new go.Part("Vertical")
    .add(
      new go.Shape({
          geometryString: pathstring,
          strokeWidth: 10, stroke: "lightblue",
          background: "whitesmoke"
        }),
      new go.TextBlock("geometryString")
    ));

diagram.layout = new go.GridLayout();

// Select them all to more easily see their sizes
diagram.commandHandler.selectAll();

Flipping Geometries Horizontally and Vertically

GoJS Geometries have several methods for modifying the geometry's points by a transformation matrix. We can use these methods to flip or mirror the geometries if needed.

geometry.scale(-1, 1) will flip a geometry horizontally. geometry.scale(1, -1) will flip a geometry vertically.


const pathstring = "M30 100 C 50 50, 70 20, 100 100, 110, 130, 45, 150, 65, 100";
const geo = go.Geometry.parse(pathstring);
geo.normalize();

diagram.add(
  new go.Part("Vertical")
    .add(
      new go.Shape({
        geometry: geo,
          strokeWidth: 10, stroke: "lightgreen",
          background: "whitesmoke"
        }),
      new go.TextBlock("geometry from string\n(normalized)")
    ));

const geo2 = geo.copy();
geo2.scale(-1, 1); // flips a geometry horizontally
diagram.add(
  new go.Part("Vertical")
    .add(
      new go.Shape({
          geometry: geo2,
          strokeWidth: 10, stroke: "lightgreen",
          background: "whitesmoke"
        }),
      new go.TextBlock("flipped horizontally")
    ));

const geo3 = geo.copy();
geo3.scale(1, -1); // flips a geometry vertically
diagram.add(
  new go.Part("Vertical")
    .add(
      new go.Shape({
          geometry: geo3,
          strokeWidth: 10, stroke: "lightgreen",
          background: "whitesmoke"
        }),
      new go.TextBlock("flipped vertically")
    ));

diagram.layout = new go.GridLayout();

Converting Path Strings

The static method Geometry.stringify can be used to output a Geometry as a string. This string will have the GoJS path string syntax. You can use Geometry.stringify and Geometry.parse to data bind custom shape geometries.

Geometry.parse(Geometry.stringify(myGeometry)) will return a geometry equal to myGeometry, though if myGeometry was created from a string, the string itself is not guaranteed to be the same. If you merely want to copy a Geometry you should use Geometry.copy.


// These path strings represent identical geometries:
const a = "m0 0 t 50 50, q 40 20, 50 10 h 10 v -23 l 45, 5, 65, 100"
const b = "M0 0 Q0 0 50 50 Q90 70 100 60 L110 60 L110 37 L155 42 L220 142"
go.Geometry.stringify(Geometry.parse(a)); // returns the string in b
go.Geometry.stringify(Geometry.parse(b)); // returns the string in b

Because of the additional non-SVG commands, a string generated from Geometry.stringify will not necessarily be a valid SVG path.

The static method Geometry.fillPath takes a path string of either syntax and adds F tokens before each PathFigure that does not have them. Because SVG path strings are not considered to be "filled" by themselves, if you are converting an SVG Path shape to GoJS you will want to call Geometry.fillPath on the SVG string.


go.Geometry.fillPath("M0 0 L20 20 L20 0");
// returns           "F M0 0 L20 20 L20 0"
The result can then be passed to Geometry.parse or Shape.geometryString.

Parameterized Geometries

Although individual Geometry objects cannot be dynamically parameterized based on the intended size or other properties, the Shape class does support such parameterization via Shape.defineFigureGenerator. When you set or bind the Shape.figure property, the shape will call the named figure generator to generate a Geometry appropriate for the desired width and height and other Shape properties.

You can see the definitions of all of the predefined figures in the extensions file: Figures.js.