def from_dict(cls, data):
"""Create a ApertureModifierSet from a dictionary.
Note that the dictionary must be a non-abridged version for this
classmethod to work.
Args:
data: Dictionary describing the ApertureModifierSet.
"""
assert data['type'] == cls.__name__, \
'Expected {}. Got {}.'.format(cls.__name__, data['type'])
extc = dict_to_modifier(data['exterior_modifier']) \
if 'exterior_modifier' in data and data['exterior_modifier'] \
is not None else None
intc = dict_to_modifier(data['interior_modifier']) \
if 'interior_modifier' in data and data['interior_modifier'] \
is not None else None
egc = dict_to_modifier(data['exterior_glass_modifier']) \
if 'exterior_glass_modifier' in data and data['exterior_glass_modifier'] \
is not None else None
igc = dict_to_modifier(data['interior_glass_modifier']) \
if 'interior_glass_modifier' in data and data['interior_glass_modifier'] \
is not None else None
ohc = dict_to_modifier(data['overhead_modifier']) \
if 'overhead_modifier' in data and data['overhead_modifier'] \
is not None else None
return cls(extc, intc, egc, igc, ohc)
def modifier_from_rad(modifier_rad, output_file):
"""Translate a Modifier JSON file to a honeybee JSON as an array of modifiers.
\n
Args:
modifier_rad: Full path to a Modifier .rad or .mat file. Only the modifiers
and materials in this file will be extracted.
"""
try:
# re-serialize the Modifiers to Python
mod_objs = []
with open(modifier_rad) as f:
rad_dicts = string_to_dicts(f.read())
for mod_dict in rad_dicts:
mod_objs.append(dict_to_modifier(mod_dict))
# create the honeybee dictionaries
json_dicts = [mod.to_dict() for mod in mod_objs]
# write out the JSON file
output_file.write(json.dumps(json_dicts))
except Exception as e:
_logger.exception('Modifier translation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def load_modifiers_from_folder(modifier_lib_folder):
"""Load all of the material layer objects from a modifier standards folder.
Args:
modifier_lib_folder: Path to a modifiers sub-folder within a
honeybee standards folder.
"""
user_modifiers = {}
for f in os.listdir(modifier_lib_folder):
f_path = os.path.join(modifier_lib_folder, f)
if os.path.isfile(f_path):
if f_path.endswith('.mat') or f_path.endswith('.rad'):
with open(f_path) as f:
try:
rad_dicts = string_to_dicts(f.read())
for mod_dict in rad_dicts:
mod = dict_to_modifier(mod_dict)
mod.lock()
user_modifiers[mod.identifier] = mod
except ValueError:
pass # empty rad file with no modifiers in them
if f_path.endswith('.json'):
with open(f_path) as json_file:
data = json.load(json_file)
if 'type' in data: # single object
load_modifier_object(data, user_modifiers)
else: # a collection of several objects
for mod_identifier in data:
load_modifier_object(data[mod_identifier],
user_modifiers)
return user_modifiers
def from_primitive_dict(cls, primitive_dict):
"""Initialize mirror from a primitive dict.
Args:
data: A dictionary in the format below.
.. code-block:: python
{
"modifier": {}, # primitive modifier (Default: None)
"type": "mirror", # primitive type
"identifier": "", # primitive identifier
"display_name": "", # primitive display name
"values": [], # values
"dependencies": []
}
"""
cls._dict_type_check(cls.__name__, primitive_dict)
modifier, dependencies = cls.filter_dict_input(primitive_dict)
if len(primitive_dict['values'][0]) == 1:
# find name
alt_id = primitive_dict['values'][0][0]
if alt_id == 'void':
alternate_material = VOID
elif isinstance(alt_id, dict):
try: # see if the mutil module has already been imported
mutil
except NameError:
# import the module here to avoid a circular import
import honeybee_radiance.mutil as mutil
alternate_material = mutil.dict_to_modifier(alt_id)
else:
alt_mats = [d for d in dependencies if d.identifier == alt_id]
assert len(alt_mats) == 1, \
'Failed to find alternate material for mirror: "{}" in ' \
'dependencies.'.format(alt_id)
# remove it from dependencies
alternate_material = alt_mats[0]
dependencies.remove(alternate_material)
else:
alternate_material = None
values = primitive_dict['values'][2]
cls_ = cls(identifier=primitive_dict["identifier"],
r_reflectance=values[0],
g_reflectance=values[1],
b_reflectance=values[2],
modifier=modifier,
alternate_material=alternate_material,
dependencies=dependencies)
if 'display_name' in primitive_dict \
and primitive_dict['display_name'] is not None:
cls_.display_name = primitive_dict['display_name']
# this might look redundant but it is NOT. see glass for explanation.
cls_.values = primitive_dict['values']
return cls_
def from_dict(cls, data):
"""Create a ModifierSet from a dictionary.
Note that the dictionary must be a non-abridged version for this
classmethod to work.
Args:
data: Dictionary describing the ModifierSet in the following format.
.. code-block:: python
{
'type': 'ModifierSet',
'identifier': str, # ModifierSet identifier
"display_name": str, # ModifierSet display name
'wall_set': {}, # WallModifierSet dictionary
'floor_set': {}, # FloorSet dictionary
'roof_ceiling_set': {}, # RoofCeilingModifierSet dictionary
'aperture_set': {}, # ApertureModifierSet dictionary
'door_set': {}, # DoorModifierSet dictionary
'shade_set': {}, # ShadeModifierSet dictionary
'air_boundary_modifier': {}, # AirBoundary dictionary
}
"""
assert data['type'] == 'ModifierSet', \
'Expected ModifierSet. Got {}.'.format(data['type'])
# build each of the sub-construction sets
wall_set = WallModifierSet.from_dict(data['wall_set']) if 'wall_set' \
in data and data['wall_set'] is not None else None
floor_set = FloorModifierSet.from_dict(data['floor_set']) if 'floor_set' \
in data and data['floor_set'] is not None else None
roof_ceiling_set = RoofCeilingModifierSet.from_dict(data['roof_ceiling_set']) \
if 'roof_ceiling_set' in data and \
data['roof_ceiling_set'] is not None else None
aperture_set = ApertureModifierSet.from_dict(data['aperture_set']) if \
'aperture_set' in data and data['aperture_set'] is not None else None
door_set = DoorModifierSet.from_dict(data['door_set']) if \
'door_set' in data and data['door_set'] is not None else None
shade_set = ShadeModifierSet.from_dict(data['shade_set']) if \
'shade_set' in data and data['shade_set'] is not None else None
air_mod = dict_to_modifier(data['air_boundary_modifier']) \
if 'air_boundary_modifier' in data and \
data['air_boundary_modifier'] is not None else None
new_obj = cls(data['identifier'], wall_set, floor_set,
roof_ceiling_set, aperture_set, door_set, shade_set,
air_mod)
if 'display_name' in data and data['display_name'] is not None:
new_obj.display_name = data['display_name']
return new_obj
def filter_dict_input(input_dict):
"""Filter a dictionary of a Primitive to get modifier and dependency objects."""
try: # see if the mutil module has already been imported
mutil
except NameError:
# import the module here (instead of at top) to avoid a circular import
import honeybee_radiance.mutil as mutil # imports all modifiers classes
# try to get modifier
if 'modifier' not in input_dict or input_dict['modifier'] is None or \
input_dict['modifier'] == 'void':
modifier = VOID
else:
modifier = mutil.dict_to_modifier(input_dict['modifier'])
if 'dependencies' not in input_dict:
dependencies = []
else:
dependencies = [
mutil.dict_to_modifier(dep) for dep in input_dict['dependencies']
]
return modifier, dependencies
def from_dict(cls, data):
"""Initialize Mirror from a dictionary.
Args:
data: A dictionary in the format below.
.. code-block:: python
{
"type": "mirror", # Material type
"identifier": "", # Material identifier
"display_name": string # Material display name
"r_reflectance": float, # Reflectance for red
"g_reflectance": float, # Reflectance for green
"b_reflectance": float, # Reflectance for blue
"modifier": {}, # Material modifier (Default: None)
"alternate_material": {}, # optional alternate material
"dependencies": []
}
"""
assert 'type' in data, 'Input dictionary is missing "type".'
if data['type'] != cls.__name__.lower():
raise ValueError(
'Type must be %s not %s.' % (cls.__name__.lower(), data['type'])
)
modifier, dependencies = Material.filter_dict_input(data)
if 'alternate_material' in data and data['alternate_material']:
# alternate material
if data['alternate_material'] == 'void':
alternate_material = VOID
else:
try: # see if the mutil module has already been imported
mutil
except NameError:
# import the module here to avoid a circular import
import honeybee_radiance.mutil as mutil
alternate_material = mutil.dict_to_modifier(data['alternate_material'])
else:
alternate_material = None
new_obj = cls(identifier=data["identifier"],
r_reflectance=data["r_reflectance"],
g_reflectance=data["g_reflectance"],
b_reflectance=data["b_reflectance"],
modifier=modifier,
alternate_material=alternate_material,
dependencies=dependencies)
if 'display_name' in data and data['display_name'] is not None:
new_obj.display_name = data['display_name']
return new_obj
mod = m_class.from_dict(mod_dict)
mod.lock()
assert mod_dict['identifier'] not in _default_mods, 'Cannot overwrite ' \
'default modifier "{}".'.format(mod_dict['identifier'])
_loaded_modifiers[mod_dict['identifier']] = mod
except (TypeError, KeyError):
pass # not a Honeybee Modifier JSON; possibly a comment
for f in os.listdir(folders.modifier_lib):
f_path = os.path.join(folders.modifier_lib, f)
if os.path.isfile(f_path):
if f_path.endswith('.mat') or f_path.endswith('.rad'):
with open(f_path) as f:
try:
rad_dicts = string_to_dicts(f.read())
for mod_dict in rad_dicts:
mod = dict_to_modifier(mod_dict)
mod.lock()
_loaded_modifiers[mod.identifier] = mod
except ValueError:
pass # empty rad file with no modifiers in them
if f_path.endswith('.json'):
with open(f_path) as json_file:
data = json.load(json_file)
if 'type' in data: # single object
load_modifier_object(data)
else: # a collection of several objects
for mod_identifier in data:
load_modifier_object(data[mod_identifier])
