feat: initial make-space full-stack release with weighted multi-provider LLM and Dockerfile

This commit is contained in:
dahyeon committed 2026-11-04 20:49:24 +09:00
commit 37b323c9ac
55 files changed
+17087

No files matched your search

+849
View File
@@ -0,0 +1,849 @@
//! The responsive place workspace keeps the scene and its selection mounted across widths.
use crate::Icon;
#[cfg(feature = "hydrate")]
use crate::{scene_bridge, ui_bridge};
use domain::{Floor, Layout, PhotoKind, PhotoSummary, Tri, ROOFTOP_LEVEL};
use leptos::prelude::*;
#[derive(Clone, Debug)]
struct PhotoSelection {
title: String,
photos: Vec<PhotoSummary>,
zone: Option<(i32, String)>,
}
fn short_floor_label(floor: &Floor) -> String {
let base = match floor.level {
ROOFTOP_LEVEL => "옥상".to_string(),
n if n < 0 => format!("B{}", n.unsigned_abs()),
0 => "층 미확인".to_string(),
n => format!("{n}층"),
};
if floor_is_uncertain(floor) {
format!("{base}(추정)")
} else {
base
}
}
fn floor_is_uncertain(floor: &Floor) -> bool {
let uncertain = |text: &str| {
[
"임시",
"추정",
"미확인",
"확인되지",
"확인 안",
"불명",
"가정",
"가능성",
"알 수 없",
"증거 없",
]
.iter()
.any(|word| text.contains(word))
};
if uncertain(&floor.label) {
return true;
}
floor.notes.split(['.', '。', '\n', ';']).any(|sentence| {
// Uncertain window positions or room dimensions do not make the floor number uncertain.
let floor_assignment = sentence.contains('층')
&& [
"촬영",
"배정",
"층수",
"층 위치",
"층 정보",
"어느 층",
"실제 층",
"층인지",
"상층",
]
.iter()
.any(|word| sentence.contains(word));
floor_assignment && uncertain(sentence)
})
}
/// Replace implementation IDs without removing the surrounding evidence or warnings.
fn readable_evidence(text: &str, photos: &[PhotoSummary]) -> String {
let mut out = String::with_capacity(text.len());
let mut rest = text;
while !rest.is_empty() {
if rest.starts_with("p_") {
let end = rest
.find(|c: char| !(c.is_ascii_alphanumeric() || c == '_' || c == '-'))
.unwrap_or(rest.len());
let token = &rest[..end];
if token.len() > 2 {
if let Some(photo) = photos.iter().find(|p| p.id == token) {
out.push_str(&format!("{} 참고 사진", photo.source.label()));
} else {
out.push_str("참고 사진");
}
rest = &rest[end..];
continue;
}
}
let ch = rest.chars().next().expect("nonempty text");
out.push(ch);
rest = &rest[ch.len_utf8()..];
}
out
}
fn unique_text(items: Vec<String>, photos: &[PhotoSummary]) -> Vec<String> {
let mut seen = std::collections::HashSet::new();
items
.into_iter()
.map(|s| readable_evidence(s.trim(), photos))
.filter(|s| !s.is_empty())
.filter(|s| {
let key: String = s
.chars()
.filter(|c| !c.is_whitespace() && !matches!(c, '·' | ',' | '.' | '-'))
.flat_map(char::to_lowercase)
.collect();
seen.insert(key)
})
.collect()
}
fn brief(text: &str, max: usize) -> String {
if text.chars().count() <= max {
text.to_string()
} else {
format!("{}…", text.chars().take(max).collect::<String>().trim_end())
}
}
fn photo_caption(photo: &PhotoSummary) -> String {
if !photo.description.trim().is_empty() {
photo.description.clone()
} else if !photo.caption.trim().is_empty() {
photo.caption.clone()
} else {
match photo.kind {
Some(PhotoKind::Exterior) => "건물 외관 사진".to_string(),
Some(PhotoKind::Interior) => "공간 내부 사진".to_string(),
_ => "공간 확인에 사용된 사진".to_string(),
}
}
}
fn source_url(photo: &PhotoSummary) -> Option<String> {
(photo.page_url.starts_with("https://") || photo.page_url.starts_with("http://"))
.then(|| photo.page_url.clone())
}
fn accessibility_label(value: Tri) -> &'static str {
match value {
Tri::Unknown => "미확인",
Tri::Likely => "있을 가능성 · 확인 필요",
Tri::Yes => "있음",
Tri::No => "없음",
}
}
#[component]
fn PhotoImage(
photo: PhotoSummary,
#[prop(default = "lazy")] loading: &'static str,
) -> impl IntoView {
let (failed, set_failed) = signal(false);
let alt = brief(&photo_caption(&photo), 120);
view! {
<div class="image-shell">
<img
src=format!("/api/photos/{}", photo.id)
alt=alt
loading=loading
decoding="async"
hidden=move || failed.get()
on:error=move |_| set_failed.set(true)
/>
<span class="image-fallback" hidden=move || !failed.get()>
<Icon name="photo"/>"사진을 불러오지 못했습니다."
</span>
</div>
}
}
#[component]
fn PhotoCaption(photo: PhotoSummary) -> impl IntoView {
let caption = photo_caption(&photo);
let has_more = caption.chars().count() > 90;
view! {
<div class="photo-caption">
<p>{brief(&caption, 90)}</p>
{has_more.then(|| view! {
<details class="photo-description">
<summary>"설명 더 보기"</summary>
<p>{caption}</p>
</details>
})}
{match source_url(&photo) {
Some(url) => view! {
<a class="photo-source" href=url target="_blank" rel="noopener noreferrer">
{format!("원문 보기 · {}", photo.source.label())}
<span class="sr-only">" (새 탭)"</span>
</a>
}.into_any(),
None => view! { <span class="photo-source">{photo.source.label()}</span> }.into_any(),
}}
</div>
}
}
#[component]
pub(crate) fn WorkspaceView(layout: Layout, photos: Vec<PhotoSummary>) -> impl IntoView {
let (active_floor, set_active_floor) = signal(0i32);
let (view_mode, set_view_mode) = signal("iso");
let (mobile_panel, set_mobile_panel) = signal("layout");
let (scene_interactive, set_scene_interactive) = signal(false);
let (scene_error, set_scene_error) = signal(Option::<String>::None);
let (scene_retry, set_scene_retry) = signal(0u32);
let (scene_fullscreen, set_scene_fullscreen) = signal(false);
let (selection, set_selection) = signal(Option::<PhotoSelection>::None);
let (photo_index, set_photo_index) = signal(0usize);
let (photo_open, set_photo_open) = signal(false);
let canvas_ref = NodeRef::<leptos::html::Canvas>::new();
let clean_photos = photos
.iter()
.cloned()
.map(|mut p| {
p.description = readable_evidence(&p.description, &photos);
p.caption = readable_evidence(&p.caption, &photos);
p
})
.collect::<Vec<_>>();
let photo_store = StoredValue::new(clean_photos.clone());
let floor_store = StoredValue::new(layout.floors.clone());
let interior_photos = clean_photos
.iter()
.filter(|p| {
matches!(
p.kind,
Some(PhotoKind::Interior | PhotoKind::Exterior) | None
)
})
.cloned()
.collect::<Vec<_>>();
let gallery_store = StoredValue::new(interior_photos.clone());
let choose_zone = Callback::new(move |(level, label, ids): (i32, String, Vec<String>)| {
let photos = photo_store.with_value(|all| {
all.iter()
.filter(|p| ids.contains(&p.id))
.cloned()
.collect::<Vec<_>>()
});
set_selection.set(Some(PhotoSelection {
title: label.clone(),
photos,
zone: Some((level, label)),
}));
set_photo_index.set(0);
#[cfg(feature = "hydrate")]
{
if ui_bridge::is_compact() || scene_fullscreen.get_untracked() {
set_photo_open.set(true);
} else {
ui_bridge::reveal_selected_photo();
}
}
});
let choose_floor = Callback::new(move |level: i32| {
set_active_floor.set(level);
let keep = selection.with_untracked(|current| {
current
.as_ref()
.and_then(|s| s.zone.as_ref())
.is_none_or(|(selected_level, _)| level == 0 || *selected_level == level)
});
if !keep {
set_selection.set(None);
set_photo_open.set(false);
}
});
let show_gallery = Callback::new(move |index: usize| {
set_selection.set(Some(PhotoSelection {
title: "공간 사진".into(),
photos: gallery_store.get_value(),
zone: None,
}));
set_photo_index.set(index);
set_photo_open.set(true);
});
#[cfg(feature = "hydrate")]
let (scene_id, set_scene_id) = signal(Option::<u32>::None);
#[cfg(feature = "hydrate")]
{
let layout_json = serde_json::to_string(&layout).unwrap_or_default();
Effect::new(move |_| {
let _ = scene_retry.get();
let Some(canvas) = canvas_ref.get() else {
return;
};
set_scene_error.set(None);
let id = scene_bridge::mount_scene(canvas.clone(), &layout_json, move |label, ids| {
let level = floor_store.with_value(|floors| {
floors
.iter()
.filter(|f| {
active_floor.get_untracked() == 0
|| f.level == active_floor.get_untracked()
})
.find(|f| {
f.zones
.iter()
.any(|z| z.label == label && z.evidence_photos == ids)
})
.or_else(|| {
floors
.iter()
.find(|f| f.zones.iter().any(|z| z.label == label))
})
.map_or(0, |f| f.level)
});
choose_zone.run((level, label, ids));
});
if id == 0 {
set_scene_error.set(Some("공간 화면을 불러오지 못했습니다.".into()));
set_scene_id.set(None);
} else {
set_scene_id.set(Some(id));
// These are untracked so changing a control does not recreate the renderer.
scene_bridge::set_floor(id, active_floor.get_untracked());
scene_bridge::set_view_mode(id, view_mode.get_untracked());
}
let watch = scene_bridge::watch_scene(canvas, move |error| set_scene_error.set(error));
on_cleanup(move || {
if let Some(watch) = watch {
scene_bridge::unwatch_scene(watch);
}
if id != 0 {
scene_bridge::dispose_scene(id);
}
});
});
Effect::new(move |_| {
let level = active_floor.get();
if let Some(id) = scene_id.get() {
scene_bridge::set_floor(id, level);
}
});
Effect::new(move |_| {
let mode = view_mode.get();
if let Some(id) = scene_id.get() {
scene_bridge::set_view_mode(id, mode);
}
});
Effect::new(move |_| {
let current = selection.get();
if let Some(id) = scene_id.get() {
if let Some(s) = current.filter(|s| s.zone.is_some()) {
let ids = s.photos.iter().map(|p| p.id.clone()).collect::<Vec<_>>();
scene_bridge::highlight_zone(id, &s.title, &ids);
} else {
scene_bridge::highlight_zone(id, "", &[]);
}
}
});
let photo_handle = StoredValue::new(None::<u32>);
Effect::new(move |_| {
if photo_open.get() {
if photo_handle.get_value().is_none() {
let handle = ui_bridge::open_dialog("space-photo-dialog", move || {
set_photo_open.set(false)
});
photo_handle.set_value(handle);
}
} else if let Some(handle) = photo_handle.get_value() {
ui_bridge::close_dialog("space-photo-dialog");
ui_bridge::release_dialog(handle);
photo_handle.set_value(None);
}
});
let scene_handle = StoredValue::new(None::<u32>);
Effect::new(move |_| {
if scene_fullscreen.get() {
if scene_handle.get_value().is_none() {
let handle = ui_bridge::open_dialog("space-scene-dialog", move || {
set_scene_fullscreen.set(false)
});
scene_handle.set_value(handle);
}
} else if let Some(handle) = scene_handle.get_value() {
ui_bridge::close_dialog("space-scene-dialog");
ui_bridge::release_dialog(handle);
scene_handle.set_value(None);
}
});
let resize_watch = ui_bridge::watch_compact(move |compact| {
if !compact
&& !scene_fullscreen.get_untracked()
&& selection.with_untracked(|s| s.as_ref().is_some_and(|s| s.zone.is_some()))
{
set_photo_open.set(false);
}
});
on_cleanup(move || {
if let Some(handle) = photo_handle.get_value() {
ui_bridge::release_dialog(handle);
}
if let Some(handle) = scene_handle.get_value() {
ui_bridge::release_dialog(handle);
}
if let Some(handle) = resize_watch {
ui_bridge::release_watch(handle);
}
});
}
#[cfg(not(feature = "hydrate"))]
let _ = (
scene_retry,
set_scene_error,
photo_open,
scene_fullscreen,
floor_store,
);
let floors_for_tabs = layout.floors.clone();
let floors_for_notes = layout.floors.clone();
let many_floors = floors_for_tabs.len() > 4;
let caveats = unique_text(layout.summary.caveats.clone(), &photos);
let all_evidence = format!(
"{} {}",
caveats.join(" "),
layout
.floors
.iter()
.map(|f| f.notes.as_str())
.collect::<Vec<_>>()
.join(" ")
);
let uncertain_branch = [
"다른 지점",
"타 지점",
"타지점",
"지점 혼",
"지점 불일치",
"지점이 불명",
]
.iter()
.any(|s| all_evidence.contains(s));
let uncertain_floor = layout.floors.iter().any(floor_is_uncertain);
let warning = match (uncertain_branch, uncertain_floor) {
(true, true) => "층·지점 정보 확인 필요 · 추정 배치",
(true, false) => "지점 정보 확인 필요 · 추정 배치",
(false, true) => "층 정보 확인 필요 · 추정 배치",
(false, false) => "사진·리뷰로 추정한 배치",
};
let seat_types = unique_text(layout.summary.seat_types.clone(), &photos);
let highlights = unique_text(layout.summary.highlights.clone(), &photos);
let more_highlights = highlights.iter().skip(3).cloned().collect::<Vec<_>>();
let brief_highlights = highlights.iter().take(3).cloned().collect::<Vec<_>>();
let floor_count = layout.floors.len();
let floor_summary = layout
.floors
.iter()
.map(short_floor_label)
.collect::<Vec<_>>()
.join(" · ");
let confidence = if layout.confidence.is_finite() {
format!(
"분석 모델이 보고한 신뢰도 {:.0}%",
layout.confidence.clamp(0.0, 1.0) * 100.0
)
} else {
"분석 모델 신뢰도 미제공".into()
};
let gallery_total = interior_photos.len();
view! {
<div class="workspace-switcher" role="group" aria-label="공간 보기">
<button type="button" aria-controls="layout-panel"
aria-pressed=move || (mobile_panel.get() == "layout").to_string()
on:click=move |_| set_mobile_panel.set("layout")>"공간 배치"</button>
<button type="button" aria-controls="info-panel"
aria-pressed=move || (mobile_panel.get() == "info").to_string()
on:click=move |_| { set_mobile_panel.set("info"); set_scene_interactive.set(false); }>"공간 정보"</button>
</div>
<p class="workspace-warning"><Icon name="info"/>{warning}</p>
<div class="workspace-grid" data-mobile-panel=move || mobile_panel.get()>
<section class="viewport-col" id="layout-panel" aria-label="공간 배치">
<div class="viewport-toolbar">
{if many_floors {
view! {
<label class="floor-select-label"><span class="sr-only">"표시할 층"</span>
<select class="floor-select" prop:value=move || active_floor.get().to_string()
on:change=move |ev| choose_floor.run(event_target_value(&ev).parse().unwrap_or(0))>
<option value="0">"전체 층"</option>
{floors_for_tabs.iter().map(|f| view! {
<option value=f.level.to_string()>{short_floor_label(f)}</option>
}).collect_view()}
</select>
</label>
}.into_any()
} else {
view! {
<div class="floor-tabs" role="group" aria-label="표시할 층">
<button type="button" class="tab" aria-pressed=move || (active_floor.get() == 0).to_string()
on:click=move |_| choose_floor.run(0)>"전체"</button>
{floors_for_tabs.iter().map(|f| {
let level = f.level;
view! {
<button type="button" class="tab" aria-pressed=move || (active_floor.get() == level).to_string()
on:click=move |_| choose_floor.run(level)>{short_floor_label(f)}</button>
}
}).collect_view()}
</div>
}.into_any()
}}
<div class="view-modes" role="group" aria-label="보기 방식">
<button type="button" class="tab" aria-pressed=move || (view_mode.get() == "iso").to_string()
on:click=move |_| set_view_mode.set("iso")>"3D"</button>
<button type="button" class="tab" aria-pressed=move || (view_mode.get() == "plan").to_string()
on:click=move |_| set_view_mode.set("plan")>"평면도"</button>
</div>
</div>
<dialog id="space-scene-dialog" class="scene-dialog" open data-inline-dialog="true"
role=move || if scene_fullscreen.get() { "dialog" } else { "region" }
aria-label="공간 배치 화면">
<div class="scene-dialog-header" hidden=move || !scene_fullscreen.get()>
<strong>{move || if view_mode.get() == "plan" { "평면도" } else { "3D 공간" }}</strong>
<button type="button" class="btn-close" on:click=move |_| set_scene_fullscreen.set(false)>"전체 화면 닫기"<Icon name="close"/></button>
</div>
<div class="canvas-holder" data-scene-failed=move || scene_error.get().is_some().to_string()>
<canvas node_ref=canvas_ref class="scene-canvas"
data-interactive=move || scene_interactive.get().to_string()
aria-label=move || if view_mode.get() == "plan" {
"층별 평면도. 아래 구역 버튼에서도 사진을 확인할 수 있습니다."
} else {
"층별 3D 공간. 아래 구역 버튼에서도 사진을 확인할 수 있습니다."
}></canvas>
<div class="scene-tools" role="group" aria-label="공간 화면 조절" hidden=move || scene_error.get().is_some()>
<button type="button" class="scene-tool" aria-label="확대" title="확대" on:click=move |_| {
#[cfg(feature = "hydrate")]
if let Some(id) = scene_id.get_untracked() { scene_bridge::zoom_scene(id, 1.0); }
}>"+"</button>
<button type="button" class="scene-tool" aria-label="축소" title="축소" on:click=move |_| {
#[cfg(feature = "hydrate")]
if let Some(id) = scene_id.get_untracked() { scene_bridge::zoom_scene(id, -1.0); }
}>"−"</button>
<button type="button" class="scene-tool" aria-label="시점 초기화" title="시점 초기화" on:click=move |_| {
#[cfg(feature = "hydrate")]
if let Some(id) = scene_id.get_untracked() { scene_bridge::reset_scene(id); }
}><Icon name="refresh"/></button>
<button type="button" class="scene-tool scene-expand" aria-label=move || if scene_fullscreen.get() { "전체 화면 닫기" } else { "전체 화면 보기" }
on:click=move |_| set_scene_fullscreen.update(|open| *open = !*open)>
{move || if scene_fullscreen.get() { "축소 보기" } else { "전체 화면" }}
</button>
</div>
<button type="button" class="scene-interaction-toggle"
hidden=move || scene_error.get().is_some()
aria-pressed=move || scene_interactive.get().to_string()
on:click=move |_| set_scene_interactive.update(|active| *active = !*active)>
{move || if scene_interactive.get() { "조작 종료" } else if view_mode.get() == "plan" { "이동·확대" } else { "회전·확대" }}
</button>
<div class="canvas-hint" hidden=move || scene_error.get().is_some()>
<span class="hint-pointer">{move || if view_mode.get() == "plan" {
"드래그로 이동 · 휠로 확대 · 핀으로 사진"
} else { "드래그로 회전 · 휠로 확대 · 핀으로 사진" }}</span>
<span class="hint-touch">{move || match (scene_interactive.get(), view_mode.get()) {
(true, "plan") => "한 손가락 이동 · 두 손가락 확대",
(true, _) => "한 손가락 회전 · 두 손가락 확대·이동",
(false, _) if scene_fullscreen.get() => "핀을 누르면 사진 · 조작 버튼으로 이동·확대",
(false, _) => "핀을 누르면 사진 · 위아래로 화면 스크롤",
}}</span>
</div>
{move || scene_error.get().map(|_| view! {
<div class="scene-failure" role="status">
<strong>"공간 화면을 불러오지 못했습니다."</strong>
<p>"사진과 공간 정보는 계속 확인할 수 있습니다."</p>
<div>
<button type="button" class="btn-secondary" on:click=move |_| set_scene_retry.update(|n| *n += 1)>"다시 불러오기"</button>
<button type="button" class="btn-secondary" on:click=move |_| {
set_scene_fullscreen.set(false);
set_mobile_panel.set("info");
}>"공간 정보 보기"</button>
</div>
</div>
})}
</div>
</dialog>
{move || selection.get().map(|s| view! {
<button type="button" class="selected-zone-mobile" on:click=move |_| set_photo_open.set(true)>
<Icon name="photo"/>
<span>{format!("{} · 사진 {}장", brief(&s.title, 24), s.photos.len())}</span>
<span>"보기"</span>
</button>
})}
<div class="floor-notes" aria-label="층별 구역">
{floors_for_notes.into_iter().map(|floor| {
let level = floor.level;
let notes = readable_evidence(&floor.notes, &photos);
let original_label = readable_evidence(&floor.label, &photos);
let short_label = short_floor_label(&floor);
let show_original = original_label != short_label && original_label != format!("{}F", level);
view! {
<section class="floor-note-card" hidden=move || active_floor.get() != 0 && active_floor.get() != level>
<div class="floor-note-head">
<h3>{short_label}</h3>
<span>{format!("약 {:.0}m × {:.0}m", floor.width_m, floor.depth_m)}</span>
</div>
<div class="zone-chips">
{floor.zones.into_iter().map(|zone| {
let label = zone.label.clone();
let label_for_selected = label.clone();
let ids = zone.evidence_photos;
let has_photos = clean_photos.iter().any(|p| ids.contains(&p.id));
if has_photos {
view! {
<button type="button" class="zone-chip"
aria-pressed=move || selection.with(|s| s.as_ref().and_then(|s| s.zone.as_ref()).is_some_and(|(l, name)| *l == level && name == &label_for_selected)).to_string()
on:click=move |_| choose_zone.run((level, label.clone(), ids.clone()))>
{zone.label}<Icon name="photo"/>
</button>
}.into_any()
} else {
view! { <span class="zone-empty">{zone.label}<span>"사진 없음"</span></span> }.into_any()
}
}).collect_view()}
</div>
{(!notes.is_empty() || show_original).then(|| view! {
<details class="summary-details floor-details">
<summary>"층 정보와 추정 근거"</summary>
{show_original.then(|| view! { <p>{original_label}</p> })}
{(!notes.is_empty()).then(|| view! { <p>{notes}</p> })}
<p class="confidence-explanation">{format!("분석 모델이 보고한 층 신뢰도 {:.0}%. 실제 정확도를 검증한 확률은 아닙니다.", floor.confidence.clamp(0.0, 1.0) * 100.0)}</p>
</details>
})}
</section>
}
}).collect_view()}
</div>
</section>
<aside class="summary-col" id="info-panel" aria-label="공간 정보">
{move || selection.get().map(|s| {
let total = s.photos.len();
let selected_photos = StoredValue::new(s.photos.clone());
view! {
<section class="summary-card selected-zone-panel" aria-label="선택한 구역 사진">
<div class="pin-drawer-head">
<h3>{s.title.clone()}</h3>
<button type="button" class="btn-close" aria-label="선택한 사진 닫기" on:click=move |_| set_selection.set(None)><Icon name="close"/></button>
</div>
<p class="photo-count">{format!("사진 {}장", total)}</p>
<button type="button" class="selected-photo-preview" aria-label="선택한 사진 크게 보기" hidden=total == 0 on:click=move |_| set_photo_open.set(true)>
{move || selected_photos.with_value(|photos| photos.get(photo_index.get()).cloned()).map(|p| view! { <PhotoImage photo=p loading="eager"/> })}
</button>
{move || selected_photos.with_value(|photos| photos.get(photo_index.get()).cloned()).map(|p| view! { <PhotoCaption photo=p/> })}
{(total > 1).then(|| view! {
<div class="photo-navigation">
<button type="button" class="btn-secondary" disabled=move || photo_index.get() == 0 on:click=move |_| set_photo_index.update(|n| *n = n.saturating_sub(1))>"이전"</button>
<span>{move || format!("{} / {}", photo_index.get() + 1, total)}</span>
<button type="button" class="btn-secondary" disabled=move || { photo_index.get() + 1 >= total } on:click=move |_| set_photo_index.update(|n| *n = (*n + 1).min(total.saturating_sub(1)))>"다음"</button>
</div>
})}
{(total == 0).then(|| view! { <p class="photo-empty">"이 구역에 연결된 사진이 없습니다."</p> })}
</section>
}
})}
<section class="summary-card">
<h3>"공간 정보"</h3>
<div class="metric-grid">
<div class="metric"><span class="metric-label">"추정 면적"</span>
<strong class="metric-val">{if layout.summary.area_pyeong_max > 0.0 {
format!("약 {:.0}~{:.0}평", layout.summary.area_pyeong_min, layout.summary.area_pyeong_max)
} else { "미확인".into() }}</strong>
</div>
<div class="metric"><span class="metric-label">"추정 좌석 수"</span>
<strong class="metric-val">{if layout.summary.seat_estimate > 0 {
format!("약 {}석", layout.summary.seat_estimate)
} else { "미확인".into() }}</strong>
</div>
</div>
<div class="summary-floor-count"><strong>{format!("추정 {}개 층", floor_count)}</strong><span>{floor_summary}</span></div>
<div class="summary-section">
<h4>"확인할 정보"</h4>
<p class="evidence-warning">{warning}"입니다. 실제 배치와 다를 수 있습니다."</p>
<details class="summary-details">
<summary>"참고사항과 분석 근거"</summary>
{(!caveats.is_empty()).then(|| view! {
<ul class="bullet-list">{caveats.into_iter().map(|c| view! { <li>{c}</li> }).collect_view()}</ul>
})}
<p>{confidence}</p>
<p class="confidence-explanation">"이 수치는 분석 모델의 자체 평가입니다. 현장 실측으로 보정한 정확도나 실제 배치가 맞을 확률이 아닙니다."</p>
</details>
</div>
{(!seat_types.is_empty()).then(|| view! {
<div class="summary-section"><h4>"좌석 구성 · 전체 층"</h4>
<div class="tag-row">{seat_types.into_iter().map(|s| view! { <span class="badge">{s}</span> }).collect_view()}</div>
</div>
})}
<div class="summary-section">
<h4>"접근성"</h4>
<dl class="fact-list">
<div><dt>"엘리베이터"</dt><dd>{accessibility_label(layout.summary.accessibility.elevator)}</dd></div>
<div><dt>"무단차 출입구"</dt><dd>{accessibility_label(layout.summary.accessibility.step_free_entrance)}</dd></div>
</dl>
<p class="accessibility-note">"미확인은 시설이 없다는 뜻이 아닙니다. 방문 전 장소에 확인해 주세요."</p>
</div>
{(!brief_highlights.is_empty()).then(|| view! {
<div class="summary-section"><h4>"공간 특징"</h4>
<ul class="bullet-list">{brief_highlights.into_iter().map(|h| view! { <li>{brief(&h, 100)}</li> }).collect_view()}</ul>
{(!more_highlights.is_empty() || highlights.iter().any(|h| h.chars().count() > 100)).then(|| view! {
<details class="summary-details"><summary>"특징 전체 보기"</summary>
<ul class="bullet-list">{highlights.into_iter().map(|h| view! { <li>{h}</li> }).collect_view()}</ul>
</details>
})}
</div>
})}
</section>
{(gallery_total > 0).then(|| view! {
<section class="summary-card gallery-card">
<div class="gallery-heading"><h3>"공간 사진"</h3><span>{format!("{}장", gallery_total)}</span></div>
<div class="gallery-grid">
{interior_photos.into_iter().take(6).enumerate().map(|(index, photo)| {
let source = photo.source.label();
view! {
<button type="button" class="gallery-item" aria-label=format!("공간 사진 {} 크게 보기", index + 1)
on:click=move |_| show_gallery.run(index)>
<PhotoImage photo=photo/>
<span class="gallery-source">{source}</span>
</button>
}
}).collect_view()}
</div>
{(gallery_total > 6).then(|| view! {
<button type="button" class="gallery-all btn-secondary" on:click=move |_| show_gallery.run(0)>{format!("사진 {}장 모두 보기", gallery_total)}</button>
})}
</section>
})}
</aside>
</div>
<dialog id="space-photo-dialog" class="photo-dialog" aria-labelledby="space-photo-title"
on:keydown=move |ev| {
if ev.key() == "ArrowLeft" {
ev.prevent_default();
set_photo_index.update(|n| *n = n.saturating_sub(1));
}
if ev.key() == "ArrowRight" {
ev.prevent_default();
let count = selection.with_untracked(|s| s.as_ref().map_or(0, |s| s.photos.len()));
set_photo_index.update(|n| *n = (*n + 1).min(count.saturating_sub(1)));
}
}>
<div class="dialog-header">
<h2 id="space-photo-title">{move || selection.get().map_or_else(|| "공간 사진".into(), |s| s.title)}</h2>
<button type="button" class="btn-close" aria-label="사진 닫기" on:click=move |_| set_photo_open.set(false)>"닫기"<Icon name="close"/></button>
</div>
<div class="photo-dialog-body">
{move || selection.get().map(|s| {
let total = s.photos.len();
let selected_photos = StoredValue::new(s.photos.clone());
view! {
{move || selected_photos.with_value(|photos| photos.get(photo_index.get()).cloned()).map(|photo| view! {
<div class="photo-viewer"><PhotoImage photo=photo.clone() loading="eager"/></div>
<PhotoCaption photo=photo/>
})}
{(total > 0).then(|| view! {
<div class="photo-navigation">
<button type="button" class="btn-secondary" aria-label="이전 사진" disabled=move || photo_index.get() == 0
on:click=move |_| set_photo_index.update(|n| *n = n.saturating_sub(1))>"이전"</button>
<span role="status" aria-live="polite">{move || format!("{} / {}", photo_index.get() + 1, total)}</span>
<button type="button" class="btn-secondary" aria-label="다음 사진" disabled=move || { photo_index.get() + 1 >= total }
on:click=move |_| set_photo_index.update(|n| *n = (*n + 1).min(total.saturating_sub(1)))>"다음"</button>
</div>
})}
{(total > 1).then(|| view! {
<div class="photo-thumbnails" role="group" aria-label="사진 선택">
{s.photos.into_iter().enumerate().map(|(i, photo)| view! {
<button type="button" aria-label=format!("{}번째 사진", i + 1) aria-pressed=move || (i == photo_index.get()).to_string()
on:click=move |_| set_photo_index.set(i)><PhotoImage photo=photo/></button>
}).collect_view()}
</div>
})}
{(total == 0).then(|| view! { <p class="photo-empty">"이 구역에 연결된 사진이 없습니다."</p> })}
}
})}
</div>
</dialog>
}
}
#[cfg(test)]
mod tests {
use super::*;
fn floor(label: &str, notes: &str, level: i32) -> Floor {
Floor {
level,
label: label.into(),
confidence: 0.5,
width_m: 10.0,
depth_m: 8.0,
openings: vec![],
zones: vec![],
verticals: vec![],
notes: notes.into(),
}
}
#[test]
fn floor_labels_distinguish_assignment_from_dimension_uncertainty() {
assert_eq!(
short_floor_label(&floor("1층", "치수와 방위는 가정입니다.", 1)),
"1층"
);
assert_eq!(
short_floor_label(&floor("상층 좌석 공간 · 2층으로 임시 배정", "", 2)),
"2층(추정)"
);
assert_eq!(
short_floor_label(&floor("2층", "사진의 촬영 층은 미확인입니다.", 2)),
"2층(추정)"
);
assert_eq!(short_floor_label(&floor("지하", "", -1)), "B1");
assert_eq!(
short_floor_label(&floor("루프탑", "", ROOFTOP_LEVEL)),
"옥상"
);
}
#[test]
fn evidence_ids_are_replaced_without_losing_caveats() {
let text = "p_ab123, p_other: 다른 지점 사진일 가능성이 있어 층은 미확인.";
assert_eq!(
readable_evidence(text, &[]),
"참고 사진, 참고 사진: 다른 지점 사진일 가능성이 있어 층은 미확인."
);
}
#[test]
fn equivalent_tags_are_not_repeated() {
assert_eq!(
unique_text(
vec!["바 좌석".into(), "바좌석".into(), "소파".into(), "".into()],
&[]
),
vec!["바 좌석", "소파"]
);
}
}