openstudio-common-measures 0.2.0 → 0.2.1

data/lib/measures/view_model/resources/va3c.rb

@@ -0,0 +1,1021 @@
+# *******************************************************************************
+# OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC.
+# All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# (4) Other than as required in clauses (1) and (2), distributions in any form
+# of modifications or other derivative works may not use the "OpenStudio"
+# trademark, "OS", "os", or any other confusingly similar designation without
+# specific prior written permission from Alliance for Sustainable Energy, LLC.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+require 'openstudio'
+
+if /^1\.8/.match(RUBY_VERSION)
+  class Struct
+    def to_h
+      h = {}
+      self.class.members.each { |m| h[m.to_sym] = self[m] }
+      return h
+    end
+  end
+end
+
+module THREE
+  FrontSide = 0
+  BackSide = 1
+  DoubleSide = 2
+end
+
+# Va3c class converts an OpenStudio model to vA3C JSON format for rendering in Three.js
+# using export at http://va3c.github.io/projects/#./osm-data-viewer/latest/index.html# as a guide
+# many thanks to Theo Armour and the vA3C team for figuring out many of the details here
+class VA3C
+  Scene = Struct.new(:geometries, :materials, :object)
+
+  Geometry = Struct.new(:uuid, :type, :data)
+  GeometryData = Struct.new(:vertices, :normals, :uvs, :faces, :scale, :visible, :castShadow, :receiveShadow, :doubleSided)
+
+  Material = Struct.new(:uuid, :type, :color, :ambient, :emissive, :specular, :shininess, :side, :opacity, :transparent, :wireframe)
+
+  SceneObject = Struct.new(:uuid, :type, :matrix, :children)
+  SceneChild = Struct.new(:uuid, :name, :type, :geometry, :material, :matrix, :userData)
+  UserData = Struct.new(:handle, :name, :surfaceType, :constructionName, :spaceName, :thermalZoneName, :spaceTypeName, :buildingStoryName,
+                        :outsideBoundaryCondition, :outsideBoundaryConditionObjectName,
+                        :outsideBoundaryConditionObjectHandle, :coincidentWithOutsideObject,
+                        :sunExposure, :windExposure, #:vertices,
+                        :surfaceTypeMaterialName, :boundaryMaterialName, :constructionMaterialName, :thermalZoneMaterialName,
+                        :spaceTypeMaterialName, :buildingStoryMaterialName) do
+    def initialize(*)
+      super
+      self.surfaceTypeMaterialName = 'Undefined' if surfaceTypeMaterialName.nil?
+      self.boundaryMaterialName = 'Undefined' if boundaryMaterialName.nil?
+      self.constructionMaterialName = 'Undefined' if constructionMaterialName.nil?
+      self.thermalZoneMaterialName = 'Undefined' if thermalZoneMaterialName.nil?
+      self.spaceTypeMaterialName = 'Undefined' if spaceTypeMaterialName.nil?
+      self.buildingStoryMaterialName = 'Undefined' if buildingStoryMaterialName.nil?
+
+      self.constructionName = '' if constructionName.nil?
+      self.spaceName = '' if spaceName.nil?
+      self.thermalZoneName = '' if thermalZoneName.nil?
+      self.spaceTypeName = '' if spaceTypeName.nil?
+      self.buildingStoryName = '' if buildingStoryName.nil?
+      self.outsideBoundaryCondition = '' if outsideBoundaryCondition.nil?
+      self.outsideBoundaryConditionObjectName = '' if outsideBoundaryConditionObjectName.nil?
+    end
+  end
+  Vertex = Struct.new(:x, :y, :z)
+
+  AmbientLight = Struct.new(:uuid, :type, :color, :matrix)
+
+  def self.convert_model(model)
+    scene = build_scene(model)
+
+    northAxis = -model.getBuilding.northAxis
+
+    boundingBox = OpenStudio::BoundingBox.new
+    boundingBox.addPoint(OpenStudio::Point3d.new(0, 0, 0))
+    boundingBox.addPoint(OpenStudio::Point3d.new(1, 1, 1))
+    model.getPlanarSurfaceGroups.each do |group|
+      boundingBox.add(group.transformation * group.boundingBox)
+    end
+
+    lookAtX = 0 # (boundingBox.minX.get + boundingBox.maxX.get) / 2.0
+    lookAtY = 0 # (boundingBox.minY.get + boundingBox.maxY.get) / 2.0
+    lookAtZ = 0 # (boundingBox.minZ.get + boundingBox.maxZ.get) / 2.0
+    lookAtR = [Math.sqrt((boundingBox.maxX.get / 2.0)**2 + (boundingBox.maxY.get / 2.0)**2 + (boundingBox.maxZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.minX.get / 2.0)**2 + (boundingBox.maxY.get / 2.0)**2 + (boundingBox.maxZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.maxX.get / 2.0)**2 + (boundingBox.minY.get / 2.0)**2 + (boundingBox.maxZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.maxX.get / 2.0)**2 + (boundingBox.maxY.get / 2.0)**2 + (boundingBox.minZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.minX.get / 2.0)**2 + (boundingBox.minY.get / 2.0)**2 + (boundingBox.maxZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.minX.get / 2.0)**2 + (boundingBox.maxY.get / 2.0)**2 + (boundingBox.minZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.maxX.get / 2.0)**2 + (boundingBox.minY.get / 2.0)**2 + (boundingBox.minZ.get / 2.0)**2),
+               Math.sqrt((boundingBox.minX.get / 2.0)**2 + (boundingBox.minY.get / 2.0)**2 + (boundingBox.minZ.get / 2.0)**2)].max
+
+    boundingBoxHash = { 'minX' => boundingBox.minX.get, 'minY' => boundingBox.minY.get, 'minZ' => boundingBox.minZ.get,
+                        'maxX' => boundingBox.maxX.get, 'maxY' => boundingBox.maxY.get, 'maxZ' => boundingBox.maxZ.get,
+                        'lookAtX' => lookAtX, 'lookAtY' => lookAtY, 'lookAtZ' => lookAtZ, 'lookAtR' => lookAtR }
+
+    buildingStoryNames = []
+    model.getBuildingStorys.each do |buildingStory|
+      buildingStoryNames << buildingStory.name.to_s
+    end
+    buildingStoryNames.sort! { |x, y| x.upcase <=> y.upcase } # case insensitive sort
+
+    # build up the json hash
+    result = {}
+    result['metadata'] = { 'version' => 4.3, 'type' => 'Object', 'generator' => 'OpenStudio',
+                           'buildingStoryNames' => buildingStoryNames, 'boundingBox' => boundingBoxHash,
+                           'northAxis' => northAxis }
+    result['geometries'] = scene.geometries
+    result['materials'] = scene.materials
+    result['object'] = scene.object
+
+    return result
+  end
+
+  # format a uuid
+  def self.format_uuid(uuid)
+    return uuid.to_s.gsub('{', '').gsub('}', '')
+  end
+
+  # format color
+  def self.format_color(r, g, b)
+    return "0x#{r.to_s(16).rjust(2, '0')}#{g.to_s(16).rjust(2, '0')}#{b.to_s(16).rjust(2, '0')}"
+  end
+
+  # create a material
+  def self.make_material(name, color, opacity, side, shininess = 50)
+    transparent = false
+    if opacity < 1
+      transparent = true
+    end
+
+    material = { uuid: format_uuid(OpenStudio.createUUID).to_s,
+                 name: name,
+                 type: 'MeshPhongMaterial',
+                 color: color.to_s.hex,
+                 ambient: color.to_s.hex,
+                 emissive: '0x000000'.hex,
+                 specular: color.to_s.hex,
+                 shininess: shininess,
+                 opacity: opacity,
+                 transparent: transparent,
+                 wireframe: false,
+                 side: side }
+    return material
+  end
+
+  # create the standard materials
+  def self.build_materials(model)
+    materials = []
+
+    # materials << make_material('Undefined', format_color(255, 255, 255), 1, THREE::DoubleSide)
+    materials << { uuid: format_uuid(OpenStudio.createUUID).to_s, name: 'Undefined', type: 'MeshBasicMaterial', color: '0xffffff'.hex, side: THREE::DoubleSide }
+
+    materials << make_material('NormalMaterial', format_color(255, 255, 255), 1, THREE::DoubleSide)
+    # materials << make_material('NormalMaterial_Ext', format_color(255, 255, 255), 1, THREE::FrontSide)
+    materials << { uuid: format_uuid(OpenStudio.createUUID).to_s, name: 'NormalMaterial_Ext', type: 'MeshBasicMaterial', color: '0xffffff'.hex, side: THREE::FrontSide }
+    materials << make_material('NormalMaterial_Int', format_color(255, 0, 0), 1, THREE::BackSide)
+
+    # materials from 'openstudio\openstudiocore\ruby\openstudio\sketchup_plugin\lib\interfaces\MaterialsInterface.rb'
+    materials << make_material('Floor', format_color(128, 128, 128), 1, THREE::DoubleSide)
+    materials << make_material('Floor_Ext', format_color(128, 128, 128), 1, THREE::FrontSide)
+    materials << make_material('Floor_Int', format_color(191, 191, 191), 1, THREE::BackSide)
+
+    materials << make_material('Wall', format_color(204, 178, 102), 1, THREE::DoubleSide)
+    materials << make_material('Wall_Ext', format_color(204, 178, 102), 1, THREE::FrontSide)
+    materials << make_material('Wall_Int', format_color(235, 226, 197), 1, THREE::BackSide)
+
+    materials << make_material('RoofCeiling', format_color(153, 76, 76), 1, THREE::DoubleSide)
+    materials << make_material('RoofCeiling_Ext', format_color(153, 76, 76), 1, THREE::FrontSide)
+    materials << make_material('RoofCeiling_Int', format_color(202, 149, 149), 1, THREE::BackSide)
+
+    materials << make_material('Window', format_color(102, 178, 204), 0.6, THREE::DoubleSide)
+    materials << make_material('Window_Ext', format_color(102, 178, 204), 0.6, THREE::FrontSide)
+    materials << make_material('Window_Int', format_color(192, 226, 235), 0.6, THREE::BackSide)
+
+    materials << make_material('Door', format_color(153, 133, 76), 1, THREE::DoubleSide)
+    materials << make_material('Door_Ext', format_color(153, 133, 76), 1, THREE::FrontSide)
+    materials << make_material('Door_Int', format_color(202, 188, 149), 1, THREE::BackSide)
+
+    materials << make_material('SiteShading', format_color(75, 124, 149), 1, THREE::DoubleSide)
+    materials << make_material('SiteShading_Ext', format_color(75, 124, 149), 1, THREE::FrontSide)
+    materials << make_material('SiteShading_Int', format_color(187, 209, 220), 1, THREE::BackSide)
+
+    materials << make_material('BuildingShading', format_color(113, 76, 153), 1, THREE::DoubleSide)
+    materials << make_material('BuildingShading_Ext', format_color(113, 76, 153), 1, THREE::FrontSide)
+    materials << make_material('BuildingShading_Int', format_color(216, 203, 229), 1, THREE::BackSide)
+
+    materials << make_material('SpaceShading', format_color(76, 110, 178), 1, THREE::DoubleSide)
+    materials << make_material('SpaceShading_Ext', format_color(76, 110, 178), 1, THREE::FrontSide)
+    materials << make_material('SpaceShading_Int', format_color(183, 197, 224), 1, THREE::BackSide)
+
+    materials << make_material('InteriorPartitionSurface', format_color(158, 188, 143), 1, THREE::DoubleSide)
+    materials << make_material('InteriorPartitionSurface_Ext', format_color(158, 188, 143), 1, THREE::FrontSide)
+    materials << make_material('InteriorPartitionSurface_Int', format_color(213, 226, 207), 1, THREE::BackSide)
+
+    # start textures for boundary conditions
+    materials << make_material('Boundary_Surface', format_color(0, 153, 0), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Adiabatic', format_color(255, 101, 178), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Space', format_color(255, 0, 0), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Outdoors', format_color(163, 204, 204), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Outdoors_Sun', format_color(40, 204, 204), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Outdoors_Wind', format_color(9, 159, 162), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Outdoors_SunWind', format_color(68, 119, 161), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Ground', format_color(204, 183, 122), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundfcfactormethod', format_color(153, 122, 30), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundslabpreprocessoraverage', format_color(255, 191, 0), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundslabpreprocessorcore', format_color(255, 182, 50), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundslabpreprocessorperimeter', format_color(255, 178, 101), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundbasementpreprocessoraveragewall', format_color(204, 51, 0), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundbasementpreprocessoraveragefloor', format_color(204, 81, 40), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundbasementpreprocessorupperwall', format_color(204, 112, 81), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Groundbasementpreprocessorlowerwall', format_color(204, 173, 163), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Othersidecoefficients', format_color(63, 63, 63), 1, THREE::DoubleSide)
+    materials << make_material('Boundary_Othersideconditionsmodel', format_color(153, 0, 76), 1, THREE::DoubleSide)
+
+    # make construction materials
+    model.getConstructionBases.each do |construction|
+      color = construction.renderingColor
+      if color.empty?
+        color = OpenStudio::Model::RenderingColor.new(model)
+        construction.setRenderingColor(color)
+      else
+        color = color.get
+      end
+      name = "Construction_#{construction.name}"
+      materials << make_material(name, format_color(color.renderingRedValue, color.renderingGreenValue, color.renderingBlueValue), color.renderingAlphaValue / 255.to_f, THREE::DoubleSide)
+    end
+
+    # make thermal zone materials
+    model.getThermalZones.each do |zone|
+      color = zone.renderingColor
+      if color.empty?
+        color = OpenStudio::Model::RenderingColor.new(model)
+        zone.setRenderingColor(color)
+      else
+        color = color.get
+      end
+      name = "ThermalZone_#{zone.name}"
+      materials << make_material(name, format_color(color.renderingRedValue, color.renderingGreenValue, color.renderingBlueValue), color.renderingAlphaValue / 255.to_f, THREE::DoubleSide)
+    end
+
+    # make space type materials
+    model.getSpaceTypes.each do |spaceType|
+      color = spaceType.renderingColor
+      if color.empty?
+        color = OpenStudio::Model::RenderingColor.new(model)
+        spaceType.setRenderingColor(color)
+      else
+        color = color.get
+      end
+      name = "SpaceType_#{spaceType.name}"
+      materials << make_material(name, format_color(color.renderingRedValue, color.renderingGreenValue, color.renderingBlueValue), color.renderingAlphaValue / 255.to_f, THREE::DoubleSide)
+    end
+
+    # make building story materials
+    model.getBuildingStorys.each do |buildingStory|
+      color = buildingStory.renderingColor
+      if color.empty?
+        color = OpenStudio::Model::RenderingColor.new(model)
+        buildingStory.setRenderingColor(color)
+      else
+        color = color.get
+      end
+      name = "BuildingStory_#{buildingStory.name}"
+      materials << make_material(name, format_color(color.renderingRedValue, color.renderingGreenValue, color.renderingBlueValue), color.renderingAlphaValue / 255.to_f, THREE::DoubleSide)
+    end
+
+    return materials
+  end
+
+  # get the index of a vertex out of a list
+  def self.get_vertex_index(vertex, vertices, tol = 0.001)
+    vertices.each_index do |i|
+      if OpenStudio.getDistance(vertex, vertices[i]) < tol
+        return i
+      end
+    end
+    vertices << vertex
+    return (vertices.length - 1)
+  end
+
+  # flatten array of vertices into a single array
+  def self.flatten_vertices(vertices)
+    result = []
+    vertices.each do |vertex|
+      # result << vertex.x
+      # result << vertex.y
+      # result << vertex.z
+
+      result << vertex.x.round(3)
+      result << vertex.z.round(3)
+      result << -vertex.y.round(3)
+    end
+    return result
+  end
+
+  # turn a surface into geometries, the first one is the surface, remaining are sub surfaces
+  def self.make_geometries(surface)
+    geometries = []
+    user_datas = []
+
+    # get the transformation to site coordinates
+    site_transformation = OpenStudio::Transformation.new
+    building = surface.model.getBuilding
+
+    space = surface.space
+    if space.is_initialized
+      site_transformation = building.transformation * space.get.transformation
+    else
+      site_transformation = building.transformation
+    end
+
+    # get the vertices
+    surface_vertices = surface.vertices
+    t = OpenStudio::Transformation.alignFace(surface_vertices)
+    r = t.rotationMatrix
+    tInv = t.inverse
+    surface_vertices = OpenStudio.reverse(tInv * surface_vertices)
+
+    # get vertices of all sub surfaces
+    sub_surface_vertices = OpenStudio::Point3dVectorVector.new
+    sub_surfaces = surface.subSurfaces
+    sub_surfaces.each do |sub_surface|
+      sub_surface_vertices << OpenStudio.reverse(tInv * sub_surface.vertices)
+    end
+
+    # triangulate surface
+    triangles = OpenStudio.computeTriangulation(surface_vertices, sub_surface_vertices)
+    if triangles.empty?
+      puts "Failed to triangulate surface #{surface.name} with #{sub_surfaces.size} sub surfaces"
+      return geometries
+    end
+
+    all_vertices = []
+    face_indices = []
+    triangles.each do |vertices|
+      vertices = site_transformation * t * vertices
+      # normal = site_transformation.rotationMatrix*r*z
+
+      # https://github.com/mrdoob/three.js/wiki/JSON-Model-format-3
+      # 0 indicates triangle
+      # 16 indicates triangle with normals
+      face_indices << 0
+      vertices.reverse_each do |vertex|
+        face_indices << get_vertex_index(vertex, all_vertices)
+      end
+
+      # convert to 1 based indices
+      # face_indices.each_index {|i| face_indices[i] = face_indices[i] + 1}
+    end
+
+    data = GeometryData.new
+    data.vertices = flatten_vertices(all_vertices)
+    data.normals = []
+    data.uvs = []
+    data.faces = face_indices
+    data.scale = 1
+    data.visible = true
+    data.castShadow = true
+    data.receiveShadow = false
+    data.doubleSided = true
+
+    geometry = Geometry.new
+    geometry.uuid = format_uuid(surface.handle)
+    geometry.type = 'Geometry'
+    geometry.data = data.to_h
+    geometries << geometry.to_h
+
+    surface_user_data = UserData.new
+    surface_user_data.handle = format_uuid(surface.handle)
+    surface_user_data.name = surface.name.to_s
+    surface_user_data.coincidentWithOutsideObject = false
+    surface_user_data.surfaceType = surface.surfaceType
+    surface_user_data.surfaceTypeMaterialName = surface.surfaceType
+
+    surface_user_data.outsideBoundaryCondition = surface.outsideBoundaryCondition
+    adjacent_surface = surface.adjacentSurface
+    if adjacent_surface.is_initialized
+      surface_user_data.outsideBoundaryConditionObjectName = adjacent_surface.get.name.to_s
+      surface_user_data.outsideBoundaryConditionObjectHandle = format_uuid(adjacent_surface.get.handle)
+
+      other_site_transformation = OpenStudio::Transformation.new
+      other_space = adjacent_surface.get.space
+      if !other_space.empty?
+        other_site_transformation = building.transformation * other_space.get.transformation
+      else
+        other_site_transformation = building.transformation
+      end
+
+      other_vertices = other_site_transformation * adjacent_surface.get.vertices
+      if OpenStudio.circularEqual(site_transformation * surface.vertices, OpenStudio.reverse(other_vertices))
+        # puts "adjacent surfaces are coincident"
+        surface_user_data.coincidentWithOutsideObject = true # controls display only, not energy model
+      else
+        # puts "adjacent surfaces are not coincident"
+        surface_user_data.coincidentWithOutsideObject = false # controls display only, not energy model
+      end
+
+    end
+    surface_user_data.sunExposure = surface.sunExposure
+    surface_user_data.windExposure = surface.windExposure
+
+    if surface.outsideBoundaryCondition == 'Outdoors'
+      if surface.sunExposure == 'SunExposed' && surface.windExposure == 'WindExposed'
+        surface_user_data.boundaryMaterialName = 'Boundary_Outdoors_SunWind'
+      elsif surface.sunExposure == 'SunExposed'
+        surface_user_data.boundaryMaterialName = 'Boundary_Outdoors_Sun'
+      elsif surface.sunExposure == 'WindExposed'
+        surface_user_data.boundaryMaterialName = 'Boundary_Outdoors_Wind'
+      else
+        surface_user_data.boundaryMaterialName = 'Boundary_Outdoors'
+      end
+    else
+      surface_user_data.boundaryMaterialName = 'Boundary_' + surface.outsideBoundaryCondition
+    end
+
+    construction = surface.construction
+    if construction.is_initialized
+      surface_user_data.constructionName = construction.get.name.to_s
+      surface_user_data.constructionMaterialName = 'Construction_' + construction.get.name.to_s
+    end
+
+    space = surface.space
+    if space.is_initialized
+      space = space.get
+      surface_user_data.spaceName = space.name.to_s
+
+      thermal_zone = space.thermalZone
+      if thermal_zone.is_initialized
+        surface_user_data.thermalZoneName = thermal_zone.get.name.to_s
+        surface_user_data.thermalZoneMaterialName = 'ThermalZone_' + thermal_zone.get.name.to_s
+      end
+
+      space_type = space.spaceType
+      if space_type.is_initialized
+        surface_user_data.spaceTypeName = space_type.get.name.to_s
+        surface_user_data.spaceTypeMaterialName = 'SpaceType_' + space_type.get.name.to_s
+      end
+
+      building_story = space.buildingStory
+      if building_story.is_initialized
+        surface_user_data.buildingStoryName = building_story.get.name.to_s
+        surface_user_data.buildingStoryMaterialName = 'BuildingStory_' + building_story.get.name.to_s
+      end
+    end
+
+    # vertices = []
+    # surface.vertices.each do |v|
+    #  vertex = Vertex.new
+    #  vertex.x = v.x
+    #  vertex.y = v.y
+    #  vertex.z = v.z
+    #  vertices << vertex.to_h
+    # end
+    # surface_user_data.vertices = vertices
+    user_datas << surface_user_data.to_h
+
+    # now add geometry for each sub surface
+    sub_surfaces.each do |sub_surface|
+      # triangulate sub surface
+      sub_surface_vertices = OpenStudio.reverse(tInv * sub_surface.vertices)
+      triangles = OpenStudio.computeTriangulation(sub_surface_vertices, OpenStudio::Point3dVectorVector.new)
+
+      all_vertices = []
+      face_indices = []
+      triangles.each do |vertices|
+        vertices = site_transformation * t * vertices
+        # normal = site_transformation.rotationMatrix*r*z
+
+        # https://github.com/mrdoob/three.js/wiki/JSON-Model-format-3
+        # 0 indicates triangle
+        # 16 indicates triangle with normals
+        face_indices << 0
+        vertices.reverse_each do |vertex|
+          face_indices << get_vertex_index(vertex, all_vertices)
+        end
+
+        # convert to 1 based indices
+        # face_indices.each_index {|i| face_indices[i] = face_indices[i] + 1}
+      end
+
+      data = GeometryData.new
+      data.vertices = flatten_vertices(all_vertices)
+      data.normals = []
+      data.uvs = []
+      data.faces = face_indices
+      data.scale = 1
+      data.visible = true
+      data.castShadow = true
+      data.receiveShadow = false
+      data.doubleSided = true
+
+      geometry = Geometry.new
+      geometry.uuid = format_uuid(sub_surface.handle)
+      geometry.type = 'Geometry'
+      geometry.data = data.to_h
+      geometries << geometry.to_h
+
+      sub_surface_user_data = UserData.new
+      sub_surface_user_data.handle = format_uuid(sub_surface.handle)
+      sub_surface_user_data.name = sub_surface.name.to_s
+      sub_surface_user_data.coincidentWithOutsideObject = false
+
+      sub_surface_user_data.surfaceType = sub_surface.subSurfaceType
+      if /Window/.match(sub_surface.subSurfaceType) || /Glass/.match(sub_surface.subSurfaceType) ||
+         /Skylight/.match(sub_surface.subSurfaceType) || /TubularDaylight/.match(sub_surface.subSurfaceType)
+        sub_surface_user_data.surfaceTypeMaterialName = 'Window'
+      else
+        sub_surface_user_data.surfaceTypeMaterialName = 'Door'
+      end
+
+      sub_surface_user_data.outsideBoundaryCondition = surface_user_data.outsideBoundaryCondition
+      adjacent_sub_surface = sub_surface.adjacentSubSurface
+      if adjacent_sub_surface.is_initialized
+        sub_surface_user_data.outsideBoundaryConditionObjectName = adjacent_sub_surface.get.name.to_s
+        sub_surface_user_data.outsideBoundaryConditionObjectHandle = format_uuid(adjacent_sub_surface.get.handle)
+
+        other_site_transformation = OpenStudio::Transformation.new
+        other_space = adjacent_sub_surface.get.space
+        if !other_space.empty?
+          other_site_transformation = building.transformation * other_space.get.transformation
+        else
+          other_site_transformation = building.transformation
+        end
+
+        other_vertices = other_site_transformation * adjacent_sub_surface.get.vertices
+        if OpenStudio.circularEqual(site_transformation * sub_surface.vertices, OpenStudio.reverse(other_vertices))
+          # puts "adjacent sub surfaces are coincident"
+          surface_user_data.coincidentWithOutsideObject = true # controls display only, not energy model
+        else
+          # puts "adjacent sub surfaces are not coincident"
+          surface_user_data.coincidentWithOutsideObject = false # controls display only, not energy model
+        end
+
+        sub_surface_user_data.boundaryMaterialName = 'Boundary_Surface'
+      else
+        if surface_user_data.boundaryMaterialName == 'Boundary_Surface'
+          sub_surface_user_data.boundaryMaterialName = 'Undefined'
+        else
+          sub_surface_user_data.boundaryMaterialName = surface_user_data.boundaryMaterialName
+        end
+      end
+      sub_surface_user_data.sunExposure = surface_user_data.sunExposure
+      sub_surface_user_data.windExposure = surface_user_data.windExposure
+
+      construction = sub_surface.construction
+      if construction.is_initialized
+        sub_surface_user_data.constructionName = construction.get.name.to_s
+        sub_surface_user_data.constructionMaterialName = 'Construction_' + construction.get.name.to_s
+      end
+      sub_surface_user_data.spaceName = surface_user_data.spaceName
+      sub_surface_user_data.thermalZoneName = surface_user_data.thermalZoneName
+      sub_surface_user_data.thermalZoneMaterialName = surface_user_data.thermalZoneMaterialName
+      sub_surface_user_data.spaceTypeName = surface_user_data.spaceTypeName
+      sub_surface_user_data.spaceTypeMaterialName = surface_user_data.spaceTypeMaterialName
+      sub_surface_user_data.buildingStoryName = surface_user_data.buildingStoryName
+      sub_surface_user_data.buildingStoryMaterialName = surface_user_data.buildingStoryMaterialName
+
+      # vertices = []
+      # surface.vertices.each do |v|
+      #  vertex = Vertex.new
+      #  vertex.x = v.x
+      #  vertex.y = v.y
+      #  vertex.z = v.z
+      #  vertices << vertex.to_h
+      # end
+      # sub_surface_user_data.vertices = vertices
+      user_datas << sub_surface_user_data.to_h
+    end
+
+    return [geometries, user_datas]
+  end
+
+  # turn a shading surface into geometries
+  def self.make_shade_geometries(surface)
+    geometries = []
+    user_datas = []
+
+    # get the transformation to site coordinates
+    site_transformation = OpenStudio::Transformation.new
+    building = surface.model.getBuilding
+
+    shading_surface_group = surface.shadingSurfaceGroup
+    shading_surface_type = 'Building'
+    space_name = nil
+    thermal_zone_name = nil
+    space_type_name = nil
+    building_story_name = nil
+    if !shading_surface_group.empty?
+      shading_surface_type = shading_surface_group.get.shadingSurfaceType
+
+      space = shading_surface_group.get.space
+      if space.is_initialized
+        space = space.get
+        space_name = space.name.to_s
+
+        thermal_zone = space.thermalZone
+        if thermal_zone.is_initialized
+          thermal_zone_name = thermal_zone.get.name.to_s
+        end
+
+        space_type = space.spaceType
+        if space_type.is_initialized
+          space_type_name = space_type.get.name.to_s
+        end
+
+        building_story = space.buildingStory
+        if building_story.is_initialized
+          building_story_name = building_story.get.name.to_s
+        end
+
+        site_transformation = building.transformation * space.transformation * shading_surface_group.get.transformation
+      elsif /Site/i.match(shading_surface_type)
+        site_transformation = shading_surface_group.get.transformation
+      else
+        site_transformation = building.transformation * shading_surface_group.get.transformation
+      end
+
+    end
+
+    # get the vertices
+    surface_vertices = surface.vertices
+    t = OpenStudio::Transformation.alignFace(surface_vertices)
+    r = t.rotationMatrix
+    tInv = t.inverse
+    surface_vertices = OpenStudio.reverse(tInv * surface_vertices)
+
+    # triangulate surface
+    triangles = OpenStudio.computeTriangulation(surface_vertices, OpenStudio::Point3dVectorVector.new)
+    if triangles.empty?
+      puts "Failed to triangulate shading surface #{surface.name}"
+      return geometries
+    end
+
+    all_vertices = []
+    face_indices = []
+    triangles.each do |vertices|
+      vertices = site_transformation * t * vertices
+      # normal = site_transformation.rotationMatrix*r*z
+
+      # https://github.com/mrdoob/three.js/wiki/JSON-Model-format-3
+      # 0 indicates triangle
+      # 16 indicates triangle with normals
+      face_indices << 0
+      vertices.reverse_each do |vertex|
+        face_indices << get_vertex_index(vertex, all_vertices)
+      end
+
+      # convert to 1 based indices
+      # face_indices.each_index {|i| face_indices[i] = face_indices[i] + 1}
+    end
+
+    data = GeometryData.new
+    data.vertices = flatten_vertices(all_vertices)
+    data.normals = []
+    data.uvs = []
+    data.faces = face_indices
+    data.scale = 1
+    data.visible = true
+    data.castShadow = true
+    data.receiveShadow = false
+    data.doubleSided = true
+
+    geometry = Geometry.new
+    geometry.uuid = format_uuid(surface.handle)
+    geometry.type = 'Geometry'
+    geometry.data = data.to_h
+    geometries << geometry.to_h
+
+    surface_user_data = UserData.new
+    surface_user_data.handle = format_uuid(surface.handle)
+    surface_user_data.name = surface.name.to_s
+    surface_user_data.coincidentWithOutsideObject = false
+
+    surface_user_data.surfaceType = shading_surface_type + 'Shading'
+    surface_user_data.surfaceTypeMaterialName = shading_surface_type + 'Shading'
+
+    # surface_user_data.outsideBoundaryCondition = nil
+    # surface_user_data.outsideBoundaryConditionObjectName = nil
+    # surface_user_data.outsideBoundaryConditionObjectHandle = nil
+    surface_user_data.sunExposure = 'SunExposed'
+    surface_user_data.windExposure = 'WindExposed'
+
+    construction = surface.construction
+    if construction.is_initialized
+      surface_user_data.constructionName = construction.get.name.to_s
+      surface_user_data.constructionMaterialName = 'Construction_' + construction.get.name.to_s
+    end
+
+    if space_name
+      surface_user_data.spaceName = space_name
+    end
+    if thermal_zone_name
+      surface_user_data.thermalZoneName = thermal_zone_name
+      surface_user_data.thermalZoneMaterialName = 'ThermalZone_' + thermal_zone_name
+    end
+    if space_type_name
+      surface_user_data.spaceTypeName = space_type_name
+      surface_user_data.spaceTypeMaterialName = 'SpaceType_' + space_type_name
+    end
+    if building_story_name
+      surface_user_data.buildingStoryName = building_story_name
+      surface_user_data.buildingStoryMaterialName = 'BuildingStory_' + building_story_name
+    end
+
+    # vertices = []
+    # surface.vertices.each do |v|
+    #  vertex = Vertex.new
+    #  vertex.x = v.x
+    #  vertex.y = v.y
+    #  vertex.z = v.z
+    #  vertices << vertex.to_h
+    # end
+    # surface_user_data.vertices = vertices
+    user_datas << surface_user_data.to_h
+
+    return [geometries, user_datas]
+  end
+
+  # turn an interior partition surface into geometries
+  def self.make_interior_partition_geometries(surface)
+    geometries = []
+    user_datas = []
+
+    # get the transformation to site coordinates
+    site_transformation = OpenStudio::Transformation.new
+    building = surface.model.getBuilding
+    interior_partition_surface_group = surface.interiorPartitionSurfaceGroup
+
+    space_name = nil
+    thermal_zone_name = nil
+    space_type_name = nil
+    building_story_name = nil
+    if !interior_partition_surface_group.empty?
+
+      space = interior_partition_surface_group.get.space
+      if space.is_initialized
+        space = space.get
+        space_name = space.name.to_s
+
+        thermal_zone = space.thermalZone
+        if thermal_zone.is_initialized
+          thermal_zone_name = thermal_zone.get.name.to_s
+        end
+
+        space_type = space.spaceType
+        if space_type.is_initialized
+          space_type_name = space_type.get.name.to_s
+        end
+
+        building_story = space.buildingStory
+        if building_story.is_initialized
+          building_story_name = building_story.get.name.to_s
+        end
+
+        site_transformation = building.transformation * space.transformation * interior_partition_surface_group.get.transformation
+      else
+        site_transformation = building.transformation * interior_partition_surface_group.get.transformation
+      end
+    end
+
+    # get the vertices
+    surface_vertices = surface.vertices
+    t = OpenStudio::Transformation.alignFace(surface_vertices)
+    r = t.rotationMatrix
+    tInv = t.inverse
+    surface_vertices = OpenStudio.reverse(tInv * surface_vertices)
+
+    # triangulate surface
+    triangles = OpenStudio.computeTriangulation(surface_vertices, OpenStudio::Point3dVectorVector.new)
+    if triangles.empty?
+      puts "Failed to triangulate interior partition surface #{surface.name}"
+      return geometries
+    end
+
+    all_vertices = []
+    face_indices = []
+    triangles.each do |vertices|
+      vertices = site_transformation * t * vertices
+      # normal = site_transformation.rotationMatrix*r*z
+
+      # https://github.com/mrdoob/three.js/wiki/JSON-Model-format-3
+      # 0 indicates triangle
+      # 16 indicates triangle with normals
+      face_indices << 0
+      vertices.reverse_each do |vertex|
+        face_indices << get_vertex_index(vertex, all_vertices)
+      end
+
+      # convert to 1 based indices
+      # face_indices.each_index {|i| face_indices[i] = face_indices[i] + 1}
+    end
+
+    data = GeometryData.new
+    data.vertices = flatten_vertices(all_vertices)
+    data.normals = []
+    data.uvs = []
+    data.faces = face_indices
+    data.scale = 1
+    data.visible = true
+    data.castShadow = true
+    data.receiveShadow = false
+    data.doubleSided = true
+
+    geometry = Geometry.new
+    geometry.uuid = format_uuid(surface.handle)
+    geometry.type = 'Geometry'
+    geometry.data = data.to_h
+    geometries << geometry.to_h
+
+    surface_user_data = UserData.new
+    surface_user_data.handle = format_uuid(surface.handle)
+    surface_user_data.name = surface.name.to_s
+    surface_user_data.coincidentWithOutsideObject = false
+
+    surface_user_data.surfaceType = 'InteriorPartitionSurface'
+    surface_user_data.surfaceTypeMaterialName = 'InteriorPartitionSurface'
+
+    # surface_user_data.outsideBoundaryCondition = nil
+    # surface_user_data.outsideBoundaryConditionObjectName = nil
+    # surface_user_data.outsideBoundaryConditionObjectHandle = nil
+    surface_user_data.sunExposure = 'NoSun'
+    surface_user_data.windExposure = 'NoWind'
+
+    construction = surface.construction
+    if construction.is_initialized
+      surface_user_data.constructionName = construction.get.name.to_s
+      surface_user_data.constructionMaterialName = 'Construction_' + construction.get.name.to_s
+    end
+
+    if space_name
+      surface_user_data.spaceName = space_name
+    end
+    if thermal_zone_name
+      surface_user_data.thermalZoneName = thermal_zone_name
+      surface_user_data.thermalZoneMaterialName = 'ThermalZone_' + thermal_zone_name
+    end
+    if space_type_name
+      surface_user_data.spaceTypeName = space_type_name
+      surface_user_data.spaceTypeMaterialName = 'SpaceType_' + space_type_name
+    end
+    if building_story_name
+      surface_user_data.buildingStoryName = building_story_name
+      surface_user_data.buildingStoryMaterialName = 'BuildingStory_' + building_story_name
+    end
+
+    # vertices = []
+    # surface.vertices.each do |v|
+    #  vertex = Vertex.new
+    #  vertex.x = v.x
+    #  vertex.y = v.y
+    #  vertex.z = v.z
+    #  vertices << vertex.to_h
+    # end
+    # surface_user_data.vertices = vertices
+    user_datas << surface_user_data.to_h
+
+    return [geometries, user_datas]
+  end
+
+  def self.identity_matrix
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  end
+
+  def self.build_scene(model)
+    materials = build_materials(model)
+
+    object = {}
+    object[:uuid] = format_uuid(OpenStudio.createUUID)
+    object[:type] = 'Scene'
+    object[:matrix] = identity_matrix
+    object[:children] = []
+
+    floor_material = materials.find { |m| m[:name] == 'Floor' }
+    wall_material = materials.find { |m| m[:name] == 'Wall' }
+    roof_material = materials.find { |m| m[:name] == 'RoofCeiling' }
+    window_material = materials.find { |m| m[:name] == 'Window' }
+    door_material = materials.find { |m| m[:name] == 'Door' }
+    site_shading_material = materials.find { |m| m[:name] == 'SiteShading' }
+    building_shading_material = materials.find { |m| m[:name] == 'BuildingShading' }
+    space_shading_material = materials.find { |m| m[:name] == 'SpaceShading' }
+    interior_partition_surface_material = materials.find { |m| m[:name] == 'InteriorPartitionSurface' }
+
+    # loop over all surfaces
+    all_geometries = []
+    model.getSurfaces.each do |surface|
+      material = nil
+      surfaceType = surface.surfaceType.upcase
+      if surfaceType == 'FLOOR'
+        material = floor_material
+      elsif surfaceType == 'WALL'
+        material = wall_material
+      elsif surfaceType == 'ROOFCEILING'
+        material = roof_material
+      end
+
+      geometries, user_datas = make_geometries(surface)
+      geometries&.each_index do |i|
+        geometry = geometries[i]
+        user_data = user_datas[i]
+
+        all_geometries << geometry
+
+        scene_child = SceneChild.new
+        scene_child.uuid = format_uuid(OpenStudio.createUUID)
+        scene_child.name = user_data[:name]
+        scene_child.type = 'Mesh'
+        scene_child.geometry = geometry[:uuid]
+
+        if i == 0
+          # first geometry is base surface
+          scene_child.material = material[:uuid]
+        else
+          # sub surface
+          if /Window/.match(user_data[:surfaceType]) || /Glass/.match(user_data[:surfaceType])
+            scene_child.material =  window_material[:uuid]
+          else
+            scene_child.material =  door_material[:uuid]
+          end
+        end
+
+        scene_child.matrix = identity_matrix
+        scene_child.userData = user_data
+        object[:children] << scene_child.to_h
+      end
+    end
+
+    # loop over all shading surfaces
+    model.getShadingSurfaces.each do |surface|
+      geometries, user_datas = make_shade_geometries(surface)
+      geometries&.each_index do |i|
+        geometry = geometries[i]
+        user_data = user_datas[i]
+
+        material = nil
+        if /Site/.match(user_data[:surfaceType])
+          material = site_shading_material
+        elsif /Building/.match(user_data[:surfaceType])
+          material = building_shading_material
+        elsif /Space/.match(user_data[:surfaceType])
+          material = space_shading_material
+        end
+
+        all_geometries << geometry
+
+        scene_child = SceneChild.new
+        scene_child.uuid = format_uuid(OpenStudio.createUUID)
+        scene_child.name = user_data[:name]
+        scene_child.type = 'Mesh'
+        scene_child.geometry = geometry[:uuid]
+        scene_child.material = material[:uuid]
+        scene_child.matrix = identity_matrix
+        scene_child.userData = user_data
+        object[:children] << scene_child.to_h
+      end
+    end
+
+    # loop over all interior partition surfaces
+    model.getInteriorPartitionSurfaces.each do |surface|
+      geometries, user_datas = make_interior_partition_geometries(surface)
+      geometries.each_index do |i|
+        geometry = geometries[i]
+        user_data = user_datas[i]
+
+        material = interior_partition_surface_material
+
+        all_geometries << geometry
+
+        scene_child = SceneChild.new
+        scene_child.uuid = format_uuid(OpenStudio.createUUID)
+        scene_child.name = user_data[:name]
+        scene_child.type = 'Mesh'
+        scene_child.geometry = geometry[:uuid]
+        scene_child.material = material[:uuid]
+        scene_child.matrix = identity_matrix
+        scene_child.userData = user_data
+        object[:children] << scene_child.to_h
+      end
+    end
+
+    # light = AmbientLight.new
+    # light.uuid = "#{format_uuid(OpenStudio::createUUID)}"
+    # light.type = "AmbientLight"
+    # light.color = "0xFFFFFF".hex
+    # light.matrix = identity_matrix
+    # object[:children] << light.to_h
+
+    scene = Scene.new
+    scene.geometries = all_geometries
+    scene.materials = materials
+    scene.object = object
+
+    return scene
+  end
+end