From 60f3f6fc2e05f111e9f18d4375af83c36cc90ad4 Mon Sep 17 00:00:00 2001
From: parkdu7 <tmdrbs0925@gmail.com>
Date: Sat, 30 Aug 2025 14:04:12 +0900
Subject: [PATCH] =?UTF-8?q?fix=20:=20POI=20=EC=9C=84=EC=B9=98=20=EA=B3=A0?=
 =?UTF-8?q?=EC=A0=95,=20=EC=B6=A9=EB=8F=8C=EC=8B=9C=20=EB=A7=88=EC=BB=A4?=
 =?UTF-8?q?=EA=B0=80=20=EC=9B=80=EC=A7=81=EC=9D=B4=EB=8F=84=EB=A1=9D=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../ui/map/ClusterManagerInitializer.kt       |   9 +-
 .../presentation/ui/map/MapClusterManager.kt  | 259 +++++++++++++++++-
 .../presentation/ui/map/POIMarkerManager.kt   | 199 ++------------
 .../presentation/ui/screens/FullMapScreen.kt  |  24 +-
 4 files changed, 291 insertions(+), 200 deletions(-)

diff --git a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/ClusterManagerInitializer.kt b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/ClusterManagerInitializer.kt
index ef2f98c..6e3d1ac 100644
--- a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/ClusterManagerInitializer.kt
+++ b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/ClusterManagerInitializer.kt
@@ -17,7 +17,8 @@ class ClusterManagerInitializer(
     fun createClusterManager(
         naverMap: NaverMap,
         mapContainer: ViewGroup? = null,
-        onHighlightedContentChanged: (MapContent?) -> Unit
+        onHighlightedContentChanged: (MapContent?) -> Unit,
+        poiMarkerManager: POIMarkerManager? = null
     ): MapClusterManager {
         return MapClusterManager(context, naverMap, mapContainer).also { manager ->
             manager.setupClustering()
@@ -85,6 +86,12 @@ class ClusterManagerInitializer(
                 Log.d("ClusterManagerInitializer", "🎯 통합 클러스터 클릭: ${mixedClusterItems.size}개 아이템")
                 mapViewModel.selectMixedCluster(mixedClusterItems)
             }
+            
+            // POI 매니저와 연결 (충돌 감지용)
+            if (poiMarkerManager != null) {
+                manager.poiMarkerManager = poiMarkerManager
+                Log.d("ClusterManagerInitializer", "🏪 POI 매니저와 마커 매니저 연결 완료")
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/MapClusterManager.kt b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/MapClusterManager.kt
index 4a893aa..2099ea9 100644
--- a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/MapClusterManager.kt
+++ b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/MapClusterManager.kt
@@ -57,6 +57,12 @@ class MapClusterManager(
     
     // POI 충돌 방지를 위한 마커 위치 업데이트 콜백
     var onMarkerPositionsUpdated: ((List<LatLng>, Double) -> Unit)? = null
+    
+    // POI 매니저 참조 (POI 위치 정보 가져오기 위함)
+    var poiMarkerManager: POIMarkerManager? = null
+    
+    // 카메라 변경 시 마커 재배치 콜백
+    var onCameraChangeForMarkerRepositioning: (() -> Unit)? = null
 
     // 선택된 마커 상태 관리
     var selectedMarker: Marker? = null
@@ -93,6 +99,10 @@ class MapClusterManager(
         private val MARKER_SIZE get() = MarkerConfig.BASE_MARKER_SIZE
         private val SELECTED_MARKER_SCALE get() = MarkerConfig.SELECTED_SCALE
         private val HIGHLIGHTED_MARKER_SCALE get() = MarkerConfig.HIGHLIGHTED_SCALE
+        
+        // 마커 충돌 감지 설정
+        private const val COLLISION_DETECTION_MIN_ZOOM = 19.0  // 줌 19 이상에서만 충돌 감지
+        private const val MARKER_COLLISION_RADIUS_PX = 60      // 마커 충돌 반경 (픽셀)
     }
     
     // 아이콘 캐싱 시스템
@@ -438,6 +448,12 @@ class MapClusterManager(
 
         // POI 매니저에 현재 마커 위치들 전달 (충돌 방지용)
         notifyMarkerPositions()
+        
+        // 줌 레벨이 높고 POI가 있으면 마커 재배치 (POI 변경 시 대응)
+        if (currentZoom >= COLLISION_DETECTION_MIN_ZOOM && poiMarkerManager != null) {
+            Log.d("MapClusterManager", "🔄 POI 업데이트 감지 - 마커 재배치 검토")
+            redistributeMarkersAvoidingPOI()
+        }
 
         // 클러스터링 완료 콜백 호출
         onComplete?.invoke()
@@ -530,11 +546,22 @@ class MapClusterManager(
                 // 단일 마커
                 val content = cluster[0]
                 Log.d("MapClusterManager", "📍 [MARKER] 단일 마커 생성: ${content.title} (ID: ${content.contentId})")
-                Log.d("MapClusterManager", "📍 [MARKER] 위치: (${content.location.latitude}, ${content.location.longitude})")
+                Log.d("MapClusterManager", "📍 [MARKER] 원래 위치: (${content.location.latitude}, ${content.location.longitude})")
                 Log.d("MapClusterManager", "🔗 [MARKER] 마커 생성 시점 onMarkerClick: ${onMarkerClick}")
                 
+                // POI와의 충돌을 피한 최적 위치 계산
+                val originalPosition = LatLng(content.location.latitude, content.location.longitude)
+                val optimalPosition = calculateOptimalMarkerPosition(originalPosition, content)
+                
+                if (optimalPosition != originalPosition) {
+                    Log.e("MapClusterManager", "🕷️ [MARKER] Spider 적용됨: ${content.title}")
+                    Log.e("MapClusterManager", "🕷️ [MARKER] 최종 위치: (${optimalPosition.latitude}, ${optimalPosition.longitude})")
+                } else {
+                    Log.d("MapClusterManager", "📍 [MARKER] 충돌 없음 - 원위치 사용: ${content.title}")
+                }
+                
                 val marker = Marker().apply {
-                    position = LatLng(content.location.latitude, content.location.longitude)
+                    position = optimalPosition
                     icon = getNormalMarkerIcon(content.postType)
                     map = naverMap
                     tag = content // MapContent 저장
@@ -551,7 +578,7 @@ class MapClusterManager(
                             onMarkerClick?.invoke(content)
                         } else {
                             Log.d("MapClusterManager", "🎯 [CLICK] 새 마커 선택 - selectMarker 호출")
-                            // 새로운 마커 선택 및 카메라 이동 (줌레벨 유지)
+                            // 새로운 마커 선택 및 카메라 이동 (원래 위치로 이동)
                             selectMarker(content)
                             
                             // 마커 클릭 이동 플래그 설정
@@ -876,7 +903,7 @@ class MapClusterManager(
                 
                 when (item) {
                     is MapContentItem -> {
-                        val marker = createContentMarker(item.content)
+                        val marker = createContentMarkerWithCollisionDetection(item.content)
                         markers.add(marker)
                         Log.d("MapClusterManager", "✅ [MIXED] Content 마커 추가 완료")
                     }
@@ -966,7 +993,52 @@ class MapClusterManager(
     }
 
     /**
-     * Content 마커를 생성하는 헬퍼 함수
+     * Content 마커를 생성하는 헬퍼 함수 (충돌 감지 적용)
+     */
+    private fun createContentMarkerWithCollisionDetection(content: MapContent): Marker {
+        // POI와의 충돌을 피한 최적 위치 계산
+        val originalPosition = LatLng(content.location.latitude, content.location.longitude)
+        val optimalPosition = calculateOptimalMarkerPosition(originalPosition, content)
+        
+        if (optimalPosition != originalPosition) {
+            Log.e("MapClusterManager", "🕷️ [MIXED CONTENT] Spider 적용됨: ${content.title}")
+        }
+        
+        return Marker().apply {
+            position = optimalPosition
+            icon = getNormalMarkerIcon(content.postType)
+            map = naverMap
+            tag = content
+
+            setOnClickListener {
+                Log.e("MapClusterManager", "🎯🎯🎯 [MIXED CONTENT] 개별 Content 마커 클릭!!!")
+                
+                if (selectedContent?.contentId == content.contentId) {
+                    clearSelection()
+                    onMarkerClick?.invoke(content)
+                } else {
+                    selectMarker(content)
+                    
+                    isClusterMoving = true
+                    
+                    naverMap.moveCamera(
+                        CameraUpdate.scrollTo(LatLng(content.location.latitude, content.location.longitude))
+                            .animate(CameraAnimation.Easing)
+                    )
+                    
+                    android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+                        isClusterMoving = false
+                    }, 1000)
+                    
+                    onMarkerClick?.invoke(content)
+                }
+                true
+            }
+        }
+    }
+    
+    /**
+     * Content 마커를 생성하는 헬퍼 함수 (기존 방식 - 호환성 유지)
      */
     private fun createContentMarker(content: MapContent): Marker {
         return Marker().apply {
@@ -1705,4 +1777,181 @@ class MapClusterManager(
         // POI 매니저에 콜백으로 전달
         onMarkerPositionsUpdated?.invoke(allPositions, currentZoom)
     }
+    
+    // ===== 🆕 마커 충돌 감지 및 Spider 알고리즘 시스템 =====
+    
+    /**
+     * POI와의 충돌을 피해 마커 최적 위치 계산 (화면 좌표 기반)
+     */
+    private fun calculateOptimalMarkerPosition(originalPosition: LatLng, content: MapContent): LatLng {
+        val currentZoom = naverMap.cameraPosition.zoom
+        
+        // 줌 레벨이 충돌 감지 임계값보다 낮으면 원위치 사용
+        if (currentZoom < COLLISION_DETECTION_MIN_ZOOM) {
+            return originalPosition
+        }
+        
+        // POI 위치들 가져오기
+        val poiPositions = poiMarkerManager?.getPOIPositions() ?: emptyList()
+        
+        if (poiPositions.isEmpty()) {
+            return originalPosition
+        }
+        
+        Log.d("MapClusterManager", "🎯 마커 충돌 감지: ${content.title} - POI ${poiPositions.size}개와 비교")
+        
+        // 1. 마커 원래 위치를 화면 좌표로 변환
+        val markerScreenPoint = naverMap.projection.toScreenLocation(originalPosition)
+        
+        // 2. POI들의 화면 좌표 계산
+        val poiScreenPoints = poiPositions.map { position ->
+            naverMap.projection.toScreenLocation(position)
+        }
+        
+        // 3. 화면상 충돌 감지
+        var hasCollision = false
+        poiScreenPoints.forEachIndexed { index, screenPoint ->
+            val pixelDistance = sqrt(
+                (markerScreenPoint.x - screenPoint.x).toDouble().pow(2) + 
+                (markerScreenPoint.y - screenPoint.y).toDouble().pow(2)
+            )
+            
+            if (pixelDistance <= MARKER_COLLISION_RADIUS_PX) {
+                hasCollision = true
+                Log.e("MapClusterManager", "🚨 마커-POI 충돌 감지! POI[$index]: ${pixelDistance.toInt()}px ≤ ${MARKER_COLLISION_RADIUS_PX}px")
+            }
+        }
+        
+        if (!hasCollision) {
+            Log.d("MapClusterManager", "✅ 마커 충돌 없음 - 원위치 사용: ${content.title}")
+            return originalPosition
+        }
+        
+        // 4. 충돌 시 Spider 알고리즘으로 8방향 오프셋 적용
+        Log.e("MapClusterManager", "🕷️ Spider 알고리즘 시작: ${content.title}")
+        
+        val offsetDistance = MARKER_COLLISION_RADIUS_PX + 20 // 여유 공간
+        val angles = listOf(0, 45, 90, 135, 180, 225, 270, 315) // 8방향
+        
+        for (angle in angles) {
+            val radians = Math.toRadians(angle.toDouble())
+            val offsetX = cos(radians) * offsetDistance
+            val offsetY = sin(radians) * offsetDistance
+            
+            val offsetScreenPoint = android.graphics.PointF(
+                (markerScreenPoint.x + offsetX).toFloat(),
+                (markerScreenPoint.y + offsetY).toFloat()
+            )
+            
+            // 오프셋된 화면 좌표를 지리 좌표로 변환
+            val offsetPosition = naverMap.projection.fromScreenLocation(offsetScreenPoint)
+            
+            // 오프셋 위치에서도 충돌 체크
+            var offsetHasCollision = false
+            poiScreenPoints.forEach { screenPoint ->
+                val pixelDistance = sqrt(
+                    (offsetScreenPoint.x - screenPoint.x).toDouble().pow(2) + 
+                    (offsetScreenPoint.y - screenPoint.y).toDouble().pow(2)
+                )
+                if (pixelDistance <= MARKER_COLLISION_RADIUS_PX) {
+                    offsetHasCollision = true
+                }
+            }
+            
+            if (!offsetHasCollision) {
+                Log.e("MapClusterManager", "✅ Spider: 최적 위치 찾음 ${angle}도 - ${content.title}")
+                Log.e("MapClusterManager", "✅ 원래: (${originalPosition.latitude}, ${originalPosition.longitude})")
+                Log.e("MapClusterManager", "✅ 최종: (${offsetPosition.latitude}, ${offsetPosition.longitude})")
+                return offsetPosition
+            }
+        }
+        
+        // 모든 방향에서 충돌하면 원위치 강제 사용
+        Log.e("MapClusterManager", "❌ Spider: 모든 방향 충돌 - 원위치 강제 사용: ${content.title}")
+        return originalPosition
+    }
+    
+    /**
+     * 마커들을 POI 충돌을 피해 재배치
+     */
+    fun redistributeMarkersAvoidingPOI() {
+        val currentZoom = naverMap.cameraPosition.zoom
+        
+        if (currentZoom < COLLISION_DETECTION_MIN_ZOOM) {
+            Log.d("MapClusterManager", "줌 레벨 낮음 ($currentZoom) - 마커 재배치 스킵")
+            return
+        }
+        
+        Log.e("MapClusterManager", "🔄 === 마커 재배치 시작 ===")
+        Log.e("MapClusterManager", "🔄 대상 마커: ${markers.size}개")
+        
+        var repositionedCount = 0
+        
+        markers.forEach { marker ->
+            val content = marker.tag as? MapContent ?: return@forEach
+            val originalPosition = LatLng(content.location.latitude, content.location.longitude)
+            val newPosition = calculateOptimalMarkerPosition(originalPosition, content)
+            
+            if (newPosition != originalPosition) {
+                marker.position = newPosition
+                repositionedCount++
+                Log.e("MapClusterManager", "🔄 마커 재배치됨: ${content.title}")
+            }
+        }
+        
+        Log.e("MapClusterManager", "🔄 마커 재배치 완료: ${repositionedCount}/${markers.size}개")
+    }
+    
+    /**
+     * 마커들을 원래 위치로 복원 (줌 아웃 시)
+     */
+    fun restoreMarkersToOriginalPositions() {
+        Log.e("MapClusterManager", "🔄 === 마커 원위치 복원 ===")
+        
+        var restoredCount = 0
+        
+        markers.forEach { marker ->
+            val content = marker.tag as? MapContent ?: return@forEach
+            val originalPosition = LatLng(content.location.latitude, content.location.longitude)
+            
+            if (marker.position != originalPosition) {
+                marker.position = originalPosition
+                restoredCount++
+                Log.e("MapClusterManager", "🔄 마커 원위치 복원: ${content.title}")
+            }
+        }
+        
+        Log.e("MapClusterManager", "🔄 원위치 복원 완료: ${restoredCount}/${markers.size}개")
+    }
+    
+    /**
+     * 카메라 변경 시 호출되는 마커 재배치 처리
+     */
+    fun onCameraChanged(zoom: Double) {
+        val wasCollisionActive = zoom >= COLLISION_DETECTION_MIN_ZOOM
+        val prevZoom = naverMap.cameraPosition.zoom
+        val wasPrevCollisionActive = prevZoom >= COLLISION_DETECTION_MIN_ZOOM
+        
+        Log.d("MapClusterManager", "📷 카메라 변경: $prevZoom → $zoom")
+        
+        // 충돌 감지 임계값을 넘나들 때만 재배치
+        when {
+            !wasPrevCollisionActive && wasCollisionActive -> {
+                // 줌 인: 마커 재배치 시작
+                Log.e("MapClusterManager", "🔍 줌 인: 마커 재배치 시작 ($zoom ≥ $COLLISION_DETECTION_MIN_ZOOM)")
+                redistributeMarkersAvoidingPOI()
+            }
+            wasPrevCollisionActive && !wasCollisionActive -> {
+                // 줌 아웃: 마커 원위치 복원
+                Log.e("MapClusterManager", "🔍 줌 아웃: 마커 원위치 복원 ($zoom < $COLLISION_DETECTION_MIN_ZOOM)")
+                restoreMarkersToOriginalPositions()
+            }
+            wasCollisionActive && wasPrevCollisionActive -> {
+                // 고줌에서 이동/줌: 실시간 재배치
+                Log.d("MapClusterManager", "🔍 고줌 상태 변경: 실시간 재배치")
+                redistributeMarkersAvoidingPOI()
+            }
+            // else: 저줌 상태 유지 - 아무 작업 안함
+        }
+    }
 }
\ No newline at end of file
diff --git a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/POIMarkerManager.kt b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/POIMarkerManager.kt
index 1df4aad..e4abc1f 100644
--- a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/POIMarkerManager.kt
+++ b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/map/POIMarkerManager.kt
@@ -45,44 +45,34 @@ class POIMarkerManager(
     // POI 표시 여부 상태
     private var isPOIVisible = true // 테스트를 위해 기본값을 true로 변경
     
-    // 마커/클러스터 충돌 감지를 위한 위치 저장  
+    // 기존 마커 위치 저장 (호환성 유지)
     private var existingMarkerPositions = mutableListOf<LatLng>()
     private var currentZoomLevel = 16.0
     
-    // 현재 표시 중인 POI 데이터 저장 (재배치용)
+    // 현재 표시 중인 POI 데이터 저장 (위치 정보 제공용)
     private var currentPOIData = mutableListOf<POIData>()
     
-    // 화면 기반 충돌 감지 설정
-    private val COLLISION_DETECTION_MIN_ZOOM = 19.0  // 줌 19 이상에서만 충돌 감지
-    private val MARKER_COLLISION_RADIUS_PX = 60      // 마커 충돌 반경 (픽셀)
-    
     init {
         Log.d("POIMarkerManager", "POI 마커 매니저 초기화 완료")
     }
     
     /**
-     * 기존 마커/클러스터 위치 업데이트 + 실시간 POI 재배치
+     * POI 위치 정보 제공 (마커 충돌 감지를 위해)
+     */
+    fun getPOIPositions(): List<LatLng> {
+        return poiMarkers.map { it.position }
+    }
+    
+    /**
+     * 기존 마커 위치 정보 저장 (호환성 유지)
      */
     fun updateExistingMarkerPositions(positions: List<LatLng>, zoomLevel: Double) {
-        val wasCollisionActive = currentZoomLevel >= COLLISION_DETECTION_MIN_ZOOM
-        
         existingMarkerPositions.clear()
         existingMarkerPositions.addAll(positions)
         currentZoomLevel = zoomLevel
         
-        val isCollisionActive = currentZoomLevel >= COLLISION_DETECTION_MIN_ZOOM
-        
         Log.d("POIMarkerManager", "🏪 기존 마커 위치 업데이트: ${positions.size}개, 줌: $zoomLevel")
-        Log.d("POIMarkerManager", "🏪 충돌 감지 활성화: $isCollisionActive (줌 $COLLISION_DETECTION_MIN_ZOOM 이상)")
-        
-        // 줌 레벨이 충돌 감지 임계값을 넘나들거나, 이미 활성화 상태에서 마커 위치가 변경된 경우 POI 재배치
-        if (isCollisionActive && currentPOIData.isNotEmpty()) {
-            Log.w("POIMarkerManager", "🏪 🔄 실시간 POI 재배치 시작 (줌: $zoomLevel)")
-            redistributePOIMarkersRealtime()
-        } else if (!isCollisionActive && wasCollisionActive && currentPOIData.isNotEmpty()) {
-            Log.w("POIMarkerManager", "🏪 🔄 줌 아웃으로 POI 원위치 복원")
-            restorePOIToOriginalPositions()
-        }
+        Log.d("POIMarkerManager", "🏪 POI는 고정 위치 유지 - 재배치 없음")
         
         // 디버깅을 위해 첫 3개 위치 출력
         positions.take(3).forEachIndexed { index, position ->
@@ -91,13 +81,12 @@ class POIMarkerManager(
     }
     
     /**
-     * POI 마커들을 지도에 표시 (화면 좌표 기반 충돌 감지)
+     * POI 마커들을 지도에 표시 (고정 위치 - 충돌 감지 제거)
      */
     fun showPOIMarkers(pois: List<POIData>) {
         Log.w("POIMarkerManager", "🏪 === showPOIMarkers 호출됨 ===")
         Log.w("POIMarkerManager", "🏪 POI 가시성: $isPOIVisible")
         Log.w("POIMarkerManager", "🏪 요청된 POI: ${pois.size}개")
-        Log.w("POIMarkerManager", "🏪 현재 줌 레벨: $currentZoomLevel")
         
         if (!isPOIVisible) {
             Log.e("POIMarkerManager", "🏪 POI 비활성화 상태 - 마커 표시 스킵")
@@ -106,16 +95,12 @@ class POIMarkerManager(
         
         clearPOIMarkers()
         
-        // 현재 POI 데이터 저장 (실시간 재배치용)
+        // 현재 POI 데이터 저장 (위치 정보 제공용)
         currentPOIData.clear()
         currentPOIData.addAll(pois)
         
         var validCount = 0
         var skippedCount = 0
-        var offsetCount = 0
-        
-        val isCollisionDetectionActive = currentZoomLevel >= COLLISION_DETECTION_MIN_ZOOM
-        Log.w("POIMarkerManager", "🏪 충돌 감지 활성화: $isCollisionDetectionActive (줌 $COLLISION_DETECTION_MIN_ZOOM 이상)")
         
         pois.forEach { poi ->
             // 썸네일 URL이 없으면 마커를 표시하지 않음
@@ -128,24 +113,9 @@ class POIMarkerManager(
             val originalPosition = LatLng(poi.latitude, poi.longitude)
             Log.d("POIMarkerManager", "🏪 [DEBUG] POI 처리 시작: ${poi.name} - 위치: (${poi.latitude}, ${poi.longitude})")
             
-            // 화면 좌표 기반 충돌 감지 (줌 19 이상에서만)
-            val finalPosition = if (isCollisionDetectionActive) {
-                calculateOptimalPositionScreenBased(originalPosition, poi.name)
-            } else {
-                originalPosition // 줌이 낮으면 원위치
-            }
-            
-            if (finalPosition != originalPosition) {
-                offsetCount++
-                Log.e("POIMarkerManager", "🏪 ✨ POI 오프셋 적용됨: ${poi.name}")
-                Log.e("POIMarkerManager", "🏪 ✨ 원래: (${poi.latitude}, ${poi.longitude})")
-                Log.e("POIMarkerManager", "🏪 ✨ 최종: (${finalPosition.latitude}, ${finalPosition.longitude})")
-            } else {
-                Log.d("POIMarkerManager", "🏪 POI 오프셋 없음: ${poi.name}")
-            }
-            
+            // POI는 항상 원래 위치에 고정 표시
             val marker = Marker().apply {
-                position = finalPosition
+                position = originalPosition
                 map = naverMap
                 tag = poi
                 zIndex = 500 // 일반 마커보다 낮게 설정하여 겹치지 않도록
@@ -166,7 +136,7 @@ class POIMarkerManager(
             loadPOIImage(marker, poi.thumbnailUrl!!, poi.category)
         }
         
-        Log.d("POIMarkerManager", "🏪 POI 마커 처리 완료 - 유효: ${validCount}개, 스킵: ${skippedCount}개, 오프셋: ${offsetCount}개")
+        Log.d("POIMarkerManager", "🏪 POI 마커 처리 완료 - 유효: ${validCount}개, 스킵: ${skippedCount}개 (고정 위치)")
     }
     
     /**
@@ -599,141 +569,4 @@ class POIMarkerManager(
         return earthRadius * c
     }
     
-    // ===== 🆕 화면 좌표 기반 충돌 감지 시스템 =====
-    
-    /**
-     * 화면 좌표 기반 POI 최적 위치 계산 (줌 19 이상)
-     */
-    private fun calculateOptimalPositionScreenBased(originalPosition: LatLng, poiName: String): LatLng {
-        Log.e("POIMarkerManager", "🏪 🖼️ === 화면 기반 위치 계산 시작 ===")
-        Log.e("POIMarkerManager", "🏪 🖼️ POI: $poiName")
-        Log.e("POIMarkerManager", "🏪 🖼️ 줌: $currentZoomLevel (임계값: $COLLISION_DETECTION_MIN_ZOOM)")
-        Log.e("POIMarkerManager", "🏪 🖼️ 기존 마커: ${existingMarkerPositions.size}개")
-        
-        if (existingMarkerPositions.isEmpty()) {
-            Log.e("POIMarkerManager", "🏪 🖼️ 기존 마커 없음 - 원위치 사용")
-            return originalPosition
-        }
-        
-        // 1. POI 원래 위치를 화면 좌표로 변환
-        val poiScreenPoint = naverMap.projection.toScreenLocation(originalPosition)
-        Log.e("POIMarkerManager", "🏪 🖼️ POI 화면 좌표: (${poiScreenPoint.x}, ${poiScreenPoint.y})")
-        
-        // 2. 기존 마커들의 화면 좌표 계산
-        val existingScreenPoints = existingMarkerPositions.map { position ->
-            naverMap.projection.toScreenLocation(position)
-        }
-        
-        // 3. 화면상 충돌 감지
-        var hasCollision = false
-        existingScreenPoints.forEachIndexed { index, screenPoint ->
-            val pixelDistance = sqrt(
-                (poiScreenPoint.x - screenPoint.x).toDouble().pow(2) + 
-                (poiScreenPoint.y - screenPoint.y).toDouble().pow(2)
-            )
-            Log.e("POIMarkerManager", "🏪 🖼️ 마커[$index] 픽셀 거리: ${pixelDistance.toInt()}px (충돌 반경: ${MARKER_COLLISION_RADIUS_PX}px)")
-            
-            if (pixelDistance <= MARKER_COLLISION_RADIUS_PX) {
-                hasCollision = true
-                Log.e("POIMarkerManager", "🏪 🚨 화면상 충돌 감지! 마커[$index]: ${pixelDistance.toInt()}px ≤ ${MARKER_COLLISION_RADIUS_PX}px")
-            }
-        }
-        
-        if (!hasCollision) {
-            Log.e("POIMarkerManager", "🏪 🖼️ 충돌 없음 - 원위치 사용")
-            return originalPosition
-        }
-        
-        // 4. 충돌 시 오프셋 적용
-        Log.e("POIMarkerManager", "🏪 🚨 충돌 감지됨! 화면 기반 오프셋 계산")
-        
-        val offsetDistance = MARKER_COLLISION_RADIUS_PX + 20 // 여유 공간
-        val angles = listOf(0, 45, 90, 135, 180, 225, 270, 315) // 8방향
-        
-        for (angle in angles) {
-            val radians = Math.toRadians(angle.toDouble())
-            val offsetX = cos(radians) * offsetDistance
-            val offsetY = sin(radians) * offsetDistance
-            
-            val offsetScreenPoint = android.graphics.PointF(
-                (poiScreenPoint.x + offsetX).toFloat(),
-                (poiScreenPoint.y + offsetY).toFloat()
-            )
-            
-            // 오프셋된 화면 좌표를 지리 좌표로 변환
-            val offsetPosition = naverMap.projection.fromScreenLocation(offsetScreenPoint)
-            
-            // 오프셋 위치에서도 충돌 체크
-            var offsetHasCollision = false
-            existingScreenPoints.forEach { screenPoint ->
-                val pixelDistance = sqrt(
-                    (offsetScreenPoint.x - screenPoint.x).toDouble().pow(2) + 
-                    (offsetScreenPoint.y - screenPoint.y).toDouble().pow(2)
-                )
-                if (pixelDistance <= MARKER_COLLISION_RADIUS_PX) {
-                    offsetHasCollision = true
-                }
-            }
-            
-            if (!offsetHasCollision) {
-                Log.e("POIMarkerManager", "🏪 ✅ 화면 기반 오프셋 위치 찾음: ${angle}도")
-                Log.e("POIMarkerManager", "🏪 ✅ 화면 좌표: (${offsetScreenPoint.x}, ${offsetScreenPoint.y})")
-                Log.e("POIMarkerManager", "🏪 ✅ 지리 좌표: (${offsetPosition.latitude}, ${offsetPosition.longitude})")
-                return offsetPosition
-            }
-        }
-        
-        Log.e("POIMarkerManager", "🏪 ❌ 모든 오프셋 위치에 충돌 - 원위치 강제 사용")
-        return originalPosition
-    }
-    
-    /**
-     * 실시간 POI 재배치 (줌/이동 시 호출)
-     */
-    private fun redistributePOIMarkersRealtime() {
-        if (currentPOIData.isEmpty()) return
-        
-        Log.e("POIMarkerManager", "🏪 🔄 === 실시간 POI 재배치 ===")
-        Log.e("POIMarkerManager", "🏪 🔄 대상 POI: ${currentPOIData.size}개")
-        
-        var repositionedCount = 0
-        
-        poiMarkers.forEachIndexed { index, marker ->
-            val poi = marker.tag as? POIData ?: return@forEachIndexed
-            val originalPosition = LatLng(poi.latitude, poi.longitude)
-            val newPosition = calculateOptimalPositionScreenBased(originalPosition, poi.name)
-            
-            if (newPosition != originalPosition) {
-                marker.position = newPosition
-                repositionedCount++
-                Log.e("POIMarkerManager", "🏪 🔄 POI 재배치: ${poi.name}")
-            }
-        }
-        
-        Log.e("POIMarkerManager", "🏪 🔄 재배치 완료: ${repositionedCount}/${poiMarkers.size}개")
-    }
-    
-    /**
-     * POI를 원래 위치로 복원 (줌 아웃 시)
-     */
-    private fun restorePOIToOriginalPositions() {
-        if (currentPOIData.isEmpty()) return
-        
-        Log.e("POIMarkerManager", "🏪 🔄 === POI 원위치 복원 ===")
-        
-        var restoredCount = 0
-        
-        poiMarkers.forEach { marker ->
-            val poi = marker.tag as? POIData ?: return@forEach
-            val originalPosition = LatLng(poi.latitude, poi.longitude)
-            
-            if (marker.position != originalPosition) {
-                marker.position = originalPosition
-                restoredCount++
-                Log.e("POIMarkerManager", "🏪 🔄 POI 원위치 복원: ${poi.name}")
-            }
-        }
-        
-        Log.e("POIMarkerManager", "🏪 🔄 원위치 복원 완료: ${restoredCount}/${poiMarkers.size}개")
-    }
 }
\ No newline at end of file
diff --git a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/screens/FullMapScreen.kt b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/screens/FullMapScreen.kt
index 627c837..6302b5f 100644
--- a/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/screens/FullMapScreen.kt
+++ b/android/campung/app/src/main/java/com/shinhan/campung/presentation/ui/screens/FullMapScreen.kt
@@ -695,28 +695,30 @@ fun FullMapScreen(
                                 naverMapRef = map
                                 mapInitializer.setupMapUI(map)
 
-                                android.util.Log.d("FullMapScreen", "🚀 [INIT] ClusterManager 생성 시작")
-                                clusterManager =
-                                    clusterManagerInitializer.createClusterManager(map) { centerContent ->
-                                        highlightedContent = centerContent
-                                    }
-                                android.util.Log.d("FullMapScreen", "✅ [INIT] ClusterManager 생성 완료")
-                                android.util.Log.d("FullMapScreen", "🔗 [INIT] clusterManager.onMarkerClick: ${clusterManager?.onMarkerClick}")
-
-                                // POI 마커 매니저 초기화
+                                // POI 마커 매니저 먼저 초기화
+                                android.util.Log.d("FullMapScreen", "🏪 [INIT] POI 마커 매니저 생성 시작")
                                 poiMarkerManager = POIMarkerManager(context, map, coroutineScope).apply {
                                     onPOIClick = { poi ->
                                         android.util.Log.d("FullMapScreen", "🏪 POI 마커 클릭됨: ${poi.name}")
                                         mapViewModel.onPOIClick(poi)
                                     }
                                 }
+                                android.util.Log.d("FullMapScreen", "✅ [INIT] POI 마커 매니저 생성 완료")
+
+                                android.util.Log.d("FullMapScreen", "🚀 [INIT] ClusterManager 생성 시작")
+                                clusterManager =
+                                    clusterManagerInitializer.createClusterManager(map, null, { centerContent ->
+                                        highlightedContent = centerContent
+                                    }, poiMarkerManager)
+                                android.util.Log.d("FullMapScreen", "✅ [INIT] ClusterManager 생성 완료")
+                                android.util.Log.d("FullMapScreen", "🔗 [INIT] clusterManager.onMarkerClick: ${clusterManager?.onMarkerClick}")
 
-                                // 클러스터 매니저와 POI 매니저 연결 (마커 위치 동기화)
+                                // 클러스터 매니저와 POI 매니저 연결 (마커 위치 동기화 - 호환성 유지)
                                 clusterManager?.onMarkerPositionsUpdated = { positions, zoomLevel ->
                                     android.util.Log.d("FullMapScreen", "🎯 클러스터 → POI 위치 동기화: ${positions.size}개, 줌: $zoomLevel")
                                     poiMarkerManager?.updateExistingMarkerPositions(positions, zoomLevel)
                                 }
-                                android.util.Log.d("FullMapScreen", "🏪 POI 마커 매니저 초기화 완료")
+                                android.util.Log.d("FullMapScreen", "🏪✅ POI 매니저와 클러스터 매니저 연결 완료")
 
                                 // 👇 카메라가 '움직이는 동안' 계속 호출됨: 아이콘 실시간 갱신
                                 map.addOnCameraChangeListener { _, _ ->