feat(engine): add transform_offset method to geometry types and updat…

…e example workflow (#661)

engine/Cargo.toml

@@ -63,10 +63,10 @@ reearth-flow-storage = { path = "runtime/storage" }
 reearth-flow-telemetry = { path = "runtime/telemetry" }
 reearth-flow-types = { path = "runtime/types" }
 
-nusamai-citygml = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.5.2", features = ["serde", "serde_json"] }
-nusamai-gltf = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.5.2" }
-nusamai-plateau = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.5.2", features = ["serde"] }
-nusamai-projection = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.5.2" }
+nusamai-citygml = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.6.0", features = ["serde", "serde_json"] }
+nusamai-gltf = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.6.0" }
+nusamai-plateau = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.6.0", features = ["serde"] }
+nusamai-projection = { git = "https://github.com/reearth/plateau-gis-converter", tag = "v0.6.0" }
 
 Inflector = "0.11.4"
 ahash = "0.8.11"

engine/docs/mdbook/src/action.md

@@ -1188,6 +1188,38 @@ Transforms features by expressions
 ### Category
 * Feature
 
+## FeatureTypeFilter
+### Type
+* processor
+### Description
+Filters features by feature type
+### Parameters
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FeatureTypeFilter",
+  "type": "object",
+  "required": [
+    "targetTypes"
+  ],
+  "properties": {
+    "targetTypes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}
+```
+### Input Ports
+* default
+### Output Ports
+* default
+* unfiltered
+### Category
+* Feature
+
 ## FilePathExtractor
 ### Type
 * source
@@ -2142,6 +2174,49 @@ noop sink
 ### Category
 * Noop
 
+## Offsetter
+### Type
+* processor
+### Description
+Adds offsets to the feature's coordinates.
+### Parameters
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "OffsetterParam",
+  "type": "object",
+  "properties": {
+    "offsetX": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "format": "double"
+    },
+    "offsetY": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "format": "double"
+    },
+    "offsetZ": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "format": "double"
+    }
+  }
+}
+```
+### Input Ports
+* default
+### Output Ports
+* default
+### Category
+* Geometry
+
 ## OrientationExtractor
 ### Type
 * processor

engine/runtime/action-processor/src/feature.rs

@@ -8,3 +8,4 @@ pub(crate) mod reader;
 pub(crate) mod rhai;
 pub(crate) mod sorter;
 pub(crate) mod transformer;
+pub(crate) mod type_filter;

engine/runtime/action-processor/src/feature/mapping.rs

@@ -7,6 +7,7 @@ use super::{
     counter::FeatureCounterFactory, filter::FeatureFilterFactory,
     list_exploder::ListExploderFactory, merger::FeatureMergerFactory, reader::FeatureReaderFactory,
     rhai::RhaiCallerFactory, sorter::FeatureSorterFactory, transformer::FeatureTransformerFactory,
+    type_filter::FeatureTypeFilterFactory,
 };
 
 pub static ACTION_FACTORY_MAPPINGS: Lazy<HashMap<String, NodeKind>> = Lazy::new(|| {
@@ -19,6 +20,7 @@ pub static ACTION_FACTORY_MAPPINGS: Lazy<HashMap<String, NodeKind>> = Lazy::new(
         Box::<FeatureReaderFactory>::default(),
         Box::<RhaiCallerFactory>::default(),
         Box::<ListExploderFactory>::default(),
+        Box::<FeatureTypeFilterFactory>::default(),
     ];
     factories
         .into_iter()

engine/runtime/action-processor/src/feature/type_filter.rs

@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+
+use once_cell::sync::Lazy;
+use reearth_flow_runtime::{
+    channels::ProcessorChannelForwarder,
+    errors::BoxedError,
+    event::EventHub,
+    executor_operation::{ExecutorContext, NodeContext},
+    node::{Port, Processor, ProcessorFactory, DEFAULT_PORT},
+};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use super::errors::FeatureProcessorError;
+
+pub static UNFILTERED_PORT: Lazy<Port> = Lazy::new(|| Port::new("unfiltered"));
+
+#[derive(Debug, Clone, Default)]
+pub struct FeatureTypeFilterFactory;
+
+impl ProcessorFactory for FeatureTypeFilterFactory {
+    fn name(&self) -> &str {
+        "FeatureTypeFilter"
+    }
+
+    fn description(&self) -> &str {
+        "Filters features by feature type"
+    }
+
+    fn parameter_schema(&self) -> Option<schemars::schema::RootSchema> {
+        Some(schemars::schema_for!(FeatureTypeFilter))
+    }
+
+    fn categories(&self) -> &[&'static str] {
+        &["Feature"]
+    }
+
+    fn get_input_ports(&self) -> Vec<Port> {
+        vec![DEFAULT_PORT.clone()]
+    }
+
+    fn get_output_ports(&self) -> Vec<Port> {
+        vec![DEFAULT_PORT.clone(), UNFILTERED_PORT.clone()]
+    }
+
+    fn build(
+        &self,
+        _ctx: NodeContext,
+        _event_hub: EventHub,
+        _action: String,
+        with: Option<HashMap<String, Value>>,
+    ) -> Result<Box<dyn Processor>, BoxedError> {
+        let process: FeatureTypeFilter = if let Some(with) = with {
+            let value: Value = serde_json::to_value(with).map_err(|e| {
+                FeatureProcessorError::TransformerFactory(format!(
+                    "Failed to serialize `with` parameter: {}",
+                    e
+                ))
+            })?;
+            serde_json::from_value(value).map_err(|e| {
+                FeatureProcessorError::TransformerFactory(format!(
+                    "Failed to deserialize `with` parameter: {}",
+                    e
+                ))
+            })?
+        } else {
+            return Err(FeatureProcessorError::TransformerFactory(
+                "Missing required parameter `with`".to_string(),
+            )
+            .into());
+        };
+        Ok(Box::new(process))
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct FeatureTypeFilter {
+    target_types: Vec<String>,
+}
+
+impl Processor for FeatureTypeFilter {
+    fn process(
+        &mut self,
+        ctx: ExecutorContext,
+        fw: &mut dyn ProcessorChannelForwarder,
+    ) -> Result<(), BoxedError> {
+        let feature = &ctx.feature;
+        let Some(feature_type) = feature.feature_type() else {
+            fw.send(ctx.new_with_feature_and_port(feature.clone(), UNFILTERED_PORT.clone()));
+            return Ok(());
+        };
+        if self.target_types.contains(&feature_type) {
+            fw.send(ctx.new_with_feature_and_port(feature.clone(), DEFAULT_PORT.clone()));
+        } else {
+            fw.send(ctx.new_with_feature_and_port(feature.clone(), UNFILTERED_PORT.clone()));
+        }
+        Ok(())
+    }
+
+    fn finish(
+        &self,
+        _ctx: NodeContext,
+        _fw: &mut dyn ProcessorChannelForwarder,
+    ) -> Result<(), BoxedError> {
+        Ok(())
+    }
+
+    fn name(&self) -> &str {
+        "FeatureTypeFilter"
+    }
+}

engine/runtime/action-processor/src/geometry.rs

@@ -20,6 +20,7 @@ pub(crate) mod horizontal_reprojector;
 pub(crate) mod line_on_line_overlayer;
 pub(crate) mod lod_filter;
 pub(crate) mod mapping;
+pub(crate) mod offsetter;
 pub(crate) mod orientation_extractor;
 pub(crate) mod planarity_filter;
 pub(crate) mod refiner;

engine/runtime/action-processor/src/geometry/errors.rs

@@ -99,6 +99,10 @@ pub(super) enum GeometryProcessorError {
     GeometryLodFilterFactory(String),
     #[error("GeometryLodFilter error: {0}")]
     GeometryLodFilter(String),
+    #[error("Offsetter Factory error: {0}")]
+    OffsetterFactory(String),
+    #[error("Offsetter error: {0}")]
+    Offsetter(String),
 }
 
 pub(super) type Result<T, E = GeometryProcessorError> = std::result::Result<T, E>;

engine/runtime/action-processor/src/geometry/mapping.rs

@@ -14,8 +14,9 @@ use super::{
     extruder::ExtruderFactory, filter::GeometryFilterFactory, hole_counter::HoleCounterFactory,
     hole_extractor::HoleExtractorFactory, horizontal_reprojector::HorizontalReprojectorFactory,
     line_on_line_overlayer::LineOnLineOverlayerFactory, lod_filter::GeometryLodFilterFactory,
-    orientation_extractor::OrientationExtractorFactory, planarity_filter::PlanarityFilterFactory,
-    refiner::RefinerFactory, replacer::GeometryReplacerFactory, splitter::GeometrySplitterFactory,
+    offsetter::OffsetterFactory, orientation_extractor::OrientationExtractorFactory,
+    planarity_filter::PlanarityFilterFactory, refiner::RefinerFactory,
+    replacer::GeometryReplacerFactory, splitter::GeometrySplitterFactory,
     three_dimension_box_replacer::ThreeDimensionBoxReplacerFactory,
     three_dimension_rotator::ThreeDimensionRotatorFactory,
     two_dimension_forcer::TwoDimensionForcerFactory, validator::GeometryValidatorFactory,
@@ -58,6 +59,7 @@ pub static ACTION_FACTORY_MAPPINGS: Lazy<HashMap<String, NodeKind>> = Lazy::new(
         Box::<DimensionFilterFactory>::default(),
         Box::<CityGmlGeometryLodFilterFactory>::default(),
         Box::<GeometryLodFilterFactory>::default(),
+        Box::<OffsetterFactory>::default(),
     ];
     factories
         .into_iter()