Apply JMA Style naming

Author: yanorei32

asset-preprocessor/src/parse_shapefile.rs

@@ -79,7 +79,7 @@ Please follow:
 }
 
 struct AreaRings {
-    area_code: codes::Area,
+    地震情報細分区域: codes::地震情報細分区域,
     bounding_box: BoundingBox<GeoDegree>,
     rings: Vec<Ring>,
 }
@@ -89,14 +89,17 @@ impl AreaRings {
         let Shape::Polygon(polygon) = shape else {
             return None;
         };
-        let area_code: codes::Area = match record.get("code").unwrap() {
+
+        let 地震情報細分区域: codes::地震情報細分区域 = match record.get("code").unwrap() {
             FieldValue::Character(Some(c)) => match c.parse() {
-                Ok(c) => c,
+                Ok(c) => codes::地震情報細分区域(c),
                 Err(_) => panic!("ｺﾜｯ…ｺﾜれたshapefileきた！"),
             },
-            FieldValue::Character(None) => codes::UNNUMBERED_AREA, // 北方領土・諸外国等がNoneになる
+
+            FieldValue::Character(None) => codes::地震情報細分区域::UNNUMBERED, // 北方領土・諸外国等がNoneになる
             _ => panic!("知らないshapefileきた？🤔"),
         };
+
         let bounding_box = (*polygon.bbox()).into();
         let rings = polygon
             .rings()
@@ -105,7 +108,7 @@ impl AreaRings {
             .collect();
 
         Some(Self {
-            area_code,
+            地震情報細分区域,
             bounding_box,
             rings,
         })
@@ -119,20 +122,20 @@ pub(crate) struct PointReferences<'a> {
 impl<'a> PointReferences<'a> {
     fn tally_of(
         shapefile: &'a Shapefile,
-        area_to_pref: &'a HashMap<codes::Area, codes::Pref>,
+        area_to_pref: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>,
     ) -> Self {
         let mut map: HashMap<Point, PointReference> = HashMap::new();
 
         shapefile.entries.iter().for_each(|area_rings| {
-            let area_code = area_rings.area_code;
+            let 地震情報細分区域 = area_rings.地震情報細分区域;
 
             area_rings.rings.iter().for_each(|ring| {
                 ring.iter_adjacent_points().for_each(|point_set| {
                     let reference = map
                         .entry(point_set.current)
                         .or_insert(PointReference::new(area_to_pref));
 
-                    reference.mark_area(area_code);
+                    reference.mark_area(地震情報細分区域);
                     reference.mark_point(point_set.previous);
                     reference.mark_point(point_set.next);
                 });
@@ -162,38 +165,41 @@ impl<'a> PointReferences<'a> {
 }
 
 pub(crate) struct PointReference<'a> {
-    area_to_pref: &'a HashMap<codes::Area, codes::Pref>,
-    areas: HashSet<codes::Area>,
+    area_to_pref: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>,
+    areas: HashSet<codes::地震情報細分区域>,
     adjacent_points: HashSet<Point>,
 }
 
 impl<'a> PointReference<'a> {
-    fn new(area_to_pref: &'a HashMap<codes::Area, codes::Pref>) -> Self {
+    fn new(
+        area_to_pref: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>
+    ) -> Self {
         Self {
             area_to_pref,
             areas: HashSet::new(),
             adjacent_points: HashSet::new(),
         }
     }
 
-    fn mark_area(&mut self, area: codes::Area) {
+    fn mark_area(&mut self, area: codes::地震情報細分区域) {
         self.areas.insert(area);
     }
 
     fn mark_point(&mut self, point: Point) {
         self.adjacent_points.insert(point);
     }
 
-    fn area_references(&self) -> &HashSet<codes::Area> {
+    fn area_references(&self) -> &HashSet<codes::地震情報細分区域> {
         &self.areas
     }
 
-    pub(crate) fn pref_references(&self) -> HashSet<codes::Pref> {
+    pub(crate) fn pref_references(&self) -> HashSet<codes::地震情報都道府県等> {
         let areas = self
             .area_references()
             .iter()
-            .filter(|a| **a != codes::UNNUMBERED_AREA)
+            .filter(|a| **a != codes::地震情報細分区域::UNNUMBERED)
             .map(|a| *self.area_to_pref.get(a).unwrap());
+
         HashSet::from_iter(areas)
     }
 
@@ -202,15 +208,18 @@ impl<'a> PointReference<'a> {
     }
 }
 pub fn read(
-    #[allow(non_snake_case)] area_code__pref_code: &HashMap<codes::Area, codes::Pref>,
+    #[allow(non_snake_case)] area_code__pref_code: &HashMap<
+        codes::地震情報細分区域,
+        codes::地震情報都道府県等,
+    >,
 ) -> (
-    HashMap<codes::Area, BoundingBox<GeoDegree>>, // area_bounding_box
-    HashMap<codes::Area, Vertex<GeoDegree>>,      // area_centers
-    Vec<(f32, f32)>,                              // vertex_buffer
-    Vec<u32>,                                     // map_indices
-    Vec<Vec<u32>>,                                // area_lines
-    Vec<Vec<u32>>,                                // pref_lines
-    Vec<(f32, usize)>,                            // scale_level_map
+    HashMap<codes::地震情報細分区域, BoundingBox<GeoDegree>>, // area_bounding_box
+    HashMap<codes::地震情報細分区域, Vertex<GeoDegree>>,      // area_centers
+    Vec<(f32, f32)>,                                          // vertex_buffer
+    Vec<u32>,                                                 // map_indices
+    Vec<Vec<u32>>,                                            // area_lines
+    Vec<Vec<u32>>,                                            // pref_lines
+    Vec<(f32, usize)>,                                        // scale_level_map
 ) {
     let shapefile = Shapefile::new(
         "../assets/shapefile/earthquake_detailed/earthquake_detailed_simplified.shp",
@@ -220,21 +229,24 @@ pub fn read(
 
     // @Siro_256 にゃ～っ…！ (ΦωΦ）
 
-    let area_centers = calculate_area_centers(&shapefile);
+    let 地震情報細分区域_centers = calculate_地震情報細分区域_centers(&shapefile);
 
-    let area_bounding_box: HashMap<codes::Area, BoundingBox<GeoDegree>> = shapefile
-        .entries
-        .iter()
-        .filter(|area_rings| area_rings.area_code != codes::UNNUMBERED_AREA)
-        .map(|area_rings| (area_rings.area_code, area_rings.bounding_box))
-        .collect();
+    let 地震情報細分区域_bounding_box: HashMap<codes::地震情報細分区域, BoundingBox<GeoDegree>> =
+        shapefile
+            .entries
+            .iter()
+            .filter(|rings| {
+                rings.地震情報細分区域 != codes::地震情報細分区域::UNNUMBERED
+            })
+            .map(|rings| (rings.地震情報細分区域, rings.bounding_box))
+            .collect();
 
     let map_indices = shapefile
         .entries
         .iter()
-        .flat_map(|area_rings| &area_rings.rings)
-        .flat_map(|r| r.triangulate())
-        .map(|p| vertex_buffer.insert(p.into()) as u32)
+        .flat_map(|rings| &rings.rings)
+        .flat_map(|ring| ring.triangulate())
+        .map(|point| vertex_buffer.insert(point.into()) as u32)
         .collect();
 
     let references = PointReferences::tally_of(&shapefile, area_code__pref_code);
@@ -322,8 +334,8 @@ pub fn read(
     // (ΦωΦ) < Meow !
     {
         (
-            area_bounding_box,
-            area_centers,
+            地震情報細分区域_bounding_box,
+            地震情報細分区域_centers,
             vertex_buffer.into_buffer(),
             map_indices,
             area_lines,
@@ -400,58 +412,60 @@ fn gen_lod(
         .collect()
 }
 
-fn calculate_area_centers(shapefile: &Shapefile) -> HashMap<codes::Area, Vertex<GeoDegree>> {
+fn calculate_地震情報細分区域_centers(
+    shapefile: &Shapefile,
+) -> HashMap<codes::地震情報細分区域, Vertex<GeoDegree>> {
     use geo::{
         algorithm::{Area, Centroid},
         LineString, Polygon,
     };
 
-    let area_weighted_vectors: HashMap<codes::Area, Vec<(f64, geo::Point)>> = shapefile
+    let weighted_vectors: HashMap<codes::地震情報細分区域, Vec<(f64, geo::Point)>> = shapefile
         .entries
         .iter()
-        .filter(|area_rings| area_rings.area_code != codes::UNNUMBERED_AREA)
-        .map(|area_rings| {
-            let area_polygons: Vec<(f64, geo::Point)> = area_rings
+        .filter(|rings| rings.地震情報細分区域 != codes::地震情報細分区域::UNNUMBERED)
+        .map(|rings| {
+            let polygons: Vec<(f64, geo::Point)> = rings
                 .rings
                 .iter()
                 .map(|ring| LineString::new(ring.points().iter().map(|p| p.into()).collect_vec()))
                 .map(|geo_line_string| Polygon::new(geo_line_string, vec![]))
                 .map(|geo_polygon| (geo_polygon.unsigned_area(), geo_polygon.centroid().unwrap()))
                 .collect();
 
-            (area_rings.area_code, area_polygons)
+            (rings.地震情報細分区域, polygons)
         })
         .collect();
 
-    let area_centers: HashMap<codes::Area, Point> = area_weighted_vectors
+    let centers: HashMap<codes::地震情報細分区域, Point> = weighted_vectors
         .into_iter()
-        .map(|(area_code, weighted_vectors)| {
-            let area_weight: f64 = weighted_vectors
+        .map(|(地震情報細分区域, weighted_vectors)| {
+            let weight: f64 = weighted_vectors
                 .iter()
                 .map(|(weight, _vector)| weight)
                 .sum();
 
-            let area_vector: Point = weighted_vectors
+            let vector: Point = weighted_vectors
                 .iter()
                 .map(|(weight, vector)| {
                     let vector: Point = vector.into();
                     vector.multiply_by(*weight as f32)
                 })
                 .fold(Point::new(0.0.into(), 0.0.into()), |a, b| a + b);
 
-            (area_code, area_vector.divide_by(area_weight as f32))
+            (地震情報細分区域, vector.divide_by(weight as f32))
         })
         .collect();
 
-    let area_centers: HashMap<codes::Area, Vertex<GeoDegree>> = area_centers
+    let centers: HashMap<codes::地震情報細分区域, Vertex<GeoDegree>> = centers
         .into_iter()
-        .map(|(area_code, center)| {
+        .map(|(code, center)| {
             (
-                area_code,
+                code,
                 Vertex::new(center.latitude.into(), center.longitude.into()),
             )
         })
         .collect();
 
-    area_centers
+    centers
 }

asset-preprocessor/src/parse_tsunami_shapefile.rs

@@ -72,7 +72,7 @@ impl VertexBuffer {
 
 struct AreaLines {
     lines: Vec<Line>,
-    tsunami_area_code: codes::TsunamiArea,
+    津波予報区: codes::津波予報区,
 }
 
 impl AreaLines {
@@ -81,17 +81,16 @@ impl AreaLines {
             return None;
         };
 
-        let tsunami_area_code: codes::TsunamiArea = match record.get("code").unwrap() {
+        let 津波予報区: codes::津波予報区 = match record.get("code").unwrap() {
             FieldValue::Character(Some(c)) => match c.parse() {
-                Ok(c) => c,
+                Ok(c) => codes::津波予報区(c),
                 Err(_) => panic!("Failed to parse code"),
             },
             FieldValue::Character(None) => panic!("UNNUMBERED_AREA DETECTED!"),
             _ => panic!("Failed to get code"),
         };
 
-        // 帰属未定 (極小の島など)
-        if tsunami_area_code == 0 {
+        if 津波予報区 == codes::津波予報区::帰属未定 {
             return None;
         }
 
@@ -103,7 +102,7 @@ impl AreaLines {
 
         Some(Self {
             lines,
-            tsunami_area_code,
+            津波予報区,
         })
     }
 }
@@ -167,7 +166,7 @@ pub fn read() -> (
                     vertex_buffer.insert((
                         Of32::from(v.longitude),
                         Of32::from(v.latitude),
-                        tsunami_area_code_buffer.insert(e.tsunami_area_code),
+                        tsunami_area_code_buffer.insert(e.津波予報区.0),
                     )) as u32
                 })
                 .collect();

renderer-assets/build.rs

@@ -60,7 +60,7 @@ fn main() {
                 .expect("エリア内に一つも観測点がない");
 
             (
-                *code,
+                code.0,
                 (nearest_intensity_station_index, bbox_to_tuple(bbox)),
             )
         })

renderer-assets/src/lib.rs

@@ -48,37 +48,41 @@ impl QueryInterface {
         }
     }
 
-    pub fn is_valid_earthquake_area_code(area_code: codes::Area) -> bool {
-        AREAS.contains_key(&area_code)
+    pub fn is_valid_地震情報細分区域(code: codes::地震情報細分区域) -> bool {
+        AREAS.contains_key(&code.0)
     }
 
-    pub fn is_valid_tsunami_area_code(area_code: codes::Area) -> bool {
-        TSUNAMI_AREA_CODE_TO_INTERNAL_CODE.contains_key(&area_code)
+    pub fn is_valid_津波予報区(code: codes::津波予報区) -> bool {
+        TSUNAMI_AREA_CODE_TO_INTERNAL_CODE.contains_key(&code.0)
     }
 
-    pub fn tsunami_area_code_to_internal_code(area_code: codes::TsunamiArea) -> Option<u16> {
-        TSUNAMI_AREA_CODE_TO_INTERNAL_CODE.get(&area_code).copied()
+    pub fn 津波予報区_to_internal_tsunami_area_code(
+        code: codes::津波予報区,
+    ) -> Option<codes::InternalTsunamiAreaCode> {
+        TSUNAMI_AREA_CODE_TO_INTERNAL_CODE
+            .get(&code.0)
+            .map(|code| codes::InternalTsunamiAreaCode(*code))
     }
 
-    pub fn tsunami_area_code_count() -> usize {
+    pub fn internal_tsunami_area_code_count() -> usize {
         TSUNAMI_AREA_CODE_TO_INTERNAL_CODE.len()
     }
 
-    pub fn query_bounding_box_by_area(area_code: codes::Area) -> Option<BoundingBox<GeoDegree>> {
-        let tuple = AREAS.get(&area_code)?.1;
+    pub fn query_bounding_box_by_地震情報細分区域(code: codes::地震情報細分区域) -> Option<BoundingBox<GeoDegree>> {
+        let tuple = AREAS.get(&code.0)?.1;
         let min = Vertex::new(tuple.0, tuple.1);
         let max = Vertex::new(tuple.2, tuple.3);
         Some(BoundingBox::new(min, max))
     }
 
-    pub fn query_rendering_center_by_area(area_code: codes::Area) -> Option<Vertex<GeoDegree>> {
-        Some(INTENSITY_STATION_POSITIONS[AREAS.get(&area_code)?.0].into())
+    pub fn query_intensity_icon_center_by_地震情報細分区域(code: codes::地震情報細分区域) -> Option<Vertex<GeoDegree>> {
+        Some(INTENSITY_STATION_POSITIONS[AREAS.get(&code.0)?.0].into())
     }
 
     pub fn query_position_by_station_code(
-        intensity_station_code: codes::IntensityStation,
+        code: codes::震度観測点,
     ) -> Option<Vertex<GeoDegree>> {
-        Some(INTENSITY_STATION_POSITIONS[*STATION_CODES.get(&intensity_station_code)?].into())
+        Some(INTENSITY_STATION_POSITIONS[*STATION_CODES.get(&code.0)?].into())
     }
 
     pub fn query_lod_level_by_scale(scale: f32) -> Option<usize> {