How to use cjio - 10 common examples

def test_get_surface_parent(self, surfaces):
        geom = models.Geometry(type='CompositeSolid')
        geom.surfaces = surfaces
        door = {
            2: {
            'type': 'Door',
            'attributes': {
                'colour': 'blue'
            },
            'parent': 0,
            'surface_idx': [[0, 0, 0], [0, 1, 0]]
            },
        }
        res = {
            0: {
                'type': 'WallSurface',
                'attributes': {
                    'slope': 33.4,

def test_build_index(self, lod):
        co = models.CityObject(id='one')
        geom = models.Geometry(type='Solid', lod=lod)
        co.geometry.append(geom)
        geometry, vtx_lookup, vtx_idx = co.build_index()
        assert 'semantics' not in geometry[0]

def test_get_surfaces(self, data_geometry, surfaces):
        geometry, vertices = data_geometry
        geom = models.Geometry(type='CompositeSolid')
        geom.boundaries = geometry[0]['boundaries']
        geom.surfaces = surfaces
        roof = geom.get_surfaces('roofsurface')
        wall = geom.get_surfaces('wallsurface')
        door = geom.get_surfaces('door')
        assert roof == {1: {
            'type': 'RoofSurface',
            'attributes': {
                'slope': 66.6,
            },
            'children': [0],
            'surface_idx': [[0, 0, 1], [0, 1, 1]]
        }}
        assert wall == {0: {
            'type': 'WallSurface',
            'attributes': {

def test_vertex_indexer(self, ms_triangles):
        vtx_lookup = {}
        vtx_idx = 0
        geom = models.Geometry(type='MultiSurface', lod=1)
        for record in ms_triangles:
            msurface = list()
            for _surface in record:
                r = list()
                for _ring in _surface:
                    bdry, vtx_lookup, vtx_idx = geom._vertex_indexer(_ring,
                                                                     vtx_lookup,
                                                                     vtx_idx)
                    r.append(bdry)
                msurface.append(r)

def test_dereference_boundaries(self, data_geometry, data_vtx_idx):
        type, boundary, result, vertex_list = data_vtx_idx
        vertices = data_geometry[1]
        geom = models.Geometry(type=type, boundaries=boundary, vertices=vertices)
        assert geom.boundaries == result

def test_get_surface_boundaries(self, data_geometry):
        """Test how to get the boundaries (geometry) of semantic surfaces"""
        geometry, vertices = data_geometry
        geom = models.Geometry(type=geometry[0]['type'],
                               lod=geometry[0]['lod'],
                               boundaries=geometry[0]['boundaries'],
                               semantics_obj=geometry[0]['semantics'],
                               vertices=vertices)
        roofsurfaces = geom.get_surfaces('roofsurface')
        rsrf_bndry = [geom.get_surface_boundaries(rsrf)
                      for i,rsrf in roofsurfaces.items()]
        roof_geom = [
            [
                [[(1.0, 1.0, 0.0), (1.0, 1.0, 0.0), (1.0, 1.0, 0.0), (1.0, 1.0, 0.0)]],
                [[(3.0, 1.0, 0.0), (3.0, 1.0, 0.0), (3.0, 1.0, 0.0), (3.0, 1.0, 0.0)]]
            ]
        ]
        assert rsrf_bndry == roof_geom

        doorsurfaces = geom.get_surfaces('door')

def cm_rdam_subset(rotterdam_subset):
    rotterdam_subset.cityobjects = dict()
    for co_id, co in rotterdam_subset.j['CityObjects'].items():
        # do some verification here
        children = co['children'] if 'children' in co else None
        parents = co['parents'] if 'parents' in co else None
        attributes = co['attributes'] if 'attributes' in co else None
        # cast to objects
        geometry = []
        for geom in co['geometry']:
            semantics = geom['semantics'] if 'semantics' in geom else None
            geometry.append(
                models.Geometry(
                    type=geom['type'],
                    lod=geom['lod'],
                    boundaries=geom['boundaries'],
                    semantics_obj=semantics,
                    vertices=rotterdam_subset.j['vertices']
                )
            )
        rotterdam_subset.cityobjects[co_id] = models.CityObject(
            id=id,
            type=co['type'],
            attributes=attributes,
            children=children,
            parents=parents,
            geometry=geometry
        )
    yield rotterdam_subset

def cm_zur_subset(zurich_subset):
    zurich_subset.cityobjects = dict()
    for co_id, co in zurich_subset.j['CityObjects'].items():
        # do some verification here
        children = co['children'] if 'children' in co else None
        parents = co['parents'] if 'parents' in co else None
        attributes = co['attributes'] if 'attributes' in co else None
        # cast to objects
        geometry = []
        for geom in co['geometry']:
            semantics = geom['semantics'] if 'semantics' in geom else None
            geometry.append(
                models.Geometry(
                    type=geom['type'],
                    lod=geom['lod'],
                    boundaries=geom['boundaries'],
                    semantics_obj=semantics,
                    vertices=zurich_subset.j['vertices']
                )
            )
        zurich_subset.cityobjects[co_id] = models.CityObject(
            id=co_id,
            type=co['type'],
            attributes=attributes,
            children=children,
            parents=parents,
            geometry=geometry
        )
    return zurich_subset

def test_set_surface_attributes(self, data_geometry):
        """Test how to set attributes on semantic surfaces"""
        geometry, vertices = data_geometry
        geom = models.Geometry(type=geometry[0]['type'],
                               lod=geometry[0]['lod'],
                               boundaries=geometry[0]['boundaries'],
                               semantics_obj=geometry[0]['semantics'],
                               vertices=vertices)
        roofsurfaces = geom.get_surfaces('roofsurface')
        for i, rsrf in roofsurfaces.items():
            if 'attributes' in rsrf.keys():
                rsrf['attributes']['colour'] = 'red'
            else:
                rsrf['attributes'] = {}
                rsrf['attributes']['colour'] = 'red'
            # overwrite the surface directly in the Geometry object
            geom.surfaces[i] = rsrf
        roofsurfaces_new = geom.get_surfaces('roofsurface')
        for i,rsrf in roofsurfaces_new.items():
            assert rsrf['attributes']['colour'] == 'red'

def test_get_surface_children(self, surfaces):
        geom = models.Geometry(type='CompositeSolid')
        geom.surfaces = surfaces
        res = {
            2: {
            'type': 'Door',
            'attributes': {
                'colour': 'blue'
            },
            'parent': 0,
            'surface_idx': [[0, 0, 0], [0, 1, 0]]
            },
            3: {
                'type': 'Door',
                'attributes': {
                    'colour': 'red'
                },
                'parent': 0,