More JMA

Author: yanorei32

asset-preprocessor/src/parse_shapefile.rs

@@ -43,7 +43,7 @@ impl VertexBuffer {
 }
 
 struct Shapefile {
-    entries: Vec<AreaRings>,
+    entries: Vec<細分区域Rings>,
 }
 
 impl Shapefile {
@@ -71,26 +71,26 @@ Please follow:
         let entries = reader
             .iter_shapes_and_records()
             .flatten()
-            .flat_map(|shape_record| AreaRings::try_new(shape_record.0, shape_record.1))
+            .flat_map(|shape_record| 細分区域Rings::try_new(shape_record.0, shape_record.1))
             .collect();
 
         Self { entries }
     }
 }
 
-struct AreaRings {
-    地震情報細分区域: codes::地震情報細分区域,
+struct 細分区域Rings {
+    細分区域: codes::地震情報細分区域,
     bounding_box: BoundingBox<GeoDegree>,
     rings: Vec<Ring>,
 }
 
-impl AreaRings {
+impl 細分区域Rings {
     fn try_new(shape: Shape, record: Record) -> Option<Self> {
         let Shape::Polygon(polygon) = shape else {
             return None;
         };
 
-        let 地震情報細分区域: codes::地震情報細分区域 = match record.get("code").unwrap() {
+        let 細分区域: codes::地震情報細分区域 = match record.get("code").unwrap() {
             FieldValue::Character(Some(c)) => match c.parse() {
                 Ok(c) => codes::地震情報細分区域(c),
                 Err(_) => panic!("ｺﾜｯ…ｺﾜれたshapefileきた！"),
@@ -108,7 +108,7 @@ impl AreaRings {
             .collect();
 
         Some(Self {
-            地震情報細分区域,
+            細分区域,
             bounding_box,
             rings,
         })
@@ -122,20 +122,20 @@ pub(crate) struct PointReferences<'a> {
 impl<'a> PointReferences<'a> {
     fn tally_of(
         shapefile: &'a Shapefile,
-        area_to_pref: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>,
+        細分区域_to_都道府県等: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>,
     ) -> Self {
         let mut map: HashMap<Point, PointReference> = HashMap::new();
 
-        shapefile.entries.iter().for_each(|area_rings| {
-            let 地震情報細分区域 = area_rings.地震情報細分区域;
+        shapefile.entries.iter().for_each(|rings| {
+            let 細分区域 = rings.細分区域;
 
-            area_rings.rings.iter().for_each(|ring| {
+            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));
+                        .or_insert(PointReference::new(細分区域_to_都道府県等));
 
-                    reference.mark_area(地震情報細分区域);
+                    reference.mark_細分区域(細分区域);
                     reference.mark_point(point_set.previous);
                     reference.mark_point(point_set.next);
                 });
@@ -153,62 +153,63 @@ impl<'a> PointReferences<'a> {
             .collect()
     }
 
-    fn pref_reference_count(&self, line: &Line) -> usize {
+    fn 都道府県等_reference_count(&self, line: &Line) -> usize {
         let first = self.map.get(line.vertices.first().unwrap()).unwrap();
         let last = self.map.get(line.vertices.last().unwrap()).unwrap();
 
         first
-            .pref_references()
-            .intersection(&last.pref_references())
+            .都道府県等_references()
+            .intersection(&last.都道府県等_references())
             .count()
     }
 }
 
 pub(crate) struct PointReference<'a> {
-    area_to_pref: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>,
-    areas: HashSet<codes::地震情報細分区域>,
+    細分区域_to_都道府県等: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>,
+    細分区域s: HashSet<codes::地震情報細分区域>,
     adjacent_points: HashSet<Point>,
 }
 
 impl<'a> PointReference<'a> {
     fn new(
-        area_to_pref: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>
+        細分区域_to_都道府県等: &'a HashMap<codes::地震情報細分区域, codes::地震情報都道府県等>
     ) -> Self {
         Self {
-            area_to_pref,
-            areas: HashSet::new(),
+            細分区域_to_都道府県等,
+            細分区域s: HashSet::new(),
             adjacent_points: HashSet::new(),
         }
     }
 
-    fn mark_area(&mut self, area: codes::地震情報細分区域) {
-        self.areas.insert(area);
+    fn mark_細分区域(&mut self, 細分区域: codes::地震情報細分区域) {
+        self.細分区域s.insert(細分区域);
     }
 
     fn mark_point(&mut self, point: Point) {
         self.adjacent_points.insert(point);
     }
 
-    fn area_references(&self) -> &HashSet<codes::地震情報細分区域> {
-        &self.areas
+    fn 細分区域_references(&self) -> &HashSet<codes::地震情報細分区域> {
+        &self.細分区域s
     }
 
-    pub(crate) fn pref_references(&self) -> HashSet<codes::地震情報都道府県等> {
-        let areas = self
-            .area_references()
+    pub(crate) fn 都道府県等_references(&self) -> HashSet<codes::地震情報都道府県等> {
+        let 都道府県等s = self
+            .細分区域_references()
             .iter()
             .filter(|a| **a != codes::地震情報細分区域::UNNUMBERED)
-            .map(|a| *self.area_to_pref.get(a).unwrap());
+            .map(|a| *self.細分区域_to_都道府県等.get(a).unwrap());
 
-        HashSet::from_iter(areas)
+        HashSet::from_iter(都道府県等s)
     }
 
     fn adjacent_points_count(&self) -> usize {
         self.adjacent_points.len()
     }
 }
+
 pub fn read(
-    #[allow(non_snake_case)] area_code__pref_code: &HashMap<
+    #[allow(non_snake_case)] 細分区域_to_都道府県等: &HashMap<
         codes::地震情報細分区域,
         codes::地震情報都道府県等,
     >,
@@ -229,16 +230,16 @@ pub fn read(
 
     // @Siro_256 にゃ～っ…！ (ΦωΦ）
 
-    let 地震情報細分区域_centers = calculate_地震情報細分区域_centers(&shapefile);
+    let 細分区域_centers = calculate_細分区域_centers(&shapefile);
 
-    let 地震情報細分区域_bounding_box: HashMap<codes::地震情報細分区域, BoundingBox<GeoDegree>> =
+    let 細分区域_bounding_box: HashMap<codes::地震情報細分区域, BoundingBox<GeoDegree>> =
         shapefile
             .entries
             .iter()
             .filter(|rings| {
-                rings.地震情報細分区域 != codes::地震情報細分区域::UNNUMBERED
+                rings.細分区域 != codes::地震情報細分区域::UNNUMBERED
             })
-            .map(|rings| (rings.地震情報細分区域, rings.bounding_box))
+            .map(|rings| (rings.細分区域, rings.bounding_box))
             .collect();
 
     let map_indices = shapefile
@@ -249,7 +250,7 @@ pub fn read(
         .map(|point| vertex_buffer.insert(point.into()) as u32)
         .collect();
 
-    let references = PointReferences::tally_of(&shapefile, area_code__pref_code);
+    let references = PointReferences::tally_of(&shapefile, 細分区域_to_都道府県等);
 
     let rings = shapefile
         .entries
@@ -267,14 +268,14 @@ pub fn read(
         .filter_map(|(l, c)| if c > 1 { Some(l) } else { None })
         .collect();
 
-    let area_lines = lines
+    let 細分区域_lines = lines
         .iter()
-        .filter(|l| references.pref_reference_count(l) == 1)
+        .filter(|l| references.都道府県等_reference_count(l) == 1)
         .collect_vec();
 
-    let pref_lines = lines
+    let 都道府県等_lines = lines
         .iter()
-        .filter(|l| references.pref_reference_count(l) >= 2)
+        .filter(|l| references.都道府県等_reference_count(l) >= 2)
         .collect_vec();
 
     let lod_details = [
@@ -320,8 +321,8 @@ pub fn read(
         (100.0_f32.powf(0.24), 0.117),
     ];
 
-    let area_lines = gen_lod(&mut vertex_buffer, &lod_details, &area_lines);
-    let pref_lines = gen_lod(&mut vertex_buffer, &lod_details, &pref_lines);
+    let 細分区域_lines = gen_lod(&mut vertex_buffer, &lod_details, &細分区域_lines);
+    let 都道府県等_lines = gen_lod(&mut vertex_buffer, &lod_details, &都道府県等_lines);
 
     let scale_level_map = lod_details
         .into_iter()
@@ -334,12 +335,12 @@ pub fn read(
     // (ΦωΦ) < Meow !
     {
         (
-            地震情報細分区域_bounding_box,
-            地震情報細分区域_centers,
+            細分区域_bounding_box,
+            細分区域_centers,
             vertex_buffer.into_buffer(),
             map_indices,
-            area_lines,
-            pref_lines,
+            細分区域_lines,
+            都道府県等_lines,
             scale_level_map,
         )
     }
@@ -412,7 +413,7 @@ fn gen_lod(
         .collect()
 }
 
-fn calculate_地震情報細分区域_centers(
+fn calculate_細分区域_centers(
     shapefile: &Shapefile,
 ) -> HashMap<codes::地震情報細分区域, Vertex<GeoDegree>> {
     use geo::{
@@ -423,7 +424,7 @@ fn calculate_地震情報細分区域_centers(
     let weighted_vectors: HashMap<codes::地震情報細分区域, Vec<(f64, geo::Point)>> = shapefile
         .entries
         .iter()
-        .filter(|rings| rings.地震情報細分区域 != codes::地震情報細分区域::UNNUMBERED)
+        .filter(|rings| rings.細分区域 != codes::地震情報細分区域::UNNUMBERED)
         .map(|rings| {
             let polygons: Vec<(f64, geo::Point)> = rings
                 .rings
@@ -433,13 +434,13 @@ fn calculate_地震情報細分区域_centers(
                 .map(|geo_polygon| (geo_polygon.unsigned_area(), geo_polygon.centroid().unwrap()))
                 .collect();
 
-            (rings.地震情報細分区域, polygons)
+            (rings.細分区域, polygons)
         })
         .collect();
 
     let centers: HashMap<codes::地震情報細分区域, Point> = weighted_vectors
         .into_iter()
-        .map(|(地震情報細分区域, weighted_vectors)| {
+        .map(|(細分区域, weighted_vectors)| {
             let weight: f64 = weighted_vectors
                 .iter()
                 .map(|(weight, _vector)| weight)
@@ -453,7 +454,7 @@ fn calculate_地震情報細分区域_centers(
                 })
                 .fold(Point::new(0.0.into(), 0.0.into()), |a, b| a + b);
 
-            (地震情報細分区域, vector.divide_by(weight as f32))
+            (細分区域, vector.divide_by(weight as f32))
         })
         .collect();