coord_polar: fix horizontal axis ticks order, fix axis circle positio…

…ned above ticks

commons/src/commonMain/kotlin/org/jetbrains/letsPlot/commons/geometry/DoubleVector.kt

@@ -8,6 +8,8 @@ package org.jetbrains.letsPlot.commons.geometry
 import kotlin.math.*
 
 class DoubleVector(val x: Double, val y: Double) {
+ constructor(x: Number, y: Number) : this(x.toDouble(), y.toDouble())
+
  operator fun component1(): Double = x
  operator fun component2(): Double = y
 

plot-builder/src/commonMain/kotlin/org/jetbrains/letsPlot/core/plot/builder/assemble/PlotAssembler.kt

@@ -18,6 +18,7 @@ import org.jetbrains.letsPlot.core.plot.builder.GeomLayer
 import org.jetbrains.letsPlot.core.plot.builder.MarginalLayerUtil
 import org.jetbrains.letsPlot.core.plot.builder.PlotSvgComponent
 import org.jetbrains.letsPlot.core.plot.builder.coord.CoordProvider
+import org.jetbrains.letsPlot.core.plot.builder.coord.PolarCoordProvider
 import org.jetbrains.letsPlot.core.plot.builder.frame.BogusFrameOfReferenceProvider
 import org.jetbrains.letsPlot.core.plot.builder.frame.SquareFrameOfReferenceProvider
 import org.jetbrains.letsPlot.core.plot.builder.layout.GeomMarginsLayout
@@ -97,9 +98,13 @@ class PlotAssembler constructor(
 
  val flipAxis = coordProvider.flipped
 
- val (hAxisPosition, vAxisPosition) = when (flipAxis) {
- true -> yAxisPosition.flip() to xAxisPosition.flip()
- else -> xAxisPosition to yAxisPosition
+ val (hAxisPosition, vAxisPosition) = if (coordProvider is PolarCoordProvider) {
+ AxisPosition.TOP to AxisPosition.LEFT
+ } else {
+ when (flipAxis) {
+ true -> yAxisPosition.flip() to xAxisPosition.flip()
+ else -> xAxisPosition to yAxisPosition
+ }
  }
 
  frameProviderByTile = frameProviderByTile(

plot-builder/src/commonMain/kotlin/org/jetbrains/letsPlot/core/plot/builder/guide/PolarAxisComponent.kt

@@ -35,8 +35,20 @@ class PolarAxisComponent(
 
  private fun buildAxis() {
  val rootElement = rootGroup
- val start = 0.0
- val end: Double = length
+
+ // Axis line
+ if (!hideAxisBreaks && axisTheme.showLine()) {
+ if (orientation.isHorizontal) {
+ val cx = length / 2
+ val cy = length / 2
+ val circle = SvgCircleElement(cx, cy, length / 2).apply {
+ strokeWidth().set(gridTheme.majorLineWidth())
+ strokeColor().set(gridTheme.majorLineColor())
+ fillColor().set(Color.TRANSPARENT)
+ }
+ rootElement.children().add(circle)
+ }
+ }
 
  // Axis
  if (!hideAxis) {
@@ -57,29 +69,14 @@ class PolarAxisComponent(
 
  when (orientation.isHorizontal) {
  false -> SvgUtils.transformTranslate(group, 0.0, br.y)
- true -> SvgUtils.transformTranslate(group, br.x, -br.y)
+ true -> SvgUtils.transformTranslate(group, br.x, br.y)
  }
 
  rootElement.children().add(group)
  //}
  }
  }
-
- // Axis line
- if (!hideAxisBreaks && axisTheme.showLine()) {
- if (orientation.isHorizontal) {
- val cx = length / 2
- val cy = -length / 2
- val circle = SvgCircleElement(cx, cy, length / 2).apply {
- strokeWidth().set(gridTheme.majorLineWidth())
- strokeColor().set(gridTheme.majorLineColor())
- fillColor().set(Color.TRANSPARENT)
- }
- rootElement.children().add(circle)
- }
- }
  }
-
  }
 
  private fun buildTick(

plot-builder/src/jvmTest/kotlin/org/jetbrains/letsPlot/core/plot/builder/BreaksDataTest.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023. JetBrains s.r.o.
+ * Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+ */
+
+package org.jetbrains.letsPlot.core.plot.builder
+
+import org.jetbrains.letsPlot.commons.geometry.DoubleRectangle
+import org.jetbrains.letsPlot.commons.geometry.DoubleVector
+import org.jetbrains.letsPlot.core.plot.base.scale.ScaleBreaks
+import org.jetbrains.letsPlot.core.plot.builder.AxisUtil.breaksData
+import org.jetbrains.letsPlot.core.plot.builder.coord.PolarCoordProvider
+import org.jetbrains.letsPlot.core.plot.builder.defaultTheme.DefaultTheme
+import org.jetbrains.letsPlot.core.plot.builder.guide.AxisComponent
+import org.jetbrains.letsPlot.core.plot.builder.guide.Orientation
+import org.junit.Test
+import kotlin.test.assertEquals
+
+class BreaksDataTest {
+ @Test
+ fun simple() {
+ val polarCoordProvider = PolarCoordProvider(thetaFromX = true, start = 0.0, clockwise = true)
+ val adjustedDomain = DoubleRectangle.XYWH(-5.0, 10.0, 5.0, 8.625)
+ val clientSize = DoubleVector(504.0, 504.0)
+ val coordinateSystem = polarCoordProvider.createCoordinateSystem(adjustedDomain, clientSize)
+ val breaksData = breaksData(
+ scaleBreaks = ScaleBreaks(
+ domainValues = listOf(-5.0, -4.0, -3.0, -2.0, -1.0, 0.0),
+ transformedValues = listOf(-5.0, -4.0, -3.0, -2.0, -1.0, 0.0),
+ labels = listOf("-5", "-4", "-3", "-2", "-1", "0"),
+ ),
+ coord = coordinateSystem,
+ domain = adjustedDomain,
+ flipAxis = false,
+ orientation = Orientation.BOTTOM,
+ axisTheme = DefaultTheme.minimal2().horizontalAxis(flipAxis = false),
+ labelAdjustments = AxisComponent.TickLabelAdjustments(Orientation.BOTTOM)
+ )
+
+ // Breaks start at top center
+ val topCenter = DoubleVector(clientSize.x / 2, 0.0)
+
+ assertDoubleVectorEquals(topCenter, breaksData.majorBreaks[0])
+ assertDoubleVectorEquals(DoubleVector(491, 174), breaksData.majorBreaks[1])
+ assertDoubleVectorEquals(DoubleVector(400, 455), breaksData.majorBreaks[2])
+ assertDoubleVectorEquals(DoubleVector(103, 455), breaksData.majorBreaks[3])
+ assertDoubleVectorEquals(DoubleVector(12, 174), breaksData.majorBreaks[4])
+ assertDoubleVectorEquals(topCenter, breaksData.majorBreaks[5])
+ }
+
+ private fun assertDoubleVectorEquals(expected: DoubleVector, actual: DoubleVector, tolerance: Double = 1.0) {
+ assertEquals(expected.x, actual.x, tolerance)
+ assertEquals(expected.y, actual.y, tolerance)
+ }
+}

plot-builder/src/jvmTest/kotlin/org/jetbrains/letsPlot/core/plot/builder/coord/CoordPolarTest.kt

@@ -14,13 +14,13 @@ import kotlin.test.Test
 import kotlin.test.assertContentEquals
 
 class PolarCoordTest {
+ private val x = listOf(0, 90, 180, 270, 360)
+ private val y = listOf(0, 1, 2, 3, 4)
+ private val adjustedDomain = DoubleRectangle.LTRB(0, 0, 360, 4)
+ private val clientSize = DoubleVector(200.0, 200.0)
 
  private fun applyPolarTransform(start: Double, clockwise: Boolean): List<Vector> {
  val polarCoordProvider = PolarCoordProvider(thetaFromX = true, start, clockwise)
- val x = listOf(0, 90, 180, 270, 360)
- val y = listOf(0, 1, 2, 3, 4)
- val adjustedDomain = DoubleRectangle.LTRB(0, 0, 360, 4)
- val clientSize = DoubleVector(200.0, 200.0)
 
  val polarMapper = polarCoordProvider.createCoordinateMapper(
  adjustedDomain = adjustedDomain,
@@ -32,6 +32,15 @@ class PolarCoordTest {
  .map { (x, y) -> Vector(x.roundToInt(), y.roundToInt()) }
  }
 
+ private fun applyPolarScreenTransform(start: Double, clockwise: Boolean): List<Vector> {
+ val polarCoordProvider = PolarCoordProvider(thetaFromX = true, start, clockwise)
+ val coordinateSystem = polarCoordProvider.createCoordinateSystem(adjustedDomain, clientSize)
+
+ return x.zip(y)
+ .mapNotNull { (x, y) -> coordinateSystem.toClient(DoubleVector(x.toDouble(), y.toDouble())) }
+ .map { (x, y) -> Vector(x.roundToInt(), y.roundToInt()) }
+ }
+
  @Test
  fun default() {
  assertContentEquals(
@@ -44,6 +53,17 @@ class PolarCoordTest {
  ),
  actual = applyPolarTransform(start = 0.0, clockwise = true)
  )
+
+ assertContentEquals(
+ expected = listOf(
+ Vector(100, 100),
+ Vector(125, 100),
+ Vector(100, 150),
+ Vector(25, 100),
+ Vector(100, 0),
+ ),
+ actual = applyPolarScreenTransform(start = 0.0, clockwise = true)
+ )
  }
 
  @Test
@@ -58,6 +78,16 @@ class PolarCoordTest {
  ),
  actual = applyPolarTransform(start = 0.0, clockwise = false)
  )
+ assertContentEquals(
+ expected = listOf(
+ Vector(100, 100),
+ Vector(75, 100),
+ Vector(100, 150),
+ Vector(175, 100),
+ Vector(100, 0),
+ ),
+ actual = applyPolarScreenTransform(start = 0.0, clockwise = false)
+ )
  }
 
  @Test
@@ -72,6 +102,17 @@ class PolarCoordTest {
  ),
  actual = applyPolarTransform(start = PI / 2, clockwise = true)
  )
+
+ assertContentEquals(
+ expected = listOf(
+ Vector(100, 100),
+ Vector(100, 125),
+ Vector(50, 100),
+ Vector(100, 25),
+ Vector(200, 100),
+ ),
+ actual = applyPolarScreenTransform(start = PI / 2, clockwise = true)
+ )
  }
 
  @Test
@@ -86,6 +127,17 @@ class PolarCoordTest {
  ),
  actual = applyPolarTransform(start = -PI / 2, clockwise = true)
  )
+
+ assertContentEquals(
+ expected = listOf(
+ Vector(100, 100),
+ Vector(100, 75),
+ Vector(150, 100),
+ Vector(100, 175),
+ Vector(0, 100),
+ ),
+ actual = applyPolarScreenTransform(start = -PI / 2, clockwise = true)
+ )
  }
 
 
@@ -101,5 +153,16 @@ class PolarCoordTest {
  ),
  actual = applyPolarTransform(start = PI / 2, clockwise = false)
  )
+
+ assertContentEquals(
+ expected = listOf(
+ Vector(100, 100),
+ Vector(100, 125),
+ Vector(150, 100),
+ Vector(100, 25),
+ Vector(0, 100),
+ ),
+ actual = applyPolarScreenTransform(start = PI / 2, clockwise = false)
+ )
  }
 }