Struct CityJSON 

pub struct CityJSON {
    pub thetype: String,
    pub version: String,
    pub transform: Transform,
    pub city_objects: HashMap<String, CityObject>,
    pub vertices: Vec<Vec<i64>>,
    pub metadata: Option<Metadata>,
    pub appearance: Option<Appearance>,
    pub geometry_templates: Option<GeometryTemplates>,
    pub extensions: Option<HashMap<String, Extension>>,
    pub other: Value,
    /* private fields */
}

Fields

thetype: String

version: String

transform: Transform

city_objects: HashMap<String, CityObject>

vertices: Vec<Vec<i64>>

metadata: Option<Metadata>

appearance: Option<Appearance>

geometry_templates: Option<GeometryTemplates>

extensions: Option<HashMap<String, Extension>>

other: Value

Implementations

impl CityJSON

pub fn new() -> Self

pub fn from_str(s: &str) -> Result<Self>

Examples found in repository

examples/obj_convert.rs (line 29)

fn main() -> std::io::Result<()> {
    // Path to the sample CityJSON file
    let file_path = Path::new("data/1b_w_texture.city.json");

    // Ensure the file exists
    if !file_path.exists() {
        println!("Sample file not found: {:?}", file_path);
        println!("Available files in data directory:");
        for entry in std::fs::read_dir("data")? {
            let entry = entry?;
            println!("  {:?}", entry.path());
        }
        return Ok(());
    }

    // Read the CityJSON file
    let mut file = File::open(file_path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;

    println!("Converting {} to OBJ format...", file_path.display());

    // Parse into CityJSON
    let city_json = CityJSON::from_str(&contents).unwrap();

    // Output file path
    let output_path = "output.obj";

    // Convert to OBJ and save to file
    obj::to_obj_file(&city_json, output_path)?;

    println!("Conversion complete. OBJ file saved to: {}", output_path);

    // Print some stats about the OBJ file
    let metadata = std::fs::metadata(output_path)?;
    println!("OBJ file size: {} bytes", metadata.len());

    // Count number of vertices and faces in the OBJ file
    let obj_contents = std::fs::read_to_string(output_path)?;
    let vertex_count = obj_contents
        .lines()
        .filter(|line| line.starts_with("v "))
        .count();
    let face_count = obj_contents
        .lines()
        .filter(|line| line.starts_with("f "))
        .count();

    println!("OBJ statistics:");
    println!("  Vertices: {}", vertex_count);
    println!("  Faces: {}", face_count);

    Ok(())
}

pub fn get_metadata(&self) -> Self

pub fn get_cjfeature(&self, i: usize) -> Option<CityJSONFeature>

pub fn add_cjfeature(&mut self, cjf: &mut CityJSONFeature)

pub fn remove_duplicate_vertices(&mut self)

pub fn update_transform(&mut self)

pub fn number_of_city_objects(&self) -> usize

pub fn sort_cjfeatures(&mut self, ss: SortingStrategy)

pub fn add_material(&mut self, jm: MaterialObject) -> usize

Trait Implementations

impl Clone for CityJSON

fn clone(&self) -> CityJSON

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CityJSON

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CityJSON

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CityJSON

fn eq(&self, other: &CityJSON) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CityJSON

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CityJSON