Merge pull request #140 from geostyler/fix-139-lineSymbolizer-withMarkerPlacement

fix(#139): case MarkerPosition, added test

Author: myriamfischer

src/processSymbolLayer.ts

@@ -93,31 +93,43 @@ const processSymbolLayerWithSubSymbol = (
   }
   if (symbol.type === "CIMLineSymbol") {
     if (layer.type === "CIMCharacterMarker") {
-      if (orientedMarkerAtStartOfLine(layer.markerPlacement)) {
-        const startSymbolizer = processOrientedMarkerAtEndOfLine(
-          layer,
-          "start",
-          options,
-        );
-        if (startSymbolizer) {
-          symbolizers.push(startSymbolizer);
+      const orientedMarkerPosition = getOrientedMarkerLinePosition(
+        layer.markerPlacement,
+      );
+      if (orientedMarkerPosition) {
+        const processOrientedMarkerAtEndOfLineFn = (
+          position: "start" | "end",
+        ) => {
+          const orientedMarkerSymbolizer = processOrientedMarkerAtEndOfLine(
+            layer,
+            position,
+            options,
+          );
+          if (orientedMarkerSymbolizer) {
+            symbolizers.push(orientedMarkerSymbolizer);
+          }
+        };
+        if (
+          orientedMarkerPosition === "start" ||
+          orientedMarkerPosition === "both"
+        ) {
+          processOrientedMarkerAtEndOfLineFn("start");
         }
-      }
-      if (orientedMarkerAtEndOfLine(layer.markerPlacement)) {
-        const endSymbolizer = processOrientedMarkerAtEndOfLine(
-          layer,
-          "end",
-          options,
-        );
-        if (endSymbolizer) {
-          symbolizers.push(endSymbolizer);
+
+        if (
+          orientedMarkerPosition === "end" ||
+          orientedMarkerPosition === "both"
+        ) {
+          processOrientedMarkerAtEndOfLineFn("end");
         }
+      } else {
+        const lineSymbolizer = formatLineSymbolizer(
+          symbolizer as PointSymbolizer,
+          layer as SymbolLayer,
+        );
+        symbolizers.push(lineSymbolizer);
       }
-      const lineSymbolizer = formatLineSymbolizer(
-        symbolizer as PointSymbolizer,
-        layer as SymbolLayer,
-      );
-      symbolizers.push(lineSymbolizer);
+
       return symbolizers;
     }
     // Not CIMCharacterMarker
@@ -254,6 +266,10 @@ const processOrientedMarkerAtEndOfLine = (
     // markerPositionFnc = MarkerPlacementPosition.END;
     // markerRotationFnc = MarkerPlacementAngle.END;
     rotation = layer?.rotation ?? 0;
+  } else if (orientedMarker === "both") {
+    // markerPositionFnc = MarkerPlacementPosition.BOTH;
+    // markerRotationFnc = MarkerPlacementAngle.BOTH;
+    rotation = layer?.rotation ?? 90;
   } else {
     return undefined;
   }
@@ -303,7 +319,7 @@ const processOrientedMarkerAtEndOfLine = (
     kind: "Mark",
     color: fillColor,
     wellKnownName: name,
-    radius: ptToPxProp(layer, "size", 10),
+    radius: ptToPxProp(layer, "size", 10) / 2,
     // @ts-ignore FIXME see issue #66
     geometry: [null, ["PropertyName", "shape"]],
     // geometry: [markerPositionFnc, ["PropertyName", "shape"]],
@@ -372,43 +388,30 @@ const processMarkerPlacementInsidePolygon = (
   return [top, right, bottom, left];
 };
 
-const orientedMarkerAtStartOfLine = (
+const getOrientedMarkerLinePosition = (
   markerPlacement: CIMMarkerPlacement,
-): boolean => {
+): "start" | "end" | "both" | undefined => {
   if (markerPlacement?.angleToLine) {
-    if (
-      markerPlacement.type === "CIMMarkerPlacementAtRatioPositions" &&
-      markerPlacement.positionArray[0] === 0 &&
-      markerPlacement.flipFirst
-    ) {
-      return true;
-    } else if (markerPlacement.type === "CIMMarkerPlacementAtExtremities") {
-      return (
-        markerPlacement.extremityPlacement === "Both" ||
-        markerPlacement.extremityPlacement === "JustBegin"
-      );
-    }
-  }
-  return false;
-};
-
-const orientedMarkerAtEndOfLine = (
-  markerPlacement: CIMMarkerPlacement,
-): boolean => {
-  if (markerPlacement?.angleToLine) {
-    if (
-      markerPlacement.type === "CIMMarkerPlacementAtRatioPositions" &&
-      markerPlacement.positionArray[0] === 1
-    ) {
-      return true;
+    if (markerPlacement.type === "CIMMarkerPlacementAtRatioPositions") {
+      if (markerPlacement.positionArray[0] === 0 && markerPlacement.flipFirst) {
+        return "start";
+      }
+      if (markerPlacement.positionArray[0] === 1) {
+        return "end";
+      }
     } else if (markerPlacement.type === "CIMMarkerPlacementAtExtremities") {
-      return (
-        markerPlacement.extremityPlacement === "Both" ||
-        markerPlacement.extremityPlacement === "JustEnd"
-      );
+      if (markerPlacement.extremityPlacement === "Both") {
+        return "both";
+      }
+      if (markerPlacement.extremityPlacement === "JustBegin") {
+        return "start";
+      }
+      if (markerPlacement.extremityPlacement === "JustEnd") {
+        return "end";
+      }
     }
   }
-  return false;
+  return undefined;
 };
 
 const processSymbolSolidStroke = (
@@ -672,7 +675,7 @@ const processSymbolHatchFill = (layer: SymbolLayer): Symbolizer[] => {
         // For the straight hatch markers, it looks that dividing the value by 2 gives best results.
         neededSize = neededSize / 2;
         // To keep the "original size" given by the separation value, we play with a negative margin.
-        let negativeMargin = ((neededSize - separation)) * -1;
+        let negativeMargin = (neededSize - separation) * -1;
         if (wellKnowName === getStraightHatchMarker()[0]) {
           fillSymbolizer.graphicFillPadding = [
             negativeMargin,

tests/renderer.polyline.spec.ts

@@ -197,3 +197,45 @@ describe("Parse dashed and dotted polyline renderer", () => {
     ]);
   });
 });
+
+describe("Parse polyline renderer with markerPlacement at the end", () => {
+  let geostylerStyle: ReadStyleResult;
+
+  beforeAll(async () => {
+    geostylerStyle = await loadGeostylerStyle(
+      "./tests/testdata/polyline/polyline_withMarkerPlacement.lyrx",
+    );
+  });
+
+  it("should parse a valid style object", () => {
+    expect(geostylerStyle).toBeDefined();
+    expect(geostylerStyle.output).toBeDefined();
+    expect(geostylerStyle.output?.name).toBe("fc_polyline_withMarkerPlacement");
+  });
+
+  it("should have a single rule", () => {
+    const rules = geostylerStyle.output?.rules;
+    expect(rules).toHaveLength(1);
+
+  });
+
+  it("should have two correct symbolizers", () => {
+    const symbolizers = geostylerStyle.output?.rules?.[0].symbolizers;
+    expect(symbolizers).toHaveLength(2);
+    const symbolizerLine = geostylerStyle.output?.rules?.[0].symbolizers?.[0] as LineSymbolizer;
+    expect(symbolizerLine).toBeDefined();
+    expect(symbolizerLine?.kind).toBe("Line");
+    expect(symbolizerLine?.color).toBe("#0070ff");
+    expect(symbolizerLine?.opacity).toBe(1);
+    expect(symbolizerLine?.width).toBe(0.5333333333333333);
+    expect(symbolizerLine?.cap).toBe("butt");
+    expect(symbolizerLine?.join).toBe("round");
+
+    const symbolizerMarker = geostylerStyle.output?.rules?.[0].symbolizers?.[1] as MarkSymbolizer;
+    expect(symbolizerMarker).toBeDefined();
+    expect(symbolizerMarker?.kind).toBe("Mark");
+    expect(symbolizerMarker?.wellKnownName).toBe("ttf://ESRI Dimensioning#0x21");
+    expect(symbolizerMarker?.fillOpacity).toBe(1);
+    expect(symbolizerMarker?.radius).toBe(4);
+  });
+});