From c4b059ccb2bb096d4a9590ed2b61f3d9a22a04b9 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 11:40:54 -0800 Subject: [PATCH 1/3] Add MarkerDrawOrder: one marker ordering rule for every driver Within the marker band, zIndex (null = 0) is the primary key and a south-then-west tiebreak in [0, 0.5) breaks ties, so the key never crosses an explicit zIndex. It replaces calculateZIndex for markers, whose -latitude * 10^6 value made Google Maps draw an explicit zIndex 1 behind an unspecified marker (north) and let unspecified markers beat explicit ones in the southern hemisphere. Marker tiles now draw in the same order instead of the spatial index enumeration order. --- .../core/marker/MarkerDrawOrder.kt | 70 +++++++++++++++++++ .../core/marker/MarkerTileRenderer.kt | 5 +- .../core/marker/MarkerDrawOrderTest.kt | 50 +++++++++++++ 3 files changed, 124 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt create mode 100644 src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt diff --git a/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt new file mode 100644 index 0000000..a25280e --- /dev/null +++ b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt @@ -0,0 +1,70 @@ +package com.mapconductor.core.marker + +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.features.GeoPointInterface + +/** + * マーカーの帯の中での描く順。どのドライバーもこれで並べる。 + * + * - 第 1 キーは `zIndex`(未指定は 0)。大きいほど手前。 + * - 同じ `zIndex` なら南(緯度が小さい)ほど手前、緯度も同じなら西ほど手前。 + * + * 返す値は `zIndex + 端数`。端数は [0, 0.5) に収めるので、`zIndex` の大小を + * 決してひっくり返さない。以前は未指定のときだけ `-緯度 × 10^6 - 経度` を + * 使っていたため、次の 2 つが起きていた。 + * + * - 北半球(東京で約 -3.57e7)では、Google Maps が明示の `zIndex = 1` を + * それより奥に描いた(大きすぎる値を正しく比べない。実機で確認)。 + * - 南半球では値が大きな正になり、明示の小さな `zIndex` を追い越した。 + * + * 値を小さく保つのはそのため。追加した順には左右されない。 + */ +@InternalMapConductorApi +object MarkerDrawOrder { + /** 端数の上限。0.5 未満にして、隣の `zIndex` と重ならないようにする。 */ + private const val TIEBREAK_SPAN = 0.49 + + /** 経度の寄与。緯度が同じときだけ効くよう、緯度の最小の差より十分小さくする。 */ + private const val LONGITUDE_WEIGHT = 1e-6 + + /** + * 描く順の値。大きいほど手前。 + * + * Float にして渡す SDK(Google Maps)でも、`zIndex` が数百までなら緯度で + * 数メートルの差を見分けられる。 + */ + fun of( + zIndex: Int?, + position: GeoPointInterface, + ): Double = (zIndex ?: 0) + tiebreak(position) + + /** + * 整数しか受けない SDK 向け(HERE の `drawOrder` など)。 + * + * `zIndex × [INT_STRIDE] + 端数を [INT_STRIDE] 段に刻んだ値`。`zIndex` は + * ±(Int.MAX / [INT_STRIDE]) の範囲に収めること。 + */ + fun ofInt( + zIndex: Int?, + position: GeoPointInterface, + ): Int { + val primary = (zIndex ?: 0).coerceIn(-MAX_INT_Z_INDEX, MAX_INT_Z_INDEX) + val step = (tiebreak(position) / TIEBREAK_SPAN * (INT_STRIDE - 1)).toInt() + return primary * INT_STRIDE + step + } + + /** [ofInt] で 1 つの `zIndex` に割り当てる段の数。緯度でおよそ 1.8e-4 度刻み。 */ + const val INT_STRIDE: Int = 1_000_000 + + /** [ofInt] が扱える `zIndex` の絶対値。 */ + const val MAX_INT_Z_INDEX: Int = Int.MAX_VALUE / INT_STRIDE - 1 + + private fun tiebreak(position: GeoPointInterface): Double { + val latitude = position.latitude.coerceIn(-90.0, 90.0) + val longitude = position.longitude.coerceIn(-180.0, 180.0) + // 南ほど大きく(0..1)、西ほど大きく(0..1)。 + val south = (90.0 - latitude) / 180.0 + val west = (180.0 - longitude) / 360.0 + return TIEBREAK_SPAN * ((south + west * LONGITUDE_WEIGHT) / (1.0 + LONGITUDE_WEIGHT)) + } +} diff --git a/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt b/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt index f664be5..d03abd0 100644 --- a/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt +++ b/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt @@ -430,7 +430,10 @@ class MarkerTileRenderer( } else { markerManager.findMarkersInBounds(extended) } - return found.filter { it.tiling } + // 後に描いたものが上に残る(間引きでも各マス目の最後が勝つ)。描く順を + // [MarkerDrawOrder] にそろえる: zIndex が大きいほど、同じなら南・西ほど上。 + // 索引の列挙順に任せると、ネイティブのマーカーと前後が食い違う。 + return found.filter { it.tiling }.sortedBy { MarkerDrawOrder.of(it.state.zIndex, it.state.position) } } // First query uses a conservative padding (in dp) so we capture markers slightly outside diff --git a/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt b/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt new file mode 100644 index 0000000..d0bebbe --- /dev/null +++ b/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt @@ -0,0 +1,50 @@ +package com.mapconductor.core.marker + +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.features.GeoPoint +import org.junit.Assert.assertTrue +import org.junit.Test + +@OptIn(InternalMapConductorApi::class) +class MarkerDrawOrderTest { + private val tokyo = GeoPoint(35.7, 139.8, 0.0) + private val sydney = GeoPoint(-33.9, 151.2, 0.0) + + @Test + fun explicitZIndexBeatsUnspecifiedInBothHemispheres() { + for (point in listOf(tokyo, sydney, GeoPoint(-89.9, -179.9, 0.0), GeoPoint(89.9, 179.9, 0.0))) { + assertTrue(MarkerDrawOrder.of(1, point) > MarkerDrawOrder.of(null, point)) + assertTrue(MarkerDrawOrder.ofInt(1, point) > MarkerDrawOrder.ofInt(null, point)) + } + // 南半球の未指定でも、北の明示 1 を越えない。 + assertTrue(MarkerDrawOrder.of(1, tokyo) > MarkerDrawOrder.of(null, GeoPoint(-89.9, -179.9, 0.0))) + assertTrue(MarkerDrawOrder.ofInt(1, tokyo) > MarkerDrawOrder.ofInt(null, GeoPoint(-89.9, -179.9, 0.0))) + } + + @Test + fun zIndexIsPrimaryIncludingNegatives() { + assertTrue(MarkerDrawOrder.of(-1, sydney) < MarkerDrawOrder.of(0, tokyo)) + assertTrue(MarkerDrawOrder.of(2, tokyo) > MarkerDrawOrder.of(1, sydney)) + assertTrue(MarkerDrawOrder.ofInt(-1, sydney) < MarkerDrawOrder.ofInt(0, tokyo)) + } + + @Test + fun southThenWestBreakTies() { + val north = GeoPoint(35.7001, 139.8, 0.0) + val west = GeoPoint(35.7, 139.7999, 0.0) + assertTrue(MarkerDrawOrder.of(null, tokyo) > MarkerDrawOrder.of(null, north)) + assertTrue(MarkerDrawOrder.of(null, west) > MarkerDrawOrder.of(null, tokyo)) + assertTrue(MarkerDrawOrder.of(3, sydney) > MarkerDrawOrder.of(3, tokyo)) + // Float にしても数メートルの緯度差は残る(Google Maps は Float で受ける)。 + val tenMetersSouth = GeoPoint(35.7 - 0.0001, 139.8, 0.0) + assertTrue(MarkerDrawOrder.of(null, tenMetersSouth).toFloat() > MarkerDrawOrder.of(null, tokyo).toFloat()) + assertTrue(MarkerDrawOrder.ofInt(null, sydney) > MarkerDrawOrder.ofInt(null, tokyo)) + } + + @Test + fun tiebreakStaysBelowHalf() { + val extreme = GeoPoint(-90.0, -180.0, 0.0) + assertTrue(MarkerDrawOrder.of(0, extreme) < 0.5) + assertTrue(MarkerDrawOrder.of(0, GeoPoint(90.0, 180.0, 0.0)) >= 0.0) + } +} From 45425c29886d3e364dc9b84c69bd2cb5675ae6a8 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 11:40:54 -0800 Subject: [PATCH 2/3] Check that the default icon anchor stays on the pin tip at any size Measured on device: the tip-to-anchor gap is the same proportion of the bitmap with scale 0.6, scale 2, iconSize 28dp and the default, so scale does not shift the anchor. --- .../marker/DefaultIconAnchorDeviceTest.kt | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt diff --git a/src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt b/src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt new file mode 100644 index 0000000..5945ed4 --- /dev/null +++ b/src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt @@ -0,0 +1,55 @@ +package com.mapconductor.core.marker + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import android.util.Log + +/** + * アンカーがピンの先端に乗っているか。`scale` で縮めても `iconSize` で縮めても同じ。 + * + * 先端は、アンカー列で一番下にある不透明な画素。アンカーの y との差を px で測る。 + */ +@RunWith(AndroidJUnit4::class) +class DefaultIconAnchorDeviceTest { + private fun tipGapPx(icon: ColorDefaultIcon): Float { + val bitmapIcon = icon.toBitmapIcon() + val bitmap = bitmapIcon.bitmap + val anchorX = (bitmapIcon.anchor.x * bitmap.width).toInt().coerceIn(0, bitmap.width - 1) + val anchorY = bitmapIcon.anchor.y * bitmap.height + var lowest = -1 + for (y in 0 until bitmap.height) { + for (dx in -1..1) { + val x = (anchorX + dx).coerceIn(0, bitmap.width - 1) + if ((bitmap.getPixel(x, y) ushr 24) > 128) lowest = y + } + } + val gap = anchorY - (lowest + 1) + Log.i( + "IconAnchor", + "${bitmap.width}x${bitmap.height} anchor=${bitmapIcon.anchor} tipBottom=${lowest + 1} gap=$gap", + ) + return gap + } + + @Test + fun anchorSitsOnTheTipWhateverTheSize() { + val icons = + listOf( + ColorDefaultIcon(fillColor = Color.Red), + ColorDefaultIcon(fillColor = Color.Red, label = "T"), + ColorDefaultIcon(fillColor = Color.Blue, label = "P", scale = 0.6f), + ColorDefaultIcon(fillColor = Color.Blue, label = "P", iconSize = 28.dp), + ColorDefaultIcon(fillColor = Color.Blue, scale = 0.6f), + ColorDefaultIcon(fillColor = Color.Blue, scale = 2f), + ) + val gaps = icons.map { tipGapPx(it) / it.toBitmapIcon().bitmap.height } + // 素のピン(1 番目)の先端とアンカーの差を基準に、どの大きさでも同じ割合であること。 + for (gap in gaps) { + assertTrue("gaps $gaps", kotlin.math.abs(gap - gaps[0]) <= 0.02f) + } + } +} From eefed66bfb73415c99e63fd89e55bbbbe36ad818 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 15:00:56 -0800 Subject: [PATCH 3/3] Order same-zIndex markers by screen position MarkerDrawOrder now takes the camera heading (and the center longitude for the antimeridian). With equal zIndex the marker lower on screen is in front and, on the same row, the one further left, matching Google Maps JS. At heading 0 the order is unchanged (south, then west). BaseMapViewController tracks the heading and, once rotation settles, asks every marker controller to reorder through MarkerOverlayRendererInterface.onDrawOrderFrameChanged. Compose-drawn markers use rememberMarkerDrawOrderFrame. Markers drawn into tiles stay north-up. --- api/android-sdk-core.api | 28 +++- .../core/controller/BaseMapViewController.kt | 19 +++ .../core/marker/AbstractMarkerController.kt | 7 +- .../marker/AbstractMarkerOverlayRenderer.kt | 24 ++++ .../core/marker/MarkerDrawOrder.kt | 125 +++++++++++++++--- .../core/marker/MarkerDrawOrderTracker.kt | 95 +++++++++++++ .../marker/MarkerOverlayRendererInterface.kt | 12 ++ .../core/marker/StrategyMarkerController.kt | 7 +- .../core/marker/MarkerDrawOrderTest.kt | 81 ++++++++++++ 9 files changed, 377 insertions(+), 21 deletions(-) create mode 100644 src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt diff --git a/api/android-sdk-core.api b/api/android-sdk-core.api index 0529e36..7905a04 100644 --- a/api/android-sdk-core.api +++ b/api/android-sdk-core.api @@ -1580,7 +1580,7 @@ final class com.mapconductor.core.marker.AbstractDefaultIcon$PinBounds { public final float getTop(); public final float getBottom(); } -public abstract class com.mapconductor.core.marker.AbstractMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.marker.MarkerEventHostInterface { +public abstract class com.mapconductor.core.marker.AbstractMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.marker.MarkerEventHostInterface, com.mapconductor.core.marker.MarkerDrawOrderReceiver { public com.mapconductor.core.marker.AbstractMarkerController(com.mapconductor.core.marker.MarkerManager, com.mapconductor.core.marker.MarkerOverlayRendererInterface, kotlin.jvm.functions.Function1); public com.mapconductor.core.marker.AbstractMarkerController(com.mapconductor.core.marker.MarkerManager, com.mapconductor.core.marker.MarkerOverlayRendererInterface, kotlin.jvm.functions.Function1, int, kotlin.jvm.internal.DefaultConstructorMarker); public com.mapconductor.core.marker.MarkerManager getMarkerManager(); @@ -1616,6 +1616,7 @@ public abstract class com.mapconductor.core.marker.AbstractMarkerController getEntity(java.lang.String); public boolean has(java.lang.String); + public java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, kotlin.coroutines.Continuation); public void setClickListenerAny(java.lang.Object); public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); public java.lang.Object find(com.mapconductor.core.features.GeoPointInterface); @@ -1645,6 +1646,11 @@ public abstract class com.mapconductor.core.marker.AbstractMarkerOverlayRenderer public final com.mapconductor.core.marker.MarkerAnimationOverlayHost getAnimationOverlayHost(); public final void setAnimationOverlayHost(com.mapconductor.core.marker.MarkerAnimationOverlayHost); public boolean getSupportsAnimationOverlay(); + public final com.mapconductor.core.marker.MarkerDrawOrder$Frame getDrawOrderFrame(); + public final double drawOrderOf(com.mapconductor.core.marker.MarkerState); + public final int drawOrderIntOf(com.mapconductor.core.marker.MarkerState); + public java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, java.util.List>, kotlin.coroutines.Continuation); + protected java.lang.Object applyDrawOrder(java.util.List>, kotlin.coroutines.Continuation); public void setMarkerVisible(com.mapconductor.core.marker.MarkerEntityInterface, boolean); public abstract void setMarkerPosition(com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.features.GeoPoint); public java.lang.Object onAnimate(com.mapconductor.core.marker.MarkerEntityInterface, kotlin.coroutines.Continuation); @@ -1805,6 +1811,21 @@ public final class com.mapconductor.core.marker.MarkerCollector implements com.m public java.lang.Object add(com.mapconductor.core.ComponentState, kotlin.coroutines.Continuation); public com.mapconductor.core.marker.MarkerCollector(long, kotlinx.coroutines.CoroutineScope, kotlin.jvm.internal.DefaultConstructorMarker); } +public final class com.mapconductor.core.marker.MarkerDrawOrder$Frame { + public static final com.mapconductor.core.marker.MarkerDrawOrder$Frame$Companion Companion; + public final double getHeadingDegrees(); + public final double getOriginLongitude(); + public final boolean differsEnoughFrom(com.mapconductor.core.marker.MarkerDrawOrder$Frame); + public final double component1(); + public final double component2(); + public final com.mapconductor.core.marker.MarkerDrawOrder$Frame copy(double, double); + public java.lang.String toString(); + public int hashCode(); + public boolean equals(java.lang.Object); +} +public final class com.mapconductor.core.marker.MarkerDrawOrder$Frame$Companion { + public final com.mapconductor.core.marker.MarkerDrawOrder$Frame getNorthUp(); +} public final class com.mapconductor.core.marker.MarkerEntity implements com.mapconductor.core.marker.MarkerEntityInterface { public com.mapconductor.core.marker.MarkerEntity(ActualMarker, com.mapconductor.core.marker.MarkerState, boolean, boolean, boolean); public com.mapconductor.core.marker.MarkerEntity(java.lang.Object, com.mapconductor.core.marker.MarkerState, boolean, boolean, boolean, int, kotlin.jvm.internal.DefaultConstructorMarker); @@ -1942,6 +1963,7 @@ public interface com.mapconductor.core.marker.MarkerOverlayRendererInterface); public default void onDragSelectionChanged(com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.marker.MarkerEntityInterface); public default void onDragPositionChanged(com.mapconductor.core.features.GeoPointInterface); + public default java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, java.util.List>, kotlin.coroutines.Continuation); } public interface com.mapconductor.core.marker.MarkerOverlayRendererInterface$AddParamsInterface { public abstract com.mapconductor.core.marker.MarkerState getState(); @@ -1955,6 +1977,7 @@ public interface com.mapconductor.core.marker.MarkerOverlayRendererInterface$Cha public final class com.mapconductor.core.marker.MarkerOverlayRendererInterface$DefaultImpls { public static void onDragSelectionChanged(com.mapconductor.core.marker.MarkerOverlayRendererInterface, com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.marker.MarkerEntityInterface); public static void onDragPositionChanged(com.mapconductor.core.marker.MarkerOverlayRendererInterface, com.mapconductor.core.features.GeoPointInterface); + public static java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerOverlayRendererInterface, com.mapconductor.core.marker.MarkerDrawOrder$Frame, java.util.List>, kotlin.coroutines.Continuation); } public interface com.mapconductor.core.marker.MarkerRenderingStrategyInterface { public abstract com.mapconductor.core.marker.MarkerManager getMarkerManager(); @@ -2147,7 +2170,7 @@ public final class com.mapconductor.core.marker.PointD { public int hashCode(); public boolean equals(java.lang.Object); } -public final class com.mapconductor.core.marker.StrategyMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.controller.OnCameraChangeReceiverInterface, com.mapconductor.core.marker.MarkerEventHostInterface { +public final class com.mapconductor.core.marker.StrategyMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.controller.OnCameraChangeReceiverInterface, com.mapconductor.core.marker.MarkerEventHostInterface, com.mapconductor.core.marker.MarkerDrawOrderReceiver { public com.mapconductor.core.marker.StrategyMarkerController(com.mapconductor.core.marker.MarkerRenderingStrategyInterface, com.mapconductor.core.marker.MarkerOverlayRendererInterface); public com.mapconductor.core.marker.MarkerOverlayRendererInterface getRenderer(); public com.mapconductor.core.marker.MarkerManager getMarkerManager(); @@ -2176,6 +2199,7 @@ public final class com.mapconductor.core.marker.StrategyMarkerController getEntity(java.lang.String); public com.mapconductor.core.marker.MarkerEntityInterface find(com.mapconductor.core.features.GeoPointInterface); public java.lang.Object onCameraChanged(com.mapconductor.core.map.MapCameraPosition, kotlin.coroutines.Continuation); + public java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, kotlin.coroutines.Continuation); public void destroy(); public com.mapconductor.core.controller.OverlayKind getKind(); public com.mapconductor.core.controller.OverlayHit resolveTap(com.mapconductor.core.features.GeoPointInterface); diff --git a/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt b/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt index 2916cdd..7ff3bd3 100644 --- a/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt +++ b/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt @@ -19,6 +19,9 @@ import com.mapconductor.core.map.MapDiagnostics import com.mapconductor.core.map.MapViewHolderInterface import com.mapconductor.core.marker.MarkerAnimationOverlayHost import com.mapconductor.core.marker.MarkerCapableInterface +import com.mapconductor.core.marker.MarkerDrawOrder +import com.mapconductor.core.marker.MarkerDrawOrderReceiver +import com.mapconductor.core.marker.MarkerDrawOrderTracker import com.mapconductor.core.marker.MarkerState import com.mapconductor.core.marker.OnMarkerEventHandler import com.mapconductor.core.marker.StrategyMarkerController @@ -54,6 +57,16 @@ abstract class BaseMapViewController : private var lastNotifiedCameraPosition: MapCameraPosition? = null abstract val mainCoroutine: CoroutineScope private val overlayControllers = CopyOnWriteArrayList>() + + /** + * 同じ zIndex のマーカーを地図の向きに合わせて並べ直させる(画面で下ほど手前)。 + * 回転が止まってから、登録されたマーカーのコントローラ全部へ一度だけ配る。 + */ + private val markerDrawOrder by lazy { + MarkerDrawOrderTracker(defaultCoroutine) { frame -> + overlayControllers.forEach { (it as? MarkerDrawOrderReceiver)?.onDrawOrderFrameChanged(frame) } + } + } protected var cameraMoveStartCallback: OnCameraMoveHandler? = null protected var cameraMoveCallback: OnCameraMoveHandler? = null protected var cameraMoveEndCallback: OnCameraMoveHandler? = null @@ -153,6 +166,11 @@ abstract class BaseMapViewController : override fun registerOverlayController(controller: OverlayControllerInterface<*, *>) { if (overlayControllers.contains(controller)) return overlayControllers.add(controller) + // 地図が回った後に登録されたら、今の向きで並べ直させる。 + val frame = markerDrawOrder.frame + if (controller is MarkerDrawOrderReceiver && frame != MarkerDrawOrder.Frame.NorthUp) { + defaultCoroutine.launch { controller.onDrawOrderFrameChanged(frame) } + } // 登録が初期カメラ確定より後になることがある(RN の拡張レンダラや遅延マウントの // クラスタリングなど)。ユーザー操作までカメライベントを出さないプロバイダ // (HERE)では次のイベントが永遠に来ず、「登録したのに一度も計算されない」型の @@ -536,6 +554,7 @@ abstract class BaseMapViewController : protected suspend fun notifyMapCameraPosition(mapCameraPosition: MapCameraPosition) { lastNotifiedCameraPosition = mapCameraPosition + markerDrawOrder.onCameraChanged(mapCameraPosition) overlayControllers.forEach { if (it is OnCameraChangeReceiverInterface) { it.onCameraChanged(mapCameraPosition) diff --git a/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt b/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt index 5c74161..128964f 100644 --- a/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt +++ b/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt @@ -17,7 +17,8 @@ abstract class AbstractMarkerController( MarkerState, MarkerEntityInterface, >, - MarkerEventHostInterface { + MarkerEventHostInterface, + MarkerDrawOrderReceiver { override val zIndex: Int = 10 val semaphore = Semaphore(1) @@ -376,6 +377,10 @@ abstract class AbstractMarkerController( override fun getEntity(id: String): MarkerEntityInterface? = markerManager.getEntity(id) override fun has(id: String): Boolean = markerManager.hasEntity(id) + + override suspend fun onDrawOrderFrameChanged(frame: MarkerDrawOrder.Frame) { + semaphore.withPermit { renderer.onDrawOrderFrameChanged(frame, markerManager.allEntities()) } + } } private const val MARKER_RENDER_BATCH_SIZE = 500 diff --git a/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt b/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt index e9896d8..15c1334 100644 --- a/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt @@ -45,6 +45,30 @@ abstract class AbstractMarkerOverlayRenderer< */ open val supportsAnimationOverlay: Boolean = false + /** 同じ zIndex のマーカーを並べる向き([onDrawOrderFrameChanged] で変わる)。 */ + var drawOrderFrame: MarkerDrawOrder.Frame = MarkerDrawOrder.Frame.NorthUp + private set + + /** [drawOrderFrame] で並べたときの描く順。大きいほど手前。 */ + fun drawOrderOf(state: MarkerState): Double = MarkerDrawOrder.of(state.zIndex, state.position, drawOrderFrame) + + /** [drawOrderOf] の整数版。 */ + fun drawOrderIntOf(state: MarkerState): Int = MarkerDrawOrder.ofInt(state.zIndex, state.position, drawOrderFrame) + + override suspend fun onDrawOrderFrameChanged( + frame: MarkerDrawOrder.Frame, + entities: List>, + ) { + drawOrderFrame = frame + applyDrawOrder(entities) + } + + /** + * [drawOrderFrame] が変わったので、[entities] の描く順を付け直す。 + * 既定は何もしない(北が上の順のまま)。 + */ + protected open suspend fun applyDrawOrder(entities: List>) = Unit + /** Hide/show the native marker while the overlay animation runs. */ open fun setMarkerVisible( markerEntity: MarkerEntityInterface, diff --git a/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt index a25280e..e263e89 100644 --- a/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt +++ b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt @@ -2,12 +2,24 @@ package com.mapconductor.core.marker import com.mapconductor.core.InternalMapConductorApi import com.mapconductor.core.features.GeoPointInterface +import kotlin.math.PI +import kotlin.math.abs +import kotlin.math.cos +import kotlin.math.floor +import kotlin.math.ln +import kotlin.math.sin +import kotlin.math.sqrt /** * マーカーの帯の中での描く順。どのドライバーもこれで並べる。 * * - 第 1 キーは `zIndex`(未指定は 0)。大きいほど手前。 - * - 同じ `zIndex` なら南(緯度が小さい)ほど手前、緯度も同じなら西ほど手前。 + * - 同じ `zIndex` なら、**地図の向きに合わせた画面で下にあるほど**手前。 + * 画面上の高さも同じなら左ほど手前(北が上なら南ほど・西ほど手前)。 + * + * 2 つ目は Google Maps JS の既定(画面で下のマーカーが手前、回転するとその場で + * 入れ替わる)に合わせている。ただし Google は高さが同じとき後から足した方を + * 手前にするが、ここでは左を手前にして、追加した順には左右させない。 * * 返す値は `zIndex + 端数`。端数は [0, 0.5) に収めるので、`zIndex` の大小を * 決してひっくり返さない。以前は未指定のときだけ `-緯度 × 10^6 - 経度` を @@ -17,26 +29,69 @@ import com.mapconductor.core.features.GeoPointInterface * それより奥に描いた(大きすぎる値を正しく比べない。実機で確認)。 * - 南半球では値が大きな正になり、明示の小さな `zIndex` を追い越した。 * - * 値を小さく保つのはそのため。追加した順には左右されない。 + * 値を小さく保つのはそのため。 + * + * 向きは [Frame] で渡す。省略すると北が上([Frame.NorthUp])。**タイルに焼き込む + * マーカーは常に北が上で並べる**(タイルは北が上で描くので、回転のたびに描き直す + * ことになるため)。 */ @InternalMapConductorApi object MarkerDrawOrder { /** 端数の上限。0.5 未満にして、隣の `zIndex` と重ならないようにする。 */ - private const val TIEBREAK_SPAN = 0.49 + private const val TIEBREAK_SPAN = 0.45 + + /** 左右の寄与。画面上の高さが同じときだけ効くよう、十分小さくする。 */ + private const val LEFT_WEIGHT = 1e-9 + + private const val MAX_MERCATOR_LATITUDE = 85.05112878 + + /** 並べ直しに値する向きの変化(度)。 */ + private const val HEADING_STEP = 0.5 + + /** 並べ直しに値する基準経度の変化(度)。ずれが効くのは基準の裏側(±180°)だけ。 */ + private const val ORIGIN_STEP = 90.0 - /** 経度の寄与。緯度が同じときだけ効くよう、緯度の最小の差より十分小さくする。 */ - private const val LONGITUDE_WEIGHT = 1e-6 + /** + * 並べる向き。 + * + * @property headingDegrees カメラが向いている方位(heading。時計回り、度。90 なら + * 画面の上が東)。MapConductor の `bearing` とは符号が逆なので + * [com.mapconductor.core.map.CameraBearing.toNativeHeading] で直して渡す。 + * @property originLongitude 経度の折り返しの基準。カメラの中心の経度を渡すと、 + * 日付変更線をまたいで見ていても正しく並ぶ。 + */ + data class Frame( + val headingDegrees: Double = 0.0, + val originLongitude: Double = 0.0, + ) { + /** [other] から変わったとき、並べ直す必要があるか。 */ + fun differsEnoughFrom(other: Frame): Boolean = + angleBetween(headingDegrees, other.headingDegrees) >= HEADING_STEP || + angleBetween(originLongitude, other.originLongitude) >= ORIGIN_STEP + + companion object { + val NorthUp = Frame() + } + } /** * 描く順の値。大きいほど手前。 * - * Float にして渡す SDK(Google Maps)でも、`zIndex` が数百までなら緯度で - * 数メートルの差を見分けられる。 + * Float にして渡す SDK(Google Maps)でも、`zIndex` が数百までなら数十メートルの + * 差を見分けられる。 */ fun of( zIndex: Int?, position: GeoPointInterface, - ): Double = (zIndex ?: 0) + tiebreak(position) + headingDegrees: Double = 0.0, + originLongitude: Double = 0.0, + ): Double = (zIndex ?: 0) + tiebreak(position, headingDegrees, originLongitude) + + fun of( + zIndex: Int?, + position: GeoPointInterface, + frame: Frame, + ): Double = of(zIndex, position, frame.headingDegrees, frame.originLongitude) /** * 整数しか受けない SDK 向け(HERE の `drawOrder` など)。 @@ -47,24 +102,60 @@ object MarkerDrawOrder { fun ofInt( zIndex: Int?, position: GeoPointInterface, + headingDegrees: Double = 0.0, + originLongitude: Double = 0.0, ): Int { val primary = (zIndex ?: 0).coerceIn(-MAX_INT_Z_INDEX, MAX_INT_Z_INDEX) - val step = (tiebreak(position) / TIEBREAK_SPAN * (INT_STRIDE - 1)).toInt() + val step = (tiebreak(position, headingDegrees, originLongitude) / TIEBREAK_SPAN * (INT_STRIDE - 1)).toInt() return primary * INT_STRIDE + step } - /** [ofInt] で 1 つの `zIndex` に割り当てる段の数。緯度でおよそ 1.8e-4 度刻み。 */ + fun ofInt( + zIndex: Int?, + position: GeoPointInterface, + frame: Frame, + ): Int = ofInt(zIndex, position, frame.headingDegrees, frame.originLongitude) + + /** [ofInt] で 1 つの `zIndex` に割り当てる段の数。赤道でおよそ 60 m 刻み。 */ const val INT_STRIDE: Int = 1_000_000 /** [ofInt] が扱える `zIndex` の絶対値。 */ const val MAX_INT_Z_INDEX: Int = Int.MAX_VALUE / INT_STRIDE - 1 - private fun tiebreak(position: GeoPointInterface): Double { - val latitude = position.latitude.coerceIn(-90.0, 90.0) - val longitude = position.longitude.coerceIn(-180.0, 180.0) - // 南ほど大きく(0..1)、西ほど大きく(0..1)。 - val south = (90.0 - latitude) / 180.0 - val west = (180.0 - longitude) / 360.0 - return TIEBREAK_SPAN * ((south + west * LONGITUDE_WEIGHT) / (1.0 + LONGITUDE_WEIGHT)) + private fun tiebreak( + position: GeoPointInterface, + headingDegrees: Double, + originLongitude: Double, + ): Double { + // Web Mercator の世界座標 [0, 1]。y は北が 0、南が 1。 + val latitude = position.latitude.coerceIn(-MAX_MERCATOR_LATITUDE, MAX_MERCATOR_LATITUDE) + val wx = (position.longitude + 180.0) / 360.0 + val sinLat = sin(latitude * PI / 180.0) + val wy = 0.5 - ln((1.0 + sinLat) / (1.0 - sinLat)) / (4.0 * PI) + // 基準からの差。経度は [-0.5, 0.5) に折り返す。 + val dx = wrap(wx - (originLongitude + 180.0) / 360.0) + val dy = wy - 0.5 + // 画面の下向き・右向きの成分(カメラは北から時計回りに heading だけ向いている)。 + val theta = headingDegrees * PI / 180.0 + val down = -dx * sin(theta) + dy * cos(theta) + val right = dx * cos(theta) + dy * sin(theta) + // どちらも [0, 1] に収める(|dx|, |dy| ≤ 0.5 なので回しても √2 / 2 以内)。 + val down01 = (0.5 + down / SQRT2).coerceIn(0.0, 1.0) + val left01 = (0.5 - right / SQRT2).coerceIn(0.0, 1.0) + val share = down01 * (1.0 - LEFT_WEIGHT) + left01 * LEFT_WEIGHT + // 0.5 に届かないよう、端の 1.0 は上限の少し手前に寄せる。 + return (TIEBREAK_SPAN * share).coerceAtMost(TIEBREAK_SPAN * (1.0 - 1e-12)) + } + + private val SQRT2 = sqrt(2.0) + + private fun wrap(value: Double): Double = value - floor(value + 0.5) + + private fun angleBetween( + a: Double, + b: Double, + ): Double { + val d = abs(((a - b) % 360.0 + 360.0) % 360.0) + return if (d > 180.0) 360.0 - d else d } } diff --git a/src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt new file mode 100644 index 0000000..50886f5 --- /dev/null +++ b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt @@ -0,0 +1,95 @@ +package com.mapconductor.core.marker + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.runtime.snapshotFlow +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.map.CameraBearing +import com.mapconductor.core.map.MapCameraPosition +import kotlin.time.Duration +import kotlin.time.Duration.Companion.milliseconds +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.launch + +/** + * 地図の向きに合わせてマーカーを並べ直してもらう側。 + * + * マーカーのコントローラが実装し、[com.mapconductor.core.controller.BaseMapViewController] + * が向きの変化を配る。 + */ +@InternalMapConductorApi +interface MarkerDrawOrderReceiver { + suspend fun onDrawOrderFrameChanged(frame: MarkerDrawOrder.Frame) +} + +/** + * カメラの向きを見て、[MarkerDrawOrder.Frame] が変わったら一度だけ知らせる。 + * + * 回している間は毎フレームのカメラが来るので、向きが [settle] のあいだ止まってから + * 知らせる(大量のマーカーを毎フレーム並べ直さない)。パンやズームでは前後関係が + * 変わらないので知らせない。 + */ +@InternalMapConductorApi +class MarkerDrawOrderTracker( + private val scope: CoroutineScope, + private val settle: Duration = 150.milliseconds, + private val onChanged: suspend (MarkerDrawOrder.Frame) -> Unit, +) { + /** 今マーカーを並べている向き。新しく足すマーカーもこれで並べる。 */ + @Volatile + var frame: MarkerDrawOrder.Frame = MarkerDrawOrder.Frame.NorthUp + private set + + private var target: MarkerDrawOrder.Frame = frame + private var pending: Job? = null + + fun onCameraChanged(camera: MapCameraPosition) { + val next = MarkerDrawOrder.Frame(CameraBearing.toNativeHeading(camera.bearing), camera.position.longitude) + synchronized(this) { + if (!next.differsEnoughFrom(target)) return + target = next + pending?.cancel() + pending = + scope.launch { + delay(settle) + frame = next + onChanged(next) + } + } + } +} + +/** + * Compose でマーカーを描くドライバー向けの [MarkerDrawOrderTracker]。 + * + * 後に置いたものほど上に描かれるので、`markers.sortedBy { MarkerDrawOrder.of(..., frame) }` + * の `frame` にこれを渡す。向きが変わって [settle] だけ止まったときだけ値が変わる + * (パン・ズームや回転の途中では組み直さない)。 + */ +@InternalMapConductorApi +@Composable +fun rememberMarkerDrawOrderFrame( + settle: Duration = 150.milliseconds, + camera: () -> MapCameraPosition, +): MarkerDrawOrder.Frame { + val frame = remember { mutableStateOf(MarkerDrawOrder.Frame.NorthUp) } + val latestCamera by rememberUpdatedState(camera) + LaunchedEffect(settle) { + snapshotFlow { + val c = latestCamera() + MarkerDrawOrder.Frame(CameraBearing.toNativeHeading(c.bearing), c.position.longitude) + }.collectLatest { next -> + if (!next.differsEnoughFrom(frame.value)) return@collectLatest + delay(settle) + frame.value = next + } + } + return frame.value +} diff --git a/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt b/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt index a4701dc..d74e387 100644 --- a/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt +++ b/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt @@ -51,4 +51,16 @@ interface MarkerOverlayRendererInterface { * ドラッグ層を持つプロバイダがここで層を描き直す。 */ fun onDragPositionChanged(position: GeoPointInterface) = Unit + + /** + * 地図が回って、同じ zIndex のマーカーを並べる向きが変わった。 + * + * [frame] を覚えておき、以後のマーカーも [MarkerDrawOrder] にこれを渡して並べる。 + * [entities] は今ある全マーカー。ネイティブの描く順を付け直す。**既定は何もしない** + * (北が上の順のまま)。 + */ + suspend fun onDrawOrderFrameChanged( + frame: MarkerDrawOrder.Frame, + entities: List>, + ) = Unit } diff --git a/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt b/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt index e9ad09d..1f41182 100644 --- a/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt +++ b/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt @@ -19,7 +19,8 @@ class StrategyMarkerController( MarkerEntityInterface, >, OnCameraChangeReceiverInterface, - MarkerEventHostInterface { + MarkerEventHostInterface, + MarkerDrawOrderReceiver { override val markerManager: MarkerManager = strategy.markerManager override val zIndex: Int = 10 private var mapCameraPosition: MapCameraPosition? = null @@ -148,6 +149,10 @@ class StrategyMarkerController( add(pending) } + override suspend fun onDrawOrderFrameChanged(frame: MarkerDrawOrder.Frame) { + semaphore.withPermit { renderer.onDrawOrderFrameChanged(frame, markerManager.allEntities()) } + } + override fun destroy() { strategy.clear() } diff --git a/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt b/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt index d0bebbe..836f20b 100644 --- a/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt +++ b/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt @@ -2,6 +2,8 @@ package com.mapconductor.core.marker import com.mapconductor.core.InternalMapConductorApi import com.mapconductor.core.features.GeoPoint +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Test @@ -47,4 +49,83 @@ class MarkerDrawOrderTest { assertTrue(MarkerDrawOrder.of(0, extreme) < 0.5) assertTrue(MarkerDrawOrder.of(0, GeoPoint(90.0, 180.0, 0.0)) >= 0.0) } + + // ---- 地図の向き(heading)に合わせた並び ---- + + private val north = GeoPoint(35.71, 139.8, 0.0) + private val south = GeoPoint(35.69, 139.8, 0.0) + private val east = GeoPoint(35.7, 139.81, 0.0) + private val west = GeoPoint(35.7, 139.79, 0.0) + + private fun inFront( + a: GeoPoint, + b: GeoPoint, + heading: Double, + origin: Double = 139.8, + ): Boolean = MarkerDrawOrder.of(null, a, heading, origin) > MarkerDrawOrder.of(null, b, heading, origin) + + @Test + fun headingZeroKeepsNorthUpOrder() { + val points = listOf(tokyo, sydney, north, south, east, west, GeoPoint(60.0, -170.0, 0.0), GeoPoint(-10.0, 20.0, 0.0)) + for (a in points) { + for (b in points) { + if (a == b) continue + assertEquals( + "$a vs $b", + MarkerDrawOrder.of(null, a) > MarkerDrawOrder.of(null, b), + MarkerDrawOrder.of(null, a, 0.0, 0.0) > MarkerDrawOrder.of(null, b, 0.0, 0.0), + ) + } + } + } + + @Test + fun lowerOnScreenIsInFrontAtEveryHeading() { + // 0°: 南が画面の下。 + assertTrue(inFront(south, north, 0.0)) + assertTrue(inFront(west, east, 0.0)) + // 90°(画面の上が東): 西が画面の下。 + assertTrue(inFront(west, east, 90.0)) + // 同じ経度の南北は画面の同じ高さに並ぶ。左(北)が手前。 + assertTrue(inFront(north, south, 90.0)) + // 180°: 北が画面の下。 + assertTrue(inFront(north, south, 180.0)) + // 270°(画面の上が西): 東が画面の下。 + assertTrue(inFront(east, west, 270.0)) + assertTrue(inFront(south, north, 270.0)) + } + + @Test + fun zIndexDominatesAtEveryHeading() { + for (heading in listOf(0.0, 45.0, 90.0, 135.0, 180.0, 270.0, 359.0)) { + for (a in listOf(north, south, east, west, sydney)) { + for (b in listOf(north, south, east, west, sydney)) { + assertTrue(MarkerDrawOrder.of(1, a, heading, 139.8) > MarkerDrawOrder.of(null, b, heading, 139.8)) + assertTrue(MarkerDrawOrder.ofInt(1, a, heading, 139.8) > MarkerDrawOrder.ofInt(null, b, heading, 139.8)) + val v = MarkerDrawOrder.of(0, a, heading, 139.8) + assertTrue(v >= 0.0 && v < 0.5) + } + } + } + } + + @Test + fun antimeridianPairOrdersAcrossTheSeam() { + // 日付変更線の両側。179.99E は 179.99W の西隣。 + val westOfSeam = GeoPoint(0.0, 179.99, 0.0) + val eastOfSeam = GeoPoint(0.0, -179.99, 0.0) + // 90°(画面の上が東)では西が手前。 + assertTrue(inFront(westOfSeam, eastOfSeam, 90.0, origin = 180.0)) + assertTrue(inFront(eastOfSeam, westOfSeam, 270.0, origin = 180.0)) + } + + @Test + fun frameChangesOnlyOnBearingOrFarOrigin() { + val f = MarkerDrawOrder.Frame(10.0, 139.0) + assertFalse(MarkerDrawOrder.Frame(10.2, 150.0).differsEnoughFrom(f)) + assertTrue(MarkerDrawOrder.Frame(10.6, 139.0).differsEnoughFrom(f)) + assertTrue(MarkerDrawOrder.Frame(359.9, 139.0).differsEnoughFrom(MarkerDrawOrder.Frame(0.5, 139.0))) + assertFalse(MarkerDrawOrder.Frame(359.9, 139.0).differsEnoughFrom(MarkerDrawOrder.Frame(0.1, 139.0))) + assertTrue(MarkerDrawOrder.Frame(10.0, -100.0).differsEnoughFrom(f)) + } }