topolys 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b3301fef0d27e3a430a205feac0bbe4560e8c58f8e5aee5a28290b74e67f204c
+  data.tar.gz: cce3dd8ea4e5a42dcf97cb98597dd6ebe05748dd2f70875981c83e04f6cd43b6
+SHA512:
+  metadata.gz: 3e6e997e94b2694cb7730127cd9022655b697ef82686db58f6b867dc83f9ac9048a77a1c0db7d22dcefdd8847f5538184d8c40bae3edc30d2fc9bac2edfd1d05
+  data.tar.gz: 61df74ca36f463dcfac81c808c425420903a3ab3a313b9037fc1fb085ac698d65c830b19e9c87957a4f13909da6e5c798be78378a93ce692207fea2b07fe13a7

data/.gitattributes

@@ -0,0 +1,2 @@
+* text=auto
+*.rb text

data/.github/workflows/pull_request.yaml

@@ -0,0 +1,25 @@
+name: Pull Request CI
+
+on:
+  pull_request:
+    branches:
+      - master
+      
+jobs:
+  test:
+    runs-on: ubuntu-18.04
+    strategy:
+      matrix:
+        ruby: [ '2.4', '2.5' ]
+    name: Ruby ${{ matrix.ruby }} Tests
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v2 
+    - name: Set up Ruby
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Run Tests
+      run: |
+        bundle update
+        bundle exec rake

data/.gitignore

@@ -0,0 +1,37 @@
+# rspec failure tracking
+.rspec_status
+
+/.bundle/
+/.yardoc
+/_yardoc/
+/.ruby-version
+/Gemfile.lock
+/gems
+/coverage/
+/doc/
+/html/
+/pkg/
+/spec/reports/
+/spec/test/
+/spec/files/*/
+/tmp/
+/test/
+/lib/.rubocop*
+
+# rspec failure tracking
+.rspec_status
+
+# Ignore IDE files
+/.idea
+*.rubocop-http*
+
+# runner conf
+runner.conf
+
+# .DS_Store (Mac)
+*.DS_Store
+
+# graphviz files
+/*.dot
+/*.pdf
+/*.json

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.2.5
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in topolys.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Dan Macumber & Denis Bourgeois
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# Topolys
+
+Topolys is a Ruby gem based on the rigorous non-manifold topology class hierarchy used in the [Topologic](https://github.com/NonManifoldTopology/Topologic) project. More information about Topologic is available on the [Topologic website](https://topologic.app). This class hierarchy is well suited to the topology of zero thickness space boundaries commonly used in energy modeling as well as other applications.  The Topolys gem is agnostic to specific applications. Current users of Topolys include:
+
+- [Thermal Bridging & Derating (tbd)](https://github.com/rd2/tbd) is a library and OpenStudio Measure for thermally derating outside-facing opaque constructions (walls, roofs and exposed floors), based on major thermal bridges (balconies, corners, fenestration perimeters, and so on).
+- [TopolysMeasures](https://github.com/automaticmagic/TopolysMeasures), includes proof of concept OpenStudio Measures with the potential to provide improved surface intersection and matching, checks if spaces are fully enclosed, or other new functionality.
+
+## Documentation
+
+Topolys is very new and does not yet have formal user documentation.  A set of initial design documents are available at https://github.com/automaticmagic/topolys/tree/master/design
+
+## Installation
+
+(revise) Add this line to your application's Gemfile:
+
+```ruby
+gem 'topolys', github: 'automaticmagic/topolys', branch: 'master'
+```
+
+And then execute:
+
+    $ bundle update
+
+## Development
+
+To run unit tests:
+
+    bundle exec rake
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/automaticmagic/topolys.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "topolys"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/topolys/geometry.rb

@@ -0,0 +1,351 @@
+module Topolys
+
+  # Point3D, Vector3D, and Plane3D represents the 3D position and orientation
+  # of geometry in Topolys.  Geometry is separate from topology (connections).
+
+  class Point3D
+
+    # @return [Float] X, Y, or Z coordinate
+    attr_reader :x, :y, :z
+
+    ##
+    # Initializes a Point3D object
+    #
+    # @param [Float] X-coordinate
+    # @param [Float] Y-coordinate
+    # @param [Float] Z-coordinate
+    def initialize(x, y, z)
+      raise "Incorrect x argument for Point3D, expected Numeric but got #{x.class}" unless x.is_a?(Numeric)
+      raise "Incorrect y argument for Point3D, expected Numeric but got #{y.class}" unless y.is_a?(Numeric)
+      raise "Incorrect z argument for Point3D, expected Numeric but got #{z.class}" unless z.is_a?(Numeric)
+      @x = x
+      @y = y
+      @z = z
+    end
+
+    def to_s
+      "[#{@x}, #{@y}, #{@z}]"
+    end
+
+    ##
+    # Adds a 3D vector to self
+    #
+    # @param [Vector3D] vector A Vector3D
+    #
+    # @return [Point3D] Returns a new Point3D - nil if vector not a Vector3D
+    def +(vector)
+      return nil unless vector.is_a?(Topolys::Vector3D)
+      x = @x + vector.x
+      y = @y + vector.y
+      z = @z + vector.z
+      return Topolys::Point3D.new(x, y, z)
+    end
+
+    ##
+    # Generates a 3D vector which goes from other to self
+    #
+    # @param [Point3D] other Another 3D point
+    #
+    # @return [Vector3D] Returns a new Vector3D - nil if other not a Point3D
+    def -(other)
+      return nil unless other.is_a?(Topolys::Point3D)
+      x = @x - other.x
+      y = @y - other.y
+      z = @z - other.z
+      return Topolys::Vector3D.new(x, y, z)
+    end
+
+  end # Point3D
+
+  class Vector3D
+
+    # @return [Float] X, Y, or Z component
+    attr_reader :x, :y, :z
+
+    ##
+    # Initializes a Vector3D object
+    #
+    # @param [Float] X-coordinate
+    # @param [Float] Y-coordinate
+    # @param [Float] Z-coordinate
+    def initialize(x, y, z)
+      raise "Incorrect x argument for Vector3D, expected Numeric but got #{x.class}" unless x.is_a?(Numeric)
+      raise "Incorrect y argument for Vector3D, expected Numeric but got #{y.class}" unless y.is_a?(Numeric)
+      raise "Incorrect z argument for Vector3D, expected Numeric but got #{z.class}" unless z.is_a?(Numeric)
+      @x = x
+      @y = y
+      @z = z
+    end
+
+    def to_s
+      "[#{@x}, #{@y}, #{@z}]"
+    end
+
+    def Vector3D.x_axis
+      Vector3D.new(1,0,0)
+    end
+
+    def Vector3D.y_axis
+      Vector3D.new(0,1,0)
+    end
+
+    def Vector3D.z_axis
+      Vector3D.new(0,0,1)
+    end
+
+    ##
+    # Adds 2x 3D vectors - overrides '+' operator
+    #
+    # @param [Vector3D] other Another 3D vector
+    #
+    # @return [Vector3D] Returns a new 3D resultant vector - nil if not Vector3D objects
+    def +(other)
+      return nil unless other.is_a?(Topolys::Vector3D)
+      x = @x + other.x
+      y = @y + other.y
+      z = @z + other.z
+      return Topolys::Vector3D.new(x, y, z)
+    end
+
+    ##
+    # Subtracts a 3D vector from another 3D vector - overrides '-' operator.
+    # Leaves original 3D vector intact if other is not a Vector3D object
+    #
+    # @param [Vector3D] other Another 3D vector
+    #
+    # @return [Vector3D] Returns a new 3D resultant vector - nil if not Vector3D objects
+    def -(other)
+      return nil unless other.is_a?(Topolys::Vector3D)
+      x = @x - other.x
+      y = @y - other.y
+      z = @z - other.z
+      return Topolys::Vector3D.new(x, y, z)
+    end
+
+    ##
+    # Multiplies a 3D vector by a scalar
+    #
+    # @param [Float] scalar A scalar
+    #
+    # @return [Vector3D] Returns a new, scaled 3D vector - nil if not numeric
+    def *(scalar)
+      return nil unless scalar.is_a?(Numeric)
+      x = @x * scalar
+      y = @y * scalar
+      z = @z * scalar
+      return Topolys::Vector3D.new(x, y, z)
+    end
+
+    ##
+    # Divides a 3D vector by a non-zero scalar
+    #
+    # @param [Float] scalar A non-zero scalar
+    #
+    # @return [Vector3D] Returns a new, scaled 3D vector - nil if 0 or not numeric
+    def /(scalar)
+      return nil unless scalar.is_a?(Numeric)
+      return nil if scalar.zero?
+      x = @x / scalar
+      y = @y / scalar
+      z = @z / scalar
+      Topolys::Vector3D.new(x, y, z)
+    end
+
+    ##
+    # Gets 3D vector magnitude (or length)
+    #
+    # @return [Float] Returns magnitude of the 3D vector
+    def magnitude
+      Math.sqrt(@x**2 + @y**2 + @z**2)
+    end
+
+    ##
+    # Normalizes a 3D vector
+    def normalize!
+      n = magnitude
+      unless n.zero?
+        @x /= n
+        @y /= n
+        @z /= n
+      end
+    end
+
+    ##
+    # Gets the dot (or inner) product of self & another 3D vector
+    #
+    # @param [Vector3D] other Another 3D vector
+    #
+    # @return [Float] Returns dot product - nil if not Vector3D objects
+    def dot(other)
+      return nil unless other.is_a?(Topolys::Vector3D)
+      return @x * other.x + @y * other.y + @z * other.z
+    end
+
+    ##
+    # Gets the cross product between self & another 3D vector
+    #
+    # @param [Vector3D] other Another 3D vector
+    #
+    # @return [Vector3D] Returns cross product - nil if not Vector3D objects
+    def cross(other)
+      return nil unless other.is_a?(Topolys::Vector3D)
+      x = @y * other.z - @z * other.y
+      y = @z * other.x - @x * other.z
+      z = @x * other.y - @y * other.x
+      return Topolys::Vector3D.new(x, y, z)
+    end
+
+    ##
+    # Gets the outer product between self & another 3D vector
+    #
+    # @param [Vector3D] other Another 3D vector
+    #
+    # @return [Matrix] Returns outer product
+    def outer_product(other)
+      return nil unless other.is_a?(Topolys::Vector3D)
+      result = Matrix.zero(3,3)
+      result[0,0] = @x*other.x
+      result[0,1] = @x*other.y
+      result[0,2] = @x*other.z
+      result[1,0] = @y*other.x
+      result[1,1] = @y*other.y
+      result[1,2] = @y*other.z
+      result[2,0] = @z*other.x
+      result[2,1] = @z*other.y
+      result[2,2] = @z*other.z
+      return result
+    end
+
+    ##
+    # Gets angle [0,PI) between self & another 3D vector
+    #
+    # @param [Vector3D] other Another 3D vector
+    #
+    # @return [Float] Returns angle - nil if not Vector3D objects
+    def angle(other)
+      return nil unless other.is_a?(Topolys::Vector3D)
+      prod = magnitude * other.magnitude
+      return nil if prod.zero?
+      val = dot(other) / prod
+      val = [-1.0, val].max
+      val = [ val, 1.0].min
+      Math.acos(val)
+    end
+
+  end # Vector3D
+
+  class Plane3D
+
+    # @return [Point3D] arbitrary point on plane
+    attr_reader :point
+
+    # @return [Vector3D] normalized vector perpendicular to plane
+    attr_reader :normal
+
+    ##
+    # Initializes a Plane3D object from a point and an outward normal
+    #
+    # @param [Point3d] point
+    # @param [Vector3D] normal
+    def initialize(point, normal)
+      raise "Incorrect point argument for Plane3D, expected Point3D but got #{point.class}" unless point.is_a?(Topolys::Point3D)
+      raise "Incorrect normal argument for Plane3D, expected Vector3D but got #{normal.class}" unless normal.is_a?(Topolys::Vector3D)
+      raise "Incorrect normal argument for Plane3D, magnitude too small" unless normal.magnitude > Float::EPSILON
+
+      @point = Point3D.new(point.x, point.y, point.z)
+      @normal = Vector3D.new(normal.x, normal.y, normal.z)
+      @normal.normalize!
+
+      # coefficients for equation of a plane
+      @a = @normal.x
+      @b = @normal.y
+      @c = @normal.z
+      @d = -(@a*@point.x + @b*@point.y + @c*@point.z)
+    end
+
+    def to_s
+      "[#{@a}, #{@b}, #{@c}, #{@d}]"
+    end
+
+    ##
+    # Initializes a Plane3D object from three non-colinear points
+    #
+    # @param [Point3d] point1
+    # @param [Point3d] point2
+    # @param [Point3d] point3
+    def Plane3D.from_points(point1, point2, point3)
+      return nil unless point1.is_a?(Topolys::Point3D)
+      return nil unless point2.is_a?(Topolys::Point3D)
+      return nil unless point3.is_a?(Topolys::Point3D)
+
+      normal = (point2-point1).cross(point3-point1)
+      return nil unless normal.magnitude > Float::EPSILON
+
+      return Plane3D.new(point1, normal)
+    end
+
+    ##
+    # Initializes a Plane3D object from a point and two vectors
+    #
+    # @param [Point3d] point
+    # @param [Vector3D] xaxis
+    # @param [Vector3D] yaxis
+    def Plane3D.from_point_axes(point, xaxis, yaxis)
+      return nil unless point.is_a?(Topolys::Point3D)
+      return nil unless xaxis.is_a?(Topolys::Vector3D)
+      return nil unless yaxis.is_a?(Topolys::Vector3D)
+
+      normal = xaxis.cross(yaxis)
+      return nil unless normal.magnitude > Float::EPSILON
+
+      return Plane3D.new(point, normal)
+    end
+
+    # TODO: implement methods below
+
+    ##
+    # Project a Point3d to this plane
+    #
+    # @param [Point3d] point
+    #
+    # @return [Point3d] Returns point projected to this plane
+    def project(point)
+      dist = @normal.dot(point-@point)
+      return point + normal*(-dist)
+    end
+
+  end # Plane3D
+
+  class BoundingBox
+
+    attr_reader :minx, :maxx, :miny, :maxy, :minz, :maxz
+
+    def initialize(tol = 0.001)
+      @tol = tol
+      @minx = Float::INFINITY
+      @miny = Float::INFINITY
+      @minz = Float::INFINITY
+      @maxx = -Float::INFINITY
+      @maxy = -Float::INFINITY
+      @maxz = -Float::INFINITY
+    end
+
+    def add_point(point)
+      @minx = [point.x, @minx].min
+      @miny = [point.y, @miny].min
+      @minz = [point.z, @minz].min
+      @maxx = [point.x, @maxx].max
+      @maxy = [point.y, @maxy].max
+      @maxz = [point.z, @maxz].max
+    end
+
+    def include?(point)
+      result = ((point.x >= @minx - @tol) && (point.x <= @maxx + @tol)) &&
+               ((point.y >= @miny - @tol) && (point.y <= @maxy + @tol)) &&
+               ((point.z >= @minz - @tol) && (point.z <= @maxz + @tol))
+      return result
+    end
+
+  end # BoundingBox
+
+end # TOPOLYS